@8-/gemini-web-api 1.0.0 → 1.0.1

package/src/router.js

@@ -0,0 +1,302 @@
+import {
+  API_KEY,
+  CORS_HEADERS,
+  DEFAULT_MODEL_LI,
+  ENABLE_THINKING,
+  ERR_MISSING_URL,
+  ERR_NOT_FOUND,
+  ERR_UNAUTHORIZED,
+  GEN_URL,
+  ROLE_ASSISTANT,
+  STATUS_BAD_REQUEST,
+  STATUS_NO_CONTENT,
+  STATUS_NOT_FOUND,
+  STATUS_OK,
+  STATUS_UNAUTHORIZED,
+  STOP_REASON_STOP,
+  STOP_REASON_TOOL_CALLS,
+  USER_AGENT,
+} from "./constant.js";
+import { modelMap } from "./modelDiscover.js";
+import { conversationFormat, payloadBuild } from "./payloadBuild.js";
+import { sessionInit, session_state } from "./sessionState.js";
+import { sseStreamCreate } from "./sseResponse.js";
+import { fullResponseCollect } from "./streamExtract.js";
+import { jsonFormat, toolCallExtract } from "./toolHandle.js";
+
+export const authVerify = (req) => {
+  if (!API_KEY) return true;
+  const auth_header = req.headers.get("authorization") ?? "",
+    key = auth_header.replace(/^Bearer\s+/i, "");
+  return key === API_KEY;
+},
+
+healthHandle = () => {
+  const res_obj = {
+      status: "healthy",
+      service: "Gemini API 代理 (Node/Bun)",
+      version: "1.0.0",
+      endpoints: ["/v1/models", "/v1/chat/completions"],
+    },
+    res_body = JSON.stringify(res_obj);
+  console.log("<-- 响应: [200 OK]\n" + jsonFormat(res_obj));
+  return new Response(res_body, {
+    status: STATUS_OK,
+    headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+  });
+},
+
+modelListHandle = (now) => {
+  const available_model_li =
+      session_state.model_li.length > 0 ? session_state.model_li : DEFAULT_MODEL_LI,
+    model_data_li = available_model_li.map((model_item) => ({
+      id: model_item.id,
+      object: "model",
+      created: now,
+      owned_by: "google-gemini-web",
+    })),
+    res_obj = { object: "list", data: model_data_li },
+    res_body = JSON.stringify(res_obj);
+  console.log("<-- 响应: [200 OK] 模型列表:\n" + jsonFormat(res_obj));
+  return new Response(res_body, {
+    status: STATUS_OK,
+    headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+  });
+},
+
+modelDetailHandle = (req_model_id, now) => {
+  const target_model = modelMap(req_model_id),
+    res_obj = {
+      id: target_model.id,
+      object: "model",
+      created: now,
+      owned_by: "google-gemini-web",
+    },
+    res_body = JSON.stringify(res_obj);
+  console.log("<-- 响应: [200 OK] 模型详情:\n" + jsonFormat(res_obj));
+  return new Response(res_body, {
+    status: STATUS_OK,
+    headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+  });
+},
+
+imageProxyHandle = async (req_url) => {
+  const target_url = req_url.searchParams.get("url");
+  if (!target_url) {
+    return new Response(
+      JSON.stringify({ code: ERR_MISSING_URL, error: "缺少 url 参数" }),
+      {
+        status: STATUS_BAD_REQUEST,
+        headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+      },
+    );
+  }
+  const img_res = await fetch(target_url, {
+      headers: {
+        "User-Agent": USER_AGENT,
+        Referer: "https://gemini.google.com/",
+      },
+    }),
+    img_bytes = new Uint8Array(await img_res.arrayBuffer()),
+    headers = {
+      ...CORS_HEADERS,
+      "Content-Type": img_res.headers.get("content-type") ?? "image/png",
+    };
+  return new Response(img_bytes, { status: STATUS_OK, headers });
+},
+
+chatCompletionsHandle = async (req, body) => {
+  if (!authVerify(req)) {
+    const res_obj = { code: ERR_UNAUTHORIZED, error: "未授权" },
+      res_body = JSON.stringify(res_obj);
+    console.log("<-- 响应: [401 Unauthorized]\n" + jsonFormat(res_obj));
+    return new Response(res_body, {
+      status: STATUS_UNAUTHORIZED,
+      headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+    });
+  }
+
+  if (!body.messages && body.prompt) {
+    body.messages = [{ role: "user", content: body.prompt }];
+  }
+
+  const model_info = modelMap(body.model),
+    has_tools = Array.isArray(body.tools) && body.tools.length > 0 && body.tool_choice !== "none",
+    conversation = conversationFormat(body.messages, body.tools, body.tool_choice);
+
+  if (!session_state.at) {
+    await sessionInit();
+  }
+
+  ++session_state.req_id;
+  const [inner_req, model_header, uuid_val] = payloadBuild(conversation, model_info),
+    form_data = new URLSearchParams();
+  form_data.set("at", session_state.at);
+  form_data.set("f.req", JSON.stringify([null, JSON.stringify(inner_req)]));
+
+  const gen_url = new URL(GEN_URL);
+  gen_url.searchParams.set("hl", "en");
+  gen_url.searchParams.set("_reqid", String(session_state.req_id));
+  gen_url.searchParams.set("rt", "c");
+  if (session_state.bl) gen_url.searchParams.set("bl", session_state.bl);
+  if (session_state.fsid) gen_url.searchParams.set("f.sid", session_state.fsid);
+
+  const gen_res = await fetch(gen_url.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded;charset=utf-8",
+        Origin: "https://gemini.google.com",
+        Referer: "https://gemini.google.com/",
+        "X-Same-Domain": "1",
+        "User-Agent": USER_AGENT,
+        Cookie: session_state.cookie_header,
+        "x-goog-ext-525001261-jspb": JSON.stringify(model_header),
+        "x-goog-ext-73010989-jspb": "[0]",
+        "x-goog-ext-73010990-jspb": "[0,0,0]",
+        "x-goog-ext-525005358-jspb": JSON.stringify([uuid_val, 1]),
+      },
+      body: form_data.toString(),
+    }),
+    completion_id = "chatcmpl-" + crypto.randomUUID(),
+    created_time = Math.floor(Date.now() / 1000);
+
+  if (body.stream) {
+    console.log("<-- 响应: [200 OK] 开始流式传输 (SSE)...");
+    const sse_stream = sseStreamCreate(
+      gen_res.body,
+      completion_id,
+      model_info.id,
+      created_time,
+      has_tools,
+    );
+    return new Response(sse_stream, {
+      status: STATUS_OK,
+      headers: {
+        ...CORS_HEADERS,
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  }
+
+  const [full_content, final_text, final_thought] = await fullResponseCollect(gen_res.body),
+    prompt_tokens = conversation.split(/\s+/).length;
+
+  let message = {
+      role: ROLE_ASSISTANT,
+      content: full_content,
+    },
+    finish_reason = STOP_REASON_STOP;
+
+  if (ENABLE_THINKING && final_thought) {
+    message.reasoning_content = final_thought;
+  }
+
+  if (has_tools) {
+    const [, tool_call_li] = toolCallExtract(final_text);
+    if (tool_call_li.length > 0) {
+      message.content = null;
+      message.tool_calls = tool_call_li;
+      finish_reason = STOP_REASON_TOOL_CALLS;
+    }
+  }
+
+  const completion_tokens = (message.content ?? "").split(/\s+/).length,
+    res_json = {
+      id: completion_id,
+      object: "chat.completion",
+      created: created_time,
+      model: model_info.id,
+      choices: [
+        {
+          index: 0,
+          message,
+          finish_reason,
+        },
+      ],
+      usage: {
+        prompt_tokens,
+        completion_tokens,
+        total_tokens: prompt_tokens + completion_tokens,
+      },
+    },
+    res_body = JSON.stringify(res_json);
+  console.log("<-- 响应: [200 OK]\n" + jsonFormat(res_json));
+  return new Response(res_body, {
+    status: STATUS_OK,
+    headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+  });
+},
+
+reqHandle = async (req) => {
+  const req_url = new URL(req.url),
+    pathname = req_url.pathname,
+    norm_path = pathname.replace(/\/+$/, "") || "/",
+    is_body_method = req.method === "POST" || req.method === "PUT" || req.method === "PATCH";
+  let body = {},
+    req_text = "";
+
+  if (is_body_method) {
+    req_text = await req.text();
+    const trimmed = req_text.trim();
+    if (trimmed && (trimmed.startsWith("{") || trimmed.startsWith("["))) {
+      body = JSON.parse(trimmed);
+    }
+  }
+
+  console.log("\n--> [" + req.method + "] " + pathname);
+  console.log("--> 请求头:", JSON.stringify(Object.fromEntries(req.headers.entries())));
+  if (req_text.trim()) {
+    console.log("--> 请求体:\n" + jsonFormat(body || req_text));
+  } else {
+    console.log("--> 请求体: (无)");
+  }
+
+  if (req.method === "OPTIONS") {
+    console.log("<-- 响应: [204 No Content]");
+    return new Response(null, { status: STATUS_NO_CONTENT, headers: CORS_HEADERS });
+  }
+
+  if (norm_path === "/" || norm_path === "/v1") {
+    return healthHandle();
+  }
+
+  const now = Math.floor(Date.now() / 1000);
+  if ((norm_path === "/models" || norm_path.endsWith("/models")) && req.method === "GET") {
+    return modelListHandle(now);
+  }
+
+  if (norm_path.includes("/models/") && req.method === "GET") {
+    const req_model_id = norm_path.split("/").pop();
+    return modelDetailHandle(req_model_id, now);
+  }
+
+  if (norm_path.endsWith("/gemini-proxy/image") && req.method === "GET") {
+    console.log("<-- 响应: [200 OK] 代理图片");
+    return imageProxyHandle(req_url);
+  }
+
+  if (
+    (norm_path === "/chat/completions" ||
+      norm_path.endsWith("/chat/completions") ||
+      norm_path === "/completions" ||
+      norm_path.endsWith("/completions")) &&
+    req.method === "POST"
+  ) {
+    return chatCompletionsHandle(req, body);
+  }
+
+  const res_obj = {
+      code: ERR_NOT_FOUND,
+      error: "未找到接口",
+      path: pathname,
+      method: req.method,
+    },
+    res_body = JSON.stringify(res_obj);
+  console.log("<-- 响应: [404 Not Found] 未找到接口: " + req.method + " " + pathname + "\n" + jsonFormat(res_obj));
+  return new Response(res_body, {
+    status: STATUS_NOT_FOUND,
+    headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+  });
+};

package/src/serverStart.js

@@ -0,0 +1,120 @@
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+import { HOST, PORT, STATUS_SERVER_ERR } from "./constant.js";
+import { modelListPrint } from "./modelDiscover.js";
+import { reqHandle } from "./router.js";
+
+export const serverStart = (custom_handler = null) => {
+  const handler = custom_handler ?? reqHandle,
+    is_tty = Boolean(process.stdout?.isTTY),
+    color = {
+      reset: is_tty ? "\x1b[0m" : "",
+      bold: is_tty ? "\x1b[1m" : "",
+      dim: is_tty ? "\x1b[2m" : "",
+      cyan: is_tty ? "\x1b[36m" : "",
+      green: is_tty ? "\x1b[32m" : "",
+    },
+    serverBannerPrint = (runtime_name) => {
+      const url = "http://" + (HOST === "0.0.0.0" ? "localhost" : HOST) + ":" + PORT;
+      console.log(
+        "\n  " +
+          color.bold +
+          color.green +
+          "Gemini Web API" +
+          color.reset +
+          " " +
+          color.dim +
+          "服务已启动 (" +
+          runtime_name +
+          ")" +
+          color.reset,
+      );
+      console.log(
+        "  " +
+          color.cyan +
+          "➜" +
+          color.reset +
+          " " +
+          color.bold +
+          "本地服务:" +
+          color.reset +
+          "   " +
+          url,
+      );
+      console.log(
+        "  " +
+          color.cyan +
+          "➜" +
+          color.reset +
+          " " +
+          color.bold +
+          "对话接口:" +
+          color.reset +
+          "   " +
+          url +
+          "/v1/chat/completions",
+      );
+      console.log(
+        "  " +
+          color.cyan +
+          "➜" +
+          color.reset +
+          " " +
+          color.bold +
+          "模型列表:" +
+          color.reset +
+          "   " +
+          url +
+          "/v1/models\n",
+      );
+      modelListPrint();
+    };
+
+  if (typeof Bun !== "undefined" && Bun.serve) {
+    const bun_server = Bun.serve({
+      port: PORT,
+      hostname: HOST,
+      fetch: handler,
+    });
+    serverBannerPrint("Bun");
+    return bun_server;
+  }
+
+  const node_server = createServer(async (node_req, node_res) => {
+    try {
+      const url =
+          "http://" + (node_req.headers.host ?? (HOST + ":" + PORT)) + node_req.url,
+        has_body = node_req.method !== "GET" && node_req.method !== "HEAD",
+        web_req = new Request(url, {
+          method: node_req.method,
+          headers: node_req.headers,
+          body: has_body ? Readable.toWeb(node_req) : null,
+          duplex: "half",
+        }),
+        web_res = await handler(web_req);
+
+      node_res.statusCode = web_res.status;
+      web_res.headers.forEach((header_val, header_key) => {
+        node_res.setHeader(header_key, header_val);
+      });
+      if (web_res.body) {
+        Readable.fromWeb(web_res.body).pipe(node_res);
+      } else {
+        node_res.end();
+      }
+    } catch (err) {
+      if (!node_res.headersSent) {
+        node_res.statusCode = STATUS_SERVER_ERR;
+        node_res.end(
+          JSON.stringify({ code: STATUS_SERVER_ERR, error: "Internal Server Error" }),
+        );
+      }
+      console.error("服务器异常:", err);
+    }
+  });
+
+  node_server.listen(PORT, HOST, () => {
+    serverBannerPrint("Node");
+  });
+  return node_server;
+};

package/src/sessionState.js

@@ -0,0 +1,70 @@
+import { DEFAULT_MODEL_LI, INIT_URL, STATUS_OK, USER_AGENT } from "./constant.js";
+import { cookieRead } from "./cookieRead.js";
+import { modelFetch } from "./modelDiscover.js";
+
+export let session_state = {
+  cookie_header: "",
+  at: "",
+  bl: "",
+  fsid: "",
+  req_id: Math.floor(Math.random() * 90000) + 10000,
+  model_li: [],
+  default_model: null,
+};
+
+export const sessionInit = async () => {
+  try {
+    if (!session_state.cookie_header) {
+      session_state.cookie_header = await cookieRead();
+    }
+    const res = await fetch(INIT_URL, {
+      headers: {
+        "User-Agent": USER_AGENT,
+        Cookie: session_state.cookie_header,
+      },
+      redirect: "manual",
+    });
+
+    let html = "";
+    if (res.status === STATUS_OK) {
+      html = await res.text();
+    } else if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location") ?? "";
+      if (location.includes("/sorry/")) {
+        console.warn("Gemini 会话初始化提示: 触发了 Google 验证码重定向 (sorry/index)");
+      } else if (location) {
+        const redirect_res = await fetch(location, {
+          headers: {
+            "User-Agent": USER_AGENT,
+            Cookie: session_state.cookie_header,
+          },
+        });
+        if (redirect_res.ok) html = await redirect_res.text();
+      }
+    }
+
+    const at_match = html.match(/"SNlM0e":\s*"([^"]+)"/),
+      bl_match = html.match(/"cfb2h":\s*"([^"]+)"/),
+      fsid_match = html.match(/"FdrFJe":\s*"([^"]+)"/);
+    session_state.at = at_match ? at_match[1] : "";
+    session_state.bl = bl_match ? bl_match[1] : "";
+    session_state.fsid = fsid_match ? fsid_match[1] : "";
+    if (session_state.at) {
+      session_state.model_li = await modelFetch(
+        session_state.at,
+        session_state.bl,
+        session_state.fsid,
+        session_state.cookie_header,
+      );
+    }
+    if (!session_state.default_model) {
+      session_state.default_model = session_state.model_li[0] ?? DEFAULT_MODEL_LI[0];
+    }
+  } catch (err) {
+    if (!session_state.default_model) {
+      session_state.default_model = session_state.model_li[0] ?? DEFAULT_MODEL_LI[0];
+    }
+    console.warn("会话初始化异常:", err.message);
+  }
+  return session_state;
+};

