@8-/gemini-web-api 1.0.0

package/.agents/skills/js_review/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: js_review
+description: JavaScript 代码审查
+---
+
+# JS / Bun 代码规范与审查指南
+
+## 1. 运行时与现代语法规范
+
+- 执行环境：优先使用 Bun 现代运行时，脚本文件顶部统一使用 `#!/usr/bin/env -S bun`。
+- 路径与元数据：必须使用 `import.meta.dirname` 获取当前目录路径，禁止使用传统 `__dirname`、`__filename` 或冗长的 `fileURLToPath(import.meta.url)`。
+- 极速文件 I/O：在 Bun 环境下，优先使用原生 `Bun.file(path).text()` / `Bun.file(path).json()` / `Bun.write(path, data)` 进行极速异步 I/O。
+- 现代语法：充分利用 ES2024+ 现代特性，如 `replaceAll()`、空值合并操作符（`??`）、可选链（`?.`，禁止过度防御式编程）。
+
+## 2. 代码风格与设计哲学
+
+- 简洁优雅：接口设计低耦合、高内聚，拆分过长函数为单一职责纯函数。
+- 纯函数优先：严禁定义 `class`，全部使用纯函数与数据流管道。
+- 箭头函数：统一使用箭头函数 `const funcName = () => {}`，不使用 `function` 关键字（生成器除外）；如可用 `.bind` 绑定参数则避免多层包装。
+- 变量声明：连续声明必须合并为一个 `const` 语句（例如 `const a = 1, b = 2, c = 3;`），减少语句冗余。
+- 异步处理：统一使用 `async/await`，严禁使用 `.then()` 链式调用。
+- 异常处理：不盲目自动生成 `try...catch`（由人工按需维护，已有 `try catch` 保留）。
+- 对象与解构：优先使用解构赋值提取需要的属性，避免在循环或内部深层反复使用点号访问。
+- 参数与多值返回：
+  - 函数参数扁平化，写 `a, b, c` 而非单一对象 `{ a, b, c }`；如可选参数多，采用 `[[配置项数字, 配置项值], ...]` 范式，配置项用数字常量定义。
+  - 多值返回统一使用数组 `[a, b, c]`；多返回值时使用数值常量定义位置语义。
+- 状态表示：严禁使用魔法字符串表示状态，统一用常量/数字枚举定义。
+- 字符串拼接：普通拼接使用 `+`，`import` 导入语句除外（方便 Vite / 打包器静态分析）。
+- 循环与列表：
+  - 数组多用 `map`、`forEach`、`filter`、`find`；
+  - `for` 循环如需序号统一使用 `++i` 而非 `i++`；
+  - 列表变量名不使用复数形式，统一以 `_li` 结尾（例如 `user_li`, `cmd_li`）。
+
+## 3. 命名规范
+
+- 极简语义：使用简短明确的动词/名词（例如用 `rm` 代替 `remove`/`delete`），禁止无意义单个字母或过度缩写。
+- 文件名与函数：名词在前、动词在后（如 `profileSet.js` 而非 `setProfile.js`）。函数命名尽量精炼动词，不带无意义的 `get` 前缀（如 `cookieByHeader` 而非 `getCookie`）。
+- 风格约定：
+  - 普通变量名：蛇形命名 `snake_case`（如 `user_auth_token`）；若变量为函数则使用小写驼峰 `camelCase`。
+  - 函数名：小写驼峰 `camelCase`。
+  - 回调函数参数：小写驼峰（如 `onChange`）。
+  - 模块级/全局常量：全大写下划线 `UPPER_SNAKE_CASE`（如 `DEFAULT_TIMEOUT`, `CODE_TO_ID`）。
+
+## 4. 模块化机制
+
+- 精准按需导入：严禁 `import * as x` 或直接导入庞大对象。
+- 导出规范：
+  - 禁止导出单一大对象，以函数、变量为粒度导出。
+  - 可变全局状态（如语言、用户信息）使用 `export let` 导出。
+  - 其余函数与常量合并使用单一 `export const` + 逗号声明。
+  - 单一功能文件使用 `export default`。
+
+## 5. 错误处理与浏览器兼容
+
+- 错误码常量化：避免使用字符串描述错误，统一用 `const` 声明数值错误码。
+- 结构化错误：需附带数据信息时使用 `[错误码, 数据项1, 数据项2]` 数组范式。
+- Web 标准兼容 API：
+  - 加解密强制使用原生 Web Crypto API (`crypto.subtle`)。
+  - 二进制处理统一使用 `Uint8Array`。

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 x-at-01
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,307 @@
+<div align="center">
+
+# Gemini Web API
+
+**OpenAI-compatible Gemini Web API reverse proxy running on Bun & Node.js.**
+**Automatically detects Chrome session cookies. Zero configuration required.**
+
+**兼容 OpenAI 格式的 Gemini Web 反向代理服务，支持 Bun 与 Node.js 双运行时。**
+**全自动探测本地 Chrome 凭据，无需任何手动配置，开箱即用。**
+
+<p>
+  <a href="#english">English</a> | <a href="#简体中文">简体中文</a>
+</p>
+
+</div>
+
+---
+
+<a id="english"></a>
+
+## English
+
+### Overview
+
+**`@8-/gemini-web-api`** is an ultra-lightweight reverse proxy that turns your Google Gemini Web session into a standard OpenAI-compatible API.
+
+**No configuration is needed**: It automatically discovers your existing Chrome / Brave / Edge browser session, retrieves the encryption key from the macOS Keychain, decrypts your Gemini session cookies, and starts serving OpenAI-compatible endpoints (`/v1/chat/completions`, `/v1/models`) instantly.
+
+### Key Highlights
+
+- **Zero Configuration**: As long as you are logged into [gemini.google.com](https://gemini.google.com) in Chrome (or Brave / Edge), the server automatically extracts and decrypts your tokens. No manual cookie copying or `.env` required!
+- **Dual Runtime Support**: Native ultra-high performance on **Bun** (`Bun.serve`) and seamless native support on **Node.js** (>= 22.5.0, via `node:sqlite` and Web Streams).
+- **Zero External Dependencies**: 100% built on standard Web APIs (`fetch`, `ReadableStream`, `crypto.subtle`) and built-in Node/Bun modules.
+- **OpenAI Drop-in Replacement**: Fully compatible with `/v1/chat/completions` and `/v1/models`. Works seamlessly with ChatGPT-Next-Web, LobeChat, Cherry Studio, OpenAI SDKs, etc.
+- **Reasoning & Thinking Models**: Full streaming support for `<think>` thoughts and `reasoning_content` deltas (compatible with DeepSeek/Gemini thinking UI renderers).
+- **Dynamic Model Discovery**: Automatically discovers available Gemini models (Flash, Pro, etc.) and capacity tiers directly from your web session.
+- **Image Proxy**: Built-in `/gemini-proxy/image` endpoint to safely render generated card images without CORS or anti-hotlinking issues.
+
+---
+
+### Installation
+
+Install globally using **Bun** or **npm**:
+
+```bash
+# Using Bun
+bun i -g @8-/gemini-web-api
+
+# Using npm
+npm i -g @8-/gemini-web-api
+```
+
+Or run instantly without installing:
+
+```bash
+# Using bunx
+bunx @8-/gemini-web-api
+
+# Using npx
+npx @8-/gemini-web-api
+```
+
+---
+
+### Usage
+
+#### 1. Start the Server
+
+Simply run:
+
+```bash
+gemini-web-api
+```
+
+The server will automatically:
+1. Detect your local Chrome / Brave / Edge cookies database.
+2. Read the encryption key from macOS Keychain.
+3. Decrypt your `__Secure-1PSID` and `__Secure-1PSIDTS` cookies.
+4. Discover available models from Gemini.
+5. Start listening on `http://0.0.0.0:7860`.
+
+#### 2. Optional Environment Variables
+
+If you want to customize the port, add an authentication key, or enable thinking mode, set environment variables inline or in a `.env` file:
+
+```bash
+# Example: Custom port, API key, and thinking mode
+PORT=8000 API_KEY=sk-mysecret ENABLE_THINKING=true gemini-web-api
+```
+
+| Variable | Default | Description |
+| :--- | :--- | :--- |
+| `PORT` | `7860` | Server listening port |
+| `HOST` | `0.0.0.0` | Server listening host |
+| `API_KEY` | *(empty)* | Optional Bearer API key for authorization |
+| `ENABLE_THINKING` | `false` | Enable reasoning thoughts (`<think>` blocks & `reasoning_content`) |
+| `SECURE_1PSID` | *(auto-detected)* | Manual override for `__Secure-1PSID` cookie (only needed if no browser is logged in) |
+| `SECURE_1PSIDTS` | *(auto-detected)* | Manual override for `__Secure-1PSIDTS` cookie |
+
+---
+
+### API Calling Examples
+
+#### Test with cURL (Streaming)
+
+```bash
+curl -N http://127.0.0.1:7860/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gemini-flash",
+    "messages": [
+      {"role": "user", "content": "Explain quantum computing in one sentence."}
+    ],
+    "stream": true
+  }'
+```
+
+#### Use with OpenAI Python SDK
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://127.0.0.1:7860/v1",
+    api_key="none"  # Any string if API_KEY is not set
+)
+
+response = client.chat.completions.create(
+    model="gemini-flash",
+    messages=[{"role": "user", "content": "Hello Gemini!"}],
+    stream=True
+)
+
+for chunk in response:
+    content = chunk.choices[0].delta.content or ""
+    print(content, end="", flush=True)
+```
+
+#### Use with OpenAI Node.js SDK
+
+```javascript
+import OpenAI from "openai";
+
+const openai = new OpenAI({
+  baseURL: "http://127.0.0.1:7860/v1",
+  apiKey: "none",
+});
+
+const stream = await openai.chat.completions.create({
+  model: "gemini-flash",
+  messages: [{ role: "user", content: "Tell me a joke." }],
+  stream: true,
+});
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk.choices[0]?.delta?.content || "");
+}
+```
+
+---
+
+<a id="简体中文"></a>
+
+## 简体中文
+
+### 项目简介
+
+**`@8-/gemini-web-api`** 是一个极简的 Google Gemini Web 转 OpenAI 标准接口反向代理服务。
+
+**无需繁琐配置**：只需在日常使用的 Chrome（或 Brave、Edge）浏览器中登录过 [gemini.google.com](https://gemini.google.com)，程序启动时即可全自动探测浏览器 Cookie 数据库，通过 macOS Keychain 提取密钥并自动解密登录凭据，立即开始提供兼容 OpenAI 的 `/v1/chat/completions` 与 `/v1/models` 接口！
+
+### 核心亮点
+
+- **开箱即用，零手动配置**：自动探测 Chrome / Brave / Edge 浏览器会话，全自动解密并获取登录令牌，彻底告别手动抓包复制 Cookie 的烦恼！
+- **Bun 与 Node.js 双运行时支持**：在 **Bun** 下使用原生 `Bun.serve` 极速响应；在 **Node.js** (>= 22.5.0) 下利用内置 `node:sqlite` 与原生 Web Streams 同样流畅运行。
+- **零第三方外部依赖**：纯基于 Web 标准接口（`fetch`、`ReadableStream`、`crypto.subtle`）与运行时内置标准模块构建。
+- **无缝替代 OpenAI 接口**：标准 `/v1/chat/completions` 与 `/v1/models` 路由，直接兼容 ChatGPT-Next-Web、LobeChat、Cherry Studio 以及各类 OpenAI SDK。
+- **深度思考与推理模式**：完整支持 `<think>` 思考标签与 SSE `reasoning_content` 流式字段传输，兼容各类思考过程前端渲染。
+- **动态模型列表发现**：启动时自动从 Gemini 网页端动态拉取已解锁的可用模型及配额层级。
+- **图片安全代理**：内置 `/gemini-proxy/image` 接口，解决 Google 生成图片防盗链和跨域展示问题。
+
+---
+
+### 安装方式
+
+通过 **Bun** 或 **npm** 全局安装：
+
+```bash
+# 使用 Bun 全局安装
+bun i -g @8-/gemini-web-api
+
+# 使用 npm 全局安装
+npm i -g @8-/gemini-web-api
+```
+
+或者无需安装，直接使用 `bunx` / `npx` 即开即用：
+
+```bash
+# 使用 bunx
+bunx @8-/gemini-web-api
+
+# 使用 npx
+npx @8-/gemini-web-api
+```
+
+---
+
+### 使用指南
+
+#### 1. 启动服务
+
+安装后直接在终端运行：
+
+```bash
+gemini-web-api
+```
+
+程序将全自动执行：
+1. 自动探测本地 Chrome、Brave、Edge 浏览器的 Cookie 存储路径；
+2. 自动从 macOS Keychain 安全读取加密密码并推导密钥；
+3. 解密 `__Secure-1PSID` 与 `__Secure-1PSIDTS` 凭据；
+4. 动态同步 Gemini 网页端模型配置；
+5. 在 `http://0.0.0.0:7860` 启动 OpenAI 兼容接口。
+
+#### 2. 可选环境变量配置
+
+如需自定义端口、设置访问密码或启用思考模式，可在命令行直接传入或在当前目录下创建 `.env` 文件：
+
+```bash
+# 示例：自定义端口 8000、密码及开启思考模式
+PORT=8000 API_KEY=sk-mysecret ENABLE_THINKING=true gemini-web-api
+```
+
+| 环境变量 | 默认值 | 说明 |
+| :--- | :--- | :--- |
+| `PORT` | `7860` | 服务的监听端口 |
+| `HOST` | `0.0.0.0` | 监听的主机地址 |
+| `API_KEY` | *(留空)* | 可选的 Bearer 访问密码鉴权 |
+| `ENABLE_THINKING` | `false` | 是否开启思考模式（输出 `<think>` 与 `reasoning_content`） |
+| `SECURE_1PSID` | *(自动探测)* | 手动指定 `__Secure-1PSID`（仅在未登录浏览器时需要） |
+| `SECURE_1PSIDTS` | *(自动探测)* | 手动指定 `__Secure-1PSIDTS` |
+
+---
+
+### 接口调用示例
+
+#### cURL 流式对话调用
+
+```bash
+curl -N http://127.0.0.1:7860/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gemini-flash",
+    "messages": [
+      {"role": "user", "content": "用一句话解释相对论"}
+    ],
+    "stream": true
+  }'
+```
+
+#### Python (OpenAI SDK)
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://127.0.0.1:7860/v1",
+    api_key="none"  # 未设置 API_KEY 时可填任意字符串
+)
+
+response = client.chat.completions.create(
+    model="gemini-flash",
+    messages=[{"role": "user", "content": "你好，Gemini！"}],
+    stream=True
+)
+
+for chunk in response:
+    content = chunk.choices[0].delta.content or ""
+    print(content, end="", flush=True)
+```
+
+#### Node.js (OpenAI SDK)
+
+```javascript
+import OpenAI from "openai";
+
+const openai = new OpenAI({
+  baseURL: "http://127.0.0.1:7860/v1",
+  apiKey: "none",
+});
+
+const stream = await openai.chat.completions.create({
+  model: "gemini-flash",
+  messages: [{ role: "user", content: "讲个笑话吧" }],
+  stream: true,
+});
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk.choices[0]?.delta?.content || "");
+}
+```
+
+---
+
+### 开源协议
+
+本项目采用 [MIT License](LICENSE) 授权。

package/index.js

@@ -0,0 +1,891 @@
+#!/usr/bin/env -S bun
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { Readable } from "node:stream";
+
+try {
+  process.loadEnvFile(join(import.meta.dirname, ".env"));
+} catch (err) {
+  if (err.code !== "ENOENT") throw err;
+}
+
+export const HOST = process.env.HOST ?? "0.0.0.0",
+  PORT = parseInt(process.env.PORT ?? "7860", 10),
+  API_KEY = process.env.API_KEY ?? "",
+  ENABLE_THINKING = process.env.ENABLE_THINKING === "true",
+  INIT_URL = "https://gemini.google.com/app",
+  GEN_URL =
+    "https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate",
+  BATCH_URL = "https://gemini.google.com/_/BardChatUi/data/batchexecute",
+  USER_AGENT =
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+  SALT = new TextEncoder().encode("saltysalt"),
+  IV = new Uint8Array(16).fill(32),
+  CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "*",
+  },
+  STATUS_OK = 200,
+  STATUS_NO_CONTENT = 204,
+  STATUS_BAD_REQUEST = 400,
+  STATUS_UNAUTHORIZED = 401,
+  STATUS_NOT_FOUND = 404,
+  STATUS_SERVER_ERR = 500,
+  ERR_MISSING_URL = 4001,
+  ERR_UNAUTHORIZED = 4011,
+  ERR_NOT_FOUND = 4041,
+  THINKING_LEVEL_DISABLED = 1,
+  THINKING_LEVEL_ENABLED = 2,
+  ROLE_ASSISTANT = "assistant",
+  STOP_REASON_STOP = "stop",
+  PAYLOAD_INNER_REQ_IDX = 0,
+  PAYLOAD_MODEL_HEADER_IDX = 1,
+  PAYLOAD_UUID_IDX = 2,
+  BROWSER_PATH_LI = [
+    {
+      db_path: join(homedir(), "Library/Application Support/Google/Chrome/Default/Cookies"),
+      account: "Chrome",
+      service: "Chrome Safe Storage",
+    },
+    {
+      db_path: join(homedir(), "Library/Application Support/Google/Chrome/Profile 1/Cookies"),
+      account: "Chrome",
+      service: "Chrome Safe Storage",
+    },
+    {
+      db_path: join(
+        homedir(),
+        "Library/Application Support/BraveSoftware/Brave-Browser/Default/Cookies",
+      ),
+      account: "Brave",
+      service: "Brave Safe Storage",
+    },
+    {
+      db_path: join(homedir(), "Library/Application Support/Microsoft Edge/Default/Cookies"),
+      account: "Microsoft Edge",
+      service: "Microsoft Edge Safe Storage",
+    },
+  ],
+  DEFAULT_MODEL_LI = [
+    {
+      id: "gemini-flash",
+      model_id: "56fdd199312815e2",
+      disp: "Flash",
+      cat: "Flash",
+      desc: "Default Flash",
+      num: 1,
+      capacity: 1,
+      alias_li: ["gemini-flash", "flash", "default"],
+    },
+    {
+      id: "gemini-pro",
+      model_id: "797f3d0293f288ad",
+      disp: "Pro",
+      cat: "Pro",
+      desc: "Default Pro",
+      num: 3,
+      capacity: 1,
+      alias_li: ["gemini-pro", "pro"],
+    },
+  ];
+
+export let session_state = {
+  cookie_header: "",
+  at: "",
+  bl: "",
+  fsid: "",
+  req_id: Math.floor(Math.random() * 90000) + 10000,
+  model_li: [],
+  default_model: null,
+};
+
+export const keychainPwdRead = (account, service) => {
+  const proc = spawnSync(
+    "/usr/bin/security",
+    ["-q", "find-generic-password", "-w", "-a", account, "-s", service],
+    { encoding: "utf8" },
+  );
+  return (proc.stdout ?? "").trim();
+},
+
+valDecrypt = async (enc_data, aes_key, has_integrity) => {
+  const data = enc_data.slice(3),
+    dec = await crypto.subtle.decrypt({ name: "AES-CBC", iv: IV }, aes_key, data);
+  let byte_li = new Uint8Array(dec);
+  if (has_integrity) byte_li = byte_li.slice(32);
+  return new TextDecoder().decode(byte_li);
+},
+
+cookieRead = async () => {
+  if (process.env.SECURE_1PSID && process.env.SECURE_1PSIDTS) {
+    return (
+      "__Secure-1PSID=" +
+      process.env.SECURE_1PSID +
+      "; __Secure-1PSIDTS=" +
+      process.env.SECURE_1PSIDTS
+    );
+  }
+  const target = BROWSER_PATH_LI.find((browser_cfg) => existsSync(browser_cfg.db_path));
+  if (!target) return "";
+  const pwd = keychainPwdRead(target.account, target.service),
+    key_mat = await crypto.subtle.importKey("raw", new TextEncoder().encode(pwd), "PBKDF2", false, [
+      "deriveKey",
+    ]),
+    aes_key = await crypto.subtle.deriveKey(
+      { name: "PBKDF2", salt: SALT, iterations: 1003, hash: "SHA-1" },
+      key_mat,
+      { name: "AES-CBC", length: 128 },
+      false,
+      ["decrypt"],
+    ),
+    db = new DatabaseSync(target.db_path, { readOnly: true }),
+    version_row = db.prepare("SELECT value FROM meta WHERE key = 'version'").get(),
+    has_integrity = parseInt(version_row?.value ?? "0", 10) >= 24,
+    row_li = db
+      .prepare(
+        "SELECT name, encrypted_value FROM cookies WHERE host_key LIKE '%google.com%' AND name IN ('__Secure-1PSID', '__Secure-1PSIDTS')",
+      )
+      .all(),
+    cookie_map = {};
+
+  for (const { name, encrypted_value } of row_li) {
+    if (encrypted_value && encrypted_value.length > 3) {
+      const val = await valDecrypt(encrypted_value, aes_key, has_integrity);
+      cookie_map[name] = val;
+    }
+  }
+  db.close();
+  return Object.entries(cookie_map)
+    .map(([cookie_name, cookie_val]) => cookie_name + "=" + cookie_val)
+    .join("; ");
+},
+
+versionCompare = (a_ver, b_ver) => {
+  const a_match = (a_ver ?? "").match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/),
+    b_match = (b_ver ?? "").match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/),
+    a_maj = a_match ? parseInt(a_match[1], 10) : 0,
+    a_min = a_match && a_match[2] ? parseInt(a_match[2], 10) : 0,
+    a_pat = a_match && a_match[3] ? parseInt(a_match[3], 10) : 0,
+    b_maj = b_match ? parseInt(b_match[1], 10) : 0,
+    b_min = b_match && b_match[2] ? parseInt(b_match[2], 10) : 0,
+    b_pat = b_match && b_match[3] ? parseInt(b_match[3], 10) : 0;
+  if (a_maj !== b_maj) return a_maj - b_maj;
+  if (a_min !== b_min) return a_min - b_min;
+  return a_pat - b_pat;
+},
+
+modelFetch = async (at, bl, fsid, cookie_header) => {
+  session_state.req_id += 1;
+  const session_id = crypto.randomUUID().toUpperCase(),
+    batch_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: cookie_header,
+      "x-goog-ext-525001261-jspb": JSON.stringify([
+        1,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        [4, 5, 6, 8],
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        session_id,
+      ]),
+      "x-goog-ext-73010989-jspb": "[0]",
+    },
+    payload = [[["otAQ7b", "[]", null, "generic"]]],
+    form_data = new URLSearchParams(),
+    batch_url = new URL(BATCH_URL),
+    discovered_li = [];
+
+  form_data.set("at", at);
+  form_data.set("f.req", JSON.stringify(payload));
+
+  batch_url.searchParams.set("rpcids", "otAQ7b");
+  batch_url.searchParams.set("hl", "en");
+  batch_url.searchParams.set("_reqid", String(session_state.req_id));
+  batch_url.searchParams.set("rt", "c");
+  batch_url.searchParams.set("source-path", "/app");
+  if (bl) batch_url.searchParams.set("bl", bl);
+  if (fsid) batch_url.searchParams.set("f.sid", fsid);
+
+  const res = await fetch(batch_url.toString(), {
+    method: "POST",
+    headers: batch_headers,
+    body: form_data.toString(),
+  });
+
+  const res_text = await res.text();
+  let clean_text = res_text;
+  if (clean_text.startsWith(")]}\x27")) clean_text = clean_text.slice(4).trimStart();
+  const match_res = clean_text.match(/^(\d+)\n/);
+  if (match_res) {
+    const chunk_len = parseInt(match_res[1], 10),
+      start_idx = match_res[1].length,
+      chunk_str = clean_text.slice(start_idx, start_idx + chunk_len).trim();
+    if (chunk_str.startsWith("[")) {
+      const part_li = JSON.parse(chunk_str);
+      for (const part of part_li) {
+        if (part[1] === "otAQ7b" && part[2]) {
+          const part_body = JSON.parse(part[2]),
+            model_li = part_body[15],
+            tier_flag_li = part_body[16] ?? [],
+            capability_flag_li = part_body[17] ?? [];
+          let cap = 1;
+          if (capability_flag_li.includes(115)) cap = 4;
+          else if (tier_flag_li.includes(16) || capability_flag_li.includes(106)) cap = 3;
+          else if (tier_flag_li.includes(8) || capability_flag_li.includes(19)) cap = 2;
+
+          for (const item of model_li ?? []) {
+            const id = item[0],
+              cat = String(item[1] ?? item[10] ?? ""),
+              disp = String(item[11] ?? item[19] ?? item[1] ?? ""),
+              desc = String(item[12] ?? item[2] ?? ""),
+              num =
+                typeof item[17] === "number" ? item[17] : typeof item[9] === "number" ? item[9] : 1,
+              disp_slug = disp.toLowerCase().replaceAll(/\s+/g, "-"),
+              cat_slug = cat.toLowerCase().replaceAll(/\s+/g, "-"),
+              primary_id = "gemini-" + disp_slug,
+              alias_li = [id.toLowerCase(), primary_id, "gemini-" + cat_slug, cat_slug, disp_slug];
+            discovered_li.push({
+              id: primary_id,
+              model_id: id,
+              disp,
+              cat,
+              desc,
+              num,
+              capacity: cap,
+              alias_li,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  const non_lite_li = discovered_li.filter(
+    (model_item) =>
+      !model_item.disp.toLowerCase().includes("lite") &&
+      !model_item.cat.toLowerCase().includes("lite") &&
+      !model_item.id.toLowerCase().includes("lite"),
+  );
+  non_lite_li.sort((a, b) => versionCompare(b.disp, a.disp));
+  session_state.default_model = non_lite_li[0] ?? discovered_li[0] ?? DEFAULT_MODEL_LI[0];
+  console.log(
+    "默认模型: " + session_state.default_model.disp + " (" + session_state.default_model.id + ")",
+  );
+
+  return discovered_li;
+},
+
+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,
+      );
+    }
+  } catch (err) {
+    console.warn("会话初始化异常:", err.message);
+  }
+  return session_state;
+},
+
+modelMap = (req_model) => {
+  const norm = (req_model ?? "").toLowerCase(),
+    available_li = session_state.model_li.length > 0 ? session_state.model_li : DEFAULT_MODEL_LI,
+    found = available_li.find(
+      (model_item) =>
+        model_item.id === norm ||
+        model_item.model_id === norm ||
+        model_item.alias_li.some((alias_item) => norm.includes(alias_item) || alias_item === norm),
+    );
+  return found ?? session_state.default_model ?? available_li[0];
+},
+
+conversationFormat = (msg_li) => {
+  let conversation = "";
+  for (const { role, content } of msg_li ?? []) {
+    const text_content = Array.isArray(content)
+      ? content
+          .filter((content_item) => content_item.type === "text")
+          .map((content_item) => content_item.text)
+          .join("")
+      : content ?? "";
+    if (role === "system") {
+      conversation += "System: " + text_content + "\n\n";
+    } else if (role === "user") {
+      conversation += "Human: " + text_content + "\n\n";
+    } else if (role === "assistant") {
+      conversation += "Assistant: " + text_content + "\n\n";
+    }
+  }
+  return conversation.trim();
+},
+
+payloadBuild = (prompt, model_info) => {
+  const session_id = crypto.randomUUID().toUpperCase(),
+    uuid_val = crypto.randomUUID().toUpperCase(),
+    thinking_level = ENABLE_THINKING ? THINKING_LEVEL_ENABLED : THINKING_LEVEL_DISABLED,
+    model_header = [
+      1,
+      null,
+      null,
+      null,
+      model_info.model_id,
+      null,
+      null,
+      0,
+      [4, 5, 6, 8],
+      null,
+      null,
+      model_info.capacity ?? 1,
+      null,
+      null,
+      model_info.num,
+      thinking_level,
+      session_id,
+    ],
+    inner_req = Array.from({ length: 81 }, () => null);
+  inner_req[0] = [prompt, 0, null, null, null, null, 0];
+  inner_req[1] = ["en"];
+  inner_req[2] = ["", "", "", null, null, null, null, null, null, ""];
+  inner_req[6] = [1];
+  inner_req[7] = 1;
+  inner_req[10] = 1;
+  inner_req[11] = 0;
+  inner_req[17] = [[0]];
+  inner_req[18] = 0;
+  inner_req[27] = 1;
+  inner_req[30] = [4];
+  inner_req[41] = [1];
+  inner_req[53] = 0;
+  inner_req[59] = uuid_val;
+  inner_req[61] = [];
+  inner_req[68] = 1;
+  inner_req[79] = model_info.num;
+  inner_req[80] = thinking_level;
+  return [inner_req, model_header, uuid_val];
+},
+
+streamChunkExtract = (buf) => {
+  let cur_buf = buf;
+  if (cur_buf.startsWith(")]}\x27")) {
+    cur_buf = cur_buf.slice(4).trimStart();
+  }
+  const extracted_li = [];
+  while (true) {
+    cur_buf = cur_buf.trimStart();
+    const match_res = cur_buf.match(/^(\d+)\n/);
+    if (!match_res) break;
+    const len_str = match_res[1],
+      chunk_len = parseInt(len_str, 10),
+      start_idx = len_str.length;
+    if (cur_buf.length < start_idx + chunk_len) break;
+    const chunk_str = cur_buf.slice(start_idx, start_idx + chunk_len).trim();
+    cur_buf = cur_buf.slice(start_idx + chunk_len);
+
+    if (chunk_str.startsWith("[")) {
+      const item_li = JSON.parse(chunk_str);
+      for (const item of item_li) {
+        if (Array.isArray(item) && item[2]) {
+          const inner = JSON.parse(item[2]),
+            cand_li = inner[4];
+          if (Array.isArray(cand_li) && cand_li.length > 0) {
+            const cand = cand_li[0],
+              thoughts = cand[37]?.[0]?.[0] ?? "",
+              raw_text = cand[1]?.[0] ?? "",
+              card_text = raw_text.startsWith("http://googleusercontent.com/card_content/")
+                ? (cand[22]?.[0] ?? raw_text)
+                : raw_text,
+              text = card_text.replaceAll(
+                /https?:\/\/googleusercontent\.com\/(?:\w+\/)+\d+\n*/g,
+                "",
+              );
+            extracted_li.push({ thoughts, text });
+          }
+        }
+      }
+    }
+  }
+  return [extracted_li, cur_buf];
+},
+
+sseStreamCreate = (body, completion_id, model, created_time) => {
+  const enc = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      const chunkSend = (delta, finish_reason = null) => {
+        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"));
+      };
+
+      chunkSend({ role: ROLE_ASSISTANT });
+
+      const reader = body.getReader(),
+        decoder = new TextDecoder();
+      let buf = "",
+        last_text = "",
+        last_thought = "",
+        thinking_started = false;
+
+      while (true) {
+        const read_res = await reader.read();
+        if (read_res.done) break;
+        buf += decoder.decode(read_res.value, { stream: true });
+
+        const [extracted_li, next_buf] = streamChunkExtract(buf);
+        buf = next_buf;
+
+        for (const { thoughts, text } of extracted_li) {
+          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 {
+              chunkSend({
+                content: thoughts,
+                reasoning_content: thoughts,
+              });
+              last_thought = thoughts;
+            }
+          }
+
+          if (text.startsWith(last_text)) {
+            const text_delta = text.slice(last_text.length);
+            if (text_delta) {
+              if (ENABLE_THINKING && thinking_started && !last_text) {
+                chunkSend({ content: "</think>\n\n" });
+              }
+              chunkSend({ content: text_delta });
+              last_text = text;
+            }
+          } else if (text) {
+            chunkSend({ content: text });
+            last_text = text;
+          }
+        }
+      }
+
+      if (ENABLE_THINKING && thinking_started && !last_text) {
+        chunkSend({ content: "</think>\n\n" });
+      }
+
+      chunkSend({}, STOP_REASON_STOP);
+      controller.enqueue(enc.encode("data: [DONE]\n\n"));
+      controller.close();
+      console.log(
+        "<-- [SSE 完成] 完整输出:\n" +
+          (last_thought ? "<think>\n" + last_thought + "\n</think>\n\n" : "") +
+          last_text,
+      );
+    },
+  });
+},
+
+fullResponseCollect = async (body) => {
+  const reader = body.getReader(),
+    decoder = new TextDecoder();
+  let buf = "",
+    final_text = "",
+    final_thought = "";
+
+  while (true) {
+    const read_res = await reader.read();
+    if (read_res.done) break;
+    buf += decoder.decode(read_res.value, { stream: true });
+
+    const [extracted_li, next_buf] = streamChunkExtract(buf);
+    buf = next_buf;
+
+    for (const { thoughts, text } of extracted_li) {
+      if (text) final_text = text;
+      if (thoughts) final_thought = thoughts;
+    }
+  }
+
+  let content = final_text;
+  if (ENABLE_THINKING && final_thought) {
+    content = "<think>\n" + final_thought + "\n</think>\n\n" + final_text;
+  }
+  return content;
+},
+
+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_body = JSON.stringify({
+    status: "healthy",
+    service: "Gemini API 代理 (Node/Bun)",
+    version: "1.0.0",
+    endpoints: ["/v1/models", "/v1/chat/completions"],
+  });
+  console.log("<-- 响应: [200 OK]", res_body);
+  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_body = JSON.stringify({ object: "list", data: model_data_li });
+  console.log("<-- 响应: [200 OK] 模型列表:", res_body);
+  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_body = JSON.stringify({
+      id: target_model.id,
+      object: "model",
+      created: now,
+      owned_by: "google-gemini-web",
+    });
+  console.log("<-- 响应: [200 OK] 模型详情:", res_body);
+  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_body = JSON.stringify({ code: ERR_UNAUTHORIZED, error: "未授权" });
+    console.log("<-- 响应: [401 Unauthorized]", res_body);
+    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),
+    conversation = conversationFormat(body.messages);
+
+  if (!session_state.at) {
+    await sessionInit();
+  }
+
+  session_state.req_id += 1;
+  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);
+    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 = await fullResponseCollect(gen_res.body),
+    prompt_tokens = conversation.split(/\s+/).length,
+    completion_tokens = full_content.split(/\s+/).length,
+    res_json = {
+      id: completion_id,
+      object: "chat.completion",
+      created: created_time,
+      model: model_info.id,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: ROLE_ASSISTANT,
+            content: full_content,
+          },
+          finish_reason: STOP_REASON_STOP,
+        },
+      ],
+      usage: {
+        prompt_tokens,
+        completion_tokens,
+        total_tokens: prompt_tokens + completion_tokens,
+      },
+    },
+    res_body = JSON.stringify(res_json);
+  console.log("<-- 响应: [200 OK]", res_body);
+  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("--> 请求体:", 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_body = JSON.stringify({
+    code: ERR_NOT_FOUND,
+    error: "未找到接口",
+    path: pathname,
+    method: req.method,
+  });
+  console.log("<-- 响应: [404 Not Found] 未找到接口: " + req.method + " " + pathname);
+  return new Response(res_body, {
+    status: STATUS_NOT_FOUND,
+    headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+  });
+},
+
+serverStart = () => {
+  if (typeof Bun !== "undefined" && Bun.serve) {
+    const bun_server = Bun.serve({
+      port: PORT,
+      hostname: HOST,
+      fetch: reqHandle,
+    });
+    console.log("服务运行在 (Bun) http://" + HOST + ":" + PORT);
+    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 reqHandle(web_req);
+
+      node_res.statusCode = web_res.status;
+      for (const [header_key, header_val] of web_res.headers.entries()) {
+        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, () => {
+    console.log("服务运行在 (Node) http://" + HOST + ":" + PORT);
+  });
+  return node_server;
+};
+
+await sessionInit();
+
+const server = serverStart();
+
+export default server;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@8-/gemini-web-api",
+  "version": "1.0.0",
+  "description": "OpenAI-compatible Gemini Web API reverse proxy running seamlessly on both Bun and Node.js with zero external dependencies.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "gemini-web-api": "./index.js"
+  },
+  "scripts": {
+    "start": "bun index.js",
+    "start:node": "node index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/x-at-01/gemini-web-api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/x-at-01/gemini-web-api/issues"
+  },
+  "homepage": "https://github.com/x-at-01/gemini-web-api#readme",
+  "keywords": [
+    "gemini",
+    "gemini-web-api",
+    "openai",
+    "openai-compatible",
+    "reverse-proxy",
+    "bun",
+    "node",
+    "llm",
+    "sse",
+    "streaming"
+  ],
+  "license": "MIT"
+}