Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+a+b.png filter=lfs diff=lfs merge=lfs -text
+a.png filter=lfs diff=lfs merge=lfs -text
+b.png filter=lfs diff=lfs merge=lfs -text
+image.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,17 @@
+# Local config / secrets
+config_data.json
+*.local.json
+*.secret
+.env
+.env.*
+
+# Runtime logs
+api_logs.json
+*.log
+
+# Python cache
+__pycache__/
+*.py[cod]
+
+# Local media cache
+media_cache/

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# Ensure media_cache directory exists and is writable
+RUN mkdir -p media_cache && chmod 777 media_cache
+
+# Ensure config_data.json exists or is writable
+# HF Spaces use a non-root user, so we need to make sure the app directory is writable
+RUN chmod -R 777 /app
+
+ENV PORT=7860
+ENV PYTHONUNBUFFERED=1
+
+EXPOSE 7860
+
+CMD ["python", "server.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 erxiansheng
+
+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.

README.md

@@ -1,10 +1,198 @@
----
-title: Gemini Open Relay
-emoji: 🚀
-colorFrom: purple
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Gemini Web 转 OpenAI API
+
+基于 Gemini 网页版的逆向工程，提供 OpenAI 兼容 API 服务。
+
+## ✨ 功能特性
+
+- ✅ 文本对话 & 多轮对话
+- ✅ 图片识别（支持 base64 和 URL）
+- ✅ 多图片支持
+- ✅ 图片生成（自动下载高清无水印原图）
+- ✅ 视频生成（异步，需到官网查看）
+- ✅ Token 自动刷新（后台定时刷新，防止失效）
+- ✅ Tools / Function Calling 支持
+- ✅ OpenAI SDK 完全兼容
+- ✅ Web 后台配置界面
+
+## 🚀 快速开始
+
+### 1. 安装依赖
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. 启动服务
+
+```bash
+python server.py
+```
+
+### 3. 配置 Cookie
+
+1. 打开后台 `http://localhost:8000/admin`（账号: admin / admin123）
+2. 登录 [Gemini](https://gemini.google.com)，F12 → Network → 复制请求头中的 Cookie
+3. 粘贴到后台配置页面，保存即可
+
+Cookie 获取示例：
+
+![Cookie获取示例](image.png)
+
+### 4. 调用 API
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:8000/v1",
+    api_key="sk-geminixxxxx"
+)
+
+response = client.chat.completions.create(
+    model="gemini-3.0-flash",
+    messages=[{"role": "user", "content": "你好"}]
+)
+print(response.choices[0].message.content)
+```
+
+## 📡 API 信息
+
+| 项目 | 值 |
+|------|-----|
+| Base URL | `http://localhost:8000/v1` |
+| API Key | `sk-geminixxxxx` |
+| 后台地址 | `http://localhost:8000/admin` |
+
+### 可用模型
+
+- `gemini-3.0-flash` - 快速响应
+- `gemini-3.0-flash-thinking` - 思考模式
+- `gemini-3.0-pro` - 专业版
+
+## 💬 使用示例
+
+### 文本对话
+
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="sk-geminixxxxx")
+
+response = client.chat.completions.create(
+    model="gemini-3.0-flash",
+    messages=[{"role": "user", "content": "你好，介绍一下你自己"}]
+)
+print(response.choices[0].message.content)
+```
+
+### 单图片识别
+
+```python
+import base64
+from openai import OpenAI
+
+client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="sk-geminixxxxx")
+
+def load_image_base64(path):
+    with open(path, "rb") as f:
+        return base64.b64encode(f.read()).decode()
+
+img_b64 = load_image_base64("image.png")
+
+response = client.chat.completions.create(
+    model="gemini-3.0-flash",
+    messages=[{
+        "role": "user",
+        "content": [
+            {"type": "text", "text": "描述这张图片"},
+            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img_b64}"}}
+        ]
+    }]
+)
+print(response.choices[0].message.content)
+```
+
+### 多图片问答
+
+![多图问答示意](a+b.png)
+
+```python
+import base64
+from openai import OpenAI
+
+client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="sk-geminixxxxx")
+
+def load_image_base64(path):
+    with open(path, "rb") as f:
+        return base64.b64encode(f.read()).decode()
+
+img1_b64 = load_image_base64("a.png")
+img2_b64 = load_image_base64("b.png")
+
+response = client.chat.completions.create(
+    model="gemini-3.0-pro",
+    messages=[{
+        "role": "user",
+        "content": [
+            {"type": "text", "text": "把科比手里的烤串换成另外一张图的枪,多生成几张"},
+            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img1_b64}"}},
+            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img2_b64}"}},
+        ]
+    }]
+)
+print(response.choices[0].message.content)
+```
+
+### 图片生成
+
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="sk-geminixxxxx")
+
+response = client.chat.completions.create(
+    model="gemini-3.0-pro",
+    messages=[{"role": "user", "content": "生成一张可爱的猫咪图片"}]
+)
+print(response.choices[0].message.content)
+```
+
+## 🔧 Token 管理
+
+后台页面左上角显示 Token 状态和刷新次数。
+
+API 端点：
+- `GET /v1/token/status` - 查看状态
+- `POST /v1/token/refresh` - 手动刷新
+- `POST /v1/client/reset` - 重置客户端
+
+## ⚙️ 配置说明
+
+编辑 `server.py` 顶部：
+
+```python
+API_KEY = "sk-geminixxxxx"           # API 密钥
+PORT = 8000                           # 端口
+ADMIN_USERNAME = "admin"              # 后台账号
+ADMIN_PASSWORD = "admin123"           # 后台密码
+TOKEN_REFRESH_INTERVAL_MIN = 200      # 刷新间隔最小秒数
+TOKEN_REFRESH_INTERVAL_MAX = 300      # 刷新间隔最大秒数
+MEDIA_BASE_URL = ""                   # 媒体外网地址，如 https://your-domain.com
+```
+
+## 📁 文件说��
+
+| 文件/文件夹 | 说明 |
+|-------------|------|
+| `server.py` | API 服务 + Web 后台 |
+| `client.py` | Gemini 逆向客户端 |
+| `demo_chat.py` | 完整调用示例（文本/单图/多图/生成） |
+| `media_cache/` | AI 返回图片的中转缓存文件夹 |
+| `image.png` | Cookie 获取示例图 |
+| `a.png` / `b.png` | 多图问答示意图 |
+| `requirements.txt` | Python 依赖 |
+| `config_data.json` | 运行时配置（自动生成） |
+
+## 📄 License
+
+MIT

api.py

@@ -0,0 +1,206 @@
+"""
+Gemini OpenAI 兼容 API
+
+提供与 OpenAI SDK 完全兼容的接口，可直接替换 openai 库使用
+
+使用方法:
+    from api import GeminiOpenAI
+    
+    client = GeminiOpenAI()
+    response = client.chat.completions.create(
+        model="gemini",
+        messages=[{"role": "user", "content": "你好"}]
+    )
+    print(response.choices[0].message.content)
+"""
+
+from client import GeminiClient, ChatCompletionResponse, Message, ChatCompletionChoice, Usage
+from config import SECURE_1PSID, SNLM0E, COOKIES_STR, PUSH_ID
+from typing import List, Dict, Any, Optional, Union
+import base64
+import time
+
+
+class GeminiOpenAI:
+    """
+    OpenAI SDK 兼容的 Gemini 客户端
+    
+    用法与 openai.OpenAI() 完全一致
+    """
+    
+    def __init__(
+        self,
+        cookies_str: str = None,
+        snlm0e: str = None,
+        push_id: str = None,
+        secure_1psid: str = None,
+    ):
+        """
+        初始化客户端
+        
+        Args:
+            cookies_str: 完整 cookie 字符串（推荐，图片功能必需）
+            snlm0e: AT Token（必填）
+            push_id: 图片上传 ID（图片功能必需）
+            secure_1psid: __Secure-1PSID cookie（如果不用 cookies_str）
+        """
+        self._client = GeminiClient(
+            secure_1psid=secure_1psid or SECURE_1PSID,
+            snlm0e=snlm0e or SNLM0E,
+            cookies_str=cookies_str or COOKIES_STR,
+            push_id=push_id or PUSH_ID,
+            debug=False,
+        )
+        self.chat = self._Chat(self._client)
+    
+    class _Chat:
+        def __init__(self, client: GeminiClient):
+            self._client = client
+            self.completions = self._Completions(client)
+        
+        class _Completions:
+            def __init__(self, client: GeminiClient):
+                self._client = client
+            
+            def create(
+                self,
+                model: str = "gemini",
+                messages: List[Dict[str, Any]] = None,
+                stream: bool = False,
+                **kwargs
+            ) -> ChatCompletionResponse:
+                """
+                创建聊天完成
+                
+                Args:
+                    model: 模型名称（忽略，始终使用 Gemini）
+                    messages: OpenAI 格式消息列表
+                    stream: 是否流式输出（暂不支持）
+                    **kwargs: 其他参数（忽略）
+                
+                Returns:
+                    ChatCompletionResponse: OpenAI 格式响应
+                
+                Example:
+                    # 纯文本
+                    response = client.chat.completions.create(
+                        model="gemini",
+                        messages=[{"role": "user", "content": "你好"}]
+                    )
+                    
+                    # 带图片
+                    response = client.chat.completions.create(
+                        model="gemini",
+                        messages=[{
+                            "role": "user",
+                            "content": [
+                                {"type": "text", "text": "这是什么？"},
+                                {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}}
+                            ]
+                        }]
+                    )
+                """
+                if stream:
+                    raise NotImplementedError("流式输出暂不支持")
+                
+                return self._client.chat(messages=messages)
+    
+    def reset(self):
+        """重置会话上下文"""
+        self._client.reset()
+    
+    def get_history(self) -> List[Dict]:
+        """获取消息历史"""
+        return self._client.get_history()
+
+
+# 便捷函数
+def create_client(
+    cookies_str: str = None,
+    snlm0e: str = None,
+    push_id: str = None,
+) -> GeminiOpenAI:
+    """
+    创建 Gemini 客户端（OpenAI 兼容）
+    
+    Args:
+        cookies_str: 完整 cookie 字符串
+        snlm0e: AT Token
+        push_id: 图片上传 ID
+    
+    Returns:
+        GeminiOpenAI: OpenAI 兼容客户端
+    """
+    return GeminiOpenAI(
+        cookies_str=cookies_str,
+        snlm0e=snlm0e,
+        push_id=push_id,
+    )
+
+
+def chat(
+    message: str,
+    image: bytes = None,
+    image_path: str = None,
+    reset: bool = False,
+) -> str:
+    """
+    快速聊天函数（单例模式）
+    
+    Args:
+        message: 消息文本
+        image: 图片二进制数据
+        image_path: 图片文件路径
+        reset: 是否重置上下文
+    
+    Returns:
+        str: AI 回复文本
+    
+    Example:
+        from api import chat
+        
+        # 纯文本
+        reply = chat("你好")
+        
+        # 带图片
+        reply = chat("这是什么？", image_path="photo.jpg")
+        
+        # 重置上下文
+        reply = chat("新话题", reset=True)
+    """
+    global _default_client
+    
+    if '_default_client' not in globals() or _default_client is None:
+        _default_client = GeminiOpenAI()
+    
+    if reset:
+        _default_client.reset()
+    
+    # 处理图片
+    img_data = None
+    if image:
+        img_data = image
+    elif image_path:
+        with open(image_path, 'rb') as f:
+            img_data = f.read()
+    
+    # 构建消息
+    if img_data:
+        messages = [{
+            "role": "user",
+            "content": [
+                {"type": "text", "text": message},
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/jpeg;base64,{base64.b64encode(img_data).decode()}"}
+                }
+            ]
+        }]
+    else:
+        messages = [{"role": "user", "content": message}]
+    
+    response = _default_client.chat.completions.create(messages=messages)
+    return response.choices[0].message.content
+
+
+_default_client: GeminiOpenAI = None

client.py