package/src/sseResponse.js

@@ -0,0 +1,166 @@
+import {
+  ENABLE_THINKING,
+  ROLE_ASSISTANT,
+  STOP_REASON_STOP,
+  STOP_REASON_TOOL_CALLS,
+} from "./constant.js";
+import { streamChunkExtract } from "./streamExtract.js";
+import { jsonFormat, toolCallExtract } from "./toolHandle.js";
+
+export const sseStreamCreate = (
+  body,
+  completion_id,
+  model,
+  created_time,
+  has_tools = false,
+) => {
+  const enc = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      const chunkSend = (delta, finish_reason = null) => {
+        try {
+          const payload = JSON.stringify({
+            id: completion_id,
+            object: "chat.completion.chunk",
+            created: created_time,
+            model,
+            choices: [
+              {
+                index: 0,
+                delta,
+                finish_reason,
+              },
+            ],
+          });
+          console.log("<-- [SSE 块]:", JSON.stringify(delta));
+          controller.enqueue(enc.encode("data: " + payload + "\n\n"));
+        } catch {
+          // Client disconnected
+        }
+      };
+
+      chunkSend({ role: ROLE_ASSISTANT });
+
+      const reader = body.getReader(),
+        decoder = new TextDecoder();
+
+      let buf = "",
+        last_text = "",
+        last_thought = "",
+        thinking_started = false,
+        thinking_ended = false;
+
+      const itemProcess = ({ thoughts, text }) => {
+        if (ENABLE_THINKING && thoughts) {
+          if (thoughts.startsWith(last_thought)) {
+            const thought_delta = thoughts.slice(last_thought.length);
+            if (thought_delta) {
+              if (!thinking_started) {
+                chunkSend({ content: "<think>\n" });
+                thinking_started = true;
+              }
+              chunkSend({
+                content: thought_delta,
+                reasoning_content: thought_delta,
+              });
+              last_thought = thoughts;
+            }
+          } else {
+            if (!thinking_started) {
+              chunkSend({ content: "<think>\n" });
+              thinking_started = true;
+            }
+            chunkSend({
+              content: thoughts,
+              reasoning_content: thoughts,
+            });
+            last_thought = thoughts;
+          }
+        }
+
+        if (text) {
+          if (!has_tools) {
+            if (ENABLE_THINKING && thinking_started && !thinking_ended) {
+              chunkSend({ content: "</think>\n\n" });
+              thinking_ended = true;
+            }
+            if (text.startsWith(last_text)) {
+              const text_delta = text.slice(last_text.length);
+              if (text_delta) {
+                chunkSend({ content: text_delta });
+              }
+            } else {
+              chunkSend({ content: text });
+            }
+          }
+          last_text = text;
+        }
+      };
+
+      while (true) {
+        const read_res = await reader.read();
+        if (read_res.done) {
+          if (buf.trim()) {
+            const [remaining_li] = streamChunkExtract(buf + "\n");
+            remaining_li.forEach(itemProcess);
+          }
+          break;
+        }
+        buf += decoder.decode(read_res.value, { stream: true });
+
+        const [extracted_li, next_buf] = streamChunkExtract(buf);
+        buf = next_buf;
+        extracted_li.forEach(itemProcess);
+      }
+
+      if (ENABLE_THINKING && thinking_started && !thinking_ended) {
+        chunkSend({ content: "</think>\n\n" });
+        thinking_ended = true;
+      }
+
+      let tool_call_li = [];
+
+      if (has_tools) {
+        const [clean_text, parsed_calls_li] = toolCallExtract(last_text);
+        tool_call_li = parsed_calls_li;
+        if (tool_call_li.length > 0) {
+          const delta_calls_li = tool_call_li.map((tc, call_idx) => ({
+            index: call_idx,
+            id: tc.id,
+            type: "function",
+            function: tc.function,
+          }));
+          chunkSend({ tool_calls: delta_calls_li });
+          chunkSend({}, STOP_REASON_TOOL_CALLS);
+        } else {
+          const chunk_size = 24,
+            emit_text = clean_text || last_text;
+          for (let i = 0; i < emit_text.length; i += chunk_size) {
+            chunkSend({ content: emit_text.slice(i, i + chunk_size) });
+          }
+          chunkSend({}, STOP_REASON_STOP);
+        }
+      } else {
+        chunkSend({}, STOP_REASON_STOP);
+      }
+
+      try {
+        controller.enqueue(enc.encode("data: [DONE]\n\n"));
+        controller.close();
+      } catch {}
+      if (tool_call_li.length > 0) {
+        console.log(
+          "<-- [SSE 完成] 工具调用:\n" +
+            (last_thought ? "<think>\n" + last_thought + "\n</think>\n\n" : "") +
+            jsonFormat(tool_call_li),
+        );
+      } else {
+        console.log(
+          "<-- [SSE 完成] 完整输出:\n" +
+            (last_thought ? "<think>\n" + last_thought + "\n</think>\n\n" : "") +
+            last_text,
+        );
+      }
+    },
+  });
+};