@@ -0,0 +1,1583 @@
+"""
+Gemini Web Reverse Engineering Client
+支持图文请求、上下文对话，OpenAI 格式输入输出
+手动配置 token，无需代码登录
+"""
+
+import re
+import json
+import random
+import string
+import base64
+import uuid
+import codecs
+import httpx
+from typing import Optional, List, Dict, Any, Union, Iterator
+from dataclasses import dataclass, field
+from datetime import datetime
+import time
+
+
+class CookieExpiredError(Exception):
+    """Cookie 过期或无效异常"""
+    pass
+
+
+class ImageUploadError(Exception):
+    """图片上传失败异常"""
+    pass
+
+
+@dataclass
+class Message:
+    """OpenAI 格式消息"""
+    role: str
+    content: Union[str, List[Dict[str, Any]]]
+
+
+@dataclass
+class ChatCompletionChoice:
+    index: int
+    message: Message
+    finish_reason: str = "stop"
+
+
+@dataclass
+class Usage:
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+
+@dataclass
+class ChatCompletionResponse:
+    """OpenAI 格式响应"""
+    id: str
+    object: str = "chat.completion"
+    created: int = 0
+    model: str = "gemini-web"
+    choices: List[ChatCompletionChoice] = field(default_factory=list)
+    usage: Usage = field(default_factory=Usage)
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "object": self.object,
+            "created": self.created,
+            "model": self.model,
+            "choices": [
+                {
+                    "index": c.index,
+                    "message": {"role": c.message.role, "content": c.message.content},
+                    "finish_reason": c.finish_reason
+                }
+                for c in self.choices
+            ],
+            "usage": {
+                "prompt_tokens": self.usage.prompt_tokens,
+                "completion_tokens": self.usage.completion_tokens,
+                "total_tokens": self.usage.total_tokens
+            }
+        }
+
+
+class GeminiClient:
+    """
+    Gemini 网页版逆向客户端
+    
+    使用方法:
+    1. 打开 https://gemini.google.com 并登录
+    2. F12 打开开发者工具 -> Application -> Cookies
+    3. 复制以下 cookie 值:
+       - __Secure-1PSID
+       - __Secure-1PSIDTS (可选)
+    4. Network 标签 -> 找任意请求 -> 复制 SNlM0e 值 (在页面源码中搜索)
+    """
+    
+    BASE_URL = "https://gemini.google.com"
+    
+    def __init__(
+        self,
+        secure_1psid: str,
+        secure_1psidts: str = None,
+        secure_1psidcc: str = None,
+        snlm0e: str = None,
+        bl: str = None,
+        cookies_str: str = None,
+        push_id: str = None,
+        model_ids: dict = None,
+        debug: bool = False,
+        media_base_url: str = None,
+    ):
+        """
+        初始化客户端 - 手动填写 token
+        
+        Args:
+            secure_1psid: __Secure-1PSID cookie (必填)
+            secure_1psidts: __Secure-1PSIDTS cookie (推荐)
+            secure_1psidcc: __Secure-1PSIDCC cookie (推荐)
+            snlm0e: SNlM0e token (必填，从页面源码获取)
+            bl: BL 版本号 (可选，自动获取)
+            cookies_str: 完整 cookie 字符串 (可选，替代单独设置)
+            push_id: Push ID for image upload (必填用于图片上传)
+            model_ids: 模型 ID 映射 {"flash": "xxx", "pro": "xxx", "thinking": "xxx"}
+            debug: 是否打印调试信息
+            media_base_url: 媒体文件的基础 URL (如 http://localhost:8000)，用于构建完整的媒体访问 URL
+        """
+        self.secure_1psid = secure_1psid
+        self.secure_1psidts = secure_1psidts
+        self.secure_1psidcc = secure_1psidcc
+        self.snlm0e = snlm0e
+        self.bl = bl
+        self.push_id = push_id
+        self.debug = debug
+        self.media_base_url = media_base_url or ""
+        
+        # 模型 ID 映射 (用于请求头选择模型)
+        self.model_ids = model_ids or {
+            "flash": "56fdd199312815e2",
+            "pro": "e6fa609c3fa255c0",
+            "thinking": "e051ce1aa80aa576",
+        }
+        
+        self.session = httpx.Client(
+            timeout=1220.0,
+            follow_redirects=True,
+            headers={
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+                "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+                "Origin": self.BASE_URL,
+                "Referer": f"{self.BASE_URL}/",
+                "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+            },
+        )
+        
+        # 设置 cookies
+        if cookies_str:
+            self._set_cookies_from_string(cookies_str)
+        else:
+            self.session.cookies.set("__Secure-1PSID", secure_1psid, domain=".google.com")
+            if secure_1psidts:
+                self.session.cookies.set("__Secure-1PSIDTS", secure_1psidts, domain=".google.com")
+            if secure_1psidcc:
+                self.session.cookies.set("__Secure-1PSIDCC", secure_1psidcc, domain=".google.com")
+        
+        # 会话上下文
+        self.conversation_id: str = ""
+        self.response_id: str = ""
+        self.choice_id: str = ""
+        self.request_count: int = 0
+        
+        # 消息历史
+        self.messages: List[Message] = []
+        
+        # 验证必填参数
+        if not self.snlm0e:
+            raise ValueError(
+                "SNlM0e 是必填参数！\n"
+                "获取方法:\n"
+                "1. 打开 https://gemini.google.com 并登录\n"
+                "2. F12 -> 查看页面源代码 (Ctrl+U)\n"
+                "3. 搜索 'SNlM0e' 找到类似: \"SNlM0e\":\"xxxxxx\"\n"
+                "4. 复制引号内的值"
+            )
+        
+        # 自动获取 bl
+        if not self.bl:
+            self._fetch_bl()
+    
+    def _set_cookies_from_string(self, cookies_str: str):
+        """从完整 cookie 字符串解析"""
+        for item in cookies_str.split(";"):
+            item = item.strip()
+            if "=" in item:
+                key, value = item.split("=", 1)
+                self.session.cookies.set(key.strip(), value.strip(), domain=".google.com")
+    
+    def _fetch_bl(self):
+        """获取 BL 版本号"""
+        try:
+            resp = self.session.get(self.BASE_URL)
+            match = re.search(r'"cfb2h":"([^"]+)"', resp.text)
+            if match:
+                self.bl = match.group(1)
+            else:
+                # 使用默认值
+                self.bl = "boq_assistant-bard-web-server_20241209.00_p0"
+            if self.debug:
+                print(f"[DEBUG] BL: {self.bl}")
+        except Exception as e:
+            self.bl = "boq_assistant-bard-web-server_20241209.00_p0"
+            if self.debug:
+                print(f"[DEBUG] 获取 BL 失败，使用默认值: {e}")
+
+    def refresh_tokens(self) -> dict:
+        """
+        刷新 token (SNlM0e 和 push_id)
+        
+        Returns:
+            dict: {"success": bool, "snlm0e": str, "push_id": str, "error": str}
+        """
+        result = {"success": False, "snlm0e": "", "push_id": "", "error": ""}
+        
+        try:
+            if self.debug:
+                print("[DEBUG] 开始刷新 token...")
+            
+            # 访问 Gemini 首页刷新 session
+            resp = self.session.get(self.BASE_URL)
+            
+            if resp.status_code != 200:
+                result["error"] = f"访问 Gemini 失败: HTTP {resp.status_code}"
+                return result
+            
+            html = resp.text
+            
+            # 提取新的 SNlM0e
+            snlm0e_patterns = [
+                r'"SNlM0e":"([^"]+)"',
+                r'SNlM0e["\s:]+["\']([^"\']+)["\']',
+                r'"at":"([^"]+)"',
+            ]
+            new_snlm0e = ""
+            for pattern in snlm0e_patterns:
+                match = re.search(pattern, html)
+                if match:
+                    new_snlm0e = match.group(1)
+                    break
+            
+            if new_snlm0e:
+                self.snlm0e = new_snlm0e
+                result["snlm0e"] = new_snlm0e
+                if self.debug:
+                    print(f"[DEBUG] SNlM0e 已刷新: {new_snlm0e[:30]}...")
+            
+            # 提取新的 push_id
+            push_id_patterns = [
+                r'"push[_-]?id["\s:]+["\'](feeds/[a-z0-9]+)["\']',
+                r'push[_-]?id["\s:=]+["\'](feeds/[a-z0-9]+)["\']',
+                r'feedName["\s:]+["\'](feeds/[a-z0-9]+)["\']',
+                r'clientId["\s:]+["\'](feeds/[a-z0-9]+)["\']',
+                r'(feeds/[a-z0-9]{14,})',
+            ]
+            new_push_id = ""
+            for pattern in push_id_patterns:
+                matches = re.findall(pattern, html, re.IGNORECASE)
+                if matches:
+                    new_push_id = matches[0]
+                    break
+            
+            if new_push_id:
+                self.push_id = new_push_id
+                result["push_id"] = new_push_id
+                if self.debug:
+                    print(f"[DEBUG] push_id 已刷新: {new_push_id}")
+            
+            # 同时刷新 BL
+            match = re.search(r'"cfb2h":"([^"]+)"', html)
+            if match:
+                self.bl = match.group(1)
+            
+            result["success"] = bool(new_snlm0e)
+            if not new_snlm0e:
+                result["error"] = "无法从页面提取 SNlM0e，Cookie 可能已完全失效"
+            
+            return result
+            
+        except Exception as e:
+            result["error"] = f"刷新 token 失败: {str(e)}"
+            if self.debug:
+                print(f"[DEBUG] 刷新失败: {e}")
+            return result
+
+    def check_token_valid(self) -> bool:
+        """
+        检查当前 token 是否有效
+        
+        Returns:
+            bool: True 表示有效，False 表示需要刷新
+        """
+        try:
+            resp = self.session.get(self.BASE_URL, timeout=10.0)
+            if resp.status_code != 200:
+                return False
+            
+            # 检查页面是否包含登录状态标识
+            if 'SNlM0e' not in resp.text:
+                return False
+            
+            return True
+        except Exception:
+            return False
+
+    
+    def _parse_content(self, content: Union[str, List[Dict]]) -> tuple:
+        """解析 OpenAI 格式 content，返回 (text, images)"""
+        if isinstance(content, str):
+            return content, []
+        
+        text_parts = []
+        images = []
+        
+        for item in content:
+            if item.get("type") == "text":
+                text_parts.append(item.get("text", ""))
+            elif item.get("type") == "image_url":
+                # 支持两种格式: {"url": "..."} 或直接字符串
+                image_url_data = item.get("image_url", {})
+                if isinstance(image_url_data, str):
+                    url = image_url_data
+                else:
+                    url = image_url_data.get("url", "")
+                
+                if not url:
+                    continue
+                    
+                if url.startswith("data:"):
+                    # base64 格式: data:image/png;base64,xxxxx
+                    match = re.match(r'data:([^;]+);base64,(.+)', url)
+                    if match:
+                        images.append({"mime_type": match.group(1), "data": match.group(2)})
+                elif url.startswith("http://") or url.startswith("https://"):
+                    # URL 格式，下载图片
+                    try:
+                        if self.debug:
+                            print(f"[DEBUG] 尝试下载图片 URL: {url[:100]}...")
+                        resp = httpx.get(url, timeout=30, follow_redirects=True)
+                        if resp.status_code == 200:
+                            mime = resp.headers.get("content-type", "image/jpeg").split(";")[0]
+                            images.append({"mime_type": mime, "data": base64.b64encode(resp.content).decode()})
+                            if self.debug:
+                                print(f"[DEBUG] 图片下载成功: {len(resp.content)} bytes, mime: {mime}")
+                        else:
+                            if self.debug:
+                                print(f"[DEBUG] 图片下载失败: HTTP {resp.status_code}")
+                    except Exception as e:
+                        if self.debug:
+                            print(f"[DEBUG] 下载图片失败: {e}")
+                else:
+                    # 可能是纯 base64 字符串 (没有 data: 前缀)
+                    try:
+                        # 尝试解码验证是否是有效 base64
+                        base64.b64decode(url[:100])  # 只验证前100字符
+                        images.append({"mime_type": "image/png", "data": url})
+                        if self.debug:
+                            print(f"[DEBUG] 检测到纯 base64 图片数据")
+                    except:
+                        if self.debug:
+                            print(f"[DEBUG] 无法识别的图片格式: {url[:50]}...")
+        
+        return " ".join(text_parts) if text_parts else "", images
+    
+    def _upload_image(self, image_data: bytes, mime_type: str = "image/jpeg") -> str:
+        """
+        上传图片到 Gemini 服务器
+        
+        Args:
+            image_data: 图片二进制数据
+            mime_type: 图片 MIME 类型
+            
+        Returns:
+            str: 上传后的图片路径（带 token）
+        """
+        if not self.push_id:
+            raise CookieExpiredError(
+                "图片上传需要 push_id\n"
+                "获取方法: 运行 python get_push_id.py 或从浏览器 Network 中获取"
+            )
+        
+        try:
+            upload_url = "https://push.clients6.google.com/upload/"
+            filename = f"image_{random.randint(100000, 999999)}.png"
+            
+            # 浏览器必需的头
+            browser_headers = {
+                "accept": "*/*",
+                "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
+                "origin": "https://gemini.google.com",
+                "referer": "https://gemini.google.com/",
+                "sec-fetch-dest": "empty",
+                "sec-fetch-mode": "cors",
+                "sec-fetch-site": "same-site",
+                "x-browser-channel": "stable",
+                "x-browser-copyright": "Copyright 2025 Google LLC. All Rights reserved.",
+                "x-browser-validation": "Aj9fzfu+SaGLBY9Oqr3S7RokOtM=",
+                "x-browser-year": "2025",
+                "x-client-data": "CIa2yQEIpbbJAQipncoBCNvaygEIk6HLAQiFoM0BCJaMzwEIkZHPAQiSpM8BGOyFzwEYsobPAQ==",
+            }
+            
+            # 第一步：获取 upload_id
+            init_headers = {
+                **browser_headers,
+                "content-type": "application/x-www-form-urlencoded;charset=utf-8",
+                "push-id": self.push_id,
+                "x-goog-upload-command": "start",
+                "x-goog-upload-header-content-length": str(len(image_data)),
+                "x-goog-upload-protocol": "resumable",
+                "x-tenant-id": "bard-storage",
+            }
+            
+            init_resp = self.session.post(upload_url, data={"File name": filename}, headers=init_headers)
+            
+            if self.debug:
+                print(f"[DEBUG] 初始化上传状态: {init_resp.status_code}")
+            
+            # 检查初始化响应状态
+            if init_resp.status_code == 401 or init_resp.status_code == 403:
+                raise CookieExpiredError(
+                    f"Cookie 已过期或无效 (HTTP {init_resp.status_code})\n"
+                    "请重新获取以下信息:\n"
+                    "1. __Secure-1PSID\n"
+                    "2. __Secure-1PSIDTS\n"
+                    "3. SNlM0e\n"
+                    "4. push_id"
+                )
+            
+            upload_id = init_resp.headers.get("x-guploader-uploadid")
+            if not upload_id:
+                raise CookieExpiredError(
+                    f"未获取到 upload_id (状态码: {init_resp.status_code})\n"
+                    "可能原因: Cookie 已过期，请重新获取所有 token"
+                )
+            
+            if self.debug:
+                print(f"[DEBUG] Upload ID: {upload_id[:50]}...")
+            
+            # 第二步：上传图片数据
+            final_upload_url = f"{upload_url}?upload_id={upload_id}&upload_protocol=resumable"
+            
+            upload_headers = {
+                **browser_headers,
+                "content-type": "application/x-www-form-urlencoded;charset=utf-8",
+                "push-id": self.push_id,
+                "x-goog-upload-command": "upload, finalize",
+                "x-goog-upload-offset": "0",
+                "x-tenant-id": "bard-storage",
+                "x-client-pctx": "CgcSBWjK7pYx",
+            }
+            
+            upload_resp = self.session.post(
+                final_upload_url,
+                headers=upload_headers,
+                content=image_data
+            )
+            
+            if self.debug:
+                print(f"[DEBUG] 上传数据状态: {upload_resp.status_code}")
+                print(f"[DEBUG] 响应头: {dict(upload_resp.headers)}")
+                print(f"[DEBUG] 响应内容完整: {upload_resp.text}")
+            
+            # 检查上传响应状态
+            if upload_resp.status_code == 401 or upload_resp.status_code == 403:
+                raise CookieExpiredError(
+                    f"上传图片认证失败 (HTTP {upload_resp.status_code})\n"
+                    "Cookie 已过期，请重新获取"
+                )
+            
+            if upload_resp.status_code != 200:
+                raise Exception(f"上传图片数据失败: {upload_resp.status_code}, 响应: {upload_resp.text[:200] if upload_resp.text else '(empty)'}")
+            
+            # 从响应中提取图片路径
+            response_text = upload_resp.text
+            image_path = None
+            
+            # 尝试解析 JSON
+            try:
+                response_json = json.loads(response_text)
+                image_path = self._extract_image_path(response_json)
+            except json.JSONDecodeError:
+                # 如果不是 JSON，尝试从文本中提取路径
+                match = re.search(r'/contrib_service/[^\s"\']+', response_text)
+                if match:
+                    image_path = match.group(0)
+            
+            # 验证图片路径完整性
+            if not image_path:
+                raise CookieExpiredError(
+                    f"无法从响应中提取图片路径\n"
+                    f"响应内容: {response_text[:300]}\n"
+                    "可能原因: Cookie 已过期，请重新获取所有 token"
+                )
+            
+            # 检查路径是否有效（长度足够即可，新版可能不带查询参数）
+            if "/contrib_service/" in image_path:
+                # 路径长度至少要有一定长度才是有效的
+                if len(image_path) < 40:
+                    raise CookieExpiredError(
+                        f"图片路径不完整\n"
+                        f"返回路径: {image_path}\n"
+                        "原因: Cookie 已过期或权限不足\n"
+                        "解决方法:\n"
+                        "1. 重新登录 https://gemini.google.com\n"
+                        "2. 更新 config.py 中的所有 token:\n"
+                        "   - SECURE_1PSID\n"
+                        "   - SECURE_1PSIDTS\n"
+                        "   - SNLM0E\n"
+                        "   - PUSH_ID"
+                    )
+            
+            if self.debug:
+                print(f"[DEBUG] 图片路径: {image_path}")
+            
+            return image_path
+            
+        except CookieExpiredError:
+            raise
+        except Exception as e:
+            if self.debug:
+                print(f"[DEBUG] 上传失败: {e}")
+            raise Exception(f"图片上传失败: {e}")
+    
+    def _extract_image_path(self, data: Any) -> str:
+        """从响应数据中递归提取图片路径"""
+        if isinstance(data, str):
+            if data.startswith("/contrib_service/"):
+                return data
+        elif isinstance(data, dict):
+            for value in data.values():
+                result = self._extract_image_path(value)
+                if result:
+                    return result
+        elif isinstance(data, list):
+            for item in data:
+                result = self._extract_image_path(item)
+                if result:
+                    return result
+        return None
+    
+    def _build_request_data(self, text: str, images: List[Dict] = None, image_paths: List[str] = None, model: str = None) -> str:
+        """构建请求数据 - 基于真实请求格式"""
+        # 会话上下文 (空字符串表示新对话)
+        conv_id = self.conversation_id or ""
+        resp_id = self.response_id or ""
+        choice_id = self.choice_id or ""
+        
+        # 处理图片数据 - 格式: [[[path, 1, null, mime_type], filename], ...]
+        image_data = None
+        if image_paths and len(image_paths) > 0:
+            image_data = []
+            for i, path in enumerate(image_paths):
+                mime_type = images[i]["mime_type"] if images and i < len(images) else "image/png"
+                filename = f"image_{random.randint(100000, 999999)}.png"
+                image_data.append([[path, 1, None, mime_type], filename])
+        
+        # 生成唯一会话 ID
+        session_id = str(uuid.uuid4()).upper()
+        timestamp = int(time.time() * 1000)
+        
+        # 模型映射: 将模型名称转换为 Gemini 内部模型标识
+        # [[0]] = gemini-3.0-pro (Pro 版)
+        # [[1]] = gemini-3.0-flash (快速版，默认)
+        # [[3]] = gemini-3.0-flash-thinking (思考版)
+        model_code = [[1]]  # 默认快速版
+        if model:
+            model_lower = model.lower()
+            if "pro" in model_lower:
+                model_code = [[0]]  # Pro 版
+            elif "thinking" in model_lower or "think" in model_lower:
+                model_code = [[3]]  # 思考版
+            # flash 或其他情况保持默认 [[1]]
+        
+        # 构建内部 JSON 数组 (基于真实请求格式)
+        # 第一个元素: [text, 0, null, image_data, null, null, 0]
+        inner_data = [
+            [text, 0, None, image_data, None, None, 0],
+            ["zh-CN"],
+            [conv_id, resp_id, choice_id, None, None, None, None, None, None, ""],
+            self.snlm0e,
+            None,  # 之前是 "test123"，改为 null
+            None,
+            [1],
+            1,
+            None,
+            None,
+            1,
+            0,
+            None,
+            None,
+            None,
+            None,
+            None,
+            model_code,  # 模型选择字段
+            0,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            1,
+            None,
+            None,
+            [4],
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            [1],
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            0,
+            None,
+            None,
+            None,
+            None,
+            None,
+            session_id,
+            None,
+            [],
+            None,
+            None,
+            None,
+            None,
+            [timestamp // 1000, (timestamp % 1000) * 1000000]
+        ]
+        
+        # 序列化为 JSON 字符串
+        inner_json = json.dumps(inner_data, ensure_ascii=False, separators=(',', ':'))
+        
+        # 外层包装
+        outer_data = [None, inner_json]
+        f_req_value = json.dumps(outer_data, ensure_ascii=False, separators=(',', ':'))
+        
+        return f_req_value
+
+    
+    def _parse_response(self, response_text: str) -> str:
+        """解析响应文本 - 修复版"""
+        try:
+            # 跳过前缀并按行解析
+            lines = response_text.split("\n")
+            final_text = ""
+            generated_images_set = set()  # 使用 set 全局去重
+            last_inner_json = None  # 保存最后一个有效的 inner_json 用于调试
+            
+            for line in lines:
+                line = line.strip()
+                if not line or line.startswith(")]}'"):
+                    continue
+                
+                # 跳过数字行（长度标记）
+                if line.isdigit():
+                    continue
+                
+                try:
+                    data = json.loads(line)
+                    # data 是一个嵌套数组，data[0] 才是真正的数据
+                    if isinstance(data, list) and len(data) > 0 and isinstance(data[0], list):
+                        actual_data = data[0]
+                        # 检查是否是 wrb.fr 响应
+                        if len(actual_data) >= 3 and actual_data[0] == "wrb.fr" and actual_data[2]:
+                            inner_json = json.loads(actual_data[2])
+                            last_inner_json = inner_json
+                            
+                            # 尝试提取生成的图片 URL，合并到全局 set 中去重
+                            imgs = self._extract_generated_images(inner_json)
+                            if imgs:
+                                for img in imgs:
+                                    generated_images_set.add(img)
+                                if self.debug:
+                                    print(f"[DEBUG] 从响应中提取到 {len(imgs)} 个图片 URL，当前总数: {len(generated_images_set)}")
+                            
+                            # 提取文本内容
+                            if inner_json and len(inner_json) > 4 and inner_json[4]:
+                                candidates = inner_json[4]
+                                if candidates and len(candidates) > 0:
+                                    candidate = candidates[0]
+                                    if candidate and len(candidate) > 1 and candidate[1]:
+                                        # candidate[1] 是一个数组，第一个元素是文本
+                                        text = candidate[1][0] if isinstance(candidate[1], list) else candidate[1]
+                                        if isinstance(text, str) and len(text) > len(final_text):
+                                            final_text = text
+                                            # 更新会话上下文
+                                            if len(inner_json) > 1 and inner_json[1]:
+                                                if isinstance(inner_json[1], list):
+                                                    if len(inner_json[1]) > 0:
+                                                        self.conversation_id = inner_json[1][0] or self.conversation_id
+                                                    if len(inner_json[1]) > 1:
+                                                        self.response_id = inner_json[1][1] or self.response_id
+                                            if len(candidate) > 0:
+                                                self.choice_id = candidate[0] or self.choice_id
+                except Exception as e:
+                    if self.debug:
+                        print(f"[DEBUG] 解析行时出错: {e}")
+                    continue
+            
+            # 转换为列表
+            generated_images = list(generated_images_set)
+            
+            if self.debug:
+                print(f"[DEBUG] 解析完成: final_text长度={len(final_text)}, 图片数量={len(generated_images)}")
+            
+            # 处理生成的图片/视频 - 下载并缓存到本地
+            if generated_images:
+                if self.debug:
+                    print(f"[DEBUG] 提取到 {len(generated_images)} 个媒体 URL，开始下载...")
+                
+                # 下载图片并获取本地代理 URL
+                local_media_urls = []
+                for i, url in enumerate(generated_images):
+                    if self.debug:
+                        print(f"[DEBUG] 下载媒体 {i+1}/{len(generated_images)}: {url[:80]}...")
+                    local_url = self._download_media_as_data_url(url)
+                    if local_url:
+                        local_media_urls.append(local_url)
+                        if self.debug:
+                            print(f"[DEBUG] 媒体 {i+1} 下载成功: {local_url}")
+                    else:
+                        # 下载失败，使用原始 URL
+                        local_media_urls.append(url)
+                        if self.debug:
+                            print(f"[DEBUG] 媒体 {i+1} 下载失败，使用原始 URL")
+                
+                # 检测占位符（如果有文本的话）
+                has_placeholder = False
+                if final_text:
+                    has_placeholder = ('image_generation_content' in final_text or 
+                                       'video_gen_chip' in final_text)
+                
+                # 构建包含本地代理 URL 的响应
+                media_parts = []
+                for i, url in enumerate(local_media_urls):
+                    media_parts.append(f"![生成的内容 {i+1}]({url})")
+                
+                media_text = "\n\n".join(media_parts)
+                
+                if has_placeholder:
+                    # 移除占位符 URL
+                    cleaned_text = re.sub(r'https?://googleusercontent\.com/(?:image_generation_content|video_gen_chip)/\d+', '', final_text)
+                    cleaned_text = re.sub(r'http://googleusercontent\.com/(?:image_generation_content|video_gen_chip)/\d+', '', cleaned_text)
+                    cleaned_text = re.sub(r'!\[.*?\]\(\)', '', cleaned_text)  # 移除空的图片标记
+                    cleaned_text = cleaned_text.strip()
+                    if cleaned_text:
+                        final_text = cleaned_text + "\n\n" + media_text
+                    else:
+                        final_text = media_text
+                elif final_text:
+                    # 有文本但没有占位符，追加图片
+                    final_text = final_text + "\n\n" + media_text
+                else:
+                    # 没有文本，只有图片
+                    final_text = media_text
+                
+                if self.debug:
+                    print(f"[DEBUG] 媒体处理完成，成功下载 {len([u for u in local_media_urls if u.startswith('/media/')])} 个")
+            
+            # 检测视频生成占位符，替换为提示文案
+            is_video_generation = False
+            if final_text and 'video_gen_chip' in final_text:
+                is_video_generation = True
+            
+            # 清理文本中的占位符 URL 和用户上传图片的 URL
+            if final_text:
+                # 清理占位符 URL
+                final_text = re.sub(r'https?://googleusercontent\.com/(?:image_generation_content|video_gen_chip)/\d+\s*', '', final_text)
+                final_text = re.sub(r'http://googleusercontent\.com/(?:image_generation_content|video_gen_chip)/\d+\s*', '', final_text)
+                # 清理用户上传图片的 URL（/gg/ 路径，非 /gg-dl/）
+                final_text = re.sub(r'!\[[^\]]*\]\(https://[^)]*googleusercontent\.com/gg/[^)]+\)', '', final_text)
+                final_text = re.sub(r'https://lh3\.googleusercontent\.com/gg/[^\s\)]+', '', final_text)
+                final_text = final_text.strip()
+            
+            # 如果是视频生成，添加提示文案
+            if is_video_generation:
+                video_notice = "\n\n---\n📹 视频为异步生成，生成结果可在官网聊天窗口查看下载。\n\n⏱️ 使用限制：\n- 视频生成 (Veo 模型)：每天总共可以生成 3 次\n- 图片生成 (Nano Banana 模型)：每天总共可以生成 1000 次"
+                if final_text:
+                    final_text = final_text + video_notice
+                else:
+                    final_text = video_notice.strip()
+            
+            if final_text:
+                # 优化图片 URL 为原始高清尺寸（仅对未下载的原始 URL）
+                final_text = self._optimize_image_urls(final_text)
+                return final_text
+            
+            # 如果没有文本也没有图片，尝试从 last_inner_json 中提取更多信息
+            if self.debug and last_inner_json:
+                print(f"[DEBUG] 无法提取内容，inner_json 结构: {str(last_inner_json)[:500]}...")
+                
+        except Exception as e:
+            if self.debug:
+                print(f"[DEBUG] 解析错误: {e}")
+        
+        return "无法解析响应"
+    
+    def _extract_generated_media(self, data: Any, depth: int = 0) -> List[str]:
+        """从响应数据中递归提取生成的图片/视频 URL
+        
+        Gemini 会返回两个媒体（带水印和不带水印），我们只保留最后一个（不带水印）
+        只提取 AI 生成的媒体 (/gg-dl/ 路径)，不提取用户上传的图片 (/gg/ 路径)
+        """
+        if depth > 30:  # 防止无限递归
+            return []
+        
+        media_urls = []
+        
+        if isinstance(data, list):
+            # 检查是否是媒体对结构: [[null, 1, "file1.png/mp4", "url1", ...], null, null, [null, 1, "file2.png/mp4", "url2", ...]]
+            # 第一个是带水印的，第二个是不带水印的
+            if (len(data) >= 1 and 
+                isinstance(data[0], list) and len(data[0]) >= 4 and
+                data[0][0] is None and 
+                isinstance(data[0][1], int) and
+                isinstance(data[0][2], str) and
+                isinstance(data[0][3], str) and 
+                data[0][3].startswith('https://') and
+                'gg-dl/' in data[0][3]):  # 只匹配 AI 生成的媒体
+                # 尝试找第二个媒体（不带水印）
+                second_url = None
+                if len(data) >= 4 and isinstance(data[3], list) and len(data[3]) >= 4:
+                    if (data[3][0] is None and 
+                        isinstance(data[3][3], str) and 
+                        'gg-dl/' in data[3][3]):
+                        second_url = data[3][3]
+                
+                # 优先使用第二个，否则用第一个
+                url = second_url if second_url else data[0][3]
+                if 'image_generation_content' not in url and 'video_gen_chip' not in url:
+                    media_urls.append(url)
+                    return media_urls
+            
+            # 检查是否是单个媒体数据结构: [null, 1, "filename.png/mp4", "https://...gg-dl/..."]
+            if (len(data) >= 4 and 
+                data[0] is None and 
+                isinstance(data[1], int) and
+                isinstance(data[2], str) and 
+                isinstance(data[3], str) and 
+                data[3].startswith('https://') and
+                'gg-dl/' in data[3]):  # 只匹配 AI 生成的媒体
+                url = data[3]
+                if 'image_generation_content' not in url and 'video_gen_chip' not in url:
+                    media_urls.append(url)
+                    return media_urls
+            
+            # 递归搜索，收集所有媒体 URL
+            all_found = []
+            for item in data:
+                found = self._extract_generated_media(item, depth + 1)
+                if found:
+                    all_found.extend(found)
+            
+            # 如果找到多个，返回最后一个（通常是不带水印的）
+            if all_found:
+                seen = set()
+                unique = []
+                for u in all_found:
+                    if u not in seen:
+                        seen.add(u)
+                        unique.append(u)
+                # 返回最后一个（不带水印）
+                return [unique[-1]] if unique else []
+                
+        elif isinstance(data, dict):
+            for value in data.values():
+                found = self._extract_generated_media(value, depth + 1)
+                if found:
+                    return found
+        
+        return media_urls
+    
+    # 保持向后兼容
+    def _extract_generated_images(self, data: Any, depth: int = 0) -> List[str]:
+        """向后兼容的别名"""
+        return self._extract_generated_media(data, depth)
+    
+    def _download_media_as_data_url(self, url: str) -> str:
+        """下载媒体文件并保存到本地缓存，返回本地代理 URL
+        
+        Args:
+            url: 媒体文件的 URL
+            
+        Returns:
+            str: 本地代理 URL 或 base64 data URL
+                 下载失败时返回空字符串
+        """
+        try:
+            # 先优化 URL 获取高清原图（仅对图片）
+            if ("googleusercontent" in url or "ggpht" in url) and not any(ext in url.lower() for ext in ['.mp4', '.webm', 'video']):
+                # 移除现有尺寸参数，添加原始尺寸参数 =s0
+                url = re.sub(r'=w\d+(-h\d+)?(-[a-zA-Z]+)*$', '=s0', url)
+                url = re.sub(r'=s\d+(-[a-zA-Z]+)*$', '=s0', url)
+                url = re.sub(r'=h\d+(-[a-zA-Z]+)*$', '=s0', url)
+                # 如果 URL 没有尺寸参数，添加 =s0
+                if not url.endswith('=s0') and '=' not in url.split('/')[-1]:
+                    url += '=s0'
+            
+            if self.debug:
+                print(f"[DEBUG] 正在下载媒体 (高清): {url[:100]}...")
+            
+            # 使用当前会话下载（带认证 cookies）
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+                "Accept": "image/webp,image/apng,image/*,*/*;q=0.8",
+                "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+                "Referer": "https://gemini.google.com/",
+            }
+            resp = self.session.get(url, timeout=60.0, headers=headers)
+            
+            if self.debug:
+                print(f"[DEBUG] 下载状态: {resp.status_code}, 大小: {len(resp.content)} bytes")
+            
+            if resp.status_code != 200:
+                if self.debug:
+                    print(f"[DEBUG] 下载媒体失败: HTTP {resp.status_code}")
+                return ""
+            
+            # 检查内容是否为空或太小（可能是错误页面）
+            if len(resp.content) < 100:
+                if self.debug:
+                    print(f"[DEBUG] 下载内容太小，可能是错误: {resp.content[:100]}")
+                return ""
+            
+            # 根据内容检测文件类型
+            content = resp.content
+            if content[:8] == b'\x89PNG\r\n\x1a\n':
+                ext = ".png"
+                mime = "image/png"
+            elif content[:3] == b'\xff\xd8\xff':
+                ext = ".jpg"
+                mime = "image/jpeg"
+            elif content[:6] in (b'GIF87a', b'GIF89a'):
+                ext = ".gif"
+                mime = "image/gif"
+            elif content[:4] == b'RIFF' and content[8:12] == b'WEBP':
+                ext = ".webp"
+                mime = "image/webp"
+            elif content[4:8] == b'ftyp' or content[:4] == b'\x00\x00\x00\x1c':
+                ext = ".mp4"
+                mime = "video/mp4"
+            else:
+                ext = ".png"
+                mime = "image/png"
+            
+            # 生成唯一文件名
+            import os
+            media_id = f"gen_{uuid.uuid4().hex[:16]}"
+            
+            # 保存到缓存目录
+            cache_dir = os.path.join(os.path.dirname(__file__), "media_cache")
+            os.makedirs(cache_dir, exist_ok=True)
+            file_path = os.path.join(cache_dir, media_id + ext)
+            
+            with open(file_path, "wb") as f:
+                f.write(content)
+            
+            if self.debug:
+                print(f"[DEBUG] 媒体已保存: {file_path}")
+            
+            # 返回完整的媒体访问 URL (包含后缀名)
+            media_path = f"/media/{media_id}{ext}"
+            if self.media_base_url:
+                return f"{self.media_base_url}{media_path}"
+            return media_path
+            
+        except Exception as e:
+            if self.debug:
+                print(f"[DEBUG] 下载媒体异常: {e}")
+            return ""
+    
+    def _optimize_image_urls(self, text: str) -> str:
+        """优化文本中的 Google 图片 URL 为原始高清尺寸
+        
+        Google 图片 URL 参数说明:
+        - =w400 或 =h400: 指定宽度或高度
+        - =s400: 指定最大边长
+        - =s0 或 =w0-h0: 原始尺寸
+        """
+        import re
+        
+        def optimize_url(url: str) -> str:
+            # 匹配 googleusercontent 或 ggpht 图片 URL
+            if "googleusercontent" not in url and "ggpht" not in url:
+                return url
+            # 移除现有尺寸参数，添加原始尺寸参数
+            url = re.sub(r'=w\d+(-h\d+)?(-[a-zA-Z]+)*$', '=s0', url)
+            url = re.sub(r'=s\d+(-[a-zA-Z]+)*$', '=s0', url)
+            url = re.sub(r'=h\d+(-[a-zA-Z]+)*$', '=s0', url)
+            # 如果 URL 没有尺寸参数，添加 =s0
+            if not url.endswith('=s0') and '=' not in url.split('/')[-1]:
+                url += '=s0'
+            return url
+        
+        # 匹配 Markdown 图片语法和纯 URL
+        # Markdown: ![alt](url)
+        def replace_md_img(match):
+            alt = match.group(1)
+            url = match.group(2)
+            return f"![{alt}]({optimize_url(url)})"
+        
+        text = re.sub(r'!\[([^\]]*)\]\(([^)]+)\)', replace_md_img, text)
+        
+        # 匹配独立的 Google 图片 URL
+        def replace_url(match):
+            return optimize_url(match.group(0))
+        
+        text = re.sub(r'https?://[^\s\)]+(?:googleusercontent|ggpht)[^\s\)]*', replace_url, text)
+        
+        return text
+
+    
+    def _extract_text(self, parsed_data: list) -> str:
+        """从解析后的数据中提取文本"""
+        try:
+            # 更新会话上下文
+            if parsed_data and len(parsed_data) > 1:
+                if parsed_data[1] and len(parsed_data[1]) > 0:
+                    self.conversation_id = parsed_data[1][0] or self.conversation_id
+                if parsed_data[1] and len(parsed_data[1]) > 1:
+                    self.response_id = parsed_data[1][1] or self.response_id
+            
+            # 提取候选回复
+            if parsed_data and len(parsed_data) > 4 and parsed_data[4]:
+                candidates = parsed_data[4]
+                if candidates and len(candidates) > 0:
+                    first_candidate = candidates[0]
+                    if first_candidate and len(first_candidate) > 1:
+                        self.choice_id = first_candidate[0] or self.choice_id
+                        content_parts = first_candidate[1]
+                        if content_parts and len(content_parts) > 0:
+                            return content_parts[0] if isinstance(content_parts[0], str) else str(content_parts[0])
+            
+            # 备用提取
+            if parsed_data and len(parsed_data) > 0:
+                def find_text(obj, depth=0):
+                    if depth > 10:
+                        return None
+                    if isinstance(obj, str) and len(obj) > 50:
+                        return obj
+                    if isinstance(obj, list):
+                        for item in obj:
+                            result = find_text(item, depth + 1)
+                            if result:
+                                return result
+                    return None
+                
+                text = find_text(parsed_data)
+                if text:
+                    return text
+                    
+        except Exception as e:
+            pass
+        
+        return "无法提取回复内容"
+    
+    def chat(
+        self,
+        messages: List[Dict[str, Any]] = None,
+        message: str = None,
+        image: bytes = None,
+        image_url: str = None,
+        reset_context: bool = False,
+        model: str = None,
+        stream: bool = False,
+    ) -> Union[ChatCompletionResponse, Iterator[Dict[str, Any]]]:
+        """
+        发送聊天请求 (OpenAI 兼容格式)
+        
+        Args:
+            messages: OpenAI 格式消息列表
+            message: 简单文本消息 (与 messages 二选一)
+            image: 图片二进制数据
+            image_url: 图片 URL
+            reset_context: 是否重置上下文
+            model: 模型名称 (gemini-3.0-flash/gemini-3.0-flash-thinking/gemini-3.0-pro)
+        
+        Returns:
+            ChatCompletionResponse: OpenAI 格式响应
+        """
+        if reset_context:
+            self.reset()
+        
+        # 处理输入
+        text_parts = []
+        images = []
+        
+        if messages:
+            # OpenAI 格式 - 合并所有消息
+            for msg in messages:
+                role = msg.get("role", "user")
+                content = msg.get("content", "")
+                
+                if role == "user":
+                    t, imgs = self._parse_content(content)
+                    if t:
+                        text_parts.append(t)
+                    if imgs:
+                        images.extend(imgs)
+                elif role == "assistant":
+                    # 助手消息也加入上下文
+                    if isinstance(content, str) and content:
+                        text_parts.append(f"[助手回复]: {content}")
+                elif role == "system":
+                    # system 消息作为前置指令
+                    if isinstance(content, str) and content:
+                        text_parts.insert(0, content)
+                
+                self.messages.append(Message(role=role, content=content))
+            
+            text = "\n\n".join(text_parts)
+        elif message:
+            text = message
+            self.messages.append(Message(role="user", content=message))
+            
+            if image:
+                images = [{"mime_type": "image/jpeg", "data": base64.b64encode(image).decode()}]
+            elif image_url:
+                if image_url.startswith("data:"):
+                    match = re.match(r'data:([^;]+);base64,(.+)', image_url)
+                    if match:
+                        images = [{"mime_type": match.group(1), "data": match.group(2)}]
+                else:
+                    try:
+                        resp = httpx.get(image_url, timeout=30)
+                        mime = resp.headers.get("content-type", "image/jpeg").split(";")[0]
+                        images = [{"mime_type": mime, "data": base64.b64encode(resp.content).decode()}]
+                    except:
+                        pass
+        else:
+            text = ""
+        
+        if not text:
+            raise ValueError("消息内容不能为空")
+        
+        # 发送请求
+        if stream:
+            return self._send_request_stream(text, images, model)
+        return self._send_request(text, images, model)
+
+    
+    def _log_gemini_call(self, request_data: dict, response_text: str, error: str = None):
+        """记录 Gemini 内部调用日志"""
+        import datetime
+        log_entry = {
+            "timestamp": datetime.datetime.now().isoformat(),
+            "type": "gemini_internal",
+            "request": request_data,
+            "response_raw": response_text,
+            "error": error
+        }
+        try:
+            with open("api_logs.json", "a", encoding="utf-8") as f:
+                f.write(json.dumps(log_entry, ensure_ascii=False, indent=2) + "\n---\n")
+        except Exception as e:
+            print(f"[LOG ERROR] 写入 Gemini 日志失败: {e}")
+
+    def _send_request(self, text: str, images: List[Dict] = None, model: str = None) -> ChatCompletionResponse:
+        """发送请求到 Gemini"""
+        url = f"{self.BASE_URL}/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate"
+        
+        params = {
+            "bl": self.bl,
+            "f.sid": "",
+            "hl": "zh-CN",
+            "_reqid": str(self.request_count * 100000 + random.randint(10000, 99999)),
+            "rt": "c",
+        }
+        
+        # 模型标识映射 (通过请求头 x-goog-ext-525001261-jspb 选择模型)
+        model_id = self.model_ids.get("flash", "56fdd199312815e2")  # 默认极速版
+        if model:
+            model_lower = model.lower()
+            if "pro" in model_lower:
+                model_id = self.model_ids.get("pro", "e6fa609c3fa255c0")
+            elif "thinking" in model_lower or "think" in model_lower:
+                model_id = self.model_ids.get("thinking", "e051ce1aa80aa576")
+        
+        # 上传图片获取路径
+        image_paths = []
+        if images and len(images) > 0:
+            if not self.push_id:
+                print("⚠️  图片上传需要 push-id，请运行: python get_push_id.py")
+                print("   然后将获取的 push-id 添加到 config.py")
+            else:
+                try:
+                    for img in images:
+                        # 解码 base64 数据
+                        img_data = base64.b64decode(img["data"])
+                        # 上传并获取路径
+                        path = self._upload_image(img_data, img["mime_type"])
+                        image_paths.append(path)
+                        if self.debug:
+                            print(f"[DEBUG] 图片上传成功: {path[:50]}...")
+                except Exception as e:
+                    print(f"⚠️  图片上传失败: {e}")
+                    image_paths = []
+        
+        req_data = self._build_request_data(text, images, image_paths, model)
+        
+        form_data = {
+            "f.req": req_data,
+            "at": self.snlm0e,
+        }
+        
+        # 模型选择请求头
+        model_headers = {
+            "x-goog-ext-525001261-jspb": json.dumps([1, None, None, None, model_id, None, None, 0, [4], None, None, 2], separators=(',', ':')),
+        }
+        
+        # 构建日志记录
+        gemini_request_log = {
+            "url": url,
+            "params": params,
+            "text": text,
+            "model": model,
+            "model_id": model_id,
+            "has_images": len(images) > 0 if images else False,
+            "image_paths": image_paths,
+            "f_req_preview": req_data[:500] + "..." if len(req_data) > 500 else req_data,
+        }
+        
+        if self.debug:
+            print(f"[DEBUG] 请求 URL: {url}")
+            print(f"[DEBUG] AT Token: {self.snlm0e[:30]}...")
+            print(f"[DEBUG] 模型: {model or '默认'}, ID: {model_id}")
+            if image_paths:
+                print(f"[DEBUG] 请求数据前300字符: {req_data[:300]}")
+        
+        # 重试机制
+        max_retries = 3
+        last_error = None
+        
+        for attempt in range(max_retries):
+            try:
+                resp = self.session.post(url, params=params, data=form_data, headers=model_headers, timeout=60.0)
+            
+                if self.debug:
+                    print(f"[DEBUG] 响应状态: {resp.status_code}")
+                    print(f"[DEBUG] 响应内容前500字符: {resp.text[:500]}")
+                    # 始终保存完整响应用于调试
+                    with open("debug_image_response.txt", "w", encoding="utf-8") as f:
+                        f.write(resp.text)
+                    print(f"[DEBUG] 完整响应已保存到 debug_image_response.txt")
+                
+                # 记录 Gemini 完整响应
+                self._log_gemini_call(gemini_request_log, resp.text)
+                
+                resp.raise_for_status()
+                self.request_count += 1
+                
+                reply_text = self._parse_response(resp.text)
+                
+                # 保存助手回复
+                self.messages.append(Message(role="assistant", content=reply_text))
+                
+                # 构建 OpenAI 格式响应
+                return ChatCompletionResponse(
+                    id=f"chatcmpl-{self.conversation_id or 'gemini'}-{int(time.time())}",
+                    created=int(time.time()),
+                    model="gemini-web",
+                    choices=[
+                        ChatCompletionChoice(
+                            index=0,
+                            message=Message(role="assistant", content=reply_text),
+                            finish_reason="stop"
+                        )
+                    ],
+                    usage=Usage(
+                        prompt_tokens=len(text),
+                        completion_tokens=len(reply_text),
+                        total_tokens=len(text) + len(reply_text)
+                    )
+                )
+                
+            except httpx.HTTPStatusError as e:
+                self._log_gemini_call(gemini_request_log, e.response.text if hasattr(e, 'response') else "", error=f"HTTP {e.response.status_code}")
+                raise Exception(f"HTTP 错误: {e.response.status_code}")
+            except (httpx.RemoteProtocolError, httpx.ReadError, httpx.ConnectError) as e:
+                # 网络连接问题，可重试
+                last_error = e
+                if attempt < max_retries - 1:
+                    wait_time = (attempt + 1) * 2  # 2, 4 秒
+                    print(f"⚠️  连接中断，{wait_time}秒后重试 ({attempt + 1}/{max_retries})...")
+                    time.sleep(wait_time)
+                    continue
+                self._log_gemini_call(gemini_request_log, "", error=str(e))
+                raise Exception(f"网络连接失败（已重试{max_retries}次）: {e}")
+            except Exception as e:
+                self._log_gemini_call(gemini_request_log, "", error=str(e))
+                raise Exception(f"请求失败: {e}")
+        
+        # 所有重试都失败
+        if last_error:
+            raise Exception(f"请求失败（已重试{max_retries}次）: {last_error}")
+    
+    def _extract_text_from_inner_json(self, inner_json: list) -> str:
+        """Extract reply text from a single inner JSON packet and update session IDs."""
+        try:
+            if not inner_json:
+                return ""
+
+            if len(inner_json) > 1 and inner_json[1]:
+                if isinstance(inner_json[1], list):
+                    if len(inner_json[1]) > 0:
+                        self.conversation_id = inner_json[1][0] or self.conversation_id
+                    if len(inner_json[1]) > 1:
+                        self.response_id = inner_json[1][1] or self.response_id
+
+            if len(inner_json) > 4 and inner_json[4]:
+                candidates = inner_json[4]
+                if candidates and len(candidates) > 0:
+                    candidate = candidates[0]
+                    if candidate and len(candidate) > 1 and candidate[1]:
+                        if len(candidate) > 0:
+                            self.choice_id = candidate[0] or self.choice_id
+                        text = candidate[1][0] if isinstance(candidate[1], list) else candidate[1]
+                        return text if isinstance(text, str) else str(text)
+        except Exception:
+            pass
+        return ""
+
+    def _send_request_stream(self, text: str, images: List[Dict] = None, model: str = None) -> Iterator[Dict[str, Any]]:
+        """True streaming path: parse Gemini length-prefixed frames and emit deltas."""
+        url = f"{self.BASE_URL}/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate"
+
+        params = {
+            "bl": self.bl,
+            "f.sid": "",
+            "hl": "zh-CN",
+            "_reqid": str(self.request_count * 100000 + random.randint(10000, 99999)),
+            "rt": "c",
+        }
+
+        model_id = self.model_ids.get("flash", "56fdd199312815e2")
+        if model:
+            model_lower = model.lower()
+            if "pro" in model_lower:
+                model_id = self.model_ids.get("pro", "e6fa609c3fa255c0")
+            elif "thinking" in model_lower or "think" in model_lower:
+                model_id = self.model_ids.get("thinking", "e051ce1aa80aa576")
+
+        image_paths = []
+        if images and len(images) > 0 and self.push_id:
+            for img in images:
+                img_data = base64.b64decode(img["data"])
+                image_paths.append(self._upload_image(img_data, img["mime_type"]))
+
+        req_data = self._build_request_data(text, images, image_paths, model)
+        form_data = {"f.req": req_data, "at": self.snlm0e}
+        model_headers = {
+            "x-goog-ext-525001261-jspb": json.dumps(
+                [1, None, None, None, model_id, None, None, 0, [4], None, None, 2],
+                separators=(",", ":"),
+            ),
+        }
+
+        completion_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
+        created = int(time.time())
+        chunk_model = model or "gemini-web"
+
+        yield {
+            "id": completion_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": chunk_model,
+            "choices": [{"index": 0, "delta": {"role": "assistant"}, "finish_reason": None}],
+        }
+
+        full_text = ""
+        raw_lines: List[str] = []
+
+        def utf16_char_len(ch: str) -> int:
+            return 2 if ord(ch) > 0xFFFF else 1
+
+        def take_utf16_units(s: str, start: int, target_units: int) -> tuple[int, int]:
+            count = 0
+            used = 0
+            n = len(s)
+            while (start + count) < n and used < target_units:
+                c = s[start + count]
+                u = utf16_char_len(c)
+                if used + u > target_units:
+                    break
+                used += u
+                count += 1
+            return count, used
+
+        def parse_length_prefixed_frames(buffer: str) -> tuple[List[Any], str]:
+            frames: List[Any] = []
+            pos = 0
+            n = len(buffer)
+            while pos < n:
+                while pos < n and buffer[pos].isspace():
+                    pos += 1
+                if pos >= n:
+                    break
+
+                m = re.match(r"(\d+)\n", buffer[pos:])
+                if not m:
+                    break
+
+                frame_units = int(m.group(1))
+                marker_len = len(m.group(1))
+                start_content = pos + marker_len
+                char_count, used_units = take_utf16_units(buffer, start_content, frame_units)
+                if used_units < frame_units:
+                    break
+
+                end_content = start_content + char_count
+                chunk = buffer[start_content:end_content].strip()
+                pos = end_content
+
+                if not chunk:
+                    continue
+
+                try:
+                    parsed = json.loads(chunk)
+                    if isinstance(parsed, list):
+                        frames.extend(parsed)
+                    else:
+                        frames.append(parsed)
+                except Exception:
+                    continue
+
+            return frames, buffer[pos:]
+
+        def calc_delta(new_text: str, sent_text: str) -> str:
+            if not new_text:
+                return ""
+            if new_text.startswith(sent_text):
+                return new_text[len(sent_text):]
+            if sent_text.startswith(new_text):
+                return ""
+            common = 0
+            max_common = min(len(new_text), len(sent_text))
+            while common < max_common and new_text[common] == sent_text[common]:
+                common += 1
+            return new_text[common:]
+
+        def process_packet(packet: Any) -> Iterator[Dict[str, Any]]:
+            nonlocal full_text
+            if not isinstance(packet, list) or len(packet) < 3 or packet[0] != "wrb.fr" or not packet[2]:
+                return
+            try:
+                inner_json = json.loads(packet[2])
+                raw_lines.append(json.dumps([packet], ensure_ascii=False))
+                text_candidate = self._extract_text_from_inner_json(inner_json)
+                if text_candidate:
+                    delta = calc_delta(text_candidate, full_text)
+                    if delta:
+                        full_text = text_candidate
+                        yield {
+                            "id": completion_id,
+                            "object": "chat.completion.chunk",
+                            "created": created,
+                            "model": chunk_model,
+                            "choices": [{"index": 0, "delta": {"content": delta}, "finish_reason": None}],
+                        }
+            except Exception:
+                return
+
+        with self.session.stream(
+            "POST",
+            url,
+            params=params,
+            data=form_data,
+            headers=model_headers,
+            timeout=60.0,
+        ) as resp:
+            resp.raise_for_status()
+            self.request_count += 1
+
+            decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+            stream_buffer = ""
+
+            for chunk_bytes in resp.iter_bytes():
+                if not chunk_bytes:
+                    continue
+
+                stream_buffer += decoder.decode(chunk_bytes, final=False)
+                if stream_buffer.startswith(")]}'"):
+                    stream_buffer = stream_buffer[4:].lstrip()
+
+                packets, stream_buffer = parse_length_prefixed_frames(stream_buffer)
+                for packet in packets:
+                    yield from process_packet(packet)
+
+                if len(stream_buffer) > 2_000_000:
+                    stream_buffer = ""
+
+            stream_buffer += decoder.decode(b"", final=True)
+            tail_packets, _ = parse_length_prefixed_frames(stream_buffer)
+            for packet in tail_packets:
+                yield from process_packet(packet)
+
+        final_reply = self._parse_response("\n".join(raw_lines)) if raw_lines else full_text
+        if not final_reply:
+            final_reply = full_text
+
+        if final_reply and len(final_reply) > len(full_text) and final_reply.startswith(full_text):
+            tail = final_reply[len(full_text):]
+            if tail:
+                yield {
+                    "id": completion_id,
+                    "object": "chat.completion.chunk",
+                    "created": created,
+                    "model": chunk_model,
+                    "choices": [{"index": 0, "delta": {"content": tail}, "finish_reason": None}],
+                }
+
+        self.messages.append(Message(role="assistant", content=final_reply))
+        yield {
+            "id": completion_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": chunk_model,
+            "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+        }
+
+    def reset(self):
+        """重置会话上下文"""
+        self.conversation_id = ""
+        self.response_id = ""
+        self.choice_id = ""
+        self.messages = []
+    
+    def get_history(self) -> List[Dict]:
+        """获取消息历史 (OpenAI 格式)"""
+        return [{"role": m.role, "content": m.content} for m in self.messages]
+
+
+# OpenAI 兼容接口
+class OpenAICompatible:
+    """OpenAI SDK 兼容封装"""
+    
+    def __init__(self, client: GeminiClient):
+        self.client = client
+        self.chat = self.Chat(client)
+    
+    class Chat:
+        def __init__(self, client: GeminiClient):
+            self.client = client
+            self.completions = self.Completions(client)
+        
+        class Completions:
+            def __init__(self, client: GeminiClient):
+                self.client = client
+            
+            def create(
+                self,
+                model: str = "gemini-web",
+                messages: List[Dict] = None,
+                **kwargs
+            ) -> ChatCompletionResponse:
+                return self.client.chat(
+                    messages=messages,
+                    model=model,
+                    stream=bool(kwargs.get("stream", False)),
+                )

demo_chat.py

@@ -0,0 +1,110 @@
+"""
+Gemini API demo with streaming responses.
+"""
+
+import base64
+from openai import OpenAI
+
+# Config
+BASE_URL = "http://127.0.0.1:8000/v1"
+API_KEY = "sk-geminixxxxx"
+
+client = OpenAI(base_url=BASE_URL, api_key=API_KEY)
+
+
+def load_image_base64(path: str) -> str:
+    with open(path, "rb") as f:
+        return base64.b64encode(f.read()).decode()
+
+
+def print_stream(stream) -> None:
+    for chunk in stream:
+        if not chunk.choices:
+            continue
+        delta = chunk.choices[0].delta
+        if delta and getattr(delta, "content", None):
+            print(delta.content, end="", flush=True)
+    print()
+
+
+def chat_text() -> None:
+    print("=" * 50)
+    print("Text chat (stream)")
+    print("=" * 50)
+
+    stream = client.chat.completions.create(
+        model="gemini-3.0-pro",
+        messages=[{"role": "user", "content": "你好，介绍一下你自己"}],
+        stream=True,
+    )
+    print_stream(stream)
+
+
+def chat_single_image() -> None:
+    print("\n" + "=" * 50)
+    print("Single image (stream)")
+    print("=" * 50)
+
+    img_b64 = load_image_base64("image.png")
+
+    stream = client.chat.completions.create(
+        model="gemini-3.0-flash",
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "描述这张图片"},
+                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img_b64}"}},
+                ],
+            }
+        ],
+        stream=True,
+    )
+    print_stream(stream)
+
+
+def chat_multi_images() -> None:
+    print("\n" + "=" * 50)
+    print("Multi image (stream)")
+    print("=" * 50)
+
+    img1_b64 = load_image_base64("a.png")
+    img2_b64 = load_image_base64("b.png")
+
+    stream = client.chat.completions.create(
+        model="gemini-3.0-pro",
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "比较这两张图片的区别"},
+                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img1_b64}"}},
+                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img2_b64}"}},
+                ],
+            }
+        ],
+        stream=True,
+    )
+    print_stream(stream)
+
+
+def chat_image_generation() -> None:
+    print("\n" + "=" * 50)
+    print("Image generation (stream)")
+    print("=" * 50)
+
+    stream = client.chat.completions.create(
+        model="gemini-3.0-pro",
+        messages=[{"role": "user", "content": "生成一张可爱的猫咪图片"}],
+        stream=True,
+    )
+    print_stream(stream)
+
+
+if __name__ == "__main__":
+    chat_text()
+
+    # Uncomment as needed:
+    # chat_single_image()
+    # chat_multi_images()
+    # chat_image_generation()

get_push_id.py

@@ -0,0 +1,156 @@
+"""
+获取 Gemini 的 push-id
+
+push-id 是图片上传所需的必要参数，格式为 feeds/xxxxx
+需要从 Gemini 页面或 API 获取
+"""
+
+import httpx
+import re
+from config import SECURE_1PSID, SECURE_1PSIDTS, SECURE_1PSIDCC, COOKIES_STR
+
+
+def get_push_id_from_page():
+    """从 Gemini 页面获取 push-id"""
+    print("正在获取 push-id...")
+    
+    session = httpx.Client(
+        timeout=30.0,
+        follow_redirects=True,
+        headers={
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+        }
+    )
+    
+    # 设置 cookies
+    if COOKIES_STR:
+        for item in COOKIES_STR.split(";"):
+            item = item.strip()
+            if "=" in item:
+                key, value = item.split("=", 1)
+                session.cookies.set(key.strip(), value.strip(), domain=".google.com")
+    else:
+        session.cookies.set("__Secure-1PSID", SECURE_1PSID, domain=".google.com")
+        if SECURE_1PSIDTS:
+            session.cookies.set("__Secure-1PSIDTS", SECURE_1PSIDTS, domain=".google.com")
+        if SECURE_1PSIDCC:
+            session.cookies.set("__Secure-1PSIDCC", SECURE_1PSIDCC, domain=".google.com")
+    
+    try:
+        # 访问 Gemini 主页
+        resp = session.get("https://gemini.google.com")
+        
+        if resp.status_code != 200:
+            print(f"❌ 访问失败: {resp.status_code}")
+            return None
+        
+        html = resp.text
+        
+        # 尝试多种模式匹配 push-id
+        patterns = [
+            r'"push[_-]?id["\s:]+["\'](feeds/[a-z0-9]+)["\']',  # "push_id": "feeds/xxx"
+            r'push[_-]?id["\s:=]+["\'](feeds/[a-z0-9]+)["\']',  # push_id="feeds/xxx"
+            r'feedName["\s:]+["\'](feeds/[a-z0-9]+)["\']',      # "feedName": "feeds/xxx"
+            r'clientId["\s:]+["\'](feeds/[a-z0-9]+)["\']',      # "clientId": "feeds/xxx"
+            r'(feeds/[a-z0-9]{14,})',                            # 直接匹配 feeds/xxx 格式
+        ]
+        
+        for pattern in patterns:
+            matches = re.findall(pattern, html, re.IGNORECASE)
+            if matches:
+                push_id = matches[0]
+                print(f"✅ 找到 push-id: {push_id}")
+                return push_id
+        
+        # 如果没找到，保存页面源码供分析
+        with open("gemini_page_debug.html", "w", encoding="utf-8") as f:
+            f.write(html)
+        print("❌ 未找到 push-id")
+        print("   页面源码已保存到 gemini_page_debug.html")
+        print("   请手动搜索 'feeds/' 或 'push' 关键字")
+        
+        return None
+        
+    except Exception as e:
+        print(f"❌ 错误: {e}")
+        return None
+
+
+def get_push_id_from_api():
+    """尝试从 API 获取 push-id"""
+    print("\n尝试从 API 获取 push-id...")
+    
+    session = httpx.Client(
+        timeout=30.0,
+        follow_redirects=True,
+        headers={
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "Content-Type": "application/json",
+        }
+    )
+    
+    # 设置 cookies
+    if COOKIES_STR:
+        for item in COOKIES_STR.split(";"):
+            item = item.strip()
+            if "=" in item:
+                key, value = item.split("=", 1)
+                session.cookies.set(key.strip(), value.strip(), domain=".google.com")
+    else:
+        session.cookies.set("__Secure-1PSID", SECURE_1PSID, domain=".google.com")
+    
+    # 可能的 API 端点
+    endpoints = [
+        "https://gemini.google.com/_/BardChatUi/data/batchexecute",
+        "https://push.clients6.google.com/v1/feeds",
+    ]
+    
+    for endpoint in endpoints:
+        try:
+            resp = session.get(endpoint)
+            print(f"  {endpoint}: {resp.status_code}")
+            if resp.status_code == 200:
+                # 尝试从响应中提取 push-id
+                text = resp.text
+                match = re.search(r'feeds/[a-z0-9]{14,}', text)
+                if match:
+                    push_id = match.group(0)
+                    print(f"  ✅ 找到: {push_id}")
+                    return push_id
+        except Exception as e:
+            print(f"  ❌ {endpoint}: {e}")
+    
+    return None
+
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("获取 Gemini push-id")
+    print("=" * 60)
+    
+    # 方法1: 从页面获取
+    push_id = get_push_id_from_page()
+    
+    # 方法2: 从 API 获取
+    if not push_id:
+        push_id = get_push_id_from_api()
+    
+    if push_id:
+        print("\n" + "=" * 60)
+        print(f"✅ 成功获取 push-id: {push_id}")
+        print("=" * 60)
+        print("\n请将此值添加到 config.py:")
+        print(f'PUSH_ID = "{push_id}"')
+    else:
+        print("\n" + "=" * 60)
+        print("❌ 未能自动获取 push-id")
+        print("=" * 60)
+        print("\n手动获取方法:")
+        print("1. 打开 https://gemini.google.com 并登录")
+        print("2. F12 打开开发者工具 -> Network 标签")
+        print("3. 上传一张图片")
+        print("4. 查找 upload 请求")
+        print("5. 在请求头中找到 push-id 或 x-goog-upload-header-content-length")
+        print("6. 复制 feeds/xxxxx 格式的值")

requirements.txt

@@ -0,0 +1,4 @@
+httpx>=0.25.0
+fastapi>=0.104.0
+uvicorn>=0.24.0
+openai>=1.0.0

server.py

@@ -0,0 +1,1719 @@
+"""
+Gemini OpenAI 兼容 API 服务
+
+启动: python server.py
+后台: http://localhost:8000/admin
+API:  http://localhost:8000/v1
+"""
+
+from fastapi import FastAPI, HTTPException, Header, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, RedirectResponse, StreamingResponse, JSONResponse
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional, Union
+import uvicorn
+import time
+import uuid
+import json
+import os
+import re
+import httpx
+import hashlib
+import secrets
+import asyncio
+
+# ============ 配置 ============
+API_KEY = os.getenv("API_KEY", "sk-geminixxxxx")
+HOST = "0.0.0.0"
+PORT = int(os.getenv("PORT", 7860))
+CONFIG_FILE = "config_data.json"
+# 后台登录账号密码
+ADMIN_USERNAME = os.getenv("ADMIN_USERNAME", "admin")
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin123")
+# Token 自动刷新配置
+TOKEN_REFRESH_INTERVAL_MIN = 1800  # 刷新间隔最小秒数（默认 30 分钟）
+TOKEN_REFRESH_INTERVAL_MAX = 3600  # 刷新间隔最大秒数（默认 60 分钟）
+TOKEN_AUTO_REFRESH = True  # 是否启用自动刷新
+TOKEN_BACKGROUND_REFRESH = True  # 是否启用后台定时刷新（防止长时间不用失效）
+# 媒体文件外网访问地址
+# 在 Hugging Face Spaces 中，可以直接获取 SPACE_ID 来构造 URL
+SPACE_ID = os.getenv("SPACE_ID")
+if SPACE_ID:
+    MEDIA_BASE_URL = f"https://{SPACE_ID.replace('/', '-')}.hf.space"
+else:
+    MEDIA_BASE_URL = os.getenv("MEDIA_BASE_URL", "http://127.0.0.1:7860")
+# ==============================
+
+
+import random
+from datetime import datetime
+
+# 后台刷新任务控制
+_background_refresh_task = None
+_background_refresh_stop = False
+
+app = FastAPI(title="Gemini OpenAI API", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 静态文件路由 (用于示例图片)
+from fastapi.responses import FileResponse
+
+# 生成的媒体文件缓存目录
+MEDIA_CACHE_DIR = os.path.join(os.path.dirname(__file__), "media_cache")
+os.makedirs(MEDIA_CACHE_DIR, exist_ok=True)
+
+@app.get("/static/{filename}")
+async def serve_static(filename: str):
+    """提供静态文件（示例图片等）"""
+    file_path = os.path.join(os.path.dirname(__file__), filename)
+    if os.path.exists(file_path):
+        return FileResponse(file_path)
+    raise HTTPException(status_code=404, detail="文件不存在")
+
+@app.get("/media/{media_filename}")
+async def serve_media(media_filename: str):
+    """提供缓存的媒体文件"""
+    # 安全检查：只允许字母数字、下划线、点和常见后缀
+    import re
+    if not re.match(r'^[a-zA-Z0-9_-]+(\.(png|jpg|jpeg|gif|webp|mp4))?$', media_filename):
+        raise HTTPException(status_code=400, detail="无效的媒体文件名")
+    
+    # 直接查找文件（带后缀名）
+    file_path = os.path.join(MEDIA_CACHE_DIR, media_filename)
+    if os.path.exists(file_path):
+        return FileResponse(file_path)
+    
+    # 兼容旧版本：不带后缀名的请求，尝试查找匹配的文件
+    media_id = media_filename.rsplit('.', 1)[0] if '.' in media_filename else media_filename
+    for ext in [".png", ".jpg", ".jpeg", ".gif", ".webp", ".mp4"]:
+        file_path = os.path.join(MEDIA_CACHE_DIR, media_id + ext)
+        if os.path.exists(file_path):
+            return FileResponse(file_path)
+    
+    raise HTTPException(status_code=404, detail="媒体文件不存在")
+
+def cleanup_old_media(max_age_hours: int = 1):
+    """清理过期的媒体缓存文件"""
+    import time
+    now = time.time()
+    max_age_seconds = max_age_hours * 3600
+    
+    try:
+        for filename in os.listdir(MEDIA_CACHE_DIR):
+            file_path = os.path.join(MEDIA_CACHE_DIR, filename)
+            if os.path.isfile(file_path):
+                file_age = now - os.path.getmtime(file_path)
+                if file_age > max_age_seconds:
+                    os.remove(file_path)
+    except Exception:
+        pass
+
+# 存储有效的 session token
+_admin_sessions = set()
+
+def generate_session_token():
+    """生成随机 session token"""
+    return secrets.token_hex(32)
+
+def verify_admin_session(request: Request):
+    """验证管理员 session"""
+    token = request.cookies.get("admin_session")
+    if not token or token not in _admin_sessions:
+        return False
+    return True
+
+# 默认可用模型列表 (Gemini 3 官网三个模型: 快速/思考/Pro)
+DEFAULT_MODELS = ["gemini-3.0-flash", "gemini-3.0-flash-thinking", "gemini-3.0-pro"]
+
+# 默认模型 ID (用于请求头选择模型)
+DEFAULT_MODEL_IDS = {
+    "flash": "56fdd199312815e2",
+    "pro": "e6fa609c3fa255c0", 
+    "thinking": "e051ce1aa80aa576",
+}
+
+# 配置存储
+_config = {
+    "SNLM0E": "",
+    "SECURE_1PSID": "",
+    "SECURE_1PSIDTS": "",
+    "SAPISID": "",
+    "SID": "",
+    "HSID": "",
+    "SSID": "",
+    "APISID": "",
+    "PUSH_ID": "",
+    "FULL_COOKIE": "",  # 存储完整cookie字符串
+    "MODELS": DEFAULT_MODELS.copy(),  # 可用模型列表
+    "MODEL_IDS": DEFAULT_MODEL_IDS.copy(),  # 模型 ID 映射
+}
+
+# Cookie 字段映射 (浏览器cookie名 -> 配置字段名)
+COOKIE_FIELD_MAP = {
+    "__Secure-1PSID": "SECURE_1PSID",
+    "__Secure-1PSIDTS": "SECURE_1PSIDTS",
+    "SAPISID": "SAPISID",
+    "__Secure-1PAPISID": "SAPISID",  # 也映射到 SAPISID
+    "SID": "SID",
+    "HSID": "HSID",
+    "SSID": "SSID",
+    "APISID": "APISID",
+}
+
+
+def parse_cookie_string(cookie_str: str) -> dict:
+    """解析完整cookie字符串，提取所需字段"""
+    result = {}
+    if not cookie_str:
+        return result
+    
+    for item in cookie_str.split(";"):
+        item = item.strip()
+        if "=" in item:
+            eq_index = item.index("=")
+            key = item[:eq_index].strip()
+            value = item[eq_index + 1:].strip()
+            if key in COOKIE_FIELD_MAP:
+                result[COOKIE_FIELD_MAP[key]] = value
+    
+    return result
+
+
+def fetch_tokens_from_page(cookies_str: str) -> dict:
+    """从 Gemini 页面自动获取 SNLM0E、PUSH_ID 和可用模型列表"""
+    result = {"snlm0e": "", "push_id": "", "models": []}
+    try:
+        session = httpx.Client(
+            timeout=30.0,
+            follow_redirects=True,
+            headers={
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+                "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+            }
+        )
+        
+        # 设置 cookies
+        for item in cookies_str.split(";"):
+            item = item.strip()
+            if "=" in item:
+                key, value = item.split("=", 1)
+                session.cookies.set(key.strip(), value.strip(), domain=".google.com")
+        
+        resp = session.get("https://gemini.google.com")
+        if resp.status_code != 200:
+            return result
+        
+        html = resp.text
+        
+        # 获取 SNLM0E (AT Token)
+        snlm0e_patterns = [
+            r'"SNlM0e":"([^"]+)"',
+            r'SNlM0e["\s:]+["\']([^"\']+)["\']',
+            r'"at":"([^"]+)"',
+        ]
+        for pattern in snlm0e_patterns:
+            match = re.search(pattern, html)
+            if match:
+                result["snlm0e"] = match.group(1)
+                break
+        
+        # 获取 PUSH_ID
+        push_id_patterns = [
+            r'"push[_-]?id["\s:]+["\'](feeds/[a-z0-9]+)["\']',
+            r'push[_-]?id["\s:=]+["\'](feeds/[a-z0-9]+)["\']',
+            r'feedName["\s:]+["\'](feeds/[a-z0-9]+)["\']',
+            r'clientId["\s:]+["\'](feeds/[a-z0-9]+)["\']',
+            r'(feeds/[a-z0-9]{14,})',
+        ]
+        for pattern in push_id_patterns:
+            matches = re.findall(pattern, html, re.IGNORECASE)
+            if matches:
+                result["push_id"] = matches[0]
+                break
+        
+        # 获取可用模型列表 (从页面中提取 gemini 模型 ID)
+        model_patterns = [
+            r'"(gemini-[a-z0-9\.\-]+)"',  # 匹配 "gemini-xxx" 格式
+            r"'(gemini-[a-z0-9\.\-]+)'",  # 匹配 'gemini-xxx' 格式
+        ]
+        models_found = set()
+        for pattern in model_patterns:
+            matches = re.findall(pattern, html, re.IGNORECASE)
+            for m in matches:
+                # 过滤有效的模型名称
+                if any(x in m.lower() for x in ['flash', 'pro', 'ultra', 'nano']):
+                    models_found.add(m)
+        
+        if models_found:
+            result["models"] = sorted(list(models_found))
+        
+        # 获取模型 ID (用于 x-goog-ext-525001261-jspb 请求头)
+        # 这些 ID 用于选择不同的模型版本
+        model_id_pattern = r'\["([a-f0-9]{16})","gemini[^"]*(?:flash|pro|thinking)[^"]*"\]'
+        model_ids = re.findall(model_id_pattern, html, re.IGNORECASE)
+        if model_ids:
+            result["model_ids"] = list(set(model_ids))
+        
+        #备用方案：直接搜索 16 位十六进制 ID（在模型配置附近）
+        if not result.get("model_ids"):
+            # 搜索类似 "56fdd199312815e2" 的模式
+            hex_id_pattern = r'"([a-f0-9]{16})"'
+            # 在包含 gemini 或 model 的上下文中查找
+            context_pattern = r'.{0,100}(?:gemini|model|flash|pro|thinking).{0,100}'
+            contexts = re.findall(context_pattern, html, re.IGNORECASE)
+            hex_ids = set()
+            for ctx in contexts:
+                ids = re.findall(hex_id_pattern, ctx)
+                hex_ids.update(ids)
+            if hex_ids:
+                result["model_ids"] = list(hex_ids)
+        
+        return result
+    except Exception:
+        return result
+
+_client = None
+_last_token_refresh = 0  # 上次 token 刷新时间
+_token_refresh_count = 0  # token 刷新次数统计
+
+
+def try_refresh_tokens(force: bool = False) -> dict:
+    """
+    尝试刷新 token
+    
+    Args:
+        force: 是否强制刷新，忽略时间间隔
+        
+    Returns:
+        dict: {"success": bool, "message": str, "snlm0e": str, "push_id": str}
+    """
+    global _client, _last_token_refresh, _token_refresh_count, _config
+    
+    result = {"success": False, "message": "", "snlm0e": "", "push_id": ""}
+    
+    if not TOKEN_AUTO_REFRESH and not force:
+        result["message"] = "自动刷新已禁用"
+        return result
+    
+    current_time = time.time()
+    now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    # 检查是否需要刷新（除非强制刷新）
+    if not force and (current_time - _last_token_refresh) < TOKEN_REFRESH_INTERVAL_MIN:
+        result["message"] = f"距离上次刷新不足 {TOKEN_REFRESH_INTERVAL_MIN} 秒"
+        return result
+    
+    try:
+        # 如果 client 存在，使用 client 的刷新方法
+        if _client is not None:
+            refresh_result = _client.refresh_tokens()
+            if refresh_result["success"]:
+                # 更新配置
+                if refresh_result["snlm0e"]:
+                    _config["SNLM0E"] = refresh_result["snlm0e"]
+                    result["snlm0e"] = refresh_result["snlm0e"]
+                if refresh_result["push_id"]:
+                    _config["PUSH_ID"] = refresh_result["push_id"]
+                    result["push_id"] = refresh_result["push_id"]
+                
+                # 保存配置
+                save_config()
+                
+                _last_token_refresh = current_time
+                _token_refresh_count += 1
+                result["success"] = True
+                result["message"] = f"Token 刷新成功 (第 {_token_refresh_count} 次)"
+                print(f"✅ [{now_str}] Token 自动刷新成功 (第 {_token_refresh_count} 次)")
+            else:
+                result["message"] = refresh_result.get("error", "刷新失败")
+                print(f"⚠️ [{now_str}] Token 刷新失败: {result['message']}")
+        else:
+            # client 不存在，使用 fetch_tokens_from_page
+            cookies = _config.get("FULL_COOKIE", "")
+            if not cookies:
+                cookies = f"__Secure-1PSID={_config.get('SECURE_1PSID', '')}"
+                if _config.get("SECURE_1PSIDTS"):
+                    cookies += f"; __Secure-1PSIDTS={_config['SECURE_1PSIDTS']}"
+            
+            tokens = fetch_tokens_from_page(cookies)
+            if tokens.get("snlm0e"):
+                _config["SNLM0E"] = tokens["snlm0e"]
+                result["snlm0e"] = tokens["snlm0e"]
+            if tokens.get("push_id"):
+                _config["PUSH_ID"] = tokens["push_id"]
+                result["push_id"] = tokens["push_id"]
+            
+            if tokens.get("snlm0e"):
+                save_config()
+                _last_token_refresh = current_time
+                _token_refresh_count += 1
+                result["success"] = True
+                result["message"] = f"Token 刷新成功 (第 {_token_refresh_count} 次)"
+                print(f"✅ [{now_str}] Token 自动刷新成功 (第 {_token_refresh_count} 次)")
+            else:
+                result["message"] = "无法从页面获取新 token"
+        
+        return result
+        
+    except Exception as e:
+        result["message"] = f"刷新异常: {str(e)}"
+        print(f"❌ [{now_str}] Token 刷新异常: {e}")
+        return result
+
+
+def reset_client():
+    """重置 client，下次请求时会重新创建"""
+    global _client
+    _client = None
+    now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"🔄 [{now_str}] Client 已重置，下次请求将重新创建")
+
+
+# ============ 后台定时刷新任务 ============
+def get_current_time_str():
+    """获取当前时间字符串"""
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def get_random_refresh_interval():
+    """获取随机刷新间隔"""
+    return random.randint(TOKEN_REFRESH_INTERVAL_MIN, TOKEN_REFRESH_INTERVAL_MAX)
+
+
+async def background_token_refresh():
+    """后台定时刷新 token 任务"""
+    global _background_refresh_stop
+    print(f"🔄 [{get_current_time_str()}] 后台 Token 定时刷新任务已启动")
+    
+    while not _background_refresh_stop:
+        try:
+            # 随机等待间隔
+            interval = get_random_refresh_interval()
+            print(f"⏳ [{get_current_time_str()}] 下次刷新将在 {interval} 秒后")
+            await asyncio.sleep(interval)
+            
+            if _background_refresh_stop:
+                break
+            
+            if not TOKEN_BACKGROUND_REFRESH:
+                continue
+            
+            # 执行刷新
+            print(f"⏰ [{get_current_time_str()}] 后台定时刷新 Token...")
+            result = try_refresh_tokens(force=True)
+            
+            if result["success"]:
+                print(f"✅ [{get_current_time_str()}] 后台刷新成功: {result['message']}")
+            else:
+                print(f"⚠️ [{get_current_time_str()}] 后台刷新失败: {result['message']}")
+                
+        except asyncio.CancelledError:
+            break
+        except Exception as e:
+            print(f"❌ [{get_current_time_str()}] 后台刷新异常: {e}")
+            await asyncio.sleep(60)  # 出错后等待 1 分钟再试
+    
+    print(f"🛑 [{get_current_time_str()}] 后台 Token 定时刷新任务已停止")
+
+
+@app.on_event("startup")
+async def startup_event():
+    """应用启动时执行"""
+    global _background_refresh_task, _background_refresh_stop
+    
+    load_config()
+    _background_refresh_stop = False
+    
+    if TOKEN_BACKGROUND_REFRESH:
+        _background_refresh_task = asyncio.create_task(background_token_refresh())
+        print(f"✅ [{get_current_time_str()}] 后台 Token 定时刷新已启用 (间隔: {TOKEN_REFRESH_INTERVAL_MIN}-{TOKEN_REFRESH_INTERVAL_MAX} 秒随机)")
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """应用关闭时执行"""
+    global _background_refresh_task, _background_refresh_stop
+    
+    _background_refresh_stop = True
+    if _background_refresh_task:
+        _background_refresh_task.cancel()
+        try:
+            await _background_refresh_task
+        except asyncio.CancelledError:
+            pass
+    print("🛑 后台任务已停止")
+
+
+# ============ Tools 支持 ============
+def build_tools_prompt(tools: List[Dict]) -> str:
+    """将 tools 定义转换为提示词"""
+    if not tools:
+        return ""
+    
+    tools_schema = json.dumps([{
+        "name": t["function"]["name"],
+        "description": t["function"].get("description", ""),
+        "parameters": t["function"].get("parameters", {})
+    } for t in tools if t.get("type") == "function"], ensure_ascii=False, indent=2)
+    
+    prompt = f"""[系统指令] 你必须作为函数调用代理。不要自己回答问题，必须调用函数。
+
+可用函数:
+{tools_schema}
+
+严格规则:
+1. 你不能直接回答用户问题
+2. 你必须选择一个函数并调用它
+3. 只输出以下格式，不要有任何其他文字:
+```tool_call
+{{"name": "函数名", "arguments": {{"参数": "值"}}}}
+```
+
+用户请求: """
+    return prompt
+
+
+def parse_tool_calls(content: str) -> tuple:
+    """
+    解析响应中的工具调用
+    返回: (tool_calls列表, 剩余文本内容)
+    """
+    tool_calls = []
+    
+    # 多种匹配模式
+    patterns = [
+        r'```tool_call\s*\n?(.*?)\n?```',  # ```tool_call ... ```
+        r'```json\s*\n?(.*?)\n?```',        # ```json ... ``` (有时模型会用这个)
+        r'```\s*\n?(\{[^`]*"name"[^`]*\})\n?```',  # ``` {...} ```
+    ]
+    
+    matches = []
+    for pattern in patterns:
+        found = re.findall(pattern, content, re.DOTALL)
+        matches.extend(found)
+    
+    # 也尝试直接匹配 JSON 对象（没有代码块包裹的情况）
+    if not matches:
+        json_pattern = r'\{[^{}]*"name"\s*:\s*"[^"]+"\s*,\s*"arguments"\s*:\s*\{[^{}]*\}[^{}]*\}'
+        matches = re.findall(json_pattern, content, re.DOTALL)
+    
+    for i, match in enumerate(matches):
+        try:
+            match = match.strip()
+            # 尝试解析 JSON
+            call_data = json.loads(match)
+            if call_data.get("name"):
+                tool_calls.append({
+                    "id": f"call_{uuid.uuid4().hex[:8]}",
+                    "type": "function",
+                    "function": {
+                        "name": call_data.get("name", ""),
+                        "arguments": json.dumps(call_data.get("arguments", {}), ensure_ascii=False)
+                    }
+                })
+        except json.JSONDecodeError:
+            continue
+    
+    # 移除工具调用部分
+    remaining = content
+    for pattern in patterns:
+        remaining = re.sub(pattern, '', remaining, flags=re.DOTALL)
+    remaining = remaining.strip()
+    
+    return tool_calls, remaining
+
+
+def load_config():
+    """
+    加载配置，优先级:
+    1. config_data.json (前端保存的配置)
+    2. config.py (本地开发配置，仅作为备用)
+    """
+    global _config
+    loaded_from_json = False
+    
+    # 优先从 JSON 文件加载
+    if os.path.exists(CONFIG_FILE):
+        try:
+            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+                saved = json.load(f)
+                if saved.get("SNLM0E") and saved.get("SECURE_1PSID"):
+                    _config.update(saved)
+                    loaded_from_json = True
+        except:
+            pass
+    
+    # 如果 JSON 没有有效配置，尝试从 config.py 加载
+    if not loaded_from_json:
+        try:
+            import config
+            for key in _config:
+                if hasattr(config, key) and getattr(config, key):
+                    _config[key] = getattr(config, key)
+        except:
+            pass
+
+
+def save_config():
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(_config, f, indent=2, ensure_ascii=False)
+
+
+def get_client(auto_refresh: bool = True):
+    global _client, _last_token_refresh
+    
+    if not _config.get("SNLM0E") or not _config.get("SECURE_1PSID"):
+        raise HTTPException(status_code=500, detail="请先在后台配置 Token 和 Cookie")
+    
+    # 检查是否需要自动刷新 token
+    if auto_refresh and TOKEN_AUTO_REFRESH:
+        current_time = time.time()
+        if (current_time - _last_token_refresh) >= TOKEN_REFRESH_INTERVAL_MIN:
+            try_refresh_tokens()
+    
+    # 如果 client 已存在，直接复用，保持会话上下文
+    if _client is not None:
+        return _client
+    
+    cookies = f"__Secure-1PSID={_config['SECURE_1PSID']}"
+    if _config.get("SECURE_1PSIDTS"):
+        cookies += f"; __Secure-1PSIDTS={_config['SECURE_1PSIDTS']}"
+    if _config.get("SAPISID"):
+        cookies += f"; SAPISID={_config['SAPISID']}; __Secure-1PAPISID={_config['SAPISID']}"
+    if _config.get("SID"):
+        cookies += f"; SID={_config['SID']}"
+    if _config.get("HSID"):
+        cookies += f"; HSID={_config['HSID']}"
+    if _config.get("SSID"):
+        cookies += f"; SSID={_config['SSID']}"
+    if _config.get("APISID"):
+        cookies += f"; APISID={_config['APISID']}"
+    
+    # 构建媒体文件的基础 URL (优先使用配置的外网地址)
+    media_base_url = MEDIA_BASE_URL if MEDIA_BASE_URL else f"http://localhost:{PORT}"
+    
+    from client import GeminiClient
+    _client = GeminiClient(
+        secure_1psid=_config["SECURE_1PSID"],
+        snlm0e=_config["SNLM0E"],
+        cookies_str=cookies,
+        push_id=_config.get("PUSH_ID") or None,
+        model_ids=_config.get("MODEL_IDS") or DEFAULT_MODEL_IDS,
+        debug=False,
+        media_base_url=media_base_url,
+    )
+    return _client
+
+
+def get_login_html():
+    return '''<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>登录 - Gemini API</title>
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); min-height: 100vh; 
+            display: flex; align-items: center; justify-content: center; padding: 20px; }
+        .login-card { background: white; border-radius: 16px; padding: 40px; box-shadow: 0 20px 60px rgba(0,0,0,0.3); width: 100%; max-width: 400px; }
+        h1 { color: #333; margin-bottom: 10px; font-size: 28px; text-align: center; }
+        .subtitle { color: #666; margin-bottom: 30px; font-size: 14px; text-align: center; }
+        .form-group { margin-bottom: 20px; }
+        label { display: block; font-size: 13px; font-weight: 500; color: #555; margin-bottom: 8px; }
+        input { width: 100%; padding: 14px 16px; border: 2px solid #e0e0e0; border-radius: 8px; font-size: 15px; transition: border-color 0.2s; }
+        input:focus { outline: none; border-color: #667eea; }
+        .btn { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border: none; padding: 14px 30px;
+            border-radius: 8px; font-size: 16px; font-weight: 600; cursor: pointer; width: 100%; margin-top: 10px; transition: transform 0.2s, box-shadow 0.2s; }
+        .btn:hover { transform: translateY(-2px); box-shadow: 0 5px 20px rgba(102,126,234,0.4); }
+        .btn:disabled { opacity: 0.7; cursor: not-allowed; transform: none; }
+        .error { background: #f8d7da; color: #721c24; padding: 12px; border-radius: 8px; margin-bottom: 20px; font-size: 14px; display: none; }
+        .logo { text-align: center; margin-bottom: 20px; font-size: 48px; }
+    </style>
+</head>
+<body>
+    <div class="login-card">
+        <div class="logo">🤖</div>
+        <h1>Gemini API</h1>
+        <p class="subtitle">请登录以访问后台管理</p>
+        
+        <div id="error" class="error"></div>
+        
+        <form id="loginForm">
+            <div class="form-group">
+                <label>用户名</label>
+                <input type="text" name="username" id="username" placeholder="请输入用户名" required autofocus>
+            </div>
+            <div class="form-group">
+                <label>密码</label>
+                <input type="password" name="password" id="password" placeholder="请输入密码" required>
+            </div>
+            <button type="submit" class="btn" id="submitBtn">登 录</button>
+        </form>
+    </div>
+    
+    <script>
+        document.getElementById('loginForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const errorEl = document.getElementById('error');
+            const submitBtn = document.getElementById('submitBtn');
+            
+            errorEl.style.display = 'none';
+            submitBtn.disabled = true;
+            submitBtn.textContent = '登录中...';
+            
+            try {
+                const resp = await fetch('/admin/login', {
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json'},
+                    body: JSON.stringify({
+                        username: document.getElementById('username').value,
+                        password: document.getElementById('password').value
+                    })
+                });
+                const result = await resp.json();
+                
+                if (result.success) {
+                    window.location.href = '/admin';
+                } else {
+                    errorEl.textContent = result.message || '登录失败';
+                    errorEl.style.display = 'block';
+                }
+            } catch (err) {
+                errorEl.textContent = '网络错误: ' + err.message;
+                errorEl.style.display = 'block';
+            } finally {
+                submitBtn.disabled = false;
+                submitBtn.textContent = '登 录';
+            }
+        });
+    </script>
+</body>
+</html>'''
+
+
+def get_admin_html():
+    return '''<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Gemini API 配置</title>
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); min-height: 100vh; padding: 20px; }
+        .container { max-width: 800px; margin: 0 auto; }
+        .card { background: white; border-radius: 16px; padding: 30px; box-shadow: 0 20px 60px rgba(0,0,0,0.3); position: relative; }
+        .token-status { position: absolute; top: 15px; left: 20px; font-size: 12px; padding: 6px 12px; border-radius: 20px; font-weight: 500; }
+        .token-status.valid { background: #d4edda; color: #155724; }
+        .token-status.invalid { background: #f8d7da; color: #721c24; }
+        .token-status.loading { background: #fff3cd; color: #856404; }
+        h1 { color: #333; margin-bottom: 10px; font-size: 28px; }
+        .subtitle { color: #666; margin-bottom: 30px; font-size: 14px; }
+        .section { margin-bottom: 25px; }
+        .section-title { font-size: 16px; font-weight: 600; color: #333; margin-bottom: 15px; padding-bottom: 10px; border-bottom: 2px solid #eee; }
+        .required { color: #e74c3c; }
+        .optional { color: #95a5a6; font-size: 12px; }
+        .form-group { margin-bottom: 15px; }
+        label { display: block; font-size: 13px; font-weight: 500; color: #555; margin-bottom: 5px; }
+        input, textarea { width: 100%; padding: 12px 15px; border: 2px solid #e0e0e0; border-radius: 8px; font-size: 14px; font-family: monospace; transition: border-color 0.2s; }
+        input:focus, textarea:focus { outline: none; border-color: #667eea; }
+        textarea { resize: vertical; min-height: 80px; }
+        .btn { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border: none; padding: 14px 30px;
+            border-radius: 8px; font-size: 16px; font-weight: 600; cursor: pointer; width: 100%; margin-top: 20px; transition: transform 0.2s, box-shadow 0.2s; }
+        .btn:hover { transform: translateY(-2px); box-shadow: 0 5px 20px rgba(102,126,234,0.4); }
+        .status { margin-top: 20px; padding: 15px; border-radius: 8px; font-size: 14px; display: none; }
+        .status.success { background: #d4edda; color: #155724; display: block; }
+        .status.error { background: #f8d7da; color: #721c24; display: block; }
+        .info-box { background: #f8f9fa; border-radius: 8px; padding: 15px; margin-bottom: 20px; font-size: 13px; color: #666; }
+        .info-box code { background: #e9ecef; padding: 2px 6px; border-radius: 4px; }
+        .api-info { background: #e8f4fd; border-left: 4px solid #667eea; padding: 15px; margin-top: 20px; border-radius: 0 8px 8px 0; }
+        .api-info h3 { font-size: 14px; margin-bottom: 10px; color: #333; }
+        .api-info pre { background: #fff; padding: 10px; border-radius: 4px; font-size: 12px; margin-top: 5px; overflow-x: auto; }
+        .parsed-info { background: #f0f9ff; border: 1px solid #bae6fd; border-radius: 8px; padding: 15px; margin-top: 15px; font-size: 12px; display: none; }
+        .parsed-info h4 { color: #0369a1; margin-bottom: 10px; }
+        .parsed-info .item { margin: 5px 0; color: #555; }
+        .parsed-info .item span { color: #059669; font-family: monospace; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="card">
+            <div id="tokenStatus" class="token-status loading">🔄 检查中...</div>
+            <h1>🤖 Gemini API 配置</h1>
+            <p class="subtitle">配置 Google Gemini 的认证信息，保存后即可调用 API <a href="/admin/logout" style="float:right;color:#667eea;text-decoration:none;">退出登录</a></p>
+            
+            <div class="info-box">
+                <strong>获取方法：</strong><br>
+                1. 打开 <a href="https://gemini.google.com" target="_blank">gemini.google.com</a> 并登录<br>
+                2. F12 → 网络 → 发送内容到聊天 →  点击任意请求 → Copy 请求头内完整cookie
+            </div>
+            
+            <form id="configForm">
+                <div class="section">
+                    <div class="section-title">🔑 Cookie 配置</div>
+                    <div class="form-group">
+                        <label>完整 Cookie <span class="required">*</span></label>
+                        <textarea name="FULL_COOKIE" id="FULL_COOKIE" rows="6" placeholder="粘贴从浏览器复制的完整 Cookie 字符串，系统会自动解析所需字段和 Token..." required></textarea>
+                        <div id="parsedInfo" class="parsed-info">
+                            <h4>✅ 已解析的字段：</h4>
+                            <div id="parsedFields"></div>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="section">
+                    <div class="section-title">🎯 模型 ID 配置 <span class="optional">(可选，如果模型切换失效请更新)</span></div>
+                    <div class="info-box">
+                        <strong>获取方法：</strong>F12 → Network → 在 Gemini 中切换模型发送消息 → 找到请求头 <code>x-goog-ext-525001261-jspb</code> → 复制整个数组值粘贴到下方输入框
+                    </div>
+                    <div class="form-group">
+                        <label>快速解析 <span class="optional">(粘贴请求头数组自动提取 ID)</span></label>
+                        <input type="text" id="MODEL_ID_PARSER" placeholder='粘贴如: [1,null,null,null,"56fdd199312815e2",null,null,0,[4],null,null,2]'>
+                        <div id="parsedModelId" class="parsed-info" style="margin-top:10px;">
+                            <h4>✅ 已提取的模型 ID：</h4>
+                            <div id="parsedModelIdValue"></div>
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label>极速版 (Flash) ID</label>
+                        <input type="text" name="MODEL_ID_FLASH" id="MODEL_ID_FLASH" placeholder="56fdd199312815e2">
+                    </div>
+                    <div class="form-group">
+                        <label>Pro 版 ID</label>
+                        <input type="text" name="MODEL_ID_PRO" id="MODEL_ID_PRO" placeholder="e6fa609c3fa255c0">
+                    </div>
+                    <div class="form-group">
+                        <label>思考版 (Thinking) ID</label>
+                        <input type="text" name="MODEL_ID_THINKING" id="MODEL_ID_THINKING" placeholder="e051ce1aa80aa576">
+                    </div>
+                </div>
+                
+                <button type="submit" class="btn">💾 保存配置</button>
+            </form>
+            
+            <div id="status" class="status"></div>
+            
+            <div class="api-info">
+                <h3>📡 API 调用信息</h3>
+                <p>Base URL: <strong id="baseUrl"></strong></p>
+                <p>API Key: <strong id="apiKey"></strong></p>
+                <p>可用模型: <code>gemini-3.0-flash</code> | <code>gemini-3.0-pro</code> | <code>gemini-3.0-flash-thinking</code></p>
+                
+                <h4 style="margin-top:15px;">💬 文本对话</h4>
+<pre>from openai import OpenAI
+client = OpenAI(base_url="<span id="codeUrl"></span>", api_key="<span id="codeKey"></span>")
+
+response = client.chat.completions.create(
+    model="gemini-3.0-flash",  # 或 gemini-3.0-pro / gemini-3.0-flash-thinking
+    messages=[{"role": "user", "content": "你好"}]
+)
+print(response.choices[0].message.content)</pre>
+
+                <h4 style="margin-top:15px;">🖼️ 图片识别</h4>
+<pre>import base64
+from openai import OpenAI
+client = OpenAI(base_url="<span id="codeUrl2"></span>", api_key="<span id="codeKey2"></span>")
+
+# 读取本地图片
+with open("image.png", "rb") as f:
+    img_b64 = base64.b64encode(f.read()).decode()
+
+response = client.chat.completions.create(
+    model="gemini-3.0-flash",
+    messages=[{
+        "role": "user",
+        "content": [
+            {"type": "text", "text": "请描述这张图片"},
+            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img_b64}"}}
+        ]
+    }]
+)
+print(response.choices[0].message.content)</pre>
+
+                <h4 style="margin-top:15px;">🌊 流式响应</h4>
+<pre>stream = client.chat.completions.create(
+    model="gemini-3.0-flash",
+    messages=[{"role": "user", "content": "写一首诗"}],
+    stream=True
+)
+for chunk in stream:
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="", flush=True)</pre>
+
+                <h4 style="margin-top:15px;">📷 示例图片</h4>
+                <p style="font-size:12px;color:#666;">以下是 image.png 示例图片，可用于测试图片识别功能（点击放大）：</p>
+                <img id="sampleImage" src="/static/image.png" alt="示例图片" style="max-width:300px;border-radius:8px;margin-top:10px;border:1px solid #ddd;cursor:pointer;" onclick="showImageModal()" onerror="this.style.display='none';this.nextElementSibling.style.display='block';">
+                <p style="display:none;font-size:12px;color:#999;">（示例图片不可用，请确保 image.png 文件存在）</p>
+            </div>
+        </div>
+    </div>
+    
+    <!-- 图片放大模态框 -->
+    <div id="imageModal" style="display:none;position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(0,0,0,0.8);z-index:1000;justify-content:center;align-items:center;cursor:pointer;" onclick="hideImageModal()">
+        <img src="/static/image.png" alt="示例图片" style="max-width:90%;max-height:90%;border-radius:8px;box-shadow:0 0 30px rgba(0,0,0,0.5);">
+        <span style="position:absolute;top:20px;right:30px;color:white;font-size:30px;cursor:pointer;">&times;</span>
+    </div>
+    
+    <script>
+        // 图片放大功能
+        function showImageModal() {
+            document.getElementById('imageModal').style.display = 'flex';
+            document.body.style.overflow = 'hidden';
+        }
+        function hideImageModal() {
+            document.getElementById('imageModal').style.display = 'none';
+            document.body.style.overflow = 'auto';
+        }
+        // ESC 键关闭
+        document.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape') hideImageModal();
+        });
+        
+        const API_KEY = "''' + API_KEY + '''";
+        const PORT = ''' + str(PORT) + ''';
+        
+        document.getElementById('baseUrl').textContent = 'http://localhost:' + PORT + '/v1';
+        document.getElementById('apiKey').textContent = API_KEY;
+        document.getElementById('codeUrl').textContent = 'http://localhost:' + PORT + '/v1';
+        document.getElementById('codeKey').textContent = API_KEY;
+        document.getElementById('codeUrl2').textContent = 'http://localhost:' + PORT + '/v1';
+        document.getElementById('codeKey2').textContent = API_KEY;
+        
+        // 获取并显示 Token 状态
+        async function updateTokenStatus() {
+            const statusEl = document.getElementById('tokenStatus');
+            try {
+                const resp = await fetch('/v1/token/status', {
+                    headers: { 'Authorization': 'Bearer ' + API_KEY }
+                });
+                const data = await resp.json();
+                
+                if (data.has_snlm0e && data.total_refresh_count >= 0) {
+                    statusEl.className = 'token-status valid';
+                    statusEl.innerHTML = '✅ Token 有效 | 已刷新 ' + data.total_refresh_count + ' 次';
+                } else {
+                    statusEl.className = 'token-status invalid';
+                    statusEl.innerHTML = '❌ Token 已失效';
+                }
+            } catch (e) {
+                statusEl.className = 'token-status invalid';
+                statusEl.innerHTML = '❌ 无法获取状态';
+            }
+        }
+        
+        // 页面加载时获取状态，并每 30 秒刷新一次
+        updateTokenStatus();
+        setInterval(updateTokenStatus, 30000);
+        
+        // 解析模型 ID (从 x-goog-ext-525001261-jspb 数组中提取)
+        function parseModelId(input) {
+            try {
+                // 尝试解析 JSON 数组
+                const arr = JSON.parse(input);
+                if (Array.isArray(arr) && arr.length > 4 && typeof arr[4] === 'string') {
+                    return arr[4];
+                }
+            } catch (e) {
+                // 尝试用正则提取 16 位十六进制字符串
+                const match = input.match(/["\']([a-f0-9]{16})["\']/i);
+                if (match) {
+                    return match[1];
+                }
+            }
+            return null;
+        }
+        
+        // 监听模型 ID 解析输入
+        document.getElementById('MODEL_ID_PARSER').addEventListener('input', (e) => {
+            const modelId = parseModelId(e.target.value);
+            const container = document.getElementById('parsedModelIdValue');
+            const infoBox = document.getElementById('parsedModelId');
+            
+            if (modelId) {
+                container.innerHTML = '<div class="item">提取到的 ID: <span style="color:#059669;font-family:monospace;">' + modelId + '</span></div>' +
+                    '<div style="margin-top:10px;">' +
+                    '<button type="button" onclick="fillModelId(\\'flash\\', \\'' + modelId + '\\')" style="margin-right:5px;padding:5px 10px;cursor:pointer;">填入极速版</button>' +
+                    '<button type="button" onclick="fillModelId(\\'pro\\', \\'' + modelId + '\\')" style="margin-right:5px;padding:5px 10px;cursor:pointer;">填入Pro版</button>' +
+                    '<button type="button" onclick="fillModelId(\\'thinking\\', \\'' + modelId + '\\')" style="padding:5px 10px;cursor:pointer;">填入思考版</button>' +
+                    '</div>';
+                infoBox.style.display = 'block';
+            } else {
+                infoBox.style.display = 'none';
+            }
+        });
+        
+        // 填入模型 ID
+        function fillModelId(type, id) {
+            const fieldMap = {
+                'flash': 'MODEL_ID_FLASH',
+                'pro': 'MODEL_ID_PRO',
+                'thinking': 'MODEL_ID_THINKING'
+            };
+            document.getElementById(fieldMap[type]).value = id;
+        }
+        
+        // Cookie 字段映射
+        const cookieFields = {
+            '__Secure-1PSID': 'SECURE_1PSID',
+            '__Secure-1PSIDTS': 'SECURE_1PSIDTS',
+            'SAPISID': 'SAPISID',
+            '__Secure-1PAPISID': 'SECURE_1PAPISID',
+            'SID': 'SID',
+            'HSID': 'HSID',
+            'SSID': 'SSID',
+            'APISID': 'APISID'
+        };
+        
+        // 解析 Cookie 字符串
+        function parseCookie(cookieStr) {
+            const result = {};
+            if (!cookieStr) return result;
+            
+            cookieStr.split(';').forEach(item => {
+                const trimmed = item.trim();
+                const eqIndex = trimmed.indexOf('=');
+                if (eqIndex > 0) {
+                    const key = trimmed.substring(0, eqIndex).trim();
+                    const value = trimmed.substring(eqIndex + 1).trim();
+                    if (cookieFields[key]) {
+                        result[cookieFields[key]] = value;
+                    }
+                }
+            });
+            return result;
+        }
+        
+        // 显示解析结果
+        function showParsedFields(parsed) {
+            const container = document.getElementById('parsedFields');
+            const infoBox = document.getElementById('parsedInfo');
+            
+            const fieldNames = {
+                'SECURE_1PSID': '__Secure-1PSID',
+                'SECURE_1PSIDTS': '__Secure-1PSIDTS',
+                'SAPISID': 'SAPISID',
+                'SID': 'SID',
+                'HSID': 'HSID',
+                'SSID': 'SSID',
+                'APISID': 'APISID'
+            };
+            
+            let html = '';
+            let hasFields = false;
+            for (const [key, name] of Object.entries(fieldNames)) {
+                if (parsed[key]) {
+                    hasFields = true;
+                    const shortValue = parsed[key].length > 30 ? parsed[key].substring(0, 30) + '...' : parsed[key];
+                    html += '<div class="item">' + name + ': <span>' + shortValue + '</span></div>';
+                }
+            }
+            
+            if (hasFields) {
+                container.innerHTML = html;
+                infoBox.style.display = 'block';
+            } else {
+                infoBox.style.display = 'none';
+            }
+        }
+        
+        // 监听 Cookie 输入
+        document.getElementById('FULL_COOKIE').addEventListener('input', (e) => {
+            const parsed = parseCookie(e.target.value);
+            showParsedFields(parsed);
+        });
+        
+        // 加载配置
+        fetch('/admin/config', {credentials: 'same-origin'}).then(r => {
+            if (!r.ok) throw new Error('未登录');
+            return r.json();
+        }).then(config => {
+            if (config.FULL_COOKIE) {
+                document.getElementById('FULL_COOKIE').value = config.FULL_COOKIE;
+                showParsedFields(parseCookie(config.FULL_COOKIE));
+            }
+            // 加载模型 ID
+            if (config.MODEL_IDS) {
+                document.getElementById('MODEL_ID_FLASH').value = config.MODEL_IDS.flash || '';
+                document.getElementById('MODEL_ID_PRO').value = config.MODEL_IDS.pro || '';
+                document.getElementById('MODEL_ID_THINKING').value = config.MODEL_IDS.thinking || '';
+            }
+        }).catch(err => {
+            console.log('加载配置失败:', err);
+        });
+        
+        document.getElementById('configForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const formData = new FormData(e.target);
+            const data = Object.fromEntries(formData.entries());
+            
+            // 构建模型 ID 对象
+            data.MODEL_IDS = {
+                flash: data.MODEL_ID_FLASH || '',
+                pro: data.MODEL_ID_PRO || '',
+                thinking: data.MODEL_ID_THINKING || ''
+            };
+            delete data.MODEL_ID_FLASH;
+            delete data.MODEL_ID_PRO;
+            delete data.MODEL_ID_THINKING;
+            
+            const statusEl = document.getElementById('status');
+            statusEl.className = 'status';
+            statusEl.style.display = 'none';
+            statusEl.textContent = '';
+            
+            // 显示保存中状态
+            const submitBtn = e.target.querySelector('button[type="submit"]');
+            const originalText = submitBtn.textContent;
+            submitBtn.textContent = '⏳ 保存中...';
+            submitBtn.disabled = true;
+            
+            try {
+                const resp = await fetch('/admin/save', {
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json'},
+                    credentials: 'same-origin',
+                    body: JSON.stringify(data)
+                });
+                
+                if (resp.status === 401) {
+                    window.location.href = '/admin/login';
+                    return;
+                }
+                
+                const result = await resp.json();
+                
+                if (result.success) {
+                    statusEl.className = 'status success';
+                    statusEl.innerHTML = '✅ ' + result.message + '<br><br>💡 <strong>配置已生效，无需重启服务！</strong>';
+                } else {
+                    statusEl.className = 'status error';
+                    statusEl.textContent = '❌ ' + result.message;
+                }
+                statusEl.style.display = 'block';
+            } catch (err) {
+                statusEl.className = 'status error';
+                statusEl.textContent = '❌ 保存失败: ' + err.message;
+                statusEl.style.display = 'block';
+            } finally {
+                submitBtn.textContent = originalText;
+                submitBtn.disabled = false;
+            }
+        });
+    </script>
+</body>
+</html>'''
+
+
+@app.get("/admin/login", response_class=HTMLResponse)
+async def admin_login_page():
+    return get_login_html()
+
+
+@app.post("/admin/login")
+async def admin_login(request: Request):
+    data = await request.json()
+    username = data.get("username", "")
+    password = data.get("password", "")
+    
+    if username == ADMIN_USERNAME and password == ADMIN_PASSWORD:
+        token = generate_session_token()
+        _admin_sessions.add(token)
+        response = JSONResponse({"success": True, "message": "登录成功"})
+        response.set_cookie(key="admin_session", value=token, httponly=True, max_age=86400)
+        return response
+    else:
+        return {"success": False, "message": "用户名或密码错误"}
+
+
+@app.get("/admin/logout")
+async def admin_logout(request: Request):
+    token = request.cookies.get("admin_session")
+    if token and token in _admin_sessions:
+        _admin_sessions.discard(token)
+    response = RedirectResponse(url="/admin/login", status_code=302)
+    response.delete_cookie("admin_session")
+    return response
+
+
+@app.get("/admin", response_class=HTMLResponse)
+async def admin_page(request: Request):
+    if not verify_admin_session(request):
+        return RedirectResponse(url="/admin/login", status_code=302)
+    return get_admin_html()
+
+
+@app.post("/admin/save")
+async def admin_save(request: Request):
+    if not verify_admin_session(request):
+        raise HTTPException(status_code=401, detail="未登录")
+    
+    global _client
+    data = await request.json()
+    
+    # 处理完整 Cookie 字符串，去除前后空格
+    full_cookie = data.get("FULL_COOKIE", "").strip()
+    if not full_cookie:
+        return {"success": False, "message": "Cookie 是必填项"}
+    
+    # 解析 Cookie 字符串
+    parsed = parse_cookie_string(full_cookie)
+    
+    if not parsed.get("SECURE_1PSID"):
+        return {"success": False, "message": "Cookie 中未找到 __Secure-1PSID 字段，请确保复制了完整的 Cookie"}
+    
+    # 从页面自动获取 SNLM0E 和 PUSH_ID
+    tokens = fetch_tokens_from_page(full_cookie)
+    
+    if not tokens.get("snlm0e"):
+        return {"success": False, "message": "无法自动获取 AT Token，请检查 Cookie 是否有效或已过期"}
+    
+    # 更新配置
+    _config["FULL_COOKIE"] = full_cookie
+    _config["SNLM0E"] = tokens["snlm0e"]
+    _config["PUSH_ID"] = tokens.get("push_id", "")
+    
+    # 从解析结果更新各字段
+    for field in ["SECURE_1PSID", "SECURE_1PSIDTS", "SAPISID", "SID", "HSID", "SSID", "APISID"]:
+        _config[field] = parsed.get(field, "")
+    
+    # 使用自动获取的模型列表，如果获取失败则使用默认值
+    if tokens.get("models"):
+        _config["MODELS"] = tokens["models"]
+    else:
+        _config["MODELS"] = DEFAULT_MODELS.copy()
+    
+    # 处理模型 ID 配置
+    model_ids = data.get("MODEL_IDS", {})
+    if model_ids:
+        # 只更新非空的值
+        if model_ids.get("flash"):
+            _config["MODEL_IDS"]["flash"] = model_ids["flash"]
+        if model_ids.get("pro"):
+            _config["MODEL_IDS"]["pro"] = model_ids["pro"]
+        if model_ids.get("thinking"):
+            _config["MODEL_IDS"]["thinking"] = model_ids["thinking"]
+    
+    save_config()
+    _client = None
+    
+    # 构建结果信息
+    parsed_fields = [k for k in ["SECURE_1PSID", "SECURE_1PSIDTS", "SAPISID", "SID", "HSID", "SSID", "APISID"] if parsed.get(k)]
+    push_id_msg = f"，PUSH_ID ✓" if tokens.get("push_id") else "，PUSH_ID ✗ (图片功能不可用)"
+    models_msg = f"，{len(_config['MODELS'])} 个模型" if _config.get("MODELS") else ""
+    
+    try:
+        get_client()
+        return {
+            "success": True, 
+            "message": f"配置已保存并验证成功！AT Token ✓{push_id_msg}{models_msg}",
+            "need_restart": False
+        }
+    except Exception as e:
+        return {
+            "success": True, 
+            "message": f"配置已保存，但连接测试失败: {str(e)[:50]}",
+            "need_restart": False
+        }
+
+
+@app.get("/admin/config")
+async def admin_get_config(request: Request):
+    if not verify_admin_session(request):
+        raise HTTPException(status_code=401, detail="未登录")
+    return _config
+
+
+# ============ API 路由 ============
+
+class ChatMessage(BaseModel):
+    role: str
+    content: Union[str, List[Dict[str, Any]]]
+    name: Optional[str] = None
+    
+    class Config:
+        extra = "ignore"
+
+
+class FunctionDefinition(BaseModel):
+    name: str
+    description: Optional[str] = None
+    parameters: Optional[Dict[str, Any]] = None
+
+class ToolDefinition(BaseModel):
+    type: str = "function"
+    function: FunctionDefinition
+
+class ChatCompletionRequest(BaseModel):
+    model: str = "gemini"
+    messages: List[ChatMessage]
+    stream: Optional[bool] = False
+    # Tools 支持
+    tools: Optional[List[ToolDefinition]] = None
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None
+    # OpenAI SDK 可能发送的额外字段
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    presence_penalty: Optional[float] = None
+    stop: Optional[Union[str, List[str]]] = None
+    n: Optional[int] = None
+    user: Optional[str] = None
+    
+    class Config:
+        extra = "ignore"  # 忽略未定义的额外字段
+
+
+class ChatCompletionChoice(BaseModel):
+    index: int
+    message: Dict[str, Any]
+    finish_reason: str
+
+
+class Usage(BaseModel):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+class ChatCompletionResponse(BaseModel):
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[ChatCompletionChoice]
+    usage: Usage
+
+
+def verify_api_key(authorization: str = Header(None)):
+    if not API_KEY:
+        return True
+    if not authorization or not authorization.startswith("Bearer ") or authorization[7:] != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+    return True
+
+
+@app.get("/")
+async def root():
+    return RedirectResponse(url="/admin")
+
+
+@app.get("/v1/models")
+async def list_models(authorization: str = Header(None)):
+    verify_api_key(authorization)
+    models = _config.get("MODELS", DEFAULT_MODELS)
+    created = int(time.time())
+    return {
+        "object": "list",
+        "data": [{"id": m, "object": "model", "created": created, "owned_by": "google"} for m in models]
+    }
+
+
+@app.post("/v1/token/refresh")
+async def refresh_token_api(authorization: str = Header(None)):
+    """手动刷新 token API"""
+    verify_api_key(authorization)
+    result = try_refresh_tokens(force=True)
+    return {
+        "success": result["success"],
+        "message": result["message"],
+        "snlm0e_updated": bool(result.get("snlm0e")),
+        "push_id_updated": bool(result.get("push_id")),
+        "refresh_count": _token_refresh_count,
+    }
+
+
+@app.get("/v1/token/status")
+async def token_status_api(authorization: str = Header(None)):
+    """��看 token 状态 API"""
+    verify_api_key(authorization)
+    current_time = time.time()
+    time_since_refresh = int(current_time - _last_token_refresh) if _last_token_refresh > 0 else -1
+    
+    return {
+        "auto_refresh_enabled": TOKEN_AUTO_REFRESH,
+        "background_refresh_enabled": TOKEN_BACKGROUND_REFRESH,
+        "refresh_interval_range": f"{TOKEN_REFRESH_INTERVAL_MIN}-{TOKEN_REFRESH_INTERVAL_MAX}",
+        "last_refresh_seconds_ago": time_since_refresh,
+        "total_refresh_count": _token_refresh_count,
+        "has_snlm0e": bool(_config.get("SNLM0E")),
+        "has_push_id": bool(_config.get("PUSH_ID")),
+        "client_active": _client is not None,
+    }
+
+
+@app.post("/v1/client/reset")
+async def reset_client_api(authorization: str = Header(None)):
+    """重置 client API，用于 token 更新后强制重新创建 client"""
+    verify_api_key(authorization)
+    reset_client()
+    return {"success": True, "message": "Client 已重置，下次请求将使用新配置"}
+
+
+def log_api_call(request_data: dict, response_data: dict, error: str = None):
+    """记录 API 调用日志到文件"""
+    import datetime
+    log_entry = {
+        "timestamp": datetime.datetime.now().isoformat(),
+        "request": request_data,
+        "response": response_data,
+        "error": error
+    }
+    try:
+        with open("api_logs.json", "a", encoding="utf-8") as f:
+            f.write(json.dumps(log_entry, ensure_ascii=False, indent=2) + "\n---\n")
+    except Exception as e:
+        print(f"[LOG ERROR] 写入日志失败: {e}")
+
+
+# 用于追踪会话：保存上次请求的所有用户消息内容
+_last_user_messages_hash = ""
+
+
+def get_user_messages_hash(messages: list) -> str:
+    """计算所有用户消息的 hash，用于判断是否是同一会话"""
+    content_str = ""
+    for m in messages:
+        role = m.role if hasattr(m, 'role') else m.get('role', '')
+        if role != "user":
+            continue
+        content = m.content if hasattr(m, 'content') else m.get('content', '')
+        if isinstance(content, list):
+            # 对于包含图片的消息，只取文本部分
+            text_parts = [item.get('text', '') for item in content if item.get('type') == 'text']
+            content_str += f"{' '.join(text_parts)}|"
+        else:
+            content_str += f"{content}|"
+    return hashlib.md5(content_str.encode()).hexdigest()
+
+
+def is_continuation(current_messages: list, last_hash: str) -> bool:
+    """
+    判断当前请求是否是上一次对话的延续
+    
+    逻辑：如果当前消息去掉最后一条用户消息后的 hash 等于上次的 hash，
+    说明是同一对话的延续
+    """
+    if not last_hash:
+        return False
+    
+    # 找到所有用户消息
+    user_indices = [i for i, m in enumerate(current_messages) 
+                    if (m.role if hasattr(m, 'role') else m.get('role', '')) == "user"]
+    
+    if len(user_indices) <= 1:
+        # 只有一条用户消息，无法判断是否延续，视为新对话
+        return False
+    
+    # 去掉最后一条用户消息，计算剩余消息的 hash
+    last_user_idx = user_indices[-1]
+    prev_messages = current_messages[:last_user_idx]
+    prev_hash = get_user_messages_hash(prev_messages)
+    
+    return prev_hash == last_hash
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: ChatCompletionRequest, authorization: str = Header(None)):
+    global _last_user_messages_hash
+    verify_api_key(authorization)
+    
+    # 记录请求入参 (图片内容截断显示)
+    request_log = {
+        "model": request.model,
+        "stream": request.stream,
+        "messages": [],
+        "tools": [t.model_dump() for t in request.tools] if request.tools else None
+    }
+    image_count = 0
+    for m in request.messages:
+        msg_log = {"role": m.role}
+        if isinstance(m.content, list):
+            content_log = []
+            for item in m.content:
+                if item.get("type") == "image_url":
+                    image_count += 1
+                    img_url = item.get("image_url", {})
+                    if isinstance(img_url, dict):
+                        url = img_url.get("url", "")
+                    else:
+                        url = str(img_url)
+                    # 判断图片格式
+                    if url.startswith("data:"):
+                        img_format = "base64"
+                    elif url.startswith("http://") or url.startswith("https://"):
+                        img_format = "url"
+                    else:
+                        img_format = "unknown"
+                    content_log.append({
+                        "type": "image_url", 
+                        "format": img_format,
+                        "url_preview": url[:100] + "..." if len(url) > 100 else url
+                    })
+                else:
+                    content_log.append(item)
+            msg_log["content"] = content_log
+        else:
+            msg_log["content"] = m.content
+        request_log["messages"].append(msg_log)
+    
+    # 打印图片接收情况
+    if image_count > 0:
+        print(f"📷 收到 {image_count} 张图片")
+    
+    try:
+        client = get_client()
+        
+        if not is_continuation(request.messages, _last_user_messages_hash):
+            client.reset()
+        
+        # 处理消息
+        messages = []
+        for m in request.messages:
+            content = m.content
+            if isinstance(content, list):
+                messages.append({"role": m.role, "content": content})
+            else:
+                messages.append({"role": m.role, "content": content})
+        
+        # 如果有 tools，把工具提示词直接加到用户消息前面
+        if request.tools and len(messages) > 0:
+            tools_prompt = build_tools_prompt([t.model_dump() for t in request.tools])
+            for i in range(len(messages) - 1, -1, -1):
+                if messages[i]["role"] == "user":
+                    original = messages[i]["content"]
+                    if isinstance(original, str):
+                        messages[i]["content"] = tools_prompt + original
+                    break
+        
+        if request.stream:
+            _last_user_messages_hash = get_user_messages_hash(request.messages)
+            stream_iter = client.chat(messages=messages, model=request.model, stream=True)
+
+            def generate_real_stream():
+                streamed_text_parts = []
+                last_chunk = None
+
+                for chunk in stream_iter:
+                    if not chunk:
+                        continue
+                    last_chunk = chunk
+
+                    try:
+                        choices = chunk.get("choices", [])
+                        if choices:
+                            delta = choices[0].get("delta", {}) or {}
+                            piece = delta.get("content")
+                            if isinstance(piece, str) and piece:
+                                streamed_text_parts.append(piece)
+                    except Exception:
+                        pass
+
+                    yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+
+                # 流式也记录最终响应摘要，便于日志排查
+                try:
+                    full_stream_text = "".join(streamed_text_parts)
+                    completion_id_log = (last_chunk or {}).get("id", f"chatcmpl-{uuid.uuid4().hex[:8]}")
+                    created_time_log = (last_chunk or {}).get("created", int(time.time()))
+                    response_log = {
+                        "id": completion_id_log,
+                        "object": "chat.completion",
+                        "created": created_time_log,
+                        "model": request.model,
+                        "choices": [{
+                            "index": 0,
+                            "message": {"role": "assistant", "content": full_stream_text},
+                            "finish_reason": "stop"
+                        }],
+                        "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+                    }
+                    log_api_call(request_log, response_log)
+                except Exception:
+                    pass
+
+                yield "data: [DONE]\n\n"
+
+            return StreamingResponse(
+                generate_real_stream(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no",
+                }
+            )
+
+        response = client.chat(messages=messages, model=request.model)
+        _last_user_messages_hash = get_user_messages_hash(request.messages)
+        
+        reply_content = response.choices[0].message.content
+        completion_id = f"chatcmpl-{uuid.uuid4().hex[:8]}"
+        created_time = int(time.time())
+        
+        # 解析工具调用
+        tool_calls = []
+        final_content = reply_content
+        if request.tools:
+            tool_calls, final_content = parse_tool_calls(reply_content)
+        
+        # 处理流式响应
+        if request.stream:
+            async def generate_stream():
+                chunk_data = {
+                    "id": completion_id,
+                    "object": "chat.completion.chunk",
+                    "created": created_time,
+                    "model": request.model,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {"role": "assistant"},
+                        "finish_reason": None
+                    }]
+                }
+                yield f"data: {json.dumps(chunk_data)}\n\n"
+                
+                if tool_calls:
+                    # 流式返回工具调用
+                    for tc in tool_calls:
+                        chunk_data = {
+                            "id": completion_id,
+                            "object": "chat.completion.chunk",
+                            "created": created_time,
+                            "model": request.model,
+                            "choices": [{
+                                "index": 0,
+                                "delta": {"tool_calls": [tc]},
+                                "finish_reason": None
+                            }]
+                        }
+                        yield f"data: {json.dumps(chunk_data)}\n\n"
+                else:
+                    chunk_data = {
+                        "id": completion_id,
+                        "object": "chat.completion.chunk",
+                        "created": created_time,
+                        "model": request.model,
+                        "choices": [{
+                            "index": 0,
+                            "delta": {"content": final_content},
+                            "finish_reason": None
+                        }]
+                    }
+                    yield f"data: {json.dumps(chunk_data)}\n\n"
+                
+                chunk_data = {
+                    "id": completion_id,
+                    "object": "chat.completion.chunk",
+                    "created": created_time,
+                    "model": request.model,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {},
+                        "finish_reason": "tool_calls" if tool_calls else "stop"
+                    }]
+                }
+                yield f"data: {json.dumps(chunk_data)}\n\n"
+                yield "data: [DONE]\n\n"
+            
+            return StreamingResponse(
+                generate_stream(), 
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no",
+                }
+            )
+        
+        # 构建响应消息
+        response_message = {"role": "assistant"}
+        if tool_calls:
+            response_message["content"] = final_content if final_content else None
+            response_message["tool_calls"] = tool_calls
+            finish_reason = "tool_calls"
+        else:
+            response_message["content"] = final_content
+            finish_reason = "stop"
+        
+        response_data = ChatCompletionResponse(
+            id=completion_id,
+            created=created_time,
+            model=request.model,
+            choices=[ChatCompletionChoice(index=0, message=response_message, finish_reason=finish_reason)],
+            usage=Usage(prompt_tokens=response.usage.prompt_tokens, completion_tokens=response.usage.completion_tokens, total_tokens=response.usage.total_tokens)
+        )
+        
+        log_api_call(request_log, response_data.model_dump())
+        
+        return JSONResponse(
+            content=response_data.model_dump(),
+            headers={
+                "Cache-Control": "no-cache",
+                "X-Request-Id": completion_id,
+            }
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        import traceback
+        error_msg = str(e)
+        
+        # 检测是否是 token 过期错误
+        is_token_error = any(keyword in error_msg.lower() for keyword in [
+            'cookie', 'expired', '过期', '401', '403', 'unauthorized', 
+            'push_id', 'snlm0e', 'upload_id', '认证失败'
+        ])
+        
+        if is_token_error:
+            print(f"[WARN] 检测到 token 可能过期，尝试自动刷新...")
+            refresh_result = try_refresh_tokens(force=True)
+            
+            if refresh_result["success"]:
+                # 刷新成功，重置 client 并提示用户重试
+                reset_client()
+                error_msg = f"Token 已自动刷新，请重试请求。原错误: {error_msg}"
+            else:
+                error_msg = f"Token 刷新失败 ({refresh_result['message']})，请手动更新 Cookie。原错误: {error_msg}"
+        
+        print(f"[ERROR] Chat error: {error_msg}")
+        traceback.print_exc()
+        log_api_call(request_log, None, error=error_msg)
+        raise HTTPException(status_code=500, detail=error_msg)
+
+
+@app.post("/v1/chat/completions/reset")
+async def reset_context(authorization: str = Header(None)):
+    verify_api_key(authorization)
+    global _client
+    if _client:
+        _client.reset()
+    return {"status": "ok"}
+
+
+# 注意: load_config() 已在 startup_event 中调用，这里保留是为了兼容直接导入模块的情况
+load_config()
+
+if __name__ == "__main__":
+    print(f"""
+���══════════════════════════════════════════════════════════╗
+║           Gemini OpenAI Compatible API Server            ║
+╠══════════════════════════════════════════════════════════╣
+║  后台配置: http://localhost:{PORT}/admin                   ║
+║  API 地址: http://localhost:{PORT}/v1                      ║
+║  API Key:  {API_KEY}                                     ║
+║  Token 自动刷新: {"开启" if TOKEN_BACKGROUND_REFRESH else "关闭"} ({TOKEN_REFRESH_INTERVAL_MIN}-{TOKEN_REFRESH_INTERVAL_MAX}秒随机)  ║
+╚══════════════════════════════════════════════════════════╝
+""")
+    uvicorn.run(app, host=HOST, port=PORT)