sync: github -> hf space

.env.example

@@ -0,0 +1,179 @@
+# ================================================================
+# GCLI2API 环境变量配置示例文件
+# 复制此文件为 .env 并根据需要修改配置值
+# ================================================================
+
+# ================================================================
+# 服务器配置
+# ================================================================
+
+# 服务器监听地址
+# 默认: 0.0.0.0 (监听所有网络接口)
+HOST=0.0.0.0
+
+# 服务器端口
+# 默认: 7861
+PORT=7861
+
+# ================================================================
+# 密码配置 (支持分离密码)
+# ================================================================
+
+# 聊天API访问密码 (用于OpenAI和Gemini API端点认证)
+# 默认: 继承通用密码或 pwd
+API_PASSWORD=your_api_password
+
+# 控制面板访问密码 (用于Web界面登录认证)
+# 默认: 继承通用密码或 pwd
+PANEL_PASSWORD=your_panel_password
+
+# 通用访问密码 (兼容性保留)
+# 设置后会覆盖上述两个专用密码，优先级最高
+# 如果只想使用一个密码，设置此项即可
+# 默认: pwd
+PASSWORD=pwd
+
+# ================================================================
+# 存储配置
+# ================================================================
+
+# 存储后端优先级: PostgreSQL > MongoDB > 本地sqlite文件存储
+# 系统会自动选择可用的最高优先级存储后端
+
+# PostgreSQL 分布式存储模式配置 (最高优先级)
+# 设置 POSTGRESQL_URI 后自动启用 PostgreSQL 模式
+# 本地 PostgreSQL: postgresql://user:password@localhost:5432/gcli2api
+# 带 SSL: postgresql://user:password@host:5432/gcli2api?sslmode=require
+# 默认: 无 (不启用 PostgreSQL 存储)
+POSTGRESQL_URI=postgresql://user:password@localhost:5432/gcli2api
+
+# MongoDB 分布式存储模式配置 (第二优先级)
+# 设置 MONGODB_URI 后自动启用 MongoDB 模式，不再使用本地文件存储
+
+# Redis 缓存存储配置
+# 设置 REDIS_URL 后自动启用 Redis 模式，性能最佳，可大幅降低 MongoDB 的读写压力
+# 本地 Redis: redis://127.0.0.1:6379/0
+# 带密码: redis://:password@127.0.0.1:6379/0
+# 默认: 无 (不启用 Redis 缓存)
+REDIS_URL=redis://127.0.0.1:6379/0
+
+# MongoDB 连接字符串 (设置后启用 MongoDB 分布式存储模式)
+# 本地 MongoDB: mongodb://localhost:27017
+# 带认证: mongodb://admin:password@localhost:27017/admin
+# MongoDB Atlas: mongodb+srv://username:password@cluster.mongodb.net
+# 副本集: mongodb://host1:27017,host2:27017,host3:27017/gcli2api?replicaSet=rs0
+# 默认: 无 (使用本地文件存储)
+MONGODB_URI=mongodb://localhost:27017
+
+# MongoDB 数据库名称 (仅在启用 MongoDB 模式时有效)
+# 默认: gcli2api
+MONGODB_DATABASE=gcli2api
+
+# ================================================================
+# Google API 配置
+# ================================================================
+
+# 凭证文件目录 (仅在文件存储模式下使用)
+# 默认: ./creds
+CREDENTIALS_DIR=./creds
+
+
+# 代理配置 (可选)
+# 支持 http, https, socks5 代理
+# 格式: http://proxy:port, https://proxy:port, socks5://proxy:port
+PROXY=http://localhost:7890
+
+# Google API 代理 URL 配置 (可选)
+
+# Google Code Assist API 端点
+# 默认: https://cloudcode-pa.googleapis.com
+CODE_ASSIST_ENDPOINT=https://cloudcode-pa.googleapis.com
+# 用于Google OAuth2认证的代理URL
+# 默认: https://oauth2.googleapis.com
+OAUTH_PROXY_URL=https://oauth2.googleapis.com
+
+# 用于Google APIs调用的代理URL
+# 默认: https://www.googleapis.com
+GOOGLEAPIS_PROXY_URL=https://www.googleapis.com
+
+# 用于Google Cloud Resource Manager API的URL
+# 默认: https://cloudresourcemanager.googleapis.com
+RESOURCE_MANAGER_API_URL=https://cloudresourcemanager.googleapis.com
+
+# 用于Google Cloud Service Usage API的URL
+# 默认: https://serviceusage.googleapis.com
+SERVICE_USAGE_API_URL=https://serviceusage.googleapis.com
+
+# 用于Google Antigravity API的URL (反重力模式)
+# 默认: https://daily-cloudcode-pa.googleapis.com
+ANTIGRAVITY_API_URL=https://daily-cloudcode-pa.googleapis.com
+
+# ================================================================
+# 错误处理和重试配置
+# ================================================================
+
+# 是否启用自动封禁功能
+# 当凭证返回特定错误码时自动禁用该凭证
+# 默认: false
+AUTO_BAN=false
+
+# 自动封禁的错误码列表 (逗号分隔)
+# 默认: 400,403
+AUTO_BAN_ERROR_CODES=403
+
+# 是否启用 429 错误重试
+# 默认: true
+RETRY_429_ENABLED=true
+
+# 429 错误最大重试次数
+# 默认: 5
+RETRY_429_MAX_RETRIES=5
+
+# 429 错误重试间隔 (秒)
+# 默认: 1
+RETRY_429_INTERVAL=1
+
+# ================================================================
+# 日志配置
+# ================================================================
+
+# 日志级别
+# 可选值: debug, info, warning, error, critical
+# 默认: info
+LOG_LEVEL=info
+
+# 日志文件路径
+# 默认: log.txt
+LOG_FILE=log.txt
+
+# ================================================================
+# 高级功能配置
+# ================================================================
+
+# 流式抗截断最大尝试次数
+# 用于 "流式抗截断/" 前缀的模型
+# 默认: 3
+ANTI_TRUNCATION_MAX_ATTEMPTS=3
+
+# ================================================================
+# 环境变量使用说明
+# ================================================================
+
+# 1. 存储模式配置 (按优先级自动选择):
+#    - PostgreSQL 分布式模式 (最高优先级): 设置 POSTGRESQL_URI，数据存储在 PostgreSQL 数据库
+#    - Redis 缓存: 同时设置 REDIS_URI和 MONGODB_URI时，数据缓存在 Redis 数据库，持久化在MONGODB，性能最佳
+#    - MongoDB 分布式模式: 设置 MONGODB_URI，数据存储在 MongoDB 数据库
+#    - 文件存储模式 (默认): 不设置上述 URI，数据存储在本地 creds/ 目录
+#    - 自动切换: 系统根据可用的存储配置自动选择最高优先级的存储后端
+
+# 2. 密码配置优先级:
+#    a) PASSWORD 环境变量 (最高优先级，设置后覆盖其他密码)
+#    b) API_PASSWORD / PANEL_PASSWORD 环境变量 (专用密码)
+#    c) 默认值 "pwd"
+#
+# 3. 通用配置优先级:
+#    环境变量 > 默认值
+
+# 4. 布尔值环境变量:
+#    true/1/yes/on 表示启用
+#    false/0/no/off 表示禁用

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,92 @@
+name: Bug 报告
+description: 报告项目使用中遇到的问题
+title: "[Bug]: "
+labels: ["bug", "待处理"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## 感谢你的反馈!
+        请填写以下信息以帮助我们更快定位问题。
+  
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: 提交前确认
+      options:
+        - label: 我已经搜索过现有的 issues,确认这不是重复问题
+          required: true
+        - label: 我已经阅读过项目文档
+          required: true
+  
+  - type: dropdown
+    id: latest-version
+    attributes:
+      label: 是否是最新版
+      description: 请确认你使用的是否是最新版本
+      options:
+        - 是,使用最新版
+        - 否,使用旧版本
+    validations:
+      required: true
+  
+  - type: input
+    id: channel
+    attributes:
+      label: 调用的是哪个渠道
+      description: 例如 geminicli 或者 antigravity
+      placeholder: "例如: geminicli"
+    validations:
+      required: true
+  
+  - type: input
+    id: model
+    attributes:
+      label: 调用的是哪个模型
+      description: 例如 gemini-2.5-flash
+      placeholder: "例如: gemini-2.5-flash"
+    validations:
+      required: true
+  
+  - type: dropdown
+    id: format
+    attributes:
+      label: 调用的是哪个格式
+      description: 选择你使用的 API 格式
+      options:
+        - gemini 格式
+        - openai 格式
+        - claude 格式
+        - 其他格式
+    validations:
+      required: true
+  
+  - type: textarea
+    id: error-content
+    attributes:
+      label: 具体报错内容
+      description: 请粘贴完整的错误信息或截图
+      placeholder: |
+        请在这里粘贴完整的错误日志或堆栈信息
+      render: shell
+    validations:
+      required: true
+  
+  - type: textarea
+    id: error-description
+    attributes:
+      label: 错误描述
+      description: 详细描述问题的发生场景、预期行为和实际行为
+      placeholder: |
+        1. 我在做什么操作时遇到了这个问题
+        2. 我期望的结果是...
+        3. 但实际上发生了...
+    validations:
+      required: true
+  
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: 补充信息(可选)
+      description: 其他任何有助于解决问题的信息
+      placeholder: 例如:操作系统、Python 版本、相关配置等

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 使用问题讨论
+    url: https://github.com/su-kaka/gcli2api/issues
+    about: 如果是使用方面的问题,请在 issues 中提问
+  - name: 项目文档
+    url: https://github.com/su-kaka/gcli2api
+    about: 查看完整文档和使用指南

.github/workflows/docker-publish.yml

@@ -0,0 +1,81 @@
+name: Docker Build and Publish
+
+on:
+  workflow_run:
+    workflows: ["Update Version File"]
+    types:
+      - completed
+    branches:
+      - master
+      - main
+  push:
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - master
+      - main
+  workflow_dispatch:
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    # 只在 workflow_run 成功时运行，或者非 workflow_run 触发时运行
+    if: ${{ github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success' }}
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          # workflow_run 触发时需要获取最新的代码（包括 version.txt 的更新）
+          ref: ${{ github.event_name == 'workflow_run' && github.event.workflow_run.head_branch || github.ref }}
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=ref,event=branch
+            type=ref,event=tag
+            type=ref,event=pr
+            type=raw,value=latest,enable={{is_default_branch}}
+            type=sha,prefix={{branch}}-
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+          build-args: |
+            BUILD_DATE=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.created'] }}
+            VERSION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.version'] }}
+            REVISION=${{ github.sha }}

.github/workflows/update-version.yml

@@ -0,0 +1,51 @@
+name: Update Version File
+
+on:
+  push:
+    branches:
+      - master
+      - main
+
+jobs:
+  update-version:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Update version.txt
+        run: |
+          # 获取最新commit信息
+          FULL_HASH=$(git log -1 --format=%H)
+          SHORT_HASH=$(git log -1 --format=%h)
+          MESSAGE=$(git log -1 --format=%s)
+          DATE=$(git log -1 --format=%ci)
+
+          # 写入version.txt
+          echo "full_hash=$FULL_HASH" > version.txt
+          echo "short_hash=$SHORT_HASH" >> version.txt
+          echo "message=$MESSAGE" >> version.txt
+          echo "date=$DATE" >> version.txt
+
+          echo "Version file updated:"
+          cat version.txt
+
+      - name: Commit version.txt if changed
+        run: |
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+
+          # 检查是否有变化
+          if git diff --quiet version.txt; then
+            echo "No changes to version.txt"
+          else
+            git add version.txt
+            git commit -m "chore: update version.txt [skip ci]"
+            git push
+          fi

.gitignore

@@ -0,0 +1,99 @@
+# Credential files - should never be committed
+*.json
+!package.json
+!package-lock.json
+!tsconfig.json
+*.toml
+!pyproject.toml
+creds/
+CLAUDE.md
+GEMINI.md
+.kiro
+# Environment configuration
+.env
+
+# Python
+uv.lock
+.python-version
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+.claude/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+log.txt
+
+# Temporary files
+*.tmp
+*.temp
+*.bak
+
+tools/

CONTRIBUTING.md

@@ -0,0 +1,169 @@
+# Contributing to gcli2api
+
+First off, thank you for considering contributing to gcli2api! It's people like you that make gcli2api such a great tool.
+
+## Code of Conduct
+
+This project is intended for personal learning and research purposes only. By participating, you are expected to uphold this code and respect the CNC-1.0 license restrictions on commercial use.
+
+## How Can I Contribute?
+
+### Reporting Bugs
+
+Before creating bug reports, please check the existing issues to avoid duplicates. When you create a bug report, include as many details as possible:
+
+* **Use a clear and descriptive title**
+* **Describe the exact steps to reproduce the problem**
+* **Provide specific examples** - Include code snippets, configuration files, or log outputs
+* **Describe the behavior you observed** and what you expected to see
+* **Include environment details**: OS, Python version, Docker version (if applicable)
+
+### Suggesting Enhancements
+
+Enhancement suggestions are tracked as GitHub issues. When creating an enhancement suggestion, include:
+
+* **Use a clear and descriptive title**
+* **Provide a detailed description** of the suggested enhancement
+* **Explain why this enhancement would be useful**
+* **List any alternative solutions** you've considered
+
+### Pull Requests
+
+1. Fork the repo and create your branch from `master`
+2. If you've added code that should be tested, add tests
+3. If you've changed APIs, update the documentation
+4. Ensure the test suite passes
+5. Make sure your code follows the existing style
+6. Write a clear commit message
+
+## Development Setup
+
+### Prerequisites
+
+* Python 3.12 or higher
+* pip or uv package manager
+
+### Setting Up Your Development Environment
+
+```bash
+# Clone your fork
+git clone https://github.com/YOUR_USERNAME/gcli2api.git
+cd gcli2api
+
+# Install development dependencies
+make install-dev
+# or
+pip install -e ".[dev]"
+
+# Copy environment example
+cp .env.example .env
+# Edit .env with your configuration
+```
+
+### Development Workflow
+
+```bash
+# Run tests
+make test
+
+# Format code
+make format
+
+# Run linters
+make lint
+
+# Run the application locally
+make run
+```
+
+### Testing
+
+We use pytest for testing. All new features should include appropriate tests.
+
+```bash
+# Run all tests
+make test
+
+# Run with coverage
+make test-cov
+
+# Run specific test file
+python -m pytest test_tool_calling.py -v
+```
+
+### Code Style
+
+* We use [Black](https://black.readthedocs.io/) for code formatting (line length: 100)
+* We use [flake8](https://flake8.pycqa.org/) for linting
+* We use [mypy](http://mypy-lang.org/) for type checking (optional, but encouraged)
+
+```bash
+# Format your code before committing
+make format
+
+# Check if code is properly formatted
+make format-check
+
+# Run linters
+make lint
+```
+
+## Project Structure
+
+```
+gcli2api/
+├── src/                    # Main source code
+│   ├── auth.py            # Authentication and OAuth
+│   ├── credential_manager.py  # Credential rotation
+│   ├── openai_router.py   # OpenAI-compatible endpoints
+│   ├── gemini_router.py   # Gemini native endpoints
+│   ├── openai_transfer.py # Format conversion
+│   ├── storage/           # Storage backends (Redis, MongoDB, Postgres, File)
+│   └── ...
+├── front/                 # Frontend static files
+├── tests/                 # Test directory (to be created)
+├── test_*.py             # Test files (root level)
+├── web.py                # Main application entry point
+├── config.py             # Configuration management
+└── requirements.txt      # Production dependencies
+```
+
+## Coding Guidelines
+
+### Python Style
+
+* Follow PEP 8 guidelines
+* Use type hints where appropriate
+* Write docstrings for classes and functions
+* Keep functions focused and concise
+
+### Commit Messages
+
+* Use the present tense ("Add feature" not "Added feature")
+* Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
+* Limit the first line to 72 characters or less
+* Reference issues and pull requests liberally after the first line
+
+### Documentation
+
+* Update the README.md if you change functionality
+* Comment your code where necessary
+* Update the .env.example if you add new configuration options
+
+## License
+
+By contributing to gcli2api, you agree that your contributions will be licensed under the CNC-1.0 license. This is a strict anti-commercial license - see [LICENSE](LICENSE) for details.
+
+### Important License Restrictions
+
+* ❌ No commercial use
+* ❌ No use by companies with revenue > $1M USD
+* ❌ No use by VC-backed or publicly traded companies
+* ✅ Personal learning, research, and educational use only
+* ✅ Open source integration (must follow same license)
+
+## Questions?
+
+Feel free to open an issue with your question or reach out to the maintainers.
+
+Thank you for contributing! 🎉

Dockerfile

@@ -0,0 +1,34 @@
+# Multi-stage build for gcli2api
+FROM python:3.13-slim as base
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    TZ=Asia/Shanghai
+
+# Install tzdata and set timezone
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends tzdata && \
+    ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && \
+    echo "Asia/Shanghai" > /etc/timezone && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy only requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 7861
+
+# Default command
+CMD ["python", "web.py"]

LICENSE

@@ -0,0 +1,83 @@
+Cooperative Non-Commercial License (CNC-1.0)
+
+Copyright (c) 2024 gcli2api contributors
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of this software and associated documentation files (the
+"Software"), to use, copy, modify, merge, publish, distribute, and/or
+sublicense the Software, subject to the following conditions:
+
+TERMS AND CONDITIONS:
+
+1. NON-COMMERCIAL USE ONLY
+   The Software may only be used for non-commercial purposes. Commercial use
+   is strictly prohibited without explicit written permission from the 
+   copyright holders.
+
+2. DEFINITION OF COMMERCIAL USE
+   "Commercial use" includes but is not limited to:
+   a) Using the Software to provide paid services or products
+   b) Integrating the Software into commercial products or services
+   c) Using the Software in any business operation that generates revenue
+   d) Offering the Software as part of a paid subscription or service
+   e) Using the Software to compete with the original project commercially
+
+3. COPYLEFT REQUIREMENT
+   Any derivative works, modifications, or substantial portions of the Software
+   must be licensed under the same or substantially similar terms. This ensures
+   that all derivatives remain non-commercial and freely available.
+
+4. SOURCE CODE AVAILABILITY
+   If you distribute the Software or any derivative works, you must make the
+   complete source code available under the same license terms at no charge.
+
+5. ATTRIBUTION REQUIREMENT
+   You must retain all copyright notices, license notices, and attribution
+   statements in all copies or substantial portions of the Software.
+
+6. ANTI-CORPORATE CLAUSE
+   This Software may not be used by corporations with annual revenue exceeding
+   $1 million USD, venture capital backed companies, or publicly traded
+   companies without explicit written permission from the copyright holders.
+
+7. EDUCATIONAL AND RESEARCH EXEMPTION
+   Use by educational institutions, non-profit research organizations, and
+   individual researchers for educational or research purposes is explicitly
+   permitted and encouraged.
+
+8. MODIFICATION AND CONTRIBUTION
+   Modifications and contributions to the Software are welcomed and encouraged,
+   provided they comply with these license terms. Contributors grant the same
+   license to their contributions.
+
+9. PATENT GRANT
+   Each contributor grants you a non-exclusive, worldwide, royalty-free patent
+   license to make, have made, use, offer to sell, sell, import, and otherwise
+   transfer the Work for non-commercial purposes only.
+
+10. TERMINATION
+    This license automatically terminates if you violate any of its terms.
+    Upon termination, you must cease all use and distribution of the Software
+    and destroy all copies in your possession.
+
+11. LIABILITY DISCLAIMER
+    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.
+
+12. JURISDICTION
+    This license shall be governed by and construed in accordance with the laws
+    of the jurisdiction where the copyright holder resides.
+
+SUMMARY:
+This license allows free use, modification, and distribution of the Software
+for non-commercial purposes only. It explicitly prohibits commercial use and
+ensures that all derivatives remain freely available under the same terms.
+The license promotes cooperative development while preventing commercial
+exploitation of the community's work.
+
+For commercial licensing inquiries, please contact the copyright holders.

README.md

@@ -0,0 +1,891 @@
+---
+title: gcli2api
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7861
+pinned: false
+---
+# GeminiCLI to API
+
+**将 GeminiCLI 和 Antigravity 转换为 OpenAI 、GEMINI 和 Claude API 兼容接口**
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: CNC-1.0](https://img.shields.io/badge/License-CNC--1.0-red.svg)](LICENSE)
+[![Docker](https://img.shields.io/badge/docker-available-blue.svg)](https://github.com/su-kaka/gcli2api/pkgs/container/gcli2api)
+
+[English](docs/README_EN.md) | 中文 | [日本語](docs/README_JA.md)
+
+## 🚀 快速部署 
+
+[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/templates/97VMEF?referralCode=sukaka)
+[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/su-kaka/gcli2api)
+---
+
+## 安装指南
+
+### Termux 环境
+
+**初始安装**
+```bash
+curl -o termux-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/termux-install.sh" && chmod +x termux-install.sh && ./termux-install.sh
+```
+
+**重启服务**
+```bash
+cd gcli2api
+bash termux-start.sh
+```
+
+### Windows 环境
+
+**初始安装**
+```powershell
+iex (iwr "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.ps1" -UseBasicParsing).Content
+```
+
+**重启服务**
+双击执行 `start.bat`
+
+### Linux 环境
+
+**初始安装**
+```bash
+curl -o install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.sh" && chmod +x install.sh && ./install.sh
+```
+
+**重启服务**
+```bash
+cd gcli2api
+bash start.sh
+```
+
+### macOS 环境
+
+**初始安装**
+```bash
+curl -o darwin-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/darwin-install.sh" && chmod +x darwin-install.sh && ./darwin-install.sh
+```
+
+**重启服务**
+```bash
+cd gcli2api
+bash start.sh
+```
+
+### Docker 环境
+
+**Docker 运行命令**
+```bash
+# 使用通用密码
+docker run -d --name gcli2api --network host -e PASSWORD=pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
+
+# 使用分离密码
+docker run -d --name gcli2api --network host -e API_PASSWORD=api_pwd -e PANEL_PASSWORD=panel_pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
+```
+
+**Docker Mac**
+```bash
+# 使用通用密码
+docker run -d \
+  --name gcli2api \
+  -p 7861:7861 \
+  -p 8080:8080 \
+  -e PASSWORD=pwd \
+  -e PORT=7861 \
+  -v "$(pwd)/data/creds":/app/creds \
+  ghcr.io/su-kaka/gcli2api:latest
+```
+
+```bash
+# 使用分离密码
+docker run -d \
+--name gcli2api \
+-p 7861:7861 \
+-p 8080:8080 \
+-e API_PASSWORD=api_pwd \
+-e PANEL_PASSWORD=panel_pwd \
+-e PORT=7861 \
+-v $(pwd)/data/creds:/app/creds \
+ghcr.io/su-kaka/gcli2api:latest
+```
+
+**Docker Compose 运行命令**
+1. 将以下内容保存为 `docker-compose.yml` 文件：
+    ```yaml
+    version: '3.8'
+
+    services:
+      gcli2api:
+        image: ghcr.io/su-kaka/gcli2api:latest
+        container_name: gcli2api
+        restart: unless-stopped
+        network_mode: host
+        environment:
+          # 使用通用密码（推荐用于简单部署）
+          - PASSWORD=pwd
+          - PORT=7861
+          # 或使用分离密码（推荐用于生产环境）
+          # - API_PASSWORD=your_api_password
+          # - PANEL_PASSWORD=your_panel_password
+        volumes:
+          - ./data/creds:/app/creds
+        healthcheck:
+          test: ["CMD-SHELL", "python -c \"import sys, urllib.request, os; port = os.environ.get('PORT', '7861'); req = urllib.request.Request(f'http://localhost:{port}/v1/models', headers={'Authorization': 'Bearer ' + os.environ.get('PASSWORD', 'pwd')}); sys.exit(0 if urllib.request.urlopen(req, timeout=5).getcode() == 200 else 1)\""]
+          interval: 30s
+          timeout: 10s
+          retries: 3
+          start_period: 40s
+    ```
+2. 启动服务：
+    ```bash
+    docker-compose up -d
+    ```
+
+## 核心功能
+
+### 🔄 API 端点和格式支持
+
+**多端点多格式支持**
+- **OpenAI 兼容端点**：`/v1/chat/completions` 和 `/v1/models`
+  - 支持标准 OpenAI 格式（messages 结构）
+  - 支持 Gemini 原生格式（contents 结构）
+  - 自动格式检测和转换，无需手动切换
+  - 支持多模态输入（文本 + 图像）
+- **Gemini 原生端点**：`/v1/models/{model}:generateContent` 和 `streamGenerateContent`
+  - 支持完整的 Gemini 原生 API 规范
+  - 多种认证方式：Bearer Token、x-goog-api-key 头部、URL 参数 key
+- **Claude 格式兼容**：完整支持 Claude API 格式
+  - 端点：`/v1/messages`（遵循 Claude API 规范）
+  - 支持 Claude 标准的 messages 格式
+  - 支持 system 参数和 Claude 特有功能
+  - 自动转换为后端支持的格式
+- **Antigravity API 支持**：同时支持 OpenAI、Gemini 和 Claude 格式
+  - OpenAI 格式端点：`/antigravity/v1/chat/completions`
+  - Gemini 格式端点：`/antigravity/v1/models/{model}:generateContent` 和 `streamGenerateContent`
+  - Claude 格式端点：`/antigravity/v1/messages`
+  - 支持所有 Antigravity 模型（Claude、Gemini 等）
+  - 自动模型名称映射和思维模式检测
+
+### 🔐 认证和安全管理
+
+**灵活的密码管理**
+- **分离密码支持**：API 密码（聊天端点）和控制面板密码可独立设置
+- **多种认证方式**：支持 Authorization Bearer、x-goog-api-key 头部、URL 参数等
+- **JWT Token 认证**：控制面板支持 JWT 令牌认证
+- **用户邮箱获取**：自动获取和显示 Google 账户邮箱地址
+
+### 📊 智能凭证管理系统
+
+**高级凭证管理**
+- 多个 Google OAuth 凭证自动轮换
+- 通过冗余认证增强稳定性
+- 负载均衡与并发请求支持
+- 自动故障检测和凭证禁用
+- 凭证使用统计和配额管理
+- 支持手动启用/禁用凭证文件
+- 批量凭证文件操作（启用、禁用、删除）
+
+**凭证状态监控**
+- 实时凭证健康检查
+- 错误码追踪（429、403、500 等）
+- 自动封禁机制（可配置）
+
+### 🌊 流式传输和响应处理
+
+**多种流式支持**
+- 真正的实时流式响应
+- 假流式模式（用于兼容性）
+- 流式抗截断功能（防止回答被截断）
+- 异步任务管理和超时处理
+
+**响应优化**
+- 思维链（Thinking）内容分离
+- 推理过程（reasoning_content）处理
+- 多轮对话上下文管理
+- 兼容性模式（将 system 消息转换为 user 消息）
+
+### 🎛️ Web 管理控制台
+
+**全功能 Web 界面**
+- OAuth 认证流程管理（支持 GCLI 和 Antigravity 双模式）
+- 凭证文件上传、下载、管理
+- 实时日志查看（WebSocket）
+- 系统配置管理
+- 使用统计和监控面板
+- 移动端适配界面
+
+**批量操作支持**
+- ZIP 文件批量上传凭证（GCLI 和 Antigravity）
+- 批量启用/禁用/删除凭证
+- 批量获取用户邮箱
+- 批量配置管理
+- 统一批量上传界面管理所有凭证类型
+
+### 📈 使用监控
+
+**实时监控**
+- WebSocket 实时日志流
+- 系统状态监控
+- 凭证健康状态
+
+### 🔧 高级配置和自定义
+
+**网络和代理配置**
+- HTTP/HTTPS 代理支持
+- 代理端点配置（OAuth、Google APIs、元数据服务）
+- 超时和重试配置
+- 网络错误处理和恢复
+
+**性能和稳定性配置**
+- 429 错误自动重试（可配置间隔和次数）
+- 抗截断最大重试次数
+
+**日志和调试**
+- 多级日志系统（DEBUG、INFO、WARNING、ERROR）
+- 日志文件管理
+- 实时日志流
+- 日志下载和清空
+
+### 🔄 环境变量和配置管理
+
+**灵活的配置方式**
+- 环境变量配置
+- 热配置更新（部分配置项）
+- 配置锁定（环境变量优先级）
+
+## 支持的模型
+
+所有模型均具备 1M 上下文窗口容量。每个凭证文件提供 1000 次请求额度。
+
+### 🤖 基础模型
+- `gemini-2.5-pro`
+- `gemini-3-pro-preview`
+- `gemini-3.1-pro-preview`
+
+### 🧠 思维模型（Thinking Models）
+- `gemini-2.5-pro-high`：思考模式
+- `gemini-2.5-pro-low`：低思考模式
+- 支持自定义思考预算配置
+- 自动分离思维内容和最终回答
+
+### 🔍 搜索增强模型
+- `gemini-2.5-pro-search`：集成搜索功能的模型
+
+### 🖼️ 图像生成模型（Antigravity）
+- `gemini-3.1-flash-image`：基础图像生成模型
+- **分辨率后缀**：
+  - `-2k`：2K 分辨率
+  - `-4k`：4K 高清分辨率
+- **比例后缀**：
+  - `-1x1`：正方形（头像）
+  - `-16x9`：横屏（电脑壁纸）
+  - `-9x16`：竖屏（手机壁纸）
+  - `-21x9`：超宽屏（带鱼屏）
+  - `-4x3`：传统显示器
+  - `-3x4`：竖版海报
+- **组合使用示例**：
+  - `gemini-3.1-flash-image-4k-16x9`：4K 横屏
+  - `gemini-3.1-flash-image-2k-9x16`：2K 竖屏
+- 不指定比例时，API 自动决定横竖比例
+
+### 🌊 特殊功能变体
+- **假流式模式**：在任何模型名称后添加 `-假流式` 后缀
+  - 例：`gemini-2.5-pro-假流式`
+  - 用于需要流式响应但服务端不支持真流式的场景
+- **流式抗截断模式**：在模型名称前添加 `流式抗截断/` 前缀
+  - 例：`流式抗截断/gemini-2.5-pro`  
+  - 自动检测响应截断并重试，确保完整回答
+
+### 🔧 模型功能自动检测
+- 系统自动识别模型名称中的功能标识
+- 透明地处理功能模式转换
+- 支持功能组合使用
+
+---
+
+## 配置说明
+
+1. 访问 `http://127.0.0.1:7861` （默认端口，可通过 PORT 环境变量修改）
+2. 完成 OAuth 认证流程（默认密码：`pwd`，可通过环境变量修改）
+   - **GCLI 模式**：用于获取 Google Cloud Gemini API 凭证
+   - **Antigravity 模式**：用于获取 Google Antigravity API 凭证
+3. 配置客户端：
+
+**OpenAI 兼容客户端：**
+   - **端点地址**：`http://127.0.0.1:7861/v1`
+   - **API 密钥**：`pwd`（默认值，可通过 API_PASSWORD 或 PASSWORD 环境变量修改）
+
+**Gemini 原生客户端：**
+   - **端点地址**：`http://127.0.0.1:7861`
+   - **认证方式**：
+     - `Authorization: Bearer your_api_password`
+     - `x-goog-api-key: your_api_password`
+     - URL 参数：`?key=your_api_password`
+
+### 🌟 双认证模式支持
+
+**GCLI 认证模式**
+- 标准的 Google Cloud Gemini API 认证
+- 支持 OAuth2.0 认证流程
+- 自动启用必需的 Google Cloud API
+
+**Antigravity 认证模式**
+- Google Antigravity API 专用认证
+- 独立的凭证管理系统
+- 支持批量上传和管理
+- 与 GCLI 凭证完全隔离
+
+**统一管理界面**
+- 在"批量上传"标签页中可一次性管理两种凭证
+- 上半部分：GCLI 凭证批量上传（蓝色主题）
+- 下半部分：Antigravity 凭证批量上传（绿色主题）
+- 各自独立的凭证管理标签页
+
+## 💾 数据存储模式
+
+### 🌟 存储后端支持
+
+gcli2api 支持两种存储后端：**本地 SQLite（默认）** 和 **MongoDB（云端分布式存储）**
+
+### 📁 本地 SQLite 存储（默认）
+
+**默认存储方式**
+- 无需配置，开箱即用
+- 数据存储在本地 SQLite 数据库中
+- 适合单机部署和个人使用
+- 自动创建和管理数据库文件
+
+### 🍃 MongoDB 云端存储模式
+
+**云端分布式存储方案**
+
+当需要多实例部署或云端存储时，可以启用 MongoDB 存储模式。
+
+### ⚙️ 启用 MongoDB 模式
+
+**步骤 1: 配置 MongoDB 连接**
+```bash
+# 本地 MongoDB
+export MONGODB_URI="mongodb://localhost:27017"
+
+# MongoDB Atlas 云服务
+export MONGODB_URI="mongodb+srv://username:password@cluster.mongodb.net"
+
+# 带认证的 MongoDB
+export MONGODB_URI="mongodb://admin:password@localhost:27017/admin"
+
+# 可选：自定义数据库名称（默认: gcli2api）
+export MONGODB_DATABASE="my_gcli_db"
+```
+
+**步骤 2: 启动应用**
+```bash
+# 应用会自动检测 MongoDB 配置并使用 MongoDB 存储
+python web.py
+```
+
+**Docker 环境使用 MongoDB**
+```bash
+# 单机 MongoDB 部署
+docker run -d --name gcli2api \
+  -e MONGODB_URI="mongodb://mongodb:27017" \
+  -e API_PASSWORD=your_password \
+  --network your_network \
+  ghcr.io/su-kaka/gcli2api:latest
+
+# 使用 MongoDB Atlas
+docker run -d --name gcli2api \
+  -e MONGODB_URI="mongodb+srv://user:pass@cluster.mongodb.net/gcli2api" \
+  -e API_PASSWORD=your_password \
+  -p 7861:7861 \
+  ghcr.io/su-kaka/gcli2api:latest
+```
+
+**Docker Compose 示例**
+```yaml
+version: '3.8'
+
+services:
+  mongodb:
+    image: mongo:7
+    container_name: gcli2api-mongodb
+    restart: unless-stopped
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: admin
+      MONGO_INITDB_ROOT_PASSWORD: password123
+    volumes:
+      - mongodb_data:/data/db
+    ports:
+      - "27017:27017"
+
+  gcli2api:
+    image: ghcr.io/su-kaka/gcli2api:latest
+    container_name: gcli2api
+    restart: unless-stopped
+    depends_on:
+      - mongodb
+    environment:
+      - MONGODB_URI=mongodb://admin:password123@mongodb:27017/admin
+      - MONGODB_DATABASE=gcli2api
+      - API_PASSWORD=your_api_password
+      - PORT=7861
+    ports:
+      - "7861:7861"
+
+volumes:
+  mongodb_data:
+```
+
+
+### 🔧 高级配置
+
+**MongoDB 连接优化**
+```bash
+# 连接池和超时配置
+export MONGODB_URI="mongodb://localhost:27017?maxPoolSize=10&serverSelectionTimeoutMS=5000"
+
+# 副本集配置
+export MONGODB_URI="mongodb://host1:27017,host2:27017,host3:27017/gcli2api?replicaSet=myReplicaSet"
+
+# 读写分离配置
+export MONGODB_URI="mongodb://localhost:27017/gcli2api?readPreference=secondaryPreferred"
+```
+
+### 环境变量配置
+
+**基础配置**
+- `PORT`: 服务端口（默认：7861）
+- `HOST`: 服务器监听地址（默认：0.0.0.0）
+
+**密码配置**
+- `API_PASSWORD`: 聊天 API 访问密码（默认：继承 PASSWORD 或 pwd）
+- `PANEL_PASSWORD`: 控制面板访问密码（默认：继承 PASSWORD 或 pwd）  
+- `PASSWORD`: 通用密码，设置后覆盖上述两个（默认：pwd）
+
+**性能和稳定性配置**
+- `RETRY_429_ENABLED`: 启用 429 错误自动重试（默认：true）
+- `RETRY_429_MAX_RETRIES`: 429 错误最大重试次数（默认：3）
+- `RETRY_429_INTERVAL`: 429 错误重试间隔，秒（默认：1.0）
+- `ANTI_TRUNCATION_MAX_ATTEMPTS`: 抗截断最大重试次数（默认：3）
+
+**网络和代理配置**
+- `PROXY`: HTTP/HTTPS 代理地址（格式：`http://host:port`）
+- `OAUTH_PROXY_URL`: OAuth 认证代理端点
+- `GOOGLEAPIS_PROXY_URL`: Google APIs 代理端点
+- `METADATA_SERVICE_URL`: 元数据服务代理端点
+
+**自动化配置**
+- `AUTO_BAN`: 启用凭证自动封禁（默认：true）
+- `AUTO_LOAD_ENV_CREDS`: 启动时自动加载环境变量凭证（默认：false）
+
+**兼容性配置**
+- `COMPATIBILITY_MODE`: 启用兼容性模式，将 system 消息转为 user 消息（默认：false）
+
+**日志配置**
+- `LOG_LEVEL`: 日志级别（DEBUG/INFO/WARNING/ERROR，默认：INFO）
+- `LOG_FILE`: 日志文件路径（默认：log.txt）
+
+**存储配置**
+
+**SQLite 配置（默认）**
+- 无需配置，自动使用本地 SQLite 数据库
+- 数据���文件自动创建在项目目录
+
+**MongoDB 配置（可选云端存储）**
+- `MONGODB_URI`: MongoDB 连接字符串（设置后启用 MongoDB 模式）
+- `MONGODB_DATABASE`: MongoDB 数据库名称（默认：gcli2api）
+
+**Docker 使用示例**
+```bash
+# 使用通用密码
+docker run -d --name gcli2api \
+  -e PASSWORD=mypassword \
+  -e PORT=7861 \
+  ghcr.io/su-kaka/gcli2api:latest
+
+# 使用分离密码
+docker run -d --name gcli2api \
+  -e API_PASSWORD=my_api_password \
+  -e PANEL_PASSWORD=my_panel_password \
+  -e PORT=7861 \
+  ghcr.io/su-kaka/gcli2api:latest
+```
+
+注意：当设置了凭证环境变量时，系统将优先使用环境变量中的凭证，忽略 `creds` 目录中的文件。
+
+### API 使用方式
+
+本服务支持三套完整的 API 端点：
+
+#### 1. OpenAI 兼容端点（GCLI）
+
+**端点：** `/v1/chat/completions`
+**认证：** `Authorization: Bearer your_api_password`
+
+支持两种请求格式，会自动检测并处理：
+
+**OpenAI 格式：**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "messages": [
+    {"role": "system", "content": "You are a helpful assistant"},
+    {"role": "user", "content": "Hello"}
+  ],
+  "temperature": 0.7,
+  "stream": true
+}
+```
+
+**Gemini 原生格式：**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "contents": [
+    {"role": "user", "parts": [{"text": "Hello"}]}
+  ],
+  "systemInstruction": {"parts": [{"text": "You are a helpful assistant"}]},
+  "generationConfig": {
+    "temperature": 0.7
+  }
+}
+```
+
+#### 2. Gemini 原生端点（GCLI）
+
+**非流式端点：** `/v1/models/{model}:generateContent`
+**流式端点：** `/v1/models/{model}:streamGenerateContent`
+**模型列表：** `/v1/models`
+
+**认证方式（任选一种）：**
+- `Authorization: Bearer your_api_password`
+- `x-goog-api-key: your_api_password`
+- URL 参数：`?key=your_api_password`
+
+**请求示例：**
+```bash
+# 使用 x-goog-api-key 头部
+curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:generateContent" \
+  -H "x-goog-api-key: your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ]
+  }'
+
+# 使用 URL 参数
+curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:streamGenerateContent?key=your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ]
+  }'
+```
+
+#### 3. Claude API 格式端点
+
+**端点：** `/v1/messages`
+**认证：** `x-api-key: your_api_password` 或 `Authorization: Bearer your_api_password`
+
+**请求示例：**
+```bash
+curl -X POST "http://127.0.0.1:7861/v1/messages" \
+  -H "x-api-key: your_api_password" \
+  -H "anthropic-version: 2023-06-01" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "max_tokens": 1024,
+    "messages": [
+      {"role": "user", "content": "Hello, Claude!"}
+    ]
+  }'
+```
+
+**支持 system 参数：**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "max_tokens": 1024,
+  "system": "You are a helpful assistant",
+  "messages": [
+    {"role": "user", "content": "Hello"}
+  ]
+}
+```
+
+**说明：**
+- 完全兼容 Claude API 格式规范
+- 自动转换为 Gemini 格式调用后端
+- 支持 Claude 的所有标准参数
+- 响应格式符合 Claude API 规范
+
+#### 4. Antigravity API 端点
+
+**支持三种格式：OpenAI、Gemini 和 Claude**
+
+##### Antigravity OpenAI 格式端点
+
+**端点：** `/antigravity/v1/chat/completions`
+**认证：** `Authorization: Bearer your_api_password`
+
+**请求示例：**
+```bash
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/chat/completions" \
+  -H "Authorization: Bearer your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "claude-sonnet-4-5",
+    "messages": [
+      {"role": "user", "content": "Hello"}
+    ],
+    "stream": true
+  }'
+```
+
+##### Antigravity Gemini 格式端点
+
+**非流式端点：** `/antigravity/v1/models/{model}:generateContent`
+**流式端点：** `/antigravity/v1/models/{model}:streamGenerateContent`
+
+**认证方式（任选一种）：**
+- `Authorization: Bearer your_api_password`
+- `x-goog-api-key: your_api_password`
+- URL 参数：`?key=your_api_password`
+
+**请求示例：**
+```bash
+# Gemini 格式非流式请求
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/claude-sonnet-4-5:generateContent" \
+  -H "x-goog-api-key: your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ],
+    "generationConfig": {
+      "temperature": 0.7
+    }
+  }'
+
+# Gemini 格式流式请求
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/gemini-2.5-flash:streamGenerateContent?key=your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ]
+  }'
+```
+
+##### Antigravity Claude 格式端点
+
+**端点：** `/antigravity/v1/messages`
+**认证：** `x-api-key: your_api_password`
+
+**请求示例：**
+```bash
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/messages" \
+  -H "x-api-key: your_api_password" \
+  -H "anthropic-version: 2023-06-01" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "claude-sonnet-4-5",
+    "max_tokens": 1024,
+    "messages": [
+      {"role": "user", "content": "Hello"}
+    ]
+  }'
+```
+
+**支持的 Antigravity 模型：**
+- Claude 系列：`claude-sonnet-4-5`、`claude-opus-4-5` 等
+- Gemini 系列：`gemini-2.5-flash`、`gemini-2.5-pro` 等
+- 自动支持思维模型（thinking models）
+
+**Gemini 原生示例：**
+```python
+from io import BytesIO
+from PIL import Image
+from google.genai import Client
+from google.genai.types import HttpOptions
+from google.genai import types
+# The client gets the API key from the environment variable `GEMINI_API_KEY`.
+
+client = Client(
+            api_key="pwd",
+            http_options=HttpOptions(base_url="http://127.0.0.1:7861"),
+        )
+
+prompt = (
+    """
+    画一只猫
+    """
+)
+
+response = client.models.generate_content(
+    model="gemini-3.1-flash-image",
+    contents=[prompt],
+    config=types.GenerateContentConfig(
+        image_config=types.ImageConfig(
+            aspect_ratio="16:9",
+        )
+    )
+)
+for part in response.candidates[0].content.parts:
+    if part.text is not None:
+        print(part.text)
+    elif part.inline_data is not None:
+        image = Image.open(BytesIO(part.inline_data.data))
+        image.save("generated_image.png")
+
+```
+
+**说明：**
+- OpenAI 端点返回 OpenAI 兼容格式
+- Gemini 端点返回 Gemini 原生格式
+- 两种端点使用相同的 API 密码
+
+## 📋 完整 API 参考
+
+### Web 控制台 API
+
+**认证端点**
+- `POST /auth/login` - 用户登录
+- `POST /auth/start` - 开始 OAuth 认证（支持 GCLI 和 Antigravity 模式）
+- `POST /auth/callback` - 处理 OAuth 回调
+- `POST /auth/callback-url` - 从回调 URL 直接完成认证
+- `GET /auth/status/{project_id}` - 检查认证状态
+
+**凭证管理端点**（支持 `mode=geminicli` 或 `mode=antigravity` 参数）
+- `POST /creds/upload` - 批量上传凭证文件（支持 JSON 和 ZIP）
+- `GET /creds/status` - 获取凭证状态列表（支持分页和筛选）
+- `GET /creds/detail/{filename}` - 获取单个凭证详情
+- `POST /creds/action` - 单个凭证操作（启用/禁用/删除）
+- `POST /creds/batch-action` - 批量凭证操作
+- `GET /creds/download/{filename}` - 下载单个凭证文件
+- `GET /creds/download-all` - 打包下载所有凭证
+- `POST /creds/fetch-email/{filename}` - 获取用户邮箱
+- `POST /creds/refresh-all-emails` - 批量刷新用户邮箱
+- `POST /creds/deduplicate-by-email` - 按邮箱去重凭证
+- `POST /creds/verify-project/{filename}` - 检验凭证 Project ID
+- `GET /creds/quota/{filename}` - 获取凭证额度信息（仅 Antigravity）
+
+**配置管理端点**
+- `GET /config/get` - 获取当前配置
+- `POST /config/save` - 保存配置
+
+**日志管理端点**
+- `POST /logs/clear` - 清空日志
+- `GET /logs/download` - 下载日志文件
+- `WebSocket /logs/stream` - 实时日志流
+
+**版本信息端点**
+- `GET /version/info` - 获取版本信息（可选 `check_update=true` 参数检查更新）
+
+### 聊天 API 功能特性
+
+**多模态支持**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "messages": [
+    {
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "描述这张图片"},
+        {
+          "type": "image_url",
+          "image_url": {
+            "url": "data:image/jpeg;base64,/9j/4AAQSkZJRgABA..."
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+**思维模式支持**
+```json
+{
+  "model": "gemini-2.5-pro-maxthinking",
+  "messages": [
+    {"role": "user", "content": "复杂数学问题"}
+  ]
+}
+```
+
+响应将包含分离的思维内容：
+```json
+{
+  "choices": [{
+    "message": {
+      "role": "assistant",
+      "content": "最终答案",
+      "reasoning_content": "详细的思考过程..."
+    }
+  }]
+}
+```
+
+**流式抗截断使用**
+```json
+{
+  "model": "流式抗截断/gemini-2.5-pro",
+  "messages": [
+    {"role": "user", "content": "写一篇长文章"}
+  ],
+  "stream": true
+}
+```
+
+**兼容性模式**
+```bash
+# 启用兼容性模式
+export COMPATIBILITY_MODE=true
+```
+此模式下，所有 `system` 消息会转换为 `user` 消息，提高与某些客户端的兼容性。
+
+---
+
+## 💬 交流群
+
+欢迎加入 QQ 群交流讨论！
+
+**QQ 群号：1083250744**
+
+<img src="docs/qq群.jpg" width="200" alt="QQ群二维码">
+
+---
+
+## 许可证与免责声明
+
+本项目仅供学习和研究用途。使用本项目表示您同意：
+- 不将本项目用于任何商业用途
+- 承担使用本项目的所有风险和责任
+- 遵守相关的服务条款和法律法规
+
+项目作者对因使用本项目而产生的任何直接或间接损失不承担责任。
+
+## ⚠️ 许可证声明
+
+**本项目采用 Cooperative Non-Commercial License (CNC-1.0)**
+
+这是一个反商业化的严格开源协议，详情请查看 [LICENSE](LICENSE) 文件。
+
+### ✅ 允许的用途：
+- 个人学习、研究、教育用途
+- 非营利组织使用
+- 开源项目集成（需遵循相同协议）
+- 学术研究和论文发表
+
+### ❌ 禁止的用途：
+- 任何形式的商业使用
+- 年收入超过100万美元的企业使用
+- 风投支持或公开交易的公司使用  
+- 提供付费服务或产品
+- 商业竞争用途

config.py

@@ -0,0 +1,496 @@
+"""
+Configuration constants for the Geminicli2api proxy server.
+Centralizes all configuration to avoid duplication across modules.
+
+- 启动时加载一次配置到内存
+- 修改配置时调用 reload_config() 重新从数据库加载
+"""
+
+import os
+from typing import Any, Optional
+
+# 全局配置缓存
+_config_cache: dict[str, Any] = {}
+_config_initialized = False
+
+# Client Configuration
+
+# 需要自动封禁的错误码 (默认值，可通过环境变量或配置覆盖)
+AUTO_BAN_ERROR_CODES = [403]
+
+# ====================== 环境变量映射表 ======================
+# 统一维护环境变量名和配置键名的映射关系
+# 格式: "环境变量名": "配置键名"
+ENV_MAPPINGS = {
+    "CODE_ASSIST_ENDPOINT": "code_assist_endpoint",
+    "CREDENTIALS_DIR": "credentials_dir",
+    "PROXY": "proxy",
+    "OAUTH_PROXY_URL": "oauth_proxy_url",
+    "GOOGLEAPIS_PROXY_URL": "googleapis_proxy_url",
+    "RESOURCE_MANAGER_API_URL": "resource_manager_api_url",
+    "SERVICE_USAGE_API_URL": "service_usage_api_url",
+    "ANTIGRAVITY_API_URL": "antigravity_api_url",
+    "AUTO_BAN": "auto_ban_enabled",
+    "AUTO_BAN_ERROR_CODES": "auto_ban_error_codes",
+    "RETRY_429_MAX_RETRIES": "retry_429_max_retries",
+    "RETRY_429_ENABLED": "retry_429_enabled",
+    "RETRY_429_INTERVAL": "retry_429_interval",
+    "ANTI_TRUNCATION_MAX_ATTEMPTS": "anti_truncation_max_attempts",
+    "COMPATIBILITY_MODE": "compatibility_mode_enabled",
+    "RETURN_THOUGHTS_TO_FRONTEND": "return_thoughts_to_frontend",
+    "ANTIGRAVITY_STREAM2NOSTREAM": "antigravity_stream2nostream",
+    "ANTIGRAVITY_SWITCH_CREDENTIAL": "antigravity_switch_credential_enabled",
+    "HOST": "host",
+    "PORT": "port",
+    "API_PASSWORD": "api_password",
+    "PANEL_PASSWORD": "panel_password",
+    "PASSWORD": "password",
+    "KEEPALIVE_URL": "keepalive_url",
+    "KEEPALIVE_INTERVAL": "keepalive_interval",
+}
+
+
+# ====================== 配置系统 ======================
+
+async def init_config():
+    """初始化配置缓存（启动时调用一次）"""
+    global _config_cache, _config_initialized
+
+    if _config_initialized:
+        return
+
+    try:
+        from src.storage_adapter import get_storage_adapter
+        storage_adapter = await get_storage_adapter()
+        _config_cache = await storage_adapter.get_all_config()
+        _config_initialized = True
+    except Exception:
+        # 初始化失败时使用空缓存
+        _config_cache = {}
+        _config_initialized = True
+
+
+async def reload_config():
+    """重新加载配置（修改配置后调用）"""
+    global _config_cache, _config_initialized
+
+    try:
+        from src.storage_adapter import get_storage_adapter
+        storage_adapter = await get_storage_adapter()
+
+        # 如果后端支持 reload_config_cache，调用它
+        if hasattr(storage_adapter._backend, 'reload_config_cache'):
+            await storage_adapter._backend.reload_config_cache()
+
+        # 重新加载配置缓存
+        _config_cache = await storage_adapter.get_all_config()
+        _config_initialized = True
+    except Exception:
+        pass
+
+
+def _get_cached_config(key: str, default: Any = None) -> Any:
+    """从内存缓存获取配置（同步）"""
+    return _config_cache.get(key, default)
+
+
+async def get_config_value(key: str, default: Any = None, env_var: Optional[str] = None) -> Any:
+    """Get configuration value with priority: ENV > Storage > default."""
+    # 确保配置已初始化
+    if not _config_initialized:
+        await init_config()
+
+    # Priority 1: Environment variable
+    if env_var and os.getenv(env_var):
+        return os.getenv(env_var)
+
+    # Priority 2: Memory cache
+    value = _get_cached_config(key)
+    if value is not None:
+        return value
+
+    return default
+
+
+# Configuration getters - all async
+async def get_proxy_config():
+    """Get proxy configuration."""
+    proxy_url = await get_config_value("proxy", env_var="PROXY")
+    return proxy_url if proxy_url else None
+
+
+async def get_auto_ban_enabled() -> bool:
+    """Get auto ban enabled setting."""
+    env_value = os.getenv("AUTO_BAN")
+    if env_value:
+        return env_value.lower() in ("true", "1", "yes", "on")
+
+    return bool(await get_config_value("auto_ban_enabled", False))
+
+
+async def get_auto_ban_error_codes() -> list:
+    """
+    Get auto ban error codes.
+
+    Environment variable: AUTO_BAN_ERROR_CODES (comma-separated, e.g., "400,403")
+    Database config key: auto_ban_error_codes
+    Default: [400, 403]
+    """
+    env_value = os.getenv("AUTO_BAN_ERROR_CODES")
+    if env_value:
+        try:
+            return [int(code.strip()) for code in env_value.split(",") if code.strip()]
+        except ValueError:
+            pass
+
+    codes = await get_config_value("auto_ban_error_codes")
+    if codes and isinstance(codes, list):
+        return codes
+    return AUTO_BAN_ERROR_CODES
+
+
+async def get_retry_429_max_retries() -> int:
+    """Get max retries for 429 errors."""
+    env_value = os.getenv("RETRY_429_MAX_RETRIES")
+    if env_value:
+        try:
+            return int(env_value)
+        except ValueError:
+            pass
+
+    return int(await get_config_value("retry_429_max_retries", 5))
+
+
+async def get_retry_429_enabled() -> bool:
+    """Get 429 retry enabled setting."""
+    env_value = os.getenv("RETRY_429_ENABLED")
+    if env_value:
+        return env_value.lower() in ("true", "1", "yes", "on")
+
+    return bool(await get_config_value("retry_429_enabled", True))
+
+
+async def get_retry_429_interval() -> float:
+    """Get 429 retry interval in seconds."""
+    env_value = os.getenv("RETRY_429_INTERVAL")
+    if env_value:
+        try:
+            return float(env_value)
+        except ValueError:
+            pass
+
+    return float(await get_config_value("retry_429_interval", 1))
+
+
+async def get_anti_truncation_max_attempts() -> int:
+    """
+    Get maximum attempts for anti-truncation continuation.
+
+    Environment variable: ANTI_TRUNCATION_MAX_ATTEMPTS
+    Database config key: anti_truncation_max_attempts
+    Default: 3
+    """
+    env_value = os.getenv("ANTI_TRUNCATION_MAX_ATTEMPTS")
+    if env_value:
+        try:
+            return int(env_value)
+        except ValueError:
+            pass
+
+    return int(await get_config_value("anti_truncation_max_attempts", 3))
+
+
+# Server Configuration
+async def get_server_host() -> str:
+    """
+    Get server host setting.
+
+    Environment variable: HOST
+    Database config key: host
+    Default: 0.0.0.0
+    """
+    return str(await get_config_value("host", "0.0.0.0", "HOST"))
+
+
+async def get_server_port() -> int:
+    """
+    Get server port setting.
+
+    Environment variable: PORT
+    Database config key: port
+    Default: 7861
+    """
+    env_value = os.getenv("PORT")
+    if env_value:
+        try:
+            return int(env_value)
+        except ValueError:
+            pass
+
+    return int(await get_config_value("port", 7861))
+
+
+async def get_api_password() -> str:
+    """
+    Get API password setting for chat endpoints.
+
+    Environment variable: API_PASSWORD
+    Database config key: api_password
+    Default: Uses PASSWORD env var for compatibility, otherwise 'pwd'
+    """
+    # 优先使用 API_PASSWORD，如果没有则使用通用 PASSWORD 保证兼容性
+    api_password = await get_config_value("api_password", None, "API_PASSWORD")
+    if api_password is not None:
+        return str(api_password)
+
+    # 兼容性：使用通用密码
+    return str(await get_config_value("password", "pwd", "PASSWORD"))
+
+
+async def get_panel_password() -> str:
+    """
+    Get panel password setting for web interface.
+
+    Environment variable: PANEL_PASSWORD
+    Database config key: panel_password
+    Default: Uses PASSWORD env var for compatibility, otherwise 'pwd'
+    """
+    # 优先使用 PANEL_PASSWORD，如果没有则使用通用 PASSWORD 保证兼容性
+    panel_password = await get_config_value("panel_password", None, "PANEL_PASSWORD")
+    if panel_password is not None:
+        return str(panel_password)
+
+    # 兼容性：使用通用密码
+    return str(await get_config_value("password", "pwd", "PASSWORD"))
+
+
+async def get_server_password() -> str:
+    """
+    Get server password setting (deprecated, use get_api_password or get_panel_password).
+
+    Environment variable: PASSWORD
+    Database config key: password
+    Default: pwd
+    """
+    return str(await get_config_value("password", "pwd", "PASSWORD"))
+
+
+async def get_credentials_dir() -> str:
+    """
+    Get credentials directory setting.
+
+    Environment variable: CREDENTIALS_DIR
+    Database config key: credentials_dir
+    Default: ./creds
+    """
+    return str(await get_config_value("credentials_dir", "./creds", "CREDENTIALS_DIR"))
+
+
+async def get_code_assist_endpoint() -> str:
+    """
+    Get Code Assist endpoint setting.
+
+    Environment variable: CODE_ASSIST_ENDPOINT
+    Database config key: code_assist_endpoint
+    Default: https://cloudcode-pa.googleapis.com
+    """
+    return str(
+        await get_config_value(
+            "code_assist_endpoint", "https://cloudcode-pa.googleapis.com", "CODE_ASSIST_ENDPOINT"
+        )
+    )
+
+
+async def get_compatibility_mode_enabled() -> bool:
+    """
+    Get compatibility mode setting.
+
+    兼容性模式：启用后所有system消息全部转换成user，停用system_instructions。
+    该选项可能会降低模型理解能力，但是能避免流式空回的情况。
+
+    Environment variable: COMPATIBILITY_MODE
+    Database config key: compatibility_mode_enabled
+    Default: False
+    """
+    env_value = os.getenv("COMPATIBILITY_MODE")
+    if env_value:
+        return env_value.lower() in ("true", "1", "yes", "on")
+
+    return bool(await get_config_value("compatibility_mode_enabled", False))
+
+
+async def get_return_thoughts_to_frontend() -> bool:
+    """
+    Get return thoughts to frontend setting.
+
+    控制是否将思维链返回到前端。
+    启用后，思维链会在��应中返回；禁用后，思维链会在响应中被过滤掉。
+
+    Environment variable: RETURN_THOUGHTS_TO_FRONTEND
+    Database config key: return_thoughts_to_frontend
+    Default: True
+    """
+    env_value = os.getenv("RETURN_THOUGHTS_TO_FRONTEND")
+    if env_value:
+        return env_value.lower() in ("true", "1", "yes", "on")
+
+    return bool(await get_config_value("return_thoughts_to_frontend", True))
+
+
+async def get_antigravity_stream2nostream() -> bool:
+    """
+    Get use stream for non-stream setting.
+
+    控制antigravity非流式请求是否使用流式API并收集为完整响应。
+    启用后，非流式请求将在后端使用流式API，然后收集所有块后再返回完整响应。
+
+    Environment variable: ANTIGRAVITY_STREAM2NOSTREAM
+    Database config key: antigravity_stream2nostream
+    Default: True
+    """
+    env_value = os.getenv("ANTIGRAVITY_STREAM2NOSTREAM")
+    if env_value:
+        return env_value.lower() in ("true", "1", "yes", "on")
+
+    return bool(await get_config_value("antigravity_stream2nostream", True))
+
+
+async def get_antigravity_switch_credential_enabled() -> bool:
+    """
+    Get antigravity switch credential setting.
+
+    控制antigravity在重试时是否切换凭证。
+    禁用时会持续使用当前凭证，直到该凭证对当前模型进入CD或被禁用。
+
+    Environment variable: ANTIGRAVITY_SWITCH_CREDENTIAL
+    Database config key: antigravity_switch_credential_enabled
+    Default: False
+    """
+    env_value = os.getenv("ANTIGRAVITY_SWITCH_CREDENTIAL")
+    if env_value:
+        return env_value.lower() in ("true", "1", "yes", "on")
+
+    return bool(await get_config_value("antigravity_switch_credential_enabled", False))
+
+
+async def get_oauth_proxy_url() -> str:
+    """
+    Get OAuth proxy URL setting.
+
+    用于Google OAuth2认证的代理URL。
+
+    Environment variable: OAUTH_PROXY_URL
+    Database config key: oauth_proxy_url
+    Default: https://oauth2.googleapis.com
+    """
+    return str(
+        await get_config_value(
+            "oauth_proxy_url", "https://oauth2.googleapis.com", "OAUTH_PROXY_URL"
+        )
+    )
+
+
+async def get_googleapis_proxy_url() -> str:
+    """
+    Get Google APIs proxy URL setting.
+
+    用于Google APIs调用的代理URL。
+
+    Environment variable: GOOGLEAPIS_PROXY_URL
+    Database config key: googleapis_proxy_url
+    Default: https://www.googleapis.com
+    """
+    return str(
+        await get_config_value(
+            "googleapis_proxy_url", "https://www.googleapis.com", "GOOGLEAPIS_PROXY_URL"
+        )
+    )
+
+
+async def get_resource_manager_api_url() -> str:
+    """
+    Get Google Cloud Resource Manager API URL setting.
+
+    用于Google Cloud Resource Manager API的URL。
+
+    Environment variable: RESOURCE_MANAGER_API_URL
+    Database config key: resource_manager_api_url
+    Default: https://cloudresourcemanager.googleapis.com
+    """
+    return str(
+        await get_config_value(
+            "resource_manager_api_url",
+            "https://cloudresourcemanager.googleapis.com",
+            "RESOURCE_MANAGER_API_URL",
+        )
+    )
+
+
+async def get_service_usage_api_url() -> str:
+    """
+    Get Google Cloud Service Usage API URL setting.
+
+    用于Google Cloud Service Usage API的URL。
+
+    Environment variable: SERVICE_USAGE_API_URL
+    Database config key: service_usage_api_url
+    Default: https://serviceusage.googleapis.com
+    """
+    return str(
+        await get_config_value(
+            "service_usage_api_url", "https://serviceusage.googleapis.com", "SERVICE_USAGE_API_URL"
+        )
+    )
+
+
+async def get_antigravity_api_url() -> str:
+    """
+    Get Antigravity API URL setting.
+
+    用于Google Antigravity API的URL。
+
+    Environment variable: ANTIGRAVITY_API_URL
+    Database config key: antigravity_api_url
+    Default: https://daily-cloudcode-pa.googleapis.com
+    """
+    return str(
+        await get_config_value(
+            "antigravity_api_url",
+            "https://daily-cloudcode-pa.googleapis.com",
+            "ANTIGRAVITY_API_URL",
+        )
+    )
+
+
+async def get_keepalive_url() -> str:
+    """
+    Get keep-alive URL setting.
+
+    配置后保活服务会定期向该URL发送GET请求。
+    留空表示禁用保活服务。
+
+    Environment variable: KEEPALIVE_URL
+    Database config key: keepalive_url
+    Default: "" (disabled)
+    """
+    return str(await get_config_value("keepalive_url", "", "KEEPALIVE_URL"))
+
+
+async def get_keepalive_interval() -> int:
+    """
+    Get keep-alive interval in seconds.
+
+    保活请求发送间隔（秒）。
+
+    Environment variable: KEEPALIVE_INTERVAL
+    Database config key: keepalive_interval
+    Default: 60
+    """
+    env_value = os.getenv("KEEPALIVE_INTERVAL")
+    if env_value:
+        try:
+            return int(env_value)
+        except ValueError:
+            pass
+
+    return int(await get_config_value("keepalive_interval", 60))

darwin-install.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# macOS 安装脚本 (支持 Intel 和 Apple Silicon)
+
+# 确保 Homebrew 已安装
+if ! command -v brew &> /dev/null; then
+    echo "未检测到 Homebrew，开始安装..."
+    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+    
+    # 检测 Homebrew 安装路径并设置环境变量
+    if [[ -f "/opt/homebrew/bin/brew" ]]; then
+        # Apple Silicon Mac
+        eval "$(/opt/homebrew/bin/brew shellenv)"
+    elif [[ -f "/usr/local/bin/brew" ]]; then
+        # Intel Mac
+        eval "$(/usr/local/bin/brew shellenv)"
+    fi
+fi
+
+# 更新 brew 并安装 git
+brew update
+brew install git
+
+# 安装 uv (Python 环境管理工具)
+curl -Ls https://astral.sh/uv/install.sh | sh
+
+# 确保 uv 在 PATH 中
+export PATH="$HOME/.local/bin:$PATH"
+
+# 克隆或进入项目目录
+if [ -f "./web.py" ]; then
+    # 已经在目标目录
+    :
+elif [ -f "./gcli2api/web.py" ]; then
+    cd ./gcli2api
+else
+    git clone https://github.com/su-kaka/gcli2api.git
+    cd ./gcli2api
+fi
+
+# 拉取最新代码
+git pull
+
+# 创建并同步虚拟环境
+uv sync
+
+# 激活虚拟环境
+if [ -f ".venv/bin/activate" ]; then
+    source .venv/bin/activate
+else
+    echo "❌ 未找到虚拟环境，请检查 uv 是否安装成功"
+    exit 1
+fi
+
+# 启动项目
+python3 web.py

docker-compose.yml

@@ -0,0 +1,79 @@
+version: '3.8'
+
+services:
+  gcli2api:
+    image: ghcr.io/su-kaka/gcli2api:latest
+    container_name: gcli2api
+    restart: unless-stopped
+    network_mode: host
+    environment:
+      # Password configuration (choose one)
+      # Option 1: Use common password
+      - PASSWORD=${PASSWORD:-pwd}
+      # Option 2: Use separate passwords (uncomment if needed)
+      # - API_PASSWORD=${API_PASSWORD:-your_api_password}
+      # - PANEL_PASSWORD=${PANEL_PASSWORD:-your_panel_password}
+
+      # Server configuration
+      - PORT=${PORT:-7861}
+      - HOST=${HOST:-0.0.0.0}
+
+      # Optional: Google credentials from environment
+      # - GOOGLE_CREDENTIALS=${GOOGLE_CREDENTIALS}
+
+      # Optional: Logging configuration
+      # - LOG_LEVEL=${LOG_LEVEL:-info}
+
+      # Optional: Redis configuration (for distributed storage)
+      # - REDIS_URI=${REDIS_URI}
+      # - REDIS_DATABASE=${REDIS_DATABASE:-0}
+
+      # Optional: MongoDB configuration (for distributed storage)
+      # - MONGODB_URI=${MONGODB_URI}
+      # - MONGODB_DATABASE=${MONGODB_DATABASE:-gcli2api}
+
+      # Optional: PostgreSQL configuration (for distributed storage)
+      # - POSTGRES_DSN=${POSTGRES_DSN}
+
+      # Optional: Proxy configuration
+      # - PROXY=${PROXY}
+    volumes:
+      - ./data/creds:/app/creds
+
+# Example with Redis for distributed storage
+#  redis:
+#    image: redis:7-alpine
+#    container_name: gcli2api-redis
+#    restart: unless-stopped
+#    ports:
+#      - "6379:6379"
+#    volumes:
+#      - redis_data:/data
+#    command: redis-server --appendonly yes
+#    healthcheck:
+#      test: ["CMD", "redis-cli", "ping"]
+#      interval: 10s
+#      timeout: 3s
+#      retries: 3
+
+# Example with MongoDB for distributed storage
+#  mongodb:
+#    image: mongo:7
+#    container_name: gcli2api-mongodb
+#    restart: unless-stopped
+#    environment:
+#      MONGO_INITDB_ROOT_USERNAME: ${MONGO_USER:-admin}
+#      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD:-password}
+#    ports:
+#      - "27017:27017"
+#    volumes:
+#      - mongodb_data:/data/db
+#    healthcheck:
+#      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
+#      interval: 10s
+#      timeout: 5s
+#      retries: 3
+
+#volumes:
+#  redis_data:
+#  mongodb_data:

docs/README_EN.md

@@ -0,0 +1,883 @@
+# GeminiCLI to API
+
+**Convert GeminiCLI and Antigravity to OpenAI, GEMINI, and Claude API Compatible Interfaces**
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: CNC-1.0](https://img.shields.io/badge/License-CNC--1.0-red.svg)](../LICENSE)
+[![Docker](https://img.shields.io/badge/docker-available-blue.svg)](https://github.com/su-kaka/gcli2api/pkgs/container/gcli2api)
+
+[中文](../README.md) | English | [日本語](./README_JA.md)
+
+## 🚀 Quick Deploy
+
+[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/templates/97VMEF?referralCode=sukaka)
+[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/su-kaka/gcli2api)
+---
+
+## Installation Guide
+
+### Termux Environment
+
+**Initial Installation**
+```bash
+curl -o termux-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/termux-install.sh" && chmod +x termux-install.sh && ./termux-install.sh
+```
+
+**Restart Service**
+```bash
+cd gcli2api
+bash termux-start.sh
+```
+
+### Windows Environment
+
+**Initial Installation**
+```powershell
+iex (iwr "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.ps1" -UseBasicParsing).Content
+```
+
+**Restart Service**
+Double-click to execute `start.bat`
+
+### Linux Environment
+
+**Initial Installation**
+```bash
+curl -o install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.sh" && chmod +x install.sh && ./install.sh
+```
+
+**Restart Service**
+```bash
+cd gcli2api
+bash start.sh
+```
+
+### macOS Environment
+
+**Initial Installation**
+```bash
+curl -o darwin-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/darwin-install.sh" && chmod +x darwin-install.sh && ./darwin-install.sh
+```
+
+**Restart Service**
+```bash
+cd gcli2api
+bash start.sh
+```
+
+### Docker Environment
+
+**Docker Run Command**
+```bash
+# Using universal password
+docker run -d --name gcli2api --network host -e PASSWORD=pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
+
+# Using separate passwords
+docker run -d --name gcli2api --network host -e API_PASSWORD=api_pwd -e PANEL_PASSWORD=panel_pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
+```
+
+**Docker Mac**
+```bash
+# Using universal password
+docker run -d \
+  --name gcli2api \
+  -p 7861:7861 \
+  -p 8080:8080 \
+  -e PASSWORD=pwd \
+  -e PORT=7861 \
+  -v "$(pwd)/data/creds":/app/creds \
+  ghcr.io/su-kaka/gcli2api:latest
+```
+
+```bash
+# Using separate passwords
+docker run -d \
+--name gcli2api \
+-p 7861:7861 \
+-p 8080:8080 \
+-e API_PASSWORD=api_pwd \
+-e PANEL_PASSWORD=panel_pwd \
+-e PORT=7861 \
+-v $(pwd)/data/creds:/app/creds \
+ghcr.io/su-kaka/gcli2api:latest
+```
+
+**Docker Compose Run Command**
+1. Save the following content as `docker-compose.yml` file:
+    ```yaml
+    version: '3.8'
+
+    services:
+      gcli2api:
+        image: ghcr.io/su-kaka/gcli2api:latest
+        container_name: gcli2api
+        restart: unless-stopped
+        network_mode: host
+        environment:
+          # Using universal password (recommended for simple deployment)
+          - PASSWORD=pwd
+          - PORT=7861
+          # Or use separate passwords (recommended for production)
+          # - API_PASSWORD=your_api_password
+          # - PANEL_PASSWORD=your_panel_password
+        volumes:
+          - ./data/creds:/app/creds
+        healthcheck:
+          test: ["CMD-SHELL", "python -c \"import sys, urllib.request, os; port = os.environ.get('PORT', '7861'); req = urllib.request.Request(f'http://localhost:{port}/v1/models', headers={'Authorization': 'Bearer ' + os.environ.get('PASSWORD', 'pwd')}); sys.exit(0 if urllib.request.urlopen(req, timeout=5).getcode() == 200 else 1)\""]
+          interval: 30s
+          timeout: 10s
+          retries: 3
+          start_period: 40s
+    ```
+2. Start the service:
+    ```bash
+    docker-compose up -d
+    ```
+
+## Core Features
+
+### 🔄 API Endpoints and Format Support
+
+**Multi-endpoint Multi-format Support**
+- **OpenAI Compatible Endpoints**: `/v1/chat/completions` and `/v1/models`
+  - Supports standard OpenAI format (messages structure)
+  - Supports Gemini native format (contents structure)
+  - Automatic format detection and conversion, no manual switching required
+  - Supports multimodal input (text + images)
+- **Gemini Native Endpoints**: `/v1/models/{model}:generateContent` and `streamGenerateContent`
+  - Supports complete Gemini native API specifications
+  - Multiple authentication methods: Bearer Token, x-goog-api-key header, URL parameter key
+- **Claude Format Compatibility**: Full support for Claude API format
+  - Endpoint: `/v1/messages` (follows Claude API specification)
+  - Supports Claude standard messages format
+  - Supports system parameter and Claude-specific features
+  - Automatically converts to backend-supported format
+- **Antigravity API Support**: Supports OpenAI, Gemini, and Claude formats
+  - OpenAI format endpoint: `/antigravity/v1/chat/completions`
+  - Gemini format endpoint: `/antigravity/v1/models/{model}:generateContent` and `streamGenerateContent`
+  - Claude format endpoint: `/antigravity/v1/messages`
+  - Supports all Antigravity models (Claude, Gemini, etc.)
+  - Automatic model name mapping and thinking mode detection
+
+### 🔐 Authentication and Security Management
+
+**Flexible Password Management**
+- **Separate Password Support**: API password (chat endpoints) and control panel password can be set independently
+- **Multiple Authentication Methods**: Supports Authorization Bearer, x-goog-api-key header, URL parameters, etc.
+- **JWT Token Authentication**: Control panel supports JWT token authentication
+- **User Email Retrieval**: Automatically retrieves and displays Google account email addresses
+
+### 📊 Intelligent Credential Management System
+
+**Advanced Credential Management**
+- Multiple Google OAuth credential automatic rotation
+- Enhanced stability through redundant authentication
+- Load balancing and concurrent request support
+- Automatic failure detection and credential disabling
+- Credential usage statistics and quota management
+- Support for manual enable/disable credential files
+- Batch credential file operations (enable, disable, delete)
+
+**Credential Status Monitoring**
+- Real-time credential health checks
+- Error code tracking (429, 403, 500, etc.)
+- Automatic banning mechanism (configurable)
+
+### 🌊 Streaming and Response Processing
+
+**Multiple Streaming Support**
+- True real-time streaming responses
+- Fake streaming mode (for compatibility)
+- Streaming anti-truncation feature (prevents answer truncation)
+- Asynchronous task management and timeout handling
+
+**Response Optimization**
+- Thinking chain content separation
+- Reasoning process (reasoning_content) handling
+- Multi-turn conversation context management
+- Compatibility mode (converts system messages to user messages)
+
+### 🎛️ Web Management Console
+
+**Full-featured Web Interface**
+- OAuth authentication flow management (supports GCLI and Antigravity dual modes)
+- Credential file upload, download, and management
+- Real-time log viewing (WebSocket)
+- System configuration management
+- Usage statistics and monitoring dashboard
+- Mobile-friendly interface
+
+**Batch Operation Support**
+- ZIP file batch credential upload (GCLI and Antigravity)
+- Batch enable/disable/delete credentials
+- Batch user email retrieval
+- Batch configuration management
+- Unified batch upload interface for all credential types
+
+### 📈 Usage Monitoring
+
+**Real-time Monitoring**
+- WebSocket real-time log streams
+- System status monitoring
+- Credential health status
+
+### 🔧 Advanced Configuration and Customization
+
+**Network and Proxy Configuration**
+- HTTP/HTTPS proxy support
+- Proxy endpoint configuration (OAuth, Google APIs, metadata service)
+- Timeout and retry configuration
+- Network error handling and recovery
+
+**Performance and Stability Configuration**
+- 429 error automatic retry (configurable interval and attempts)
+- Anti-truncation maximum retry attempts
+
+**Logging and Debugging**
+- Multi-level logging system (DEBUG, INFO, WARNING, ERROR)
+- Log file management
+- Real-time log streams
+- Log download and clearing
+
+### 🔄 Environment Variables and Configuration Management
+
+**Flexible Configuration Methods**
+- Environment variable configuration
+- Hot configuration updates (partial configuration items)
+- Configuration locking (environment variable priority)
+
+## Supported Models
+
+All models have 1M context window capacity. Each credential file provides 1000 request quota.
+
+### 🤖 Base Models
+- `gemini-2.5-pro`
+- `gemini-3-pro-preview`
+- `gemini-3.1-pro-preview`
+
+### 🧠 Thinking Models
+- `gemini-2.5-pro-high`: Thinking mode
+- `gemini-2.5-pro-low`: Low thinking mode
+- Supports custom thinking budget configuration
+- Automatic separation of thinking content and final answers
+
+### 🔍 Search-Enhanced Models
+- `gemini-2.5-pro-search`: Model with integrated search functionality
+
+### 🖼️ Image Generation Models (Antigravity)
+- `gemini-3.1-flash-image`: Base image generation model
+- **Resolution Suffixes**:
+  - `-2k`: 2K resolution
+  - `-4k`: 4K HD resolution
+- **Aspect Ratio Suffixes**:
+  - `-1x1`: Square (avatar)
+  - `-16x9`: Landscape (desktop wallpaper)
+  - `-9x16`: Portrait (mobile wallpaper)
+  - `-21x9`: Ultra-wide (ultrawide monitor)
+  - `-4x3`: Traditional display
+  - `-3x4`: Portrait poster
+- **Combination Examples**:
+  - `gemini-3.1-flash-image-4k-16x9`: 4K landscape
+  - `gemini-3.1-flash-image-2k-9x16`: 2K portrait
+- When no ratio is specified, the API automatically decides the aspect ratio
+
+### 🌊 Special Feature Variants
+- **Fake Streaming Mode**: Add `-假流式` suffix to any model name
+  - Example: `gemini-2.5-pro-假流式`
+  - For scenarios requiring streaming responses but server doesn't support true streaming
+- **Streaming Anti-truncation Mode**: Add `流式抗截断/` prefix to model name
+  - Example: `流式抗截断/gemini-2.5-pro`
+  - Automatically detects response truncation and retries to ensure complete answers
+
+### 🔧 Automatic Model Feature Detection
+- System automatically recognizes feature identifiers in model names
+- Transparently handles feature mode transitions
+- Supports feature combination usage
+
+---
+
+## Configuration Instructions
+
+1. Visit `http://127.0.0.1:7861` (default port, modifiable via PORT environment variable)
+2. Complete OAuth authentication flow (default password: `pwd`, modifiable via environment variables)
+   - **GCLI Mode**: For obtaining Google Cloud Gemini API credentials
+   - **Antigravity Mode**: For obtaining Google Antigravity API credentials
+3. Configure client:
+
+**OpenAI Compatible Client:**
+   - **Endpoint Address**: `http://127.0.0.1:7861/v1`
+   - **API Key**: `pwd` (default value, modifiable via API_PASSWORD or PASSWORD environment variables)
+
+**Gemini Native Client:**
+   - **Endpoint Address**: `http://127.0.0.1:7861`
+   - **Authentication Methods**:
+     - `Authorization: Bearer your_api_password`
+     - `x-goog-api-key: your_api_password`
+     - URL parameter: `?key=your_api_password`
+
+### 🌟 Dual Authentication Mode Support
+
+**GCLI Authentication Mode**
+- Standard Google Cloud Gemini API authentication
+- Supports OAuth2.0 authentication flow
+- Automatically enables required Google Cloud APIs
+
+**Antigravity Authentication Mode**
+- Dedicated authentication for Google Antigravity API
+- Independent credential management system
+- Supports batch upload and management
+- Completely isolated from GCLI credentials
+
+**Unified Management Interface**
+- Manage both credential types in the "Batch Upload" tab
+- Upper section: GCLI credential batch upload (blue theme)
+- Lower section: Antigravity credential batch upload (green theme)
+- Separate credential management tabs for each type
+
+## 💾 Data Storage Mode
+
+### 🌟 Storage Backend Support
+
+gcli2api supports two storage backends: **Local SQLite (Default)** and **MongoDB (Cloud Distributed Storage)**
+
+### 📁 Local SQLite Storage (Default)
+
+**Default Storage Method**
+- No configuration required, works out of the box
+- Data is stored in a local SQLite database
+- Suitable for single-machine deployment and personal use
+- Automatically creates and manages database files
+
+### 🍃 MongoDB Cloud Storage Mode
+
+**Cloud Distributed Storage Solution**
+
+When multi-instance deployment or cloud storage is needed, MongoDB storage mode can be enabled.
+
+### ⚙️ Enable MongoDB Mode
+
+**Step 1: Configure MongoDB Connection**
+```bash
+# Local MongoDB
+export MONGODB_URI="mongodb://localhost:27017"
+
+# MongoDB Atlas cloud service
+export MONGODB_URI="mongodb+srv://username:password@cluster.mongodb.net"
+
+# MongoDB with authentication
+export MONGODB_URI="mongodb://admin:password@localhost:27017/admin"
+
+# Optional: Custom database name (default: gcli2api)
+export MONGODB_DATABASE="my_gcli_db"
+```
+
+**Step 2: Start Application**
+```bash
+# Application will automatically detect MongoDB configuration and use MongoDB storage
+python web.py
+```
+
+**Docker Environment using MongoDB**
+```bash
+# Single MongoDB deployment
+docker run -d --name gcli2api \
+  -e MONGODB_URI="mongodb://mongodb:27017" \
+  -e API_PASSWORD=your_password \
+  --network your_network \
+  ghcr.io/su-kaka/gcli2api:latest
+
+# Using MongoDB Atlas
+docker run -d --name gcli2api \
+  -e MONGODB_URI="mongodb+srv://user:pass@cluster.mongodb.net/gcli2api" \
+  -e API_PASSWORD=your_password \
+  -p 7861:7861 \
+  ghcr.io/su-kaka/gcli2api:latest
+```
+
+**Docker Compose Example**
+```yaml
+version: '3.8'
+
+services:
+  mongodb:
+    image: mongo:7
+    container_name: gcli2api-mongodb
+    restart: unless-stopped
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: admin
+      MONGO_INITDB_ROOT_PASSWORD: password123
+    volumes:
+      - mongodb_data:/data/db
+    ports:
+      - "27017:27017"
+
+  gcli2api:
+    image: ghcr.io/su-kaka/gcli2api:latest
+    container_name: gcli2api
+    restart: unless-stopped
+    depends_on:
+      - mongodb
+    environment:
+      - MONGODB_URI=mongodb://admin:password123@mongodb:27017/admin
+      - MONGODB_DATABASE=gcli2api
+      - API_PASSWORD=your_api_password
+      - PORT=7861
+    ports:
+      - "7861:7861"
+
+volumes:
+  mongodb_data:
+```
+
+
+### 🔧 Advanced Configuration
+
+**MongoDB Connection Optimization**
+```bash
+# Connection pool and timeout configuration
+export MONGODB_URI="mongodb://localhost:27017?maxPoolSize=10&serverSelectionTimeoutMS=5000"
+
+# Replica set configuration
+export MONGODB_URI="mongodb://host1:27017,host2:27017,host3:27017/gcli2api?replicaSet=myReplicaSet"
+
+# Read-write separation configuration
+export MONGODB_URI="mongodb://localhost:27017/gcli2api?readPreference=secondaryPreferred"
+```
+
+### Environment Variable Configuration
+
+**Basic Configuration**
+- `PORT`: Service port (default: 7861)
+- `HOST`: Server listen address (default: 0.0.0.0)
+
+**Password Configuration**
+- `API_PASSWORD`: Chat API access password (default: inherits PASSWORD or pwd)
+- `PANEL_PASSWORD`: Control panel access password (default: inherits PASSWORD or pwd)
+- `PASSWORD`: Universal password, overrides the above two when set (default: pwd)
+
+**Performance and Stability Configuration**
+- `RETRY_429_ENABLED`: Enable 429 error automatic retry (default: true)
+- `RETRY_429_MAX_RETRIES`: Maximum retry attempts for 429 errors (default: 3)
+- `RETRY_429_INTERVAL`: Retry interval for 429 errors, in seconds (default: 1.0)
+- `ANTI_TRUNCATION_MAX_ATTEMPTS`: Maximum retry attempts for anti-truncation (default: 3)
+
+**Network and Proxy Configuration**
+- `PROXY`: HTTP/HTTPS proxy address (format: `http://host:port`)
+- `OAUTH_PROXY_URL`: OAuth authentication proxy endpoint
+- `GOOGLEAPIS_PROXY_URL`: Google APIs proxy endpoint
+- `METADATA_SERVICE_URL`: Metadata service proxy endpoint
+
+**Automation Configuration**
+- `AUTO_BAN`: Enable automatic credential banning (default: true)
+- `AUTO_LOAD_ENV_CREDS`: Automatically load environment variable credentials at startup (default: false)
+
+**Compatibility Configuration**
+- `COMPATIBILITY_MODE`: Enable compatibility mode, converts system messages to user messages (default: false)
+
+**Logging Configuration**
+- `LOG_LEVEL`: Log level (DEBUG/INFO/WARNING/ERROR, default: INFO)
+- `LOG_FILE`: Log file path (default: log.txt)
+
+**Storage Configuration**
+
+**SQLite Configuration (Default)**
+- No configuration required, automatically uses local SQLite database
+- Database files are automatically created in the project directory
+
+**MongoDB Configuration (Optional Cloud Storage)**
+- `MONGODB_URI`: MongoDB connection string (enables MongoDB mode when set)
+- `MONGODB_DATABASE`: MongoDB database name (default: gcli2api)
+
+**Docker Usage Example**
+```bash
+# Using universal password
+docker run -d --name gcli2api \
+  -e PASSWORD=mypassword \
+  -e PORT=7861 \
+  ghcr.io/su-kaka/gcli2api:latest
+
+# Using separate passwords
+docker run -d --name gcli2api \
+  -e API_PASSWORD=my_api_password \
+  -e PANEL_PASSWORD=my_panel_password \
+  -e PORT=7861 \
+  ghcr.io/su-kaka/gcli2api:latest
+```
+
+Note: When credential environment variables are set, the system will prioritize using credentials from environment variables and ignore files in the `creds` directory.
+
+### API Usage Methods
+
+This service supports multiple complete sets of API endpoints:
+
+#### 1. OpenAI Compatible Endpoints (GCLI)
+
+**Endpoint:** `/v1/chat/completions`
+**Authentication:** `Authorization: Bearer your_api_password`
+
+Supports two request formats with automatic detection and processing:
+
+**OpenAI Format:**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "messages": [
+    {"role": "system", "content": "You are a helpful assistant"},
+    {"role": "user", "content": "Hello"}
+  ],
+  "temperature": 0.7,
+  "stream": true
+}
+```
+
+**Gemini Native Format:**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "contents": [
+    {"role": "user", "parts": [{"text": "Hello"}]}
+  ],
+  "systemInstruction": {"parts": [{"text": "You are a helpful assistant"}]},
+  "generationConfig": {
+    "temperature": 0.7
+  }
+}
+```
+
+#### 2. Gemini Native Endpoints (GCLI)
+
+**Non-streaming Endpoint:** `/v1/models/{model}:generateContent`
+**Streaming Endpoint:** `/v1/models/{model}:streamGenerateContent`
+**Model List:** `/v1/models`
+
+**Authentication Methods (choose one):**
+- `Authorization: Bearer your_api_password`
+- `x-goog-api-key: your_api_password`
+- URL parameter: `?key=your_api_password`
+
+**Request Examples:**
+```bash
+# Using x-goog-api-key header
+curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:generateContent" \
+  -H "x-goog-api-key: your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ]
+  }'
+
+# Using URL parameter
+curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:streamGenerateContent?key=your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ]
+  }'
+```
+
+#### 3. Claude API Format Endpoints
+
+**Endpoint:** `/v1/messages`
+**Authentication:** `x-api-key: your_api_password` or `Authorization: Bearer your_api_password`
+
+**Request Example:**
+```bash
+curl -X POST "http://127.0.0.1:7861/v1/messages" \
+  -H "x-api-key: your_api_password" \
+  -H "anthropic-version: 2023-06-01" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "max_tokens": 1024,
+    "messages": [
+      {"role": "user", "content": "Hello, Claude!"}
+    ]
+  }'
+```
+
+**Support for system parameter:**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "max_tokens": 1024,
+  "system": "You are a helpful assistant",
+  "messages": [
+    {"role": "user", "content": "Hello"}
+  ]
+}
+```
+
+**Notes:**
+- Fully compatible with Claude API format specification
+- Automatically converts to Gemini format for backend calls
+- Supports all Claude standard parameters
+- Response format follows Claude API specification
+
+#### 4. Antigravity API Endpoints
+
+**Supports three formats: OpenAI, Gemini, and Claude**
+
+##### Antigravity OpenAI Format Endpoints
+
+**Endpoint:** `/antigravity/v1/chat/completions`
+**Authentication:** `Authorization: Bearer your_api_password`
+
+**Request Example:**
+```bash
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/chat/completions" \
+  -H "Authorization: Bearer your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "claude-sonnet-4-5",
+    "messages": [
+      {"role": "user", "content": "Hello"}
+    ],
+    "stream": true
+  }'
+```
+
+##### Antigravity Gemini Format Endpoints
+
+**Non-streaming Endpoint:** `/antigravity/v1/models/{model}:generateContent`
+**Streaming Endpoint:** `/antigravity/v1/models/{model}:streamGenerateContent`
+
+**Authentication Methods (choose one):**
+- `Authorization: Bearer your_api_password`
+- `x-goog-api-key: your_api_password`
+- URL parameter: `?key=your_api_password`
+
+**Request Examples:**
+```bash
+# Gemini format non-streaming request
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/claude-sonnet-4-5:generateContent" \
+  -H "x-goog-api-key: your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ],
+    "generationConfig": {
+      "temperature": 0.7
+    }
+  }'
+
+# Gemini format streaming request
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/gemini-2.5-flash:streamGenerateContent?key=your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ]
+  }'
+```
+
+##### Antigravity Claude Format Endpoints
+
+**Endpoint:** `/antigravity/v1/messages`
+**Authentication:** `x-api-key: your_api_password`
+
+**Request Example:**
+```bash
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/messages" \
+  -H "x-api-key: your_api_password" \
+  -H "anthropic-version: 2023-06-01" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "claude-sonnet-4-5",
+    "max_tokens": 1024,
+    "messages": [
+      {"role": "user", "content": "Hello"}
+    ]
+  }'
+```
+
+**Supported Antigravity Models:**
+- Claude series: `claude-sonnet-4-5`, `claude-opus-4-5`, etc.
+- Gemini series: `gemini-2.5-flash`, `gemini-2.5-pro`, etc.
+- Automatically supports thinking models
+
+**Gemini Native Example:**
+```python
+from io import BytesIO
+from PIL import Image
+from google.genai import Client
+from google.genai.types import HttpOptions
+from google.genai import types
+# The client gets the API key from the environment variable `GEMINI_API_KEY`.
+
+client = Client(
+            api_key="pwd",
+            http_options=HttpOptions(base_url="http://127.0.0.1:7861"),
+        )
+
+prompt = (
+    """
+    Draw a cat
+    """
+)
+
+response = client.models.generate_content(
+    model="gemini-3.1-flash-image",
+    contents=[prompt],
+    config=types.GenerateContentConfig(
+        image_config=types.ImageConfig(
+            aspect_ratio="16:9",
+        )
+    )
+)
+for part in response.candidates[0].content.parts:
+    if part.text is not None:
+        print(part.text)
+    elif part.inline_data is not None:
+        image = Image.open(BytesIO(part.inline_data.data))
+        image.save("generated_image.png")
+
+```
+
+**Notes:**
+- OpenAI endpoints return OpenAI-compatible format
+- Gemini endpoints return Gemini native format
+- Both endpoints use the same API password
+
+## 📋 Complete API Reference
+
+### Web Console API
+
+**Authentication Endpoints**
+- `POST /auth/login` - User login
+- `POST /auth/start` - Start OAuth authentication (supports GCLI and Antigravity modes)
+- `POST /auth/callback` - Handle OAuth callback
+- `POST /auth/callback-url` - Complete authentication directly from callback URL
+- `GET /auth/status/{project_id}` - Check authentication status
+
+**Credential Management Endpoints** (supports `mode=geminicli` or `mode=antigravity` parameter)
+- `POST /creds/upload` - Batch upload credential files (supports JSON and ZIP)
+- `GET /creds/status` - Get credential status list (supports pagination and filtering)
+- `GET /creds/detail/{filename}` - Get single credential details
+- `POST /creds/action` - Single credential operation (enable/disable/delete)
+- `POST /creds/batch-action` - Batch credential operations
+- `GET /creds/download/{filename}` - Download single credential file
+- `GET /creds/download-all` - Package download all credentials
+- `POST /creds/fetch-email/{filename}` - Get user email
+- `POST /creds/refresh-all-emails` - Batch refresh user emails
+- `POST /creds/deduplicate-by-email` - Deduplicate credentials by email
+- `POST /creds/verify-project/{filename}` - Verify credential Project ID
+- `GET /creds/quota/{filename}` - Get credential quota information (Antigravity only)
+
+**Configuration Management Endpoints**
+- `GET /config/get` - Get current configuration
+- `POST /config/save` - Save configuration
+
+**Log Management Endpoints**
+- `POST /logs/clear` - Clear logs
+- `GET /logs/download` - Download log file
+- `WebSocket /logs/stream` - Real-time log stream
+
+**Version Information Endpoints**
+- `GET /version/info` - Get version information (optional `check_update=true` parameter to check for updates)
+
+### Chat API Features
+
+**Multimodal Support**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "messages": [
+    {
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "Describe this image"},
+        {
+          "type": "image_url",
+          "image_url": {
+            "url": "data:image/jpeg;base64,/9j/4AAQSkZJRgABA..."
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+**Thinking Mode Support**
+```json
+{
+  "model": "gemini-2.5-pro-high",
+  "messages": [
+    {"role": "user", "content": "Complex math problem"}
+  ]
+}
+```
+
+Response will include separated thinking content:
+```json
+{
+  "choices": [{
+    "message": {
+      "role": "assistant",
+      "content": "Final answer",
+      "reasoning_content": "Detailed thought process..."
+    }
+  }]
+}
+```
+
+**Streaming Anti-truncation Usage**
+```json
+{
+  "model": "流式抗截断/gemini-2.5-pro",
+  "messages": [
+    {"role": "user", "content": "Write a long article"}
+  ],
+  "stream": true
+}
+```
+
+**Compatibility Mode**
+```bash
+# Enable compatibility mode
+export COMPATIBILITY_MODE=true
+```
+In this mode, all `system` messages are converted to `user` messages, improving compatibility with certain clients.
+
+---
+
+## 💬 Community
+
+Welcome to join the QQ group for discussion!
+
+**QQ Group: 1083250744**
+
+<img src="qq群.jpg" width="200" alt="QQ Group QR Code">
+
+---
+
+## License and Disclaimer
+
+This project is for learning and research purposes only. Using this project indicates that you agree to:
+- Not use this project for any commercial purposes
+- Bear all risks and responsibilities of using this project
+- Comply with relevant terms of service and legal regulations
+
+The project authors are not responsible for any direct or indirect losses arising from the use of this project.
+
+## ⚠️ License Declaration
+
+**This project is licensed under the Cooperative Non-Commercial License (CNC-1.0)**
+
+This is a strict anti-commercial open source license. Please refer to the [LICENSE](../LICENSE) file for details.
+
+### ✅ Permitted Uses:
+- Personal learning, research, and educational purposes
+- Non-profit organization use
+- Open source project integration (must comply with the same license)
+- Academic research and publication
+
+### ❌ Prohibited Uses:
+- Any form of commercial use
+- Enterprise use with annual revenue exceeding $1 million
+- Venture capital-backed or publicly traded companies
+- Providing paid services or products
+- Commercial competitive use

docs/README_JA.md

@@ -0,0 +1,883 @@
+# GeminiCLI to API
+
+**GeminiCLIおよびAntigravityをOpenAI、GEMINI、Claude API互換インターフェースに変換**
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: CNC-1.0](https://img.shields.io/badge/License-CNC--1.0-red.svg)](../LICENSE)
+[![Docker](https://img.shields.io/badge/docker-available-blue.svg)](https://github.com/su-kaka/gcli2api/pkgs/container/gcli2api)
+
+[中文](../README.md) | [English](README_EN.md) | 日本語
+
+## 🚀 クイックデプロイ
+
+[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/templates/97VMEF?referralCode=sukaka)
+[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/su-kaka/gcli2api)
+---
+
+## インストールガイド
+
+### Termux環境
+
+**初期インストール**
+```bash
+curl -o termux-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/termux-install.sh" && chmod +x termux-install.sh && ./termux-install.sh
+```
+
+**サービス再起動**
+```bash
+cd gcli2api
+bash termux-start.sh
+```
+
+### Windows環境
+
+**初期インストール**
+```powershell
+iex (iwr "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.ps1" -UseBasicParsing).Content
+```
+
+**サービス再起動**
+`start.bat` をダブルクリックして実行
+
+### Linux環境
+
+**初期インストール**
+```bash
+curl -o install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.sh" && chmod +x install.sh && ./install.sh
+```
+
+**サービス再起動**
+```bash
+cd gcli2api
+bash start.sh
+```
+
+### macOS環境
+
+**初期インストール**
+```bash
+curl -o darwin-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/darwin-install.sh" && chmod +x darwin-install.sh && ./darwin-install.sh
+```
+
+**サービス再起動**
+```bash
+cd gcli2api
+bash start.sh
+```
+
+### Docker環境
+
+**Docker Runコマンド**
+```bash
+# 共通パスワードを使用
+docker run -d --name gcli2api --network host -e PASSWORD=pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
+
+# 個別パスワードを使用
+docker run -d --name gcli2api --network host -e API_PASSWORD=api_pwd -e PANEL_PASSWORD=panel_pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
+```
+
+**Docker Mac**
+```bash
+# 共通パスワードを使用
+docker run -d \
+  --name gcli2api \
+  -p 7861:7861 \
+  -p 8080:8080 \
+  -e PASSWORD=pwd \
+  -e PORT=7861 \
+  -v "$(pwd)/data/creds":/app/creds \
+  ghcr.io/su-kaka/gcli2api:latest
+```
+
+```bash
+# 個別パスワードを使用
+docker run -d \
+--name gcli2api \
+-p 7861:7861 \
+-p 8080:8080 \
+-e API_PASSWORD=api_pwd \
+-e PANEL_PASSWORD=panel_pwd \
+-e PORT=7861 \
+-v $(pwd)/data/creds:/app/creds \
+ghcr.io/su-kaka/gcli2api:latest
+```
+
+**Docker Compose Runコマンド**
+1. 以下の内容を `docker-compose.yml` ファイルとして保存:
+    ```yaml
+    version: '3.8'
+
+    services:
+      gcli2api:
+        image: ghcr.io/su-kaka/gcli2api:latest
+        container_name: gcli2api
+        restart: unless-stopped
+        network_mode: host
+        environment:
+          # 共通パスワードを使用（シンプルなデプロイに推奨）
+          - PASSWORD=pwd
+          - PORT=7861
+          # または個別パスワードを使用（本番環境に推奨）
+          # - API_PASSWORD=your_api_password
+          # - PANEL_PASSWORD=your_panel_password
+        volumes:
+          - ./data/creds:/app/creds
+        healthcheck:
+          test: ["CMD-SHELL", "python -c \"import sys, urllib.request, os; port = os.environ.get('PORT', '7861'); req = urllib.request.Request(f'http://localhost:{port}/v1/models', headers={'Authorization': 'Bearer ' + os.environ.get('PASSWORD', 'pwd')}); sys.exit(0 if urllib.request.urlopen(req, timeout=5).getcode() == 200 else 1)\""]
+          interval: 30s
+          timeout: 10s
+          retries: 3
+          start_period: 40s
+    ```
+2. サービスを起動:
+    ```bash
+    docker-compose up -d
+    ```
+
+## コア機能
+
+### 🔄 APIエンドポイントとフォーマット対応
+
+**マルチエンドポイント・マルチフォーマット対応**
+- **OpenAI互換エンドポイント**: `/v1/chat/completions` および `/v1/models`
+  - 標準OpenAIフォーマット（messages構造）に対応
+  - Geminiネイティブフォーマット（contents構造）に対応
+  - フォーマットの自動検出・変換、手動切替不要
+  - マルチモーダル入力に対応（テキスト＋画像）
+- **Geminiネイティブエンドポイント**: `/v1/models/{model}:generateContent` および `streamGenerateContent`
+  - Geminiネイティブ API仕様に完全対応
+  - 複数の認証方式: Bearer Token、x-goog-api-keyヘッダー、URLパラメータkey
+- **Claudeフォーマット互換**: Claude APIフォーマットに完全��応
+  - エンドポイント: `/v1/messages`（Claude API仕様に準拠）
+  - Claude標準messagesフォーマットに対応
+  - systemパラメータおよびClaude固有機能に対応
+  - バックエンド対応フォーマットへの自動変換
+- **Antigravity API対応**: OpenAI、Gemini、Claudeフォーマットに対応
+  - OpenAIフォーマットエンドポイント: `/antigravity/v1/chat/completions`
+  - Geminiフォーマットエンドポイント: `/antigravity/v1/models/{model}:generateContent` および `streamGenerateContent`
+  - Claudeフォーマットエンドポイント: `/antigravity/v1/messages`
+  - 全Antigravityモデルに対応（Claude、Geminiなど）
+  - モデル名の自動マッピングおよびThinkingモード検出
+
+### 🔐 認証とセキュリティ管理
+
+**柔軟なパスワード管理**
+- **個別パスワード対応**: APIパスワード（チャットエンドポイント）とコントロールパネルパスワードを個別に設定可能
+- **複数の認証方式**: Authorization Bearer、x-goog-api-keyヘッダー、URLパラメータなどに対応
+- **JWTトークン認証**: コントロールパネルはJWTトークン認証に対応
+- **ユーザーメール取得**: Googleアカウントのメールアドレスを自動取得・表示
+
+### 📊 インテリジェントなクレデンシャル管理システム
+
+**高度なクレデンシャル管理**
+- 複数のGoogle OAuthクレデンシャルの自動ローテーション
+- 冗長認証による安定性の向上
+- ロードバランシングと同時リクエスト対応
+- 自動障害検出とクレデンシャル無効化
+- クレデンシャル使用統計とクォータ管理
+- クレデンシャルファイルの手動有効化/無効化に対応
+- クレデンシャルファイルの一括操作（有効化、無効化、削除）
+
+**クレデンシャルステータス監視**
+- リアルタイムのクレデンシャルヘルスチェック
+- エラーコードの追跡（429、403、500など）
+- 自動BAN機能（設定可能）
+
+### 🌊 ストリーミングとレスポンス処理
+
+**複数のストリーミング対応**
+- リアルタイムストリーミングレスポンス
+- 疑似ストリーミングモード（互換性向上用）
+- ストリーミング途切れ防止機能（回答の途切れを防止）
+- 非同期タスク管理とタイムアウト処理
+
+**レスポンス最適化**
+- 思考チェーン内容の分離
+- 推論プロセス（reasoning_content）の処理
+- マルチターン会話のコンテキスト管理
+- 互換モード（systemメッセージをuserメッセージに変換）
+
+### 🎛️ Web管理コンソール
+
+**フル機能のWebインターフェース**
+- OAuth認証フロー管理（GCLIおよびAntigravityデュアルモード対応）
+- クレデンシャルファイルのアップロード、ダウンロード、管理
+- リアルタイムログ表示（WebSocket）
+- システム設定管理
+- 使用統計と監視ダッシュボード
+- モバイル対応インターフェース
+
+**一括操作対応**
+- ZIPファイルによるクレデンシャル一括アップロード（GCLIおよびAntigravity）
+- クレデンシャルの一括有効化/無効化/削除
+- ユーザーメールの一括取得
+- 設定の一括管理
+- 全クレデンシャルタイプ統合一括アップロードインターフェース
+
+### 📈 使用状況モニタリング
+
+**リアルタイム監視**
+- WebSocketリアルタイムログストリーム
+- システムステータス監視
+- クレデンシャルヘルスステータス
+
+### 🔧 高度な設定とカスタマイズ
+
+**ネットワークとプロキシ設定**
+- HTTP/HTTPSプロキシ対応
+- プロキシエンドポイント設定（OAuth、Google APIs、メタデータサービス）
+- タイムアウトとリトライ設定
+- ネットワークエラー処理とリカバリ
+
+**パフォーマンスと安定性の設定**
+- 429エラーの自動リトライ（間隔と回数を設定可能）
+- 途切れ防止の最大リトライ回数
+
+**ログとデバッグ**
+- マルチレベルログシステム（DEBUG、INFO、WARNING、ERROR）
+- ログファイル管理
+- リアルタイムログストリーム
+- ログのダウンロードとクリア
+
+### 🔄 環境変数と設定管理
+
+**柔軟な設定方法**
+- 環境変数による設定
+- ホット設定更新（一部設定項目）
+- 設定ロック（環境変数優先）
+
+## 対応モデル
+
+全モデルが100万トークンのコンテキストウィンドウに対応。各クレデンシャルファイルで1000リクエストのクォータを提供。
+
+### 🤖 基本モデル
+- `gemini-2.5-pro`
+- `gemini-3-pro-preview`
+- `gemini-3.1-pro-preview`
+
+### 🧠 Thinkingモデル
+- `gemini-2.5-pro-high`: Thinkingモード
+- `gemini-2.5-pro-low`: 低Thinkingモード
+- カスタムThinkingバジェット設定に対応
+- 思考内���と最終回答の自動分離
+
+### 🔍 検索拡張モデル
+- `gemini-2.5-pro-search`: 検索機能統合モデル
+
+### 🖼️ 画像生成モデル（Antigravity）
+- `gemini-3.1-flash-image`: 基本画像生成モデル
+- **解像度サフィックス**:
+  - `-2k`: 2K解像度
+  - `-4k`: 4K HD解像度
+- **アスペクト比サフィックス**:
+  - `-1x1`: 正方形（アバター）
+  - `-16x9`: 横長（デスクトップ壁紙）
+  - `-9x16`: 縦長（モバイル壁紙）
+  - `-21x9`: ウルトラワイド（ウルトラワイドモニター）
+  - `-4x3`: 従来のディスプレイ
+  - `-3x4`: 縦型ポスター
+- **組み合わせ例**:
+  - `gemini-3.1-flash-image-4k-16x9`: 4K横長
+  - `gemini-3.1-flash-image-2k-9x16`: 2K縦長
+- 比率未指定時はAPIが自動的にアスペクト比を決定
+
+### 🌊 特殊機能バリアント
+- **疑似ストリーミングモード**: 任意のモデル名に `-假流式` サフィックスを追加
+  - 例: `gemini-2.5-pro-假流式`
+  - ストリーミングレスポンスが必要だがサーバーが真のストリーミングに対応していない場合に使用
+- **ストリーミング途切れ防止モード**: モデル名に `流式抗截断/` プレフィックスを追加
+  - 例: `流式抗截断/gemini-2.5-pro`
+  - レスポンスの途切れを自動検出しリトライして完全な回答を保証
+
+### 🔧 モデル機能の自動検出
+- システムがモデル名内の機能識別子を自動認識
+- 機能モード切替を透過的に処理
+- 機能の組み合わせ使用に対応
+
+---
+
+## 設定手順
+
+1. `http://127.0.0.1:7861` にアクセス（デフォルトポート、PORT環境変数で変更可能）
+2. OAuth認証フローを完了（デフォルトパスワード: `pwd`、環境変数で変更可能）
+   - **GCLIモード**: Google Cloud Gemini APIクレデンシャルの取得用
+   - **Antigravityモード**: Google Antigravity APIクレデンシャルの取得用
+3. クライアントを設定:
+
+**OpenAI互換クライアント:**
+   - **エンドポイントアドレス**: `http://127.0.0.1:7861/v1`
+   - **APIキー**: `pwd`（デフォルト値、API_PASSWORDまたはPASSWORD環境変数で変更可能）
+
+**Geminiネイティブクライアント:**
+   - **エンドポイントアドレス**: `http://127.0.0.1:7861`
+   - **認証方式**:
+     - `Authorization: Bearer your_api_password`
+     - `x-goog-api-key: your_api_password`
+     - URLパラメータ: `?key=your_api_password`
+
+### 🌟 デュアル認証モード対応
+
+**GCLI認証モード**
+- 標準Google Cloud Gemini API認証
+- OAuth2.0認証フローに対応
+- 必要なGoogle Cloud APIを自動的に有効化
+
+**Antigravity認証モード**
+- Google Antigravity API専用認証
+- 独立したクレデンシャル管理システム
+- 一括アップロードと管理に対応
+- GCLIクレデンシャルとは完全に分離
+
+**統合管理インターフェース**
+- 「一括アップロード」タブで両方のクレデンシャルタイプを管理
+- 上部セクション: GCLIクレデンシャル一括アップロード（青テーマ）
+- 下部セクション: Antigravityクレデンシャル一括アップロード（緑テーマ）
+- 各タイプ別のクレデンシャル管理タブ
+
+## 💾 データストレージモード
+
+### 🌟 ストレージバックエンド対応
+
+gcli2apiは2つのストレージバックエンドに対応: **ローカルSQLite（デフォルト）** と **MongoDB（クラウド分散ストレージ）**
+
+### 📁 ローカルSQLiteストレージ（デフォルト）
+
+**デフォルトストレージ方式**
+- 設定不要、すぐに利用可能
+- データはローカルSQLiteデータベースに保存
+- 単一マシンデプロイおよび個人利用に最適
+- データベースファイルの自動作成・管理
+
+### 🍃 MongoDBクラウドストレージモード
+
+**クラウド分散ストレージソリューション**
+
+マルチインスタンスデプロイやクラウドストレージが必要な場合、MongoDBストレージモードを有効にできます。
+
+### ⚙️ MongoDBモードの有効化
+
+**ステップ1: MongoDB接続の設定**
+```bash
+# ローカルMongoDB
+export MONGODB_URI="mongodb://localhost:27017"
+
+# MongoDB Atlasクラウドサービス
+export MONGODB_URI="mongodb+srv://username:password@cluster.mongodb.net"
+
+# 認証付きMongoDB
+export MONGODB_URI="mongodb://admin:password@localhost:27017/admin"
+
+# オプション: カスタムデータベース名（デフォルト: gcli2api）
+export MONGODB_DATABASE="my_gcli_db"
+```
+
+**ステップ2: アプリケーションの起動**
+```bash
+# アプリケーションがMongoDB設定を自動検出し、MongoDBストレージを使用します
+python web.py
+```
+
+**Docker環境でのMongoDB使用**
+```bash
+# 単一MongoDBデプロイ
+docker run -d --name gcli2api \
+  -e MONGODB_URI="mongodb://mongodb:27017" \
+  -e API_PASSWORD=your_password \
+  --network your_network \
+  ghcr.io/su-kaka/gcli2api:latest
+
+# MongoDB Atlasの使用
+docker run -d --name gcli2api \
+  -e MONGODB_URI="mongodb+srv://user:pass@cluster.mongodb.net/gcli2api" \
+  -e API_PASSWORD=your_password \
+  -p 7861:7861 \
+  ghcr.io/su-kaka/gcli2api:latest
+```
+
+**Docker Composeの例**
+```yaml
+version: '3.8'
+
+services:
+  mongodb:
+    image: mongo:7
+    container_name: gcli2api-mongodb
+    restart: unless-stopped
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: admin
+      MONGO_INITDB_ROOT_PASSWORD: password123
+    volumes:
+      - mongodb_data:/data/db
+    ports:
+      - "27017:27017"
+
+  gcli2api:
+    image: ghcr.io/su-kaka/gcli2api:latest
+    container_name: gcli2api
+    restart: unless-stopped
+    depends_on:
+      - mongodb
+    environment:
+      - MONGODB_URI=mongodb://admin:password123@mongodb:27017/admin
+      - MONGODB_DATABASE=gcli2api
+      - API_PASSWORD=your_api_password
+      - PORT=7861
+    ports:
+      - "7861:7861"
+
+volumes:
+  mongodb_data:
+```
+
+
+### 🔧 高度な設定
+
+**MongoDB接続の最適化**
+```bash
+# コネクションプールとタイムアウト設定
+export MONGODB_URI="mongodb://localhost:27017?maxPoolSize=10&serverSelectionTimeoutMS=5000"
+
+# レプリカセット設定
+export MONGODB_URI="mongodb://host1:27017,host2:27017,host3:27017/gcli2api?replicaSet=myReplicaSet"
+
+# リード・ライト分離設定
+export MONGODB_URI="mongodb://localhost:27017/gcli2api?readPreference=secondaryPreferred"
+```
+
+### 環境変数設定
+
+**基本設定**
+- `PORT`: サービスポート（デフォルト: 7861）
+- `HOST`: サーバーリッスンアドレス（デフォルト: 0.0.0.0）
+
+**パスワード設定**
+- `API_PASSWORD`: チャットAPIアクセスパスワード（デフォルト: PASSWORDまたはpwdを継承）
+- `PANEL_PASSWORD`: コントロールパネルアクセスパスワード（デフォルト: PASSWORDまたはpwdを継承）
+- `PASSWORD`: 共通パスワード、設定時に上記2つを上書き（デフォルト: pwd）
+
+**パフォーマンスと安定性の設定**
+- `RETRY_429_ENABLED`: 429エラー自動リトライの有効化（デフォルト: true）
+- `RETRY_429_MAX_RETRIES`: 429エラーの最大リトライ回数（デフォルト: 3）
+- `RETRY_429_INTERVAL`: 429エラーのリトライ間隔、秒単位（デフォルト: 1.0）
+- `ANTI_TRUNCATION_MAX_ATTEMPTS`: 途切れ防止の最大リトライ回数（デフォルト: 3）
+
+**ネットワークとプロキシ設定**
+- `PROXY`: HTTP/HTTPSプロキシアドレス（形式: `http://host:port`）
+- `OAUTH_PROXY_URL`: OAuth認証プロキシエンドポイント
+- `GOOGLEAPIS_PROXY_URL`: Google APIsプロキシエンドポイント
+- `METADATA_SERVICE_URL`: メタデータサービスプロキシエンドポイント
+
+**自動化設定**
+- `AUTO_BAN`: クレデンシャル自動BANの有効化（デフォルト: true）
+- `AUTO_LOAD_ENV_CREDS`: 起動時に環境変数クレデンシャルを自動ロード（デフォルト: false）
+
+**互換性設定**
+- `COMPATIBILITY_MODE`: 互換モードの有効化、systemメッセージをuserメッセージに変換（デフォルト: false）
+
+**ログ設定**
+- `LOG_LEVEL`: ログレベル（DEBUG/INFO/WARNING/ERROR、デフォルト: INFO）
+- `LOG_FILE`: ログファイルパス（デフォルト: log.txt）
+
+**ストレージ設定**
+
+**SQLite設定（デフォルト）**
+- 設定不要、自動的にローカルSQLiteデータベースを使用
+- データベースファイルはプロジェクトディレクトリに自動作成
+
+**MongoDB設定（オプションのクラウドストレージ）**
+- `MONGODB_URI`: MongoDB接続文字列（設定時にMongoDBモードを有効化）
+- `MONGODB_DATABASE`: MongoDBデータベース名（デフォルト: gcli2api）
+
+**Docker使用例**
+```bash
+# 共通パスワードを使用
+docker run -d --name gcli2api \
+  -e PASSWORD=mypassword \
+  -e PORT=7861 \
+  ghcr.io/su-kaka/gcli2api:latest
+
+# 個別パスワードを使用
+docker run -d --name gcli2api \
+  -e API_PASSWORD=my_api_password \
+  -e PANEL_PASSWORD=my_panel_password \
+  -e PORT=7861 \
+  ghcr.io/su-kaka/gcli2api:latest
+```
+
+注意: クレデンシャル環境変数が設定されている場合、システムは環境変数のクレデンシャルを優先的に使用し、`creds` ディレクトリ内のファイルを無視します。
+
+### API使用方法
+
+本サービスは複数の完全なAPIエンドポイントセットに対応しています:
+
+#### 1. OpenAI互換エンドポイント（GCLI）
+
+**エンドポイント:** `/v1/chat/completions`
+**認証:** `Authorization: Bearer your_api_password`
+
+2つのリクエストフォーマットに対応し、自動検出・処理を行います:
+
+**OpenAIフォーマット:**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "messages": [
+    {"role": "system", "content": "You are a helpful assistant"},
+    {"role": "user", "content": "Hello"}
+  ],
+  "temperature": 0.7,
+  "stream": true
+}
+```
+
+**Geminiネイティブフォーマット:**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "contents": [
+    {"role": "user", "parts": [{"text": "Hello"}]}
+  ],
+  "systemInstruction": {"parts": [{"text": "You are a helpful assistant"}]},
+  "generationConfig": {
+    "temperature": 0.7
+  }
+}
+```
+
+#### 2. Geminiネイティブエンドポイント（GCLI）
+
+**非ストリーミングエンドポイント:** `/v1/models/{model}:generateContent`
+**ストリーミングエンドポイント:** `/v1/models/{model}:streamGenerateContent`
+**モデル一覧:** `/v1/models`
+
+**認証方式（いずれか1つを選択）:**
+- `Authorization: Bearer your_api_password`
+- `x-goog-api-key: your_api_password`
+- URLパラメータ: `?key=your_api_password`
+
+**リクエスト例:**
+```bash
+# x-goog-api-keyヘッダーを使用
+curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:generateContent" \
+  -H "x-goog-api-key: your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ]
+  }'
+
+# URLパラメータを使用
+curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:streamGenerateContent?key=your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ]
+  }'
+```
+
+#### 3. Claude APIフォーマットエンドポイント
+
+**エンドポイント:** `/v1/messages`
+**認証:** `x-api-key: your_api_password` または `Authorization: Bearer your_api_password`
+
+**リクエスト例:**
+```bash
+curl -X POST "http://127.0.0.1:7861/v1/messages" \
+  -H "x-api-key: your_api_password" \
+  -H "anthropic-version: 2023-06-01" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "max_tokens": 1024,
+    "messages": [
+      {"role": "user", "content": "Hello, Claude!"}
+    ]
+  }'
+```
+
+**systemパラメータの対応:**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "max_tokens": 1024,
+  "system": "You are a helpful assistant",
+  "messages": [
+    {"role": "user", "content": "Hello"}
+  ]
+}
+```
+
+**注意事項:**
+- Claude APIフォーマット仕様に完全互換
+- バックエンド呼び出し時にGeminiフォーマットへ自動変換
+- すべてのClaude標準パラメータに対応
+- レスポンスフォーマットはClaude API仕様に準拠
+
+#### 4. Antigravity APIエンドポイント
+
+**OpenAI、Gemini、Claudeの3フォーマットに対応**
+
+##### Antigravity OpenAIフォーマットエンドポイント
+
+**エンドポイント:** `/antigravity/v1/chat/completions`
+**認証:** `Authorization: Bearer your_api_password`
+
+**リクエスト例:**
+```bash
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/chat/completions" \
+  -H "Authorization: Bearer your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "claude-sonnet-4-5",
+    "messages": [
+      {"role": "user", "content": "Hello"}
+    ],
+    "stream": true
+  }'
+```
+
+##### Antigravity Geminiフォーマットエンドポイント
+
+**非ストリーミングエンドポイント:** `/antigravity/v1/models/{model}:generateContent`
+**ストリーミングエンドポイント:** `/antigravity/v1/models/{model}:streamGenerateContent`
+
+**認証方式（いずれか1つを選択）:**
+- `Authorization: Bearer your_api_password`
+- `x-goog-api-key: your_api_password`
+- URLパラメータ: `?key=your_api_password`
+
+**リクエスト例:**
+```bash
+# Geminiフォーマット非ストリーミングリクエスト
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/claude-sonnet-4-5:generateContent" \
+  -H "x-goog-api-key: your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ],
+    "generationConfig": {
+      "temperature": 0.7
+    }
+  }'
+
+# Geminiフォーマットストリーミングリクエスト
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/gemini-2.5-flash:streamGenerateContent?key=your_api_password" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "contents": [
+      {"role": "user", "parts": [{"text": "Hello"}]}
+    ]
+  }'
+```
+
+##### Antigravity Claudeフォーマットエンドポイント
+
+**エンドポイント:** `/antigravity/v1/messages`
+**認証:** `x-api-key: your_api_password`
+
+**リクエスト例:**
+```bash
+curl -X POST "http://127.0.0.1:7861/antigravity/v1/messages" \
+  -H "x-api-key: your_api_password" \
+  -H "anthropic-version: 2023-06-01" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "claude-sonnet-4-5",
+    "max_tokens": 1024,
+    "messages": [
+      {"role": "user", "content": "Hello"}
+    ]
+  }'
+```
+
+**対応Antigravityモデル:**
+- Claudeシリーズ: `claude-sonnet-4-5`、`claude-opus-4-5` など
+- Geminiシリーズ: `gemini-2.5-flash`、`gemini-2.5-pro` など
+- Thinkingモデルに自動対��
+
+**Geminiネイティブの例:**
+```python
+from io import BytesIO
+from PIL import Image
+from google.genai import Client
+from google.genai.types import HttpOptions
+from google.genai import types
+# クライアントは環境変数 `GEMINI_API_KEY` からAPIキーを取得します。
+
+client = Client(
+            api_key="pwd",
+            http_options=HttpOptions(base_url="http://127.0.0.1:7861"),
+        )
+
+prompt = (
+    """
+    猫を描いて
+    """
+)
+
+response = client.models.generate_content(
+    model="gemini-3.1-flash-image",
+    contents=[prompt],
+    config=types.GenerateContentConfig(
+        image_config=types.ImageConfig(
+            aspect_ratio="16:9",
+        )
+    )
+)
+for part in response.candidates[0].content.parts:
+    if part.text is not None:
+        print(part.text)
+    elif part.inline_data is not None:
+        image = Image.open(BytesIO(part.inline_data.data))
+        image.save("generated_image.png")
+
+```
+
+**注意事項:**
+- OpenAIエンドポイントはOpenAI互換フォーマットを返します
+- GeminiエンドポイントはGeminiネイティブフォーマットを返します
+- 両エンドポイントとも同一のAPIパスワードを使用
+
+## 📋 完全なAPIリファレンス
+
+### Webコンソール API
+
+**認証エンドポイント**
+- `POST /auth/login` - ユーザーログイン
+- `POST /auth/start` - OAuth認証の開始（GCLIおよびAntigravityモード対応）
+- `POST /auth/callback` - OAuthコールバックの処理
+- `POST /auth/callback-url` - コールバックURLから直接認証を完了
+- `GET /auth/status/{project_id}` - 認証ステータスの確認
+
+**クレデンシャル管理エンドポイント**（`mode=geminicli` または `mode=antigravity` パラメータ対応）
+- `POST /creds/upload` - クレデンシャルファイルの一括アップロード（JSONおよびZIP対応）
+- `GET /creds/status` - クレデンシャルステータス一覧の取得（ページネーションとフィルタリング対応）
+- `GET /creds/detail/{filename}` - 単一クレデンシャルの詳細取得
+- `POST /creds/action` - 単一クレデンシャル操作（有効化/無効化/削除）
+- `POST /creds/batch-action` - クレデンシャルの一括操作
+- `GET /creds/download/{filename}` - 単一クレデンシャルファイルのダウンロード
+- `GET /creds/download-all` - 全クレデンシャルの一括ダウンロード
+- `POST /creds/fetch-email/{filename}` - ユーザーメールの取得
+- `POST /creds/refresh-all-emails` - ユーザーメールの一括更新
+- `POST /creds/deduplicate-by-email` - メールによるクレデンシャルの重複排除
+- `POST /creds/verify-project/{filename}` - クレデンシャルのProject ID検証
+- `GET /creds/quota/{filename}` - クレデンシャルのクォータ情報取得（Antigravityのみ）
+
+**設定管理エンドポイント**
+- `GET /config/get` - 現在の設定の取得
+- `POST /config/save` - 設定の保存
+
+**ログ管理エンドポイント**
+- `POST /logs/clear` - ログのクリア
+- `GET /logs/download` - ログファイルのダウンロード
+- `WebSocket /logs/stream` - リアルタイムログストリーム
+
+**バージョン情報エンドポイント**
+- `GET /version/info` - バージョン情報の取得（オプション `check_update=true` パラメータで更新確認）
+
+### チャットAPI機能
+
+**マルチモーダル対応**
+```json
+{
+  "model": "gemini-2.5-pro",
+  "messages": [
+    {
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "この画像を説明してください"},
+        {
+          "type": "image_url",
+          "image_url": {
+            "url": "data:image/jpeg;base64,/9j/4AAQSkZJRgABA..."
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+**Thinkingモード対応**
+```json
+{
+  "model": "gemini-2.5-pro-high",
+  "messages": [
+    {"role": "user", "content": "複雑な数学の問題"}
+  ]
+}
+```
+
+レスポンスには分離された思考内容が含まれます:
+```json
+{
+  "choices": [{
+    "message": {
+      "role": "assistant",
+      "content": "最終回答",
+      "reasoning_content": "詳細な思考プロセス..."
+    }
+  }]
+}
+```
+
+**ストリーミング途切れ防止の使用方法**
+```json
+{
+  "model": "流式抗截断/gemini-2.5-pro",
+  "messages": [
+    {"role": "user", "content": "長い記事を書いてください"}
+  ],
+  "stream": true
+}
+```
+
+**互換モード**
+```bash
+# 互換モードを有効化
+export COMPATIBILITY_MODE=true
+```
+このモードでは、すべての `system` メッセージが `user` メッセージに変換され、特定のクライアントとの互換性が向上します。
+
+---
+
+## 💬 コミュニティ
+
+QQグループへの参加をお待ちしています！
+
+**QQグループ: 1083250744**
+
+<img src="qq群.jpg" width="200" alt="QQグループQRコード">
+
+---
+
+## ライセンスと免責事項
+
+本プロジェクトは学��および研究目的のみに使用できます。本プロジェクトの使用は、以下に同意したことを意味します:
+- 本プロジェクトをいかなる商用目的にも使用しないこと
+- 本プロジェクトの使用に伴うすべてのリスクと責任を負うこと
+- 関連するサービス利用規約および法的規制を遵守すること
+
+プロジェクトの作者は、本プロジェクトの使用から生じるいかなる直接的または間接的な損害についても責任を負いません。
+
+## ⚠️ ライセンスについて
+
+**本プロジェクトはCooperative Non-Commercial License (CNC-1.0) の下でライセンスされています**
+
+これは厳格な非商用オープンソースライセンスです。詳細は [LICENSE](../LICENSE) ファイルをご参照ください。
+
+### ✅ 許可される用途:
+- 個人の学習、研究、教育目的
+- 非営利団体での利用
+- オープンソースプロジェクトへの統合（同一ライセンスの遵守が必要）
+- 学術研究および論文発表
+
+### ❌ 禁止される用途:
+- あらゆる形態の商用利用
+- 年間売上が100万ドルを超える企業での利用
+- ベンチャーキャピタルの出資を受けた企業または上場企業
+- 有料サービスまたは製品の提供
+- 商業的な競合利用

install.ps1

@@ -0,0 +1,35 @@
+# 检测是否为管理员
+$IsElevated = ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).
+    IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+
+# Skip Scoop install if already present to avoid stopping the script
+if (Get-Command scoop -ErrorAction SilentlyContinue) {
+    Write-Host "Scoop is already installed. Skipping installation."
+} else {
+    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser -Force
+    if ($IsElevated) {
+        # 管理员：使用官方一行命令并传入 -RunAsAdmin
+        Invoke-Expression "& {$(Invoke-RestMethod get.scoop.sh)} -RunAsAdmin"
+    } else {
+        # 普通用户安装
+        Invoke-WebRequest -useb get.scoop.sh | Invoke-Expression
+    }
+}
+
+scoop install git uv
+if (Test-Path -LiteralPath "./web.py") {
+    # Already in target directory; skip clone and cd
+}
+elseif (Test-Path -LiteralPath "./gcli2api/web.py") {
+    Set-Location ./gcli2api
+}
+else {
+    git clone https://github.com/su-kaka/gcli2api.git
+    Set-Location ./gcli2api
+}
+# Create relocatable virtual environment to ensure portability
+$env:UV_VENV_CLEAR = "1"
+uv venv --relocatable
+uv sync
+.venv/Scripts/activate.ps1
+python web.py

install.sh

@@ -0,0 +1,302 @@
+#!/bin/bash
+set -e  # Exit on error
+set -u  # Exit on undefined variable
+set -o pipefail  # Exit on pipe failure
+
+# Color codes for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Logging functions
+log_info() {
+    echo -e "${GREEN}[INFO]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1" >&2
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+log_debug() {
+    echo -e "${BLUE}[DEBUG]${NC} $1"
+}
+
+# Cleanup function for error handling
+cleanup() {
+    local exit_code=$?
+    if [ $exit_code -ne 0 ]; then
+        log_error "Installation failed with exit code $exit_code"
+    fi
+    exit $exit_code
+}
+
+trap cleanup EXIT
+
+# Detect OS and distribution
+detect_os() {
+    log_info "Detecting operating system..."
+    
+    if [[ "$OSTYPE" == "linux-gnu"* ]]; then
+        if [ -f /etc/os-release ]; then
+            . /etc/os-release
+            OS_NAME=$ID
+            OS_VERSION=$VERSION_ID
+            log_info "Detected: $NAME $VERSION_ID"
+        elif [ -f /etc/lsb-release ]; then
+            . /etc/lsb-release
+            OS_NAME=$DISTRIB_ID
+            OS_VERSION=$DISTRIB_RELEASE
+            log_info "Detected: $DISTRIB_ID $DISTRIB_RELEASE"
+        else
+            OS_NAME="linux"
+            OS_VERSION="unknown"
+            log_warn "Could not determine specific Linux distribution"
+        fi
+    elif [[ "$OSTYPE" == "darwin"* ]]; then
+        OS_NAME="macos"
+        OS_VERSION=$(sw_vers -productVersion)
+        log_info "Detected: macOS $OS_VERSION"
+    elif [[ "$OSTYPE" == "freebsd"* ]]; then
+        OS_NAME="freebsd"
+        OS_VERSION=$(freebsd-version)
+        log_info "Detected: FreeBSD $OS_VERSION"
+    else
+        log_error "Unsupported operating system: $OSTYPE"
+        exit 1
+    fi
+}
+
+# Check for root privileges (only for Linux package managers that need it)
+check_root_if_needed() {
+    if [[ "$OS_NAME" == "ubuntu" ]] || [[ "$OS_NAME" == "debian" ]] || [[ "$OS_NAME" == "linuxmint" ]] || [[ "$OS_NAME" == "kali" ]]; then
+        if [ "$EUID" -ne 0 ]; then
+            log_error "This script requires root privileges for apt. Please run with sudo."
+            exit 1
+        fi
+    elif [[ "$OS_NAME" == "fedora" ]] || [[ "$OS_NAME" == "rhel" ]] || [[ "$OS_NAME" == "centos" ]] || [[ "$OS_NAME" == "rocky" ]] || [[ "$OS_NAME" == "almalinux" ]]; then
+        if [ "$EUID" -ne 0 ]; then
+            log_error "This script requires root privileges for dnf/yum. Please run with sudo."
+            exit 1
+        fi
+    elif [[ "$OS_NAME" == "arch" ]] || [[ "$OS_NAME" == "manjaro" ]]; then
+        if [ "$EUID" -ne 0 ]; then
+            log_error "This script requires root privileges for pacman. Please run with sudo."
+            exit 1
+        fi
+    fi
+}
+
+# Update package manager
+update_packages() {
+    log_info "Updating package manager..."
+    
+    case "$OS_NAME" in
+        ubuntu|debian|linuxmint|kali|pop)
+            if ! apt update; then
+                log_error "Failed to update apt package lists"
+                exit 1
+            fi
+            ;;
+        fedora|rhel|centos|rocky|almalinux)
+            if command -v dnf &> /dev/null; then
+                if ! dnf check-update; then
+                    # dnf check-update returns 100 if updates are available, which is not an error
+                    if [ $? -ne 100 ]; then
+                        log_warn "dnf check-update returned non-standard exit code"
+                    fi
+                fi
+            else
+                if ! yum check-update; then
+                    if [ $? -ne 100 ]; then
+                        log_warn "yum check-update returned non-standard exit code"
+                    fi
+                fi
+            fi
+            ;;
+        arch|manjaro)
+            if ! pacman -Syu; then
+                log_error "Failed to update pacman database"
+                exit 1
+            fi
+            ;;
+        macos)
+            if command -v brew &> /dev/null; then
+                log_info "Updating Homebrew..."
+                brew update
+            else
+                log_warn "Homebrew not installed. Skipping package manager update."
+            fi
+            ;;
+        *)
+            log_warn "Unknown package manager for $OS_NAME. Skipping update."
+            ;;
+    esac
+}
+
+# Install git based on OS
+install_git() {
+    if ! command -v git &> /dev/null; then
+        log_info "Installing git..."
+        
+        case "$OS_NAME" in
+            ubuntu|debian|linuxmint|kali|pop)
+                if ! apt install git -y; then
+                    log_error "Failed to install git"
+                    exit 1
+                fi
+                ;;
+            fedora|rhel|centos|rocky|almalinux)
+                if command -v dnf &> /dev/null; then
+                    if ! dnf install git -y; then
+                        log_error "Failed to install git"
+                        exit 1
+                    fi
+                else
+                    if ! yum install git -y; then
+                        log_error "Failed to install git"
+                        exit 1
+                    fi
+                fi
+                ;;
+            arch|manjaro)
+                if ! pacman -S git --noconfirm; then
+                    log_error "Failed to install git"
+                    exit 1
+                fi
+                ;;
+            macos)
+                if command -v brew &> /dev/null; then
+                    if ! brew install git; then
+                        log_error "Failed to install git"
+                        exit 1
+                    fi
+                else
+                    log_error "Homebrew is required for macOS. Install from https://brew.sh/"
+                    exit 1
+                fi
+                ;;
+            *)
+                log_error "Don't know how to install git on $OS_NAME"
+                exit 1
+                ;;
+        esac
+    else
+        log_info "Git is already installed ($(git --version))"
+    fi
+}
+
+# Detect OS first
+detect_os
+
+# Check root if needed
+check_root_if_needed
+
+log_info "Starting installation process..."
+
+# Update package lists
+update_packages
+
+# Install git
+install_git
+
+# Install uv if not present
+if ! command -v uv &> /dev/null; then
+    log_info "Installing uv package manager..."
+    if ! curl -Ls https://astral.sh/uv/install.sh | sh; then
+        log_error "Failed to install uv"
+        exit 1
+    fi
+    
+    # Source environment
+    if [ -f "$HOME/.local/bin/env" ]; then
+        source "$HOME/.local/bin/env"
+    elif [ -f "$HOME/.cargo/env" ]; then
+        source "$HOME/.cargo/env"
+    fi
+    
+    # Verify uv installation
+    if ! command -v uv &> /dev/null; then
+        log_error "uv installation failed - command not found after install"
+        exit 1
+    fi
+else
+    log_info "uv is already installed"
+fi
+
+# Determine working directory
+log_info "Checking project directory..."
+if [ -f "./web.py" ]; then
+    log_info "Already in target directory"
+elif [ -f "./gcli2api/web.py" ]; then
+    log_info "Changing to gcli2api directory"
+    cd ./gcli2api || exit 1
+else
+    log_info "Cloning repository..."
+    if [ -d "./gcli2api" ]; then
+        log_warn "gcli2api directory exists but web.py not found. Removing and re-cloning..."
+        rm -rf ./gcli2api
+    fi
+    
+    if ! git clone https://github.com/su-kaka/gcli2api.git; then
+        log_error "Failed to clone repository"
+        exit 1
+    fi
+    
+    cd ./gcli2api || exit 1
+fi
+
+# Update repository if it's a git repo
+if [ -d ".git" ]; then
+    log_info "Updating repository..."
+    if ! git pull; then
+        log_warn "Git pull failed, continuing anyway..."
+    fi
+else
+    log_warn "Not a git repository, skipping update"
+fi
+
+# Create relocatable virtual environment to ensure portability
+log_info "Creating relocatable virtual environment..."
+export UV_VENV_CLEAR=1
+if ! uv venv --relocatable; then
+    log_error "Failed to create virtual environment"
+    exit 1
+fi
+
+# Sync dependencies
+log_info "Syncing dependencies with uv..."
+if ! uv sync; then
+    log_error "Failed to sync dependencies"
+    exit 1
+fi
+
+# Activate virtual environment
+log_info "Activating virtual environment..."
+if [ -f ".venv/bin/activate" ]; then
+    source .venv/bin/activate
+else
+    log_error "Virtual environment not found at .venv/bin/activate"
+    exit 1
+fi
+
+# Verify Python is available
+if ! command -v python3 &> /dev/null; then
+    log_error "python3 not found in virtual environment"
+    exit 1
+fi
+
+# Check if web.py exists
+if [ ! -f "web.py" ]; then
+    log_error "web.py not found in current directory"
+    exit 1
+fi
+
+# Start the application
+log_info "Starting application..."
+python3 web.py

log.py

@@ -0,0 +1,327 @@
+"""
+日志模块 - 使用环境变量配置
+"""
+
+import os
+import sys
+import threading
+from datetime import datetime
+from collections import deque
+import atexit
+
+# 日志级别定义
+LOG_LEVELS = {"debug": 0, "info": 1, "warning": 2, "error": 3, "critical": 4}
+
+# 文件写入状态标志（仅由 writer 线程修改，无需锁保护）
+_file_writing_disabled = False
+_disable_reason = None
+
+# 全局文件句柄（仅由 writer 线程访问，无需文件锁）
+_log_file_handle = None
+
+# -----------------------------------------------------------------
+# 高性能无锁队列：用 deque + Condition 替代 Queue
+# deque.append / deque.popleft 在 CPython 中受 GIL 保护，是原子操作，
+# 不需要额外的 Lock 做入队保护，只用 Condition 做"有数据"通知。
+# -----------------------------------------------------------------
+_log_deque: deque = deque()
+_deque_condition = threading.Condition(threading.Lock())
+_writer_thread = None
+_writer_running = False
+
+# -----------------------------------------------------------------
+# 缓存日志级别，避免每次都读 os.getenv（高并发热路径）
+# -----------------------------------------------------------------
+_cached_log_level: int = LOG_LEVELS["info"]
+_cached_log_file: str = "log.txt"
+# ENABLE_LOG=0/false/no/off 时彻底关闭日志
+_log_enabled: bool = True
+
+
+def _refresh_config():
+    """从环境变量刷新缓存配置（模块加载时及需要时调用）"""
+    global _cached_log_level, _cached_log_file, _log_enabled
+    level = os.getenv("LOG_LEVEL", "info").lower()
+    _cached_log_level = LOG_LEVELS.get(level, LOG_LEVELS["info"])
+    _cached_log_file = os.getenv("LOG_FILE", "log.txt")
+    _log_enabled = os.getenv("ENABLE_LOG", "1").strip().lower() not in ("0", "false", "no", "off")
+
+
+def _get_current_log_level() -> int:
+    return _cached_log_level
+
+
+def _get_log_file_path() -> str:
+    return _cached_log_file
+
+
+# -----------------------------------------------------------------
+# 文件句柄管理（仅在 writer 线程内调用，不需要 _file_lock）
+# -----------------------------------------------------------------
+
+def _close_log_file():
+    global _log_file_handle
+    if _log_file_handle is not None:
+        try:
+            _log_file_handle.flush()
+            _log_file_handle.close()
+        except Exception:
+            pass
+        finally:
+            _log_file_handle = None
+
+
+def _open_log_file(mode: str = "a") -> bool:
+    global _log_file_handle, _file_writing_disabled, _disable_reason
+    _close_log_file()
+    try:
+        # 使用较大缓冲区（64 KB），由 writer 线程定期 flush，减少系统调用
+        _log_file_handle = open(_cached_log_file, mode, encoding="utf-8", buffering=65536)
+        return True
+    except (PermissionError, OSError, IOError) as e:
+        _file_writing_disabled = True
+        _disable_reason = str(e)
+        print(f"Warning: Cannot open log file, disabling file writing: {e}", file=sys.stderr)
+        print("Log messages will continue to display in console only.", file=sys.stderr)
+        return False
+    except Exception as e:
+        print(f"Warning: Failed to open log file: {e}", file=sys.stderr)
+        return False
+
+
+def _clear_log_file():
+    """清空日志文件（启动时调用，此时 writer 线程尚未启动，直接操作安全）"""
+    global _file_writing_disabled, _disable_reason
+    try:
+        with open(_cached_log_file, "w", encoding="utf-8") as f:
+            pass  # 覆盖清空
+        _open_log_file("a")
+    except (PermissionError, OSError, IOError) as e:
+        _file_writing_disabled = True
+        _disable_reason = str(e)
+        print(
+            f"Warning: File system appears to be read-only or permission denied. "
+            f"Disabling log file writing: {e}",
+            file=sys.stderr,
+        )
+        print("Log messages will continue to display in console only.", file=sys.stderr)
+    except Exception as e:
+        print(f"Warning: Failed to clear log file: {e}", file=sys.stderr)
+
+
+# -----------------------------------------------------------------
+# Writer 线程：批量从 deque 取出并写入，减少系统调用次数
+# -----------------------------------------------------------------
+_BATCH_SIZE = 1000          # 单次最多批量写入条数
+_FLUSH_INTERVAL = 2      # 秒：无新消息时强制 flush 周期
+
+
+def _log_writer_worker():
+    global _writer_running
+
+    last_flush_time = 0.0
+
+    while True:
+        # 等待数据或超时
+        with _deque_condition:
+            if not _log_deque and _writer_running:
+                _deque_condition.wait(timeout=_FLUSH_INTERVAL)
+
+            # 批量取出
+            batch = []
+            for _ in range(_BATCH_SIZE):
+                if _log_deque:
+                    batch.append(_log_deque.popleft())
+                else:
+                    break
+
+        if batch and not _file_writing_disabled:
+            # 一次 write 调用��定整批，最大化减少系统调用
+            chunk = "\n".join(batch) + "\n"
+            try:
+                if _log_file_handle is None:
+                    _open_log_file("a")
+                if _log_file_handle is not None:
+                    _log_file_handle.write(chunk)
+            except Exception as e:
+                print(f"Warning: Failed to write log batch: {e}", file=sys.stderr)
+                _close_log_file()
+                try:
+                    _open_log_file("a")
+                except Exception:
+                    pass
+
+        # 定时 flush
+        now = _now_ts()
+        if now - last_flush_time >= _FLUSH_INTERVAL:
+            if _log_file_handle is not None:
+                try:
+                    _log_file_handle.flush()
+                except Exception:
+                    pass
+            last_flush_time = now
+
+        # 退出条件：已停止 + deque 已清空
+        if not _writer_running and not _log_deque:
+            break
+
+    # 最终 flush & close
+    if _log_file_handle is not None:
+        try:
+            _log_file_handle.flush()
+        except Exception:
+            pass
+    _close_log_file()
+
+
+def _now_ts() -> float:
+    import time
+    return time.monotonic()
+
+
+def _start_writer_thread():
+    global _writer_thread, _writer_running
+
+    if _writer_thread is None or not _writer_thread.is_alive():
+        _writer_running = True
+        _writer_thread = threading.Thread(target=_log_writer_worker, daemon=True, name="LogWriter")
+        _writer_thread.start()
+
+
+def _stop_writer_thread():
+    global _writer_running
+
+    _writer_running = False
+    # 唤醒 writer 线程让它能感知退出信号
+    with _deque_condition:
+        _deque_condition.notify_all()
+
+    if _writer_thread and _writer_thread.is_alive():
+        _writer_thread.join(timeout=3.0)
+
+
+# -----------------------------------------------------------------
+# 入队（热路径，极轻量）
+# -----------------------------------------------------------------
+_MAX_QUEUE_SIZE = 5000  # 防止极端情况内存无限增长
+
+
+def _write_to_file(message: str):
+    if _file_writing_disabled:
+        return
+    # deque.append 在 CPython 受 GIL 保护，无需额外锁
+    if len(_log_deque) >= _MAX_QUEUE_SIZE:
+        return  # 过载保护：丢弃而非阻塞
+    _log_deque.append(message)
+    # 非阻塞通知 writer（acquire 失败直接跳过，不影响主线程）
+    if _deque_condition.acquire(blocking=False):
+        try:
+            _deque_condition.notify()
+        finally:
+            _deque_condition.release()
+
+
+# -----------------------------------------------------------------
+# 核心日志函数（热路径）
+# -----------------------------------------------------------------
+
+def _log(level: str, message: str):
+    # 最快短路：日志整体已禁用时直接返回，零开销
+    if not _log_enabled:
+        return
+
+    level = level.lower()
+    level_val = LOG_LEVELS.get(level)
+    if level_val is None:
+        print(f"Warning: Unknown log level '{level}'", file=sys.stderr)
+        return
+
+    # 热路径：直接与缓存值比较，无函数调用开销
+    if level_val < _cached_log_level:
+        return
+
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    entry = f"[{timestamp}] [{level.upper()}] {message}"
+
+    if level in ("error", "critical"):
+        print(entry, file=sys.stderr)
+    else:
+        print(entry)
+
+    _write_to_file(entry)
+
+
+def set_log_level(level: str):
+    """动态设置日志级别（同时更新缓存）"""
+    global _cached_log_level
+    level = level.lower()
+    if level not in LOG_LEVELS:
+        print(f"Warning: Unknown log level '{level}'. Valid levels: {', '.join(LOG_LEVELS.keys())}")
+        return False
+    _cached_log_level = LOG_LEVELS[level]
+    return True
+
+
+class Logger:
+    """支持 log('info', 'msg') 和 log.info('msg') 两种调用方式"""
+
+    def __call__(self, level: str, message: str):
+        _log(level, message)
+
+    def debug(self, message: str):
+        _log("debug", message)
+
+    def info(self, message: str):
+        _log("info", message)
+
+    def warning(self, message: str):
+        _log("warning", message)
+
+    def error(self, message: str):
+        _log("error", message)
+
+    def critical(self, message: str):
+        _log("critical", message)
+
+    def get_current_level(self) -> str:
+        current_level = _get_current_log_level()
+        for name, value in LOG_LEVELS.items():
+            if value == current_level:
+                return name
+        return "info"
+
+    def get_log_file(self) -> str:
+        return _get_log_file_path()
+
+    def close(self):
+        """手动关闭（优雅退出用）"""
+        _stop_writer_thread()
+
+    def get_queue_size(self) -> int:
+        return len(_log_deque)
+
+
+# 导出全局日志实例
+log = Logger()
+
+# 导出的公共接口
+__all__ = ["log", "set_log_level", "LOG_LEVELS"]
+
+# 模块加载时：读取配置���存 → 清空日志文件 → 启动 writer 线程
+_refresh_config()
+if _log_enabled:
+    _clear_log_file()
+    _start_writer_thread()
+
+# 注册退出清理
+atexit.register(_stop_writer_thread)
+
+# 使用说明:
+# 1. 设置日志级别: export LOG_LEVEL=debug  (或在 .env 中设置)
+# 2. 设置日志文件: export LOG_FILE=log.txt (或在 .env 中设置)
+# 3. 日志级别已缓存，热路径零 os.getenv 调用
+# 4. 写入线程批量处理（最多 200 条/次），64 KB 缓冲区，每 0.5 s flush 一次
+# 5. 队列上限 5000 条，超出时丢弃新日志（过载保护，不阻塞主线程）
+# 6. 动态调整级别：set_log_level('debug') 立即生效
+# 7. 彻底关闭日志（最高性能）：export ENABLE_LOG=0  (或 false/no/off)
+#    关闭后不会启动 writer 线程、不写文件、不打印控制台，_log 直接 return

pyproject.toml

@@ -0,0 +1,103 @@
+[project]
+name = "gcli2api"
+version = "0.1.0"
+description = "Convert GeminiCLI to OpenAI and Gemini API interfaces"
+readme = "README.md"
+requires-python = ">=3.12"
+license = {text = "CNC-1.0"}
+authors = [
+    {name = "su-kaka"}
+]
+keywords = ["gemini", "openai", "api", "converter", "cli"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: Other/Proprietary License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "aiofiles>=24.1.0",
+    "fastapi>=0.116.1",
+    "httpx[socks]>=0.28.1",
+    "hypercorn>=0.17.3",
+    "motor>=3.7.1",
+    "oauthlib>=3.3.1",
+    "pydantic>=2.11.7",
+    "pyjwt>=2.10.1",
+    "python-dotenv>=1.1.1",
+    "python-multipart>=0.0.20",
+    "pypinyin>=0.51.0",
+    "aiosqlite>=0.20.0",
+    "redis>=7.2.0",
+    "asyncpg>=0.31.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=4.1.0",
+    "black>=24.0.0",
+    "flake8>=7.0.0",
+    "mypy>=1.8.0",
+    "pre-commit>=3.6.0",
+]
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+testpaths = ["."]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+asyncio_mode = "auto"
+addopts = [
+    "-v",
+    "--strict-markers",
+]
+
+[tool.black]
+line-length = 100
+target-version = ["py313"]
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  # directories
+  \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | build
+  | dist
+)/
+'''
+
+[tool.mypy]
+python_version = "3.13"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false
+ignore_missing_imports = true
+exclude = [
+    "build",
+    "dist",
+]
+
+[tool.coverage.run]
+source = ["src"]
+omit = [
+    "*/tests/*",
+    "*/test_*.py",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]

render.yaml

@@ -0,0 +1,20 @@
+services:
+  - type: web
+    name: gcli2api
+    runtime: docker
+    dockerfilePath: ./Dockerfile
+    dockerContext: .
+    plan: free
+    region: singapore
+    healthCheckPath: /
+
+    envVars:
+      # ========== 必填：访问密码 ==========
+      - key: PASSWORD
+        sync: false          # 部署时手动填写，不同步到代码库
+
+      # ========== 服务器配置 ==========
+      - key: HOST
+        value: 0.0.0.0
+      - key: PORT
+        value: "10000"        # Render 要求 Web 服务监听 10000 端口

requirements-termux.txt

@@ -0,0 +1,14 @@
+fastapi
+httpx[socks]
+pydantic==1.10.22
+python-dotenv
+hypercorn
+aiofiles
+python-multipart
+PyJWT
+oauthlib
+motor
+pypinyin
+aiosqlite
+redis
+asyncpg

requirements.txt

@@ -0,0 +1,14 @@
+fastapi>=0.116.1
+httpx[socks]>=0.28.1
+pydantic>=2.11.7
+python-dotenv>=1.1.1
+hypercorn>=0.17.3
+aiofiles>=24.1.0
+python-multipart>=0.0.20
+PyJWT>=2.10.1
+oauthlib>=3.3.1
+motor>=3.7.1
+aiosqlite>=0.20.0
+pypinyin>=0.51.0
+redis>=4.2.0
+asyncpg

src/api/Response_example.txt

@@ -0,0 +1,210 @@
+================================================================================  
+GeminiCli API 测试
+================================================================================  
+
+================================================================================  
+【测试1】流式请求 (stream_request with native=False)
+================================================================================  
+请求体: {
+  "model": "gemini-2.5-flash",
+  "request": {
+    "contents": [
+      {
+        "role": "user",
+        "parts": [
+          {
+            "text": "Hello, tell me a joke in one sentence."
+          }
+        ]
+      }
+    ]
+  }
+}
+
+流式响应数据 (每个chunk):
+--------------------------------------------------------------------------------  
+[2026-01-10 09:55:29] [INFO] SQLite storage initialized at ./creds\credentials.db 
+[2026-01-10 09:55:29] [INFO] Using SQLite storage backend
+[2026-01-10 09:55:31] [INFO] Token刷新成 功并已保存: my-project-9-481103-1765596755.json (mode=geminicli)
+[2026-01-10 09:55:34] [INFO] [DB] 准备commit，总更新行数=1
+[2026-01-10 09:55:34] [INFO] [DB] commit 完成
+[2026-01-10 09:55:34] [INFO] [DB] update_credential_state 结束: success=True, updated_count=1
+
+Chunk #1:
+  类型: str
+  长度: 626
+  内容预览: 'data: {"response": {"candidates": [{"content": {"role": "model","parts": [{"text": "Why did the scarecrow win an award? Because he was outstanding in his field."}]},"finishReason": "STOP"}],"usageMeta'
+  解析后的JSON: {
+    "response": {
+        "candidates": [
+            {
+                "content": {
+                    "role": "model",     
+                    "parts": [
+                        {
+                            "text": "Why did the scarecrow win an award? Because he was outstanding in his field."
+                        }
+                    ]
+                },
+                "finishReason": "STOP"   
+            }
+        ],
+        "usageMetadata": {
+            "promptTokenCount": 10,      
+            "candidatesTokenCount": 17,  
+            "totalTokenCount": 51,       
+            "trafficType": "PROVISIONED_THROUGHPUT",
+            "promptTokensDetails": [     
+                {
+                    "modality": "TEXT",  
+                    "tokenCount": 10     
+                }
+            ],
+            "candidatesTokensDetails": [ 
+                {
+                    "modality": "TEXT",  
+                    "tokenCount": 17     
+                }
+            ],
+            "thoughtsTokenCount": 24     
+        },
+        "modelVersion": "gemini-2.5-flash",
+        "createTime": "2026-01-10T01:55:29.168589Z",
+        "responseId": "kbFhaY2lCr-ZseMPqMiDmAU"
+    },
+    "traceId": "55650653afd3c738"        
+}
+
+Chunk #2:
+  类型: str
+  长度: 0
+  内容预览: ''
+E:\projects\gcli2api\src\api\geminicli.py:491: RuntimeWarning: coroutine 'get_auto_ban_error_codes' was never awaited      
+  async for chunk in stream_request(body=test_body, native=False):
+RuntimeWarning: Enable tracemalloc to get the object allocation traceback
+
+总共收到 2 个chunk
+
+================================================================================  
+【测试2】非流式请求 (non_stream_request) 
+================================================================================  
+请求体: {
+  "model": "gemini-2.5-flash",
+  "request": {
+    "contents": [
+      {
+        "role": "user",
+        "parts": [
+          {
+            "text": "Hello, tell me a joke in one sentence."
+          }
+        ]
+      }
+    ]
+  }
+}
+
+[2026-01-10 09:55:35] [INFO] Token刷新成 功并已保存: gen-lang-client-0194852792-1767296759.json (mode=geminicli)
+[2026-01-10 09:55:38] [INFO] [DB] 准备commit，总更新行数=1
+[2026-01-10 09:55:38] [INFO] [DB] commit 完成
+[2026-01-10 09:55:38] [INFO] [DB] update_credential_state 结束: success=True, updated_count=1
+E:\projects\gcli2api\src\api\geminicli.py:530: RuntimeWarning: coroutine 'get_auto_ban_error_codes' was never awaited      
+  response = await non_stream_request(body=test_body)
+RuntimeWarning: Enable tracemalloc to get the object allocation traceback
+非流式响应数据:
+--------------------------------------------------------------------------------  
+状态码: 200
+Content-Type: application/json; charset=UTF-8
+
+响应头: {'server': 'openresty', 'date': 'Sat, 10 Jan 2026 01:55:34 GMT', 'content-type': 'application/json; charset=UTF-8', 'transfer-encoding': 'chunked', 'connection': 'keep-alive', 'x-cloudaicompanion-trace-id': 'bf3a5eb6636774d2', 'vary': 'Origin, X-Origin, Referer', 'content-encoding': 'gzip', 'x-xss-protection': '0', 'x-frame-options': 'SAMEORIGIN', 'x-content-type-options': 'nosniff', 'server-timing': 'gfet4t7; dur=1377', 'alt-svc': 'h3=":443"; ma=2592000,h3-29=":443"; ma=2592000', 'access-control-allow-origin': '*', 'access-control-allow-methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS', 'access-control-allow-headers': 'Content-Type, Authorization, X-Requested-With', 'cache-control': 'no-cache', 'content-length': '969'}
+
+响应内容 (原始):
+{
+  "response": {
+    "candidates": [
+      {
+        "content": {
+          "role": "model",
+          "parts": [
+            {
+              "text": "Why did the scarecrow win an award? Because he was outstanding in his field!"
+            }
+          ]
+        },
+        "finishReason": "STOP",
+        "avgLogprobs": -0.54438119776108684
+      }
+    ],
+    "usageMetadata": {
+      "promptTokenCount": 10,
+      "candidatesTokenCount": 17,        
+      "totalTokenCount": 47,
+      "trafficType": "PROVISIONED_THROUGHPUT",
+      "promptTokensDetails": [
+        {
+          "modality": "TEXT",
+          "tokenCount": 10
+        }
+      ],
+      "candidatesTokensDetails": [       
+        {
+          "modality": "TEXT",
+          "tokenCount": 17
+        }
+      ],
+      "thoughtsTokenCount": 20
+    },
+    "modelVersion": "gemini-2.5-flash",  
+    "createTime": "2026-01-10T01:55:33.450396Z",
+    "responseId": "lbFhady-G7yi694PmLOP4As"
+  },
+  "traceId": "bf3a5eb6636774d2"
+}
+
+
+响应内容 (格式化JSON):
+{
+  "response": {
+    "candidates": [
+      {
+        "content": {
+          "role": "model",
+          "parts": [
+            {
+              "text": "Why did the scarecrow win an award? Because he was outstanding in his field!"
+            }
+          ]
+        },
+        "finishReason": "STOP",
+        "avgLogprobs": -0.5443811977610868
+      }
+    ],
+    "usageMetadata": {
+      "promptTokenCount": 10,
+      "candidatesTokenCount": 17,        
+      "totalTokenCount": 47,
+      "trafficType": "PROVISIONED_THROUGHPUT",
+      "promptTokensDetails": [
+        {
+          "modality": "TEXT",
+          "tokenCount": 10
+        }
+      ],
+      "candidatesTokensDetails": [       
+        {
+          "modality": "TEXT",
+          "tokenCount": 17
+        }
+      ],
+      "thoughtsTokenCount": 20
+    },
+    "modelVersion": "gemini-2.5-flash",  
+    "createTime": "2026-01-10T01:55:33.450396Z",
+    "responseId": "lbFhady-G7yi694PmLOP4As"
+  },
+  "traceId": "bf3a5eb6636774d2"
+}
+
+================================================================================  
+测试完成
+================================================================================ 

src/api/antigravity.py

@@ -0,0 +1,1009 @@
+"""
+Antigravity API Client - Handles communication with Google's Antigravity API
+处理与 Google Antigravity API 的通信
+"""
+
+import asyncio
+import hashlib
+import json
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Callable, Tuple
+
+from fastapi import Response
+from config import (
+    get_antigravity_api_url,
+    get_antigravity_stream2nostream,
+    get_antigravity_switch_credential_enabled,
+    get_auto_ban_error_codes,
+)
+from log import log
+
+from src.credential_manager import credential_manager
+from src.httpx_client import stream_post_async, post_async
+from src.models import Model, model_to_dict
+from src.utils import ANTIGRAVITY_USER_AGENT
+
+# 导入共同的基础功能
+from src.api.utils import (
+    handle_error_with_retry,
+    check_should_auto_ban,
+    get_retry_config,
+    record_api_call_success,
+    record_api_call_error,
+    parse_and_log_cooldown,
+    collect_streaming_response,
+)
+
+# ==================== 全局凭证管理器 ====================
+
+# 使用全局单例 credential_manager，自动初始化
+
+
+# ==================== 辅助函数 ====================
+
+def build_antigravity_headers(access_token: str, model_name: str = "") -> Dict[str, str]:
+    """
+    构建 Antigravity API 请求头
+
+    Args:
+        access_token: 访问令牌
+        model_name: 模型名称，用于判断 request_type
+
+    Returns:
+        请求头字典
+    """
+    headers = {
+        'User-Agent': ANTIGRAVITY_USER_AGENT,
+        'Authorization': f'Bearer {access_token}',
+        'Content-Type': 'application/json',
+        'Accept-Encoding': 'gzip',
+        'requestId': f"req-{uuid.uuid4()}"
+    }
+
+    # 根据模型名称判断 request_type
+    if model_name:
+        # 先判断是否是图片模型
+        if "image" in model_name.lower():
+            request_type = "image_gen"
+            headers['requestType'] = request_type
+        else:
+            request_type = "agent"
+            headers['requestType'] = request_type
+
+    return headers
+
+
+def _generate_stable_session_id(request_payload: Dict[str, Any]) -> str:
+    contents = request_payload.get("contents")
+    if isinstance(contents, list):
+        for content in contents:
+            if not isinstance(content, dict) or content.get("role") != "user":
+                continue
+            parts = content.get("parts")
+            if not isinstance(parts, list) or not parts:
+                continue
+            first_part = parts[0]
+            if not isinstance(first_part, dict):
+                continue
+            text = first_part.get("text")
+            if isinstance(text, str) and text:
+                digest = hashlib.sha256(text.encode("utf-8")).digest()
+                value = int.from_bytes(digest[:8], "big") & 0x7FFFFFFFFFFFFFFF
+                return f"-{value}"
+
+    value = uuid.uuid4().int % 9_000_000_000_000_000_000
+    return f"-{value}"
+
+
+def _ensure_antigravity_session_id(payload: Dict[str, Any], model_name: str) -> None:
+    if "image" in (model_name or "").lower():
+        return
+
+    request_payload = payload.get("request")
+    if not isinstance(request_payload, dict):
+        return
+
+    if request_payload.get("sessionId"):
+        return
+
+    request_payload["sessionId"] = _generate_stable_session_id(request_payload)
+
+
+def _empty_object_schema() -> Dict[str, Any]:
+    return {"type": "object", "properties": {}}
+
+
+def _prepare_antigravity_tool(tool: Any, is_claude: bool) -> Any:
+    if not isinstance(tool, dict):
+        return tool
+
+    normalized_tool = tool.copy()
+
+    custom_tool = normalized_tool.get("custom")
+    if isinstance(custom_tool, dict):
+        normalized_custom = custom_tool.copy()
+        if "input_schema" not in normalized_custom:
+            schema = (
+                normalized_custom.pop("parametersJsonSchema", None)
+                or normalized_custom.pop("parameters_json_schema", None)
+                or normalized_custom.get("parameters")
+            )
+            normalized_custom["input_schema"] = schema or _empty_object_schema()
+        normalized_tool["custom"] = normalized_custom
+
+    declarations_key = None
+    declarations = None
+    if isinstance(normalized_tool.get("functionDeclarations"), list):
+        declarations_key = "functionDeclarations"
+        declarations = normalized_tool.get("functionDeclarations")
+    elif isinstance(normalized_tool.get("function_declarations"), list):
+        declarations_key = "function_declarations"
+        declarations = normalized_tool.get("function_declarations")
+
+    if isinstance(declarations, list) and declarations_key:
+        normalized_declarations = []
+        for declaration in declarations:
+            if not isinstance(declaration, dict):
+                normalized_declarations.append(declaration)
+                continue
+
+            normalized_declaration = declaration.copy()
+            schema = None
+            if "parametersJsonSchema" in normalized_declaration:
+                schema = normalized_declaration.pop("parametersJsonSchema")
+            elif "parameters_json_schema" in normalized_declaration:
+                schema = normalized_declaration.pop("parameters_json_schema")
+            elif "parameters" in normalized_declaration:
+                schema = normalized_declaration.get("parameters")
+
+            if schema not in (None, {}, []):
+                normalized_declaration["parameters"] = schema
+            elif is_claude or "parameters" not in normalized_declaration:
+                normalized_declaration["parameters"] = _empty_object_schema()
+
+            normalized_declarations.append(normalized_declaration)
+
+        normalized_tool[declarations_key] = normalized_declarations
+
+    return normalized_tool
+
+
+def _prepare_antigravity_payload(payload: Dict[str, Any], model_name: str) -> Dict[str, Any]:
+    """Match Antigravity's upstream payload quirks before the HTTP request."""
+    payload["userAgent"] = "antigravity"
+    if "image" in (model_name or "").lower():
+        payload["requestType"] = "image_gen"
+        payload.setdefault(
+            "requestId",
+            f"image_gen/{int(datetime.now(timezone.utc).timestamp() * 1000)}/{uuid.uuid4()}/12",
+        )
+    else:
+        payload["requestType"] = "agent"
+        payload.setdefault("requestId", f"agent-{uuid.uuid4()}")
+
+    request_payload = payload.get("request")
+    if not isinstance(request_payload, dict):
+        return payload
+
+    _ensure_antigravity_session_id(payload, model_name)
+    request_payload.pop("safetySettings", None)
+
+    is_claude = "claude" in (model_name or "").lower()
+    tools = request_payload.get("tools")
+    if isinstance(tools, list):
+        request_payload["tools"] = [
+            _prepare_antigravity_tool(tool, is_claude)
+            for tool in tools
+        ]
+
+    if is_claude:
+        tool_config = request_payload.get("toolConfig")
+        if not isinstance(tool_config, dict):
+            tool_config = {}
+            request_payload["toolConfig"] = tool_config
+
+        function_config = tool_config.get("functionCallingConfig")
+        if not isinstance(function_config, dict):
+            function_config = {}
+            tool_config["functionCallingConfig"] = function_config
+
+        function_config["mode"] = "VALIDATED"
+
+    return payload
+
+
+def _is_retryable_status(status_code: int, disable_error_codes: List[int]) -> bool:
+    """统一判断是否属于可重试状态码。"""
+    return status_code in (429, 503) or status_code in disable_error_codes
+
+
+async def _switch_credential_for_retry(
+    *,
+    next_cred_task: Optional[asyncio.Task],
+    retry_interval: float,
+    refresh_credential_fast: Callable[[], Any],
+    apply_cred_result: Callable[[Tuple[str, Dict[str, Any]]], bool],
+    log_prefix: str,
+) -> Tuple[bool, Optional[asyncio.Task]]:
+    """优先使用预热凭证，失败后退回同步刷新。"""
+    if next_cred_task is not None:
+        try:
+            cred_result = await next_cred_task
+            next_cred_task = None
+            if cred_result and apply_cred_result(cred_result):
+                await asyncio.sleep(retry_interval)
+                return True, next_cred_task
+        except Exception as e:
+            log.warning(f"{log_prefix} 预热凭证任务失败: {e}")
+            next_cred_task = None
+
+    await asyncio.sleep(retry_interval)
+    if await refresh_credential_fast():
+        return True, next_cred_task
+
+    return False, next_cred_task
+
+
+# ==================== 新的流式和非流式请求函数 ====================
+
+async def stream_request(
+    body: Dict[str, Any],
+    native: bool = False,
+    headers: Optional[Dict[str, str]] = None,
+):
+    """
+    流式请求函数
+
+    Args:
+        body: 请求体
+        native: 是否返回原生bytes流，False则返回str流
+        headers: 额外的请求头
+
+    Yields:
+        Response对象（错误时）或 bytes流/str流（成功时）
+    """
+    model_name = body.get("model", "")
+    switch_credential_enabled = await get_antigravity_switch_credential_enabled()
+
+    # 1. 获取有效凭证
+    cred_result = await credential_manager.get_valid_credential(
+        mode="antigravity", model_name=model_name
+    )
+
+    if not cred_result:
+        # 如果返回值是None，直接返回错误500
+        log.error("[ANTIGRAVITY STREAM] 当前无可用凭证")
+        yield Response(
+            content=json.dumps({"error": "当前无可用凭证"}),
+            status_code=500,
+            media_type="application/json"
+        )
+        return
+
+    current_file, credential_data = cred_result
+    access_token = credential_data.get("access_token") or credential_data.get("token")
+    project_id = credential_data.get("project_id", "")
+
+    if not access_token:
+        log.error(f"[ANTIGRAVITY STREAM] No access token in credential: {current_file}")
+        yield Response(
+            content=json.dumps({"error": "凭证中没有访问令牌"}),
+            status_code=500,
+            media_type="application/json"
+        )
+        return
+
+    # 2. 构建URL和请求头
+    antigravity_url = await get_antigravity_api_url()
+    target_url = f"{antigravity_url}/v1internal:streamGenerateContent?alt=sse"
+
+    auth_headers = build_antigravity_headers(access_token, model_name)
+
+    # 合并自定义headers
+    if headers:
+        auth_headers.update(headers)
+
+    # 构建包含project的payload
+    final_payload = {
+        "model": body.get("model"),
+        "project": project_id,
+        "request": body.get("request", {}),
+    }
+    _prepare_antigravity_payload(final_payload, model_name)
+
+    # 仅当凭证明确开启积分消耗时注入 enabledCreditTypes
+    def apply_enabled_credit_types(cred_data: Dict[str, Any]) -> None:
+        if cred_data.get("enable_credit") is True:
+            final_payload["enabledCreditTypes"] = ["GOOGLE_ONE_AI"]
+        else:
+            final_payload.pop("enabledCreditTypes", None)
+
+    apply_enabled_credit_types(credential_data)
+
+    # 3. 调用stream_post_async进行请求
+    retry_config = await get_retry_config()
+    max_retries = retry_config["max_retries"]
+    retry_interval = retry_config["retry_interval"]
+
+    DISABLE_ERROR_CODES = await get_auto_ban_error_codes()  # 禁用凭证的错误码
+    last_error_response = None  # 记录最后一次的错误响应
+    next_cred_task = None  # 预热的下一个凭证任务
+
+    # 内部函数：快速更新凭证(只更新token和project_id,避免重建整个请求)
+    async def refresh_credential_fast():
+        nonlocal current_file, access_token, auth_headers, project_id, final_payload
+        cred_result = await credential_manager.get_valid_credential(
+            mode="antigravity", model_name=model_name
+        )
+        if not cred_result:
+            return None
+        current_file, credential_data = cred_result
+        access_token = credential_data.get("access_token") or credential_data.get("token")
+        project_id = credential_data.get("project_id", "")
+        if not access_token:
+            return None
+        # 只更新token和project_id,不重建整个headers和payload
+        auth_headers["Authorization"] = f"Bearer {access_token}"
+        final_payload["project"] = project_id
+        apply_enabled_credit_types(credential_data)
+        return True
+
+    def apply_cred_result(cred_result: Tuple[str, Dict[str, Any]]) -> bool:
+        nonlocal current_file, access_token, project_id, auth_headers, final_payload
+        current_file, credential_data = cred_result
+        access_token = credential_data.get("access_token") or credential_data.get("token")
+        project_id = credential_data.get("project_id", "")
+        if not access_token or not project_id:
+            return False
+        auth_headers["Authorization"] = f"Bearer {access_token}"
+        final_payload["project"] = project_id
+        apply_enabled_credit_types(credential_data)
+        return True
+
+    for attempt in range(max_retries + 1):
+        success_recorded = False  # 标记是否已记录成功
+        need_retry = False  # 标记是否需要重试
+        should_force_switch = False
+
+        try:
+            async for chunk in stream_post_async(
+                url=target_url,
+                body=final_payload,
+                native=native,
+                headers=auth_headers
+            ):
+                # 判断是否是Response对象
+                if isinstance(chunk, Response):
+                    status_code = chunk.status_code
+                    last_error_response = chunk  # 记录最后一次错误
+
+                    # 缓存错误解析结果,避免重复decode
+                    error_body = None
+                    try:
+                        error_body = chunk.body.decode('utf-8') if isinstance(chunk.body, bytes) else str(chunk.body)
+                    except Exception:
+                        error_body = ""
+
+                    # 如果错误码是429、503或者在禁用码当中，做好记录后进行重试
+                    if _is_retryable_status(status_code, DISABLE_ERROR_CODES):
+                        log.warning(f"[ANTIGRAVITY STREAM] 流式请求失败 (status={status_code}), 凭证: {current_file}, 响应: {error_body[:500] if error_body else '无'}")
+
+                        # 解析冷却时间
+                        cooldown_until = None
+                        if (status_code == 429 or status_code == 503) and error_body:
+                            try:
+                                cooldown_until = await parse_and_log_cooldown(error_body, mode="antigravity")
+                            except Exception:
+                                pass
+
+                        if cooldown_until is not None:
+                            should_force_switch = True
+                        elif await check_should_auto_ban(status_code):
+                            should_force_switch = True
+
+                        # 预热下一个凭证
+                        if (switch_credential_enabled or should_force_switch) and next_cred_task is None and attempt < max_retries:
+                            next_cred_task = asyncio.create_task(
+                                credential_manager.get_valid_credential(
+                                    mode="antigravity", model_name=model_name
+                                )
+                            )
+
+                        # 记录错误并切换凭证
+                        await record_api_call_error(
+                            credential_manager, current_file, status_code,
+                            cooldown_until, mode="antigravity", model_name=model_name,
+                            error_message=error_body
+                        )
+
+                        # 检查是否应该重试
+                        should_retry = await handle_error_with_retry(
+                            credential_manager, status_code, current_file,
+                            retry_config["retry_enabled"], attempt, max_retries, retry_interval,
+                            mode="antigravity"
+                        )
+
+                        if should_retry and attempt < max_retries:
+                            need_retry = True
+                            break  # 跳出内层循环，准备重试
+                        else:
+                            # 不重试，直接返回原始错误
+                            log.error(f"[ANTIGRAVITY STREAM] 达到最大重试次数或不应重试，返回原始错误")
+                            yield chunk
+                            return
+                    else:
+                        # 错误码不在禁用码当中，直接返回，无需重试
+                        log.error(f"[ANTIGRAVITY STREAM] 流式请求失败，非重试错误码 (status={status_code}), 凭证: {current_file}, 响应: {error_body[:500] if error_body else '无'}")
+                        await record_api_call_error(
+                            credential_manager, current_file, status_code,
+                            None, mode="antigravity", model_name=model_name,
+                            error_message=error_body
+                        )
+                        yield chunk
+                        return
+                else:
+                    # 不是Response，说明是真流，直接yield返回
+                    # 只在第一个chunk时记录成功
+                    if not success_recorded:
+                        await record_api_call_success(
+                            credential_manager, current_file, mode="antigravity", model_name=model_name
+                        )
+                        success_recorded = True
+                        log.debug(f"[ANTIGRAVITY STREAM] 开始接收流式响应，模型: {model_name}")
+
+                    # 记录原始chunk内容（用于调试）
+                    if isinstance(chunk, bytes):
+                        log.debug(f"[ANTIGRAVITY STREAM RAW] chunk(bytes): {chunk}")
+                    else:
+                        log.debug(f"[ANTIGRAVITY STREAM RAW] chunk(str): {chunk}")
+
+                    yield chunk
+
+            # 流式请求完成，检查结果
+            if success_recorded:
+                log.debug(f"[ANTIGRAVITY STREAM] 流式响应完成，模型: {model_name}")
+                return
+            elif not need_retry:
+                # 没有收到任何数据（空回复），需要重试
+                log.warning(f"[ANTIGRAVITY STREAM] 收到空回复，无任何内容，凭证: {current_file}")
+                await record_api_call_error(
+                    credential_manager, current_file, 200,
+                    None, mode="antigravity", model_name=model_name,
+                    error_message="Empty response from API"
+                )
+                
+                if attempt < max_retries:
+                    need_retry = True
+                else:
+                    log.error(f"[ANTIGRAVITY STREAM] 空回复达到最大重试次数")
+                    yield Response(
+                        content=json.dumps({"error": "服务返回空回复"}),
+                        status_code=500,
+                        media_type="application/json"
+                    )
+                    return
+            
+            # 统一处理重试
+            if need_retry:
+                log.info(f"[ANTIGRAVITY STREAM] 重试请求 (attempt {attempt + 2}/{max_retries + 1})...")
+
+                if switch_credential_enabled or should_force_switch:
+                    switched, next_cred_task = await _switch_credential_for_retry(
+                        next_cred_task=next_cred_task,
+                        retry_interval=retry_interval,
+                        refresh_credential_fast=refresh_credential_fast,
+                        apply_cred_result=apply_cred_result,
+                        log_prefix="[ANTIGRAVITY STREAM]",
+                    )
+                    if not switched:
+                        log.error("[ANTIGRAVITY STREAM] 重试时无可用凭证或令牌")
+                        yield Response(
+                            content=json.dumps({"error": "当前无可用凭证"}),
+                            status_code=500,
+                            media_type="application/json"
+                        )
+                        return
+                else:
+                    await asyncio.sleep(retry_interval)
+                continue  # 重试
+
+        except Exception as e:
+            log.error(f"[ANTIGRAVITY STREAM] 流式请求异常: {e}, 凭证: {current_file}")
+            if attempt < max_retries:
+                log.info(f"[ANTIGRAVITY STREAM] 异常后重试 (attempt {attempt + 2}/{max_retries + 1})...")
+                await asyncio.sleep(retry_interval)
+                continue
+            else:
+                # 所有重试都失败，返回最后一次的错误（如果有）
+                log.error(f"[ANTIGRAVITY STREAM] 所有重试均失败，最后异常: {e}")
+                if last_error_response:
+                    yield last_error_response
+                else:
+                    # 如果没有记录到错误响应，返回500错误
+                    yield Response(
+                        content=json.dumps({"error": f"流式请求异常: {str(e)}"}),
+                        status_code=500,
+                        media_type="application/json"
+                    )
+                return
+
+    # 所有重试均已耗尽（for循环正常结束），返回最后记录的错误
+    log.error("[ANTIGRAVITY STREAM] 所有重试均失败")
+    if last_error_response:
+        yield last_error_response
+    else:
+        yield Response(
+            content=json.dumps({"error": "请求失败，所有重试均已耗尽"}),
+            status_code=429,
+            media_type="application/json"
+        )
+
+
+async def non_stream_request(
+    body: Dict[str, Any],
+    headers: Optional[Dict[str, str]] = None,
+) -> Response:
+    """
+    非流式请求函数
+
+    Args:
+        body: 请求体
+        headers: 额外的请求头
+
+    Returns:
+        Response对象
+    """
+    # 检查是否启用流式收集模式
+    if await get_antigravity_stream2nostream():
+        log.debug("[ANTIGRAVITY] 使用流式收集模式实现非流式请求")
+
+        # 调用stream_request获取流
+        stream = stream_request(body=body, native=False, headers=headers)
+
+        # 收集流式响应
+        # stream_request是一个异步生成器，可能yield Response（错误）或流数据
+        # collect_streaming_response会自动处理这两种情况
+        return await collect_streaming_response(stream)
+
+    # 否则使用传统非流式模式
+    log.debug("[ANTIGRAVITY] 使用传统非流式模式")
+
+    model_name = body.get("model", "")
+    switch_credential_enabled = await get_antigravity_switch_credential_enabled()
+
+    # 1. 获取有效凭证
+    cred_result = await credential_manager.get_valid_credential(
+        mode="antigravity", model_name=model_name
+    )
+
+    if not cred_result:
+        # 如果返回值是None，直接返回错误500
+        log.error("[ANTIGRAVITY] 当前无可用凭证")
+        return Response(
+            content=json.dumps({"error": "当前无可用凭证"}),
+            status_code=500,
+            media_type="application/json"
+        )
+
+    current_file, credential_data = cred_result
+    access_token = credential_data.get("access_token") or credential_data.get("token")
+    project_id = credential_data.get("project_id", "")
+
+    if not access_token:
+        log.error(f"[ANTIGRAVITY] No access token in credential: {current_file}")
+        return Response(
+            content=json.dumps({"error": "凭证中没有访问令牌"}),
+            status_code=500,
+            media_type="application/json"
+        )
+
+    # 2. 构建URL和请求头
+    antigravity_url = await get_antigravity_api_url()
+    target_url = f"{antigravity_url}/v1internal:generateContent"
+
+    auth_headers = build_antigravity_headers(access_token, model_name)
+
+    # 合并自定义headers
+    if headers:
+        auth_headers.update(headers)
+
+    # 构建包含project的payload
+    final_payload = {
+        "model": body.get("model"),
+        "project": project_id,
+        "request": body.get("request", {}),
+    }
+    _prepare_antigravity_payload(final_payload, model_name)
+
+    # 仅当凭证明确开启积分消耗时注入 enabledCreditTypes
+    def apply_enabled_credit_types(cred_data: Dict[str, Any]) -> None:
+        if cred_data.get("enable_credit") is True:
+            final_payload["enabledCreditTypes"] = ["GOOGLE_ONE_AI"]
+        else:
+            final_payload.pop("enabledCreditTypes", None)
+
+    apply_enabled_credit_types(credential_data)
+
+    # 3. 调用post_async进行请求
+    retry_config = await get_retry_config()
+    max_retries = retry_config["max_retries"]
+    retry_interval = retry_config["retry_interval"]
+
+    DISABLE_ERROR_CODES = await get_auto_ban_error_codes()  # 禁用凭证的错误码
+    last_error_response = None  # 记录最后一次的错误响应
+    next_cred_task = None  # 预热的下一个凭证任务
+
+    # 内部函数：快速更新凭证(只更新token和project_id,避免重建整个请求)
+    async def refresh_credential_fast():
+        nonlocal current_file, access_token, auth_headers, project_id, final_payload
+        cred_result = await credential_manager.get_valid_credential(
+            mode="antigravity", model_name=model_name
+        )
+        if not cred_result:
+            return None
+        current_file, credential_data = cred_result
+        access_token = credential_data.get("access_token") or credential_data.get("token")
+        project_id = credential_data.get("project_id", "")
+        if not access_token:
+            return None
+        # 只更新token和project_id,不重建整个headers和payload
+        auth_headers["Authorization"] = f"Bearer {access_token}"
+        final_payload["project"] = project_id
+        apply_enabled_credit_types(credential_data)
+        return True
+
+    def apply_cred_result(cred_result: Tuple[str, Dict[str, Any]]) -> bool:
+        nonlocal current_file, access_token, project_id, auth_headers, final_payload
+        current_file, credential_data = cred_result
+        access_token = credential_data.get("access_token") or credential_data.get("token")
+        project_id = credential_data.get("project_id", "")
+        if not access_token or not project_id:
+            return False
+        auth_headers["Authorization"] = f"Bearer {access_token}"
+        final_payload["project"] = project_id
+        apply_enabled_credit_types(credential_data)
+        return True
+
+    for attempt in range(max_retries + 1):
+        need_retry = False  # 标记是否需要重试
+        should_force_switch = False
+        
+        try:
+            response = await post_async(
+                url=target_url,
+                json=final_payload,
+                headers=auth_headers,
+                timeout=300.0
+            )
+
+            status_code = response.status_code
+
+            # 成功
+            if status_code == 200:
+                # 检查是否为空回复
+                if not response.content or len(response.content) == 0:
+                    log.warning(f"[ANTIGRAVITY] 收到200响应但内容为空，凭证: {current_file}")
+                    
+                    # 记录错误
+                    await record_api_call_error(
+                        credential_manager, current_file, 200,
+                        None, mode="antigravity", model_name=model_name,
+                        error_message="Empty response from API"
+                    )
+                    
+                    if attempt < max_retries:
+                        need_retry = True
+                    else:
+                        log.error(f"[ANTIGRAVITY] 空回复达到最大重试次数")
+                        return Response(
+                            content=json.dumps({"error": "服务返回空回复"}),
+                            status_code=500,
+                            media_type="application/json"
+                        )
+                else:
+                    # 正常响应
+                    await record_api_call_success(
+                        credential_manager, current_file, mode="antigravity", model_name=model_name
+                    )
+                    return Response(
+                        content=response.content,
+                        status_code=200,
+                        headers=dict(response.headers)
+                    )
+
+            # 失败 - 记录最后一次错误
+            if status_code != 200:
+                last_error_response = Response(
+                    content=response.content,
+                    status_code=status_code,
+                    headers=dict(response.headers)
+                )
+
+                # 判断是否需要重试
+                # 缓存错误文本,避免重复解析
+                error_text = ""
+                try:
+                    error_text = response.text
+                except Exception:
+                    pass
+
+                if _is_retryable_status(status_code, DISABLE_ERROR_CODES):
+                    log.warning(f"[ANTIGRAVITY] 非流式请求失败 (status={status_code}), 凭证: {current_file}, 响应: {error_text[:500] if error_text else '无'}")
+
+                    # 解析冷却时间
+                    cooldown_until = None
+                    if (status_code == 429 or status_code == 503) and error_text:
+                        try:
+                            cooldown_until = await parse_and_log_cooldown(error_text, mode="antigravity")
+                        except Exception:
+                            pass
+
+                    if cooldown_until is not None:
+                        should_force_switch = True
+                    elif await check_should_auto_ban(status_code):
+                        should_force_switch = True
+
+                    # 并行预热下一个凭证,不阻塞当前处理
+                    if (switch_credential_enabled or should_force_switch) and next_cred_task is None and attempt < max_retries:
+                        next_cred_task = asyncio.create_task(
+                            credential_manager.get_valid_credential(
+                                mode="antigravity", model_name=model_name
+                            )
+                        )
+
+                    # 记录错误并切换凭证
+                    await record_api_call_error(
+                        credential_manager, current_file, status_code,
+                        cooldown_until, mode="antigravity", model_name=model_name,
+                        error_message=error_text
+                    )
+
+                    # 检查是否应该重试
+                    should_retry = await handle_error_with_retry(
+                        credential_manager, status_code, current_file,
+                        retry_config["retry_enabled"], attempt, max_retries, retry_interval,
+                        mode="antigravity"
+                    )
+
+                    if should_retry and attempt < max_retries:
+                        need_retry = True
+                    else:
+                        # 不重试，直接返回原始错误
+                        log.error(f"[ANTIGRAVITY] 达到最大重试次数或不应重试，返回原始错误")
+                        return last_error_response
+                else:
+                    # 错误码不在禁用码当中，直接返回，无需重试
+                    log.error(f"[ANTIGRAVITY] 非流式请求失败，非重试错误码 (status={status_code}), 凭证: {current_file}, 响应: {error_text[:500] if error_text else '无'}")
+                    await record_api_call_error(
+                        credential_manager, current_file, status_code,
+                        None, mode="antigravity", model_name=model_name,
+                        error_message=error_text
+                    )
+                    return last_error_response
+            
+            # 统一处理重试
+            if need_retry:
+                log.info(f"[ANTIGRAVITY] 重试请求 (attempt {attempt + 2}/{max_retries + 1})...")
+
+                if switch_credential_enabled or should_force_switch:
+                    switched, next_cred_task = await _switch_credential_for_retry(
+                        next_cred_task=next_cred_task,
+                        retry_interval=retry_interval,
+                        refresh_credential_fast=refresh_credential_fast,
+                        apply_cred_result=apply_cred_result,
+                        log_prefix="[ANTIGRAVITY]",
+                    )
+                    if not switched:
+                        log.error("[ANTIGRAVITY] 重试时无可用凭证或令牌")
+                        return Response(
+                            content=json.dumps({"error": "当前无可用凭证"}),
+                            status_code=500,
+                            media_type="application/json"
+                        )
+                else:
+                    await asyncio.sleep(retry_interval)
+                continue  # 重试
+
+        except Exception as e:
+            log.error(f"[ANTIGRAVITY] 非流式请求异常: {e}, 凭证: {current_file}")
+            if attempt < max_retries:
+                log.info(f"[ANTIGRAVITY] 异常后重试 (attempt {attempt + 2}/{max_retries + 1})...")
+                await asyncio.sleep(retry_interval)
+                continue
+            else:
+                # 所有重试都失败，返回最后一次的错误（如果有）或500错误
+                log.error(f"[ANTIGRAVITY] 所有重试均失败，最后异常: {e}")
+                if last_error_response:
+                    return last_error_response
+                else:
+                    return Response(
+                        content=json.dumps({"error": f"非流式请求异常: {str(e)}"}),
+                        status_code=500,
+                        media_type="application/json"
+                    )
+
+    # 所有重试都失败，返回最后一次的原始错误（如果有）或500错误
+    log.error("[ANTIGRAVITY] 所有重试均失败")
+    if last_error_response:
+        return last_error_response
+    else:
+        return Response(
+            content=json.dumps({"error": "所有重试均失败"}),
+            status_code=500,
+            media_type="application/json"
+        )
+
+
+# ==================== 模型和配额查询 ====================
+
+async def fetch_available_models() -> List[Dict[str, Any]]:
+    """
+    获取可用模型列表，返回符合 OpenAI API 规范的格式
+    
+    Returns:
+        模型列表，格式为字典列表（用于兼容现有代码）
+        
+    Raises:
+        返回空列表如果获取失败
+    """
+    # 获取凭证管理器和可用凭证
+    cred_result = await credential_manager.get_valid_credential(mode="antigravity")
+    if not cred_result:
+        log.error("[ANTIGRAVITY] No valid credentials available for fetching models")
+        return []
+
+    current_file, credential_data = cred_result
+    access_token = credential_data.get("access_token") or credential_data.get("token")
+
+    if not access_token:
+        log.error(f"[ANTIGRAVITY] No access token in credential: {current_file}")
+        return []
+
+    # 构建请求头
+    headers = build_antigravity_headers(access_token)
+
+    try:
+        # 使用 POST 请求获取模型列表
+        antigravity_url = await get_antigravity_api_url()
+
+        response = await post_async(
+            url=f"{antigravity_url}/v1internal:fetchAvailableModels",
+            json={},  # 空的请求体
+            headers=headers
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+            log.debug(f"[ANTIGRAVITY] Raw models response: {json.dumps(data, ensure_ascii=False)[:500]}")
+
+            # 转换为 OpenAI 格式的模型列表，使用 Model 类
+            model_list = []
+            current_timestamp = int(datetime.now(timezone.utc).timestamp())
+
+            if 'models' in data and isinstance(data['models'], dict):
+                # 遍历模型字典
+                for model_id in data['models'].keys():
+                    model = Model(
+                        id=model_id,
+                        object='model',
+                        created=current_timestamp,
+                        owned_by='google'
+                    )
+                    model_list.append(model_to_dict(model))
+            # 添加额外的 claude-sonnet-4-6-thinking 模型
+            if "claude-sonnet-4-6" in data.get('models', {}):
+                model = Model(
+                    id='claude-sonnet-4-6-thinking',
+                    object='model',
+                    created=current_timestamp,
+                    owned_by='google'
+                )
+                model_list.append(model_to_dict(model))
+            # 添加额外的 claude-opus-4-6 模型
+            if "claude-opus-4-6-thinking" in data.get('models', {}):
+                claude_opus_model = Model(
+                    id='claude-opus-4-6',
+                    object='model',
+                    created=current_timestamp,
+                    owned_by='google'
+                )
+                model_list.append(model_to_dict(claude_opus_model))
+
+            log.info(f"[ANTIGRAVITY] Fetched {len(model_list)} available models")
+            return model_list
+        else:
+            log.error(f"[ANTIGRAVITY] Failed to fetch models ({response.status_code}): {response.text[:500]}")
+            return []
+
+    except Exception as e:
+        import traceback
+        log.error(f"[ANTIGRAVITY] Failed to fetch models: {e}")
+        log.error(f"[ANTIGRAVITY] Traceback: {traceback.format_exc()}")
+        return []
+
+
+async def fetch_quota_info(access_token: str) -> Dict[str, Any]:
+    """
+    获取指定凭证的额度信息
+    
+    Args:
+        access_token: Antigravity 访问令牌
+        
+    Returns:
+        包含额度信息的字典，格式为：
+        {
+            "success": True/False,
+            "models": {
+                "model_name": {
+                    "remaining": 0.95,
+                    "resetTime": "12-20 10:30",
+                    "resetTimeRaw": "2025-12-20T02:30:00Z"
+                }
+            },
+            "error": "错误信息" (仅在失败时)
+        }
+    """
+
+    headers = build_antigravity_headers(access_token)
+
+    try:
+        antigravity_url = await get_antigravity_api_url()
+
+        response = await post_async(
+            url=f"{antigravity_url}/v1internal:fetchAvailableModels",
+            json={},
+            headers=headers,
+            timeout=30.0
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+            log.debug(f"[ANTIGRAVITY QUOTA] Raw response: {json.dumps(data, ensure_ascii=False)[:500]}")
+
+            quota_info = {}
+
+            if 'models' in data and isinstance(data['models'], dict):
+                for model_id, model_data in data['models'].items():
+                    if isinstance(model_data, dict) and 'quotaInfo' in model_data:
+                        quota = model_data['quotaInfo']
+                        remaining = quota.get('remainingFraction', 0)
+                        reset_time_raw = quota.get('resetTime', '')
+
+                        # 转换为北京时间
+                        reset_time_beijing = 'N/A'
+                        if reset_time_raw:
+                            try:
+                                utc_date = datetime.fromisoformat(reset_time_raw.replace('Z', '+00:00'))
+                                # 转换为北京时间 (UTC+8)
+                                from datetime import timedelta
+                                beijing_date = utc_date + timedelta(hours=8)
+                                reset_time_beijing = beijing_date.strftime('%m-%d %H:%M')
+                            except Exception as e:
+                                log.warning(f"[ANTIGRAVITY QUOTA] Failed to parse reset time: {e}")
+
+                        quota_info[model_id] = {
+                            "remaining": remaining,
+                            "resetTime": reset_time_beijing,
+                            "resetTimeRaw": reset_time_raw
+                        }
+
+            return {
+                "success": True,
+                "models": quota_info
+            }
+        else:
+            log.error(f"[ANTIGRAVITY QUOTA] Failed to fetch quota ({response.status_code}): {response.text[:500]}")
+            return {
+                "success": False,
+                "error": f"API返回错误: {response.status_code}"
+            }
+
+    except Exception as e:
+        import traceback
+        log.error(f"[ANTIGRAVITY QUOTA] Failed to fetch quota: {e}")
+        log.error(f"[ANTIGRAVITY QUOTA] Traceback: {traceback.format_exc()}")
+        return {
+            "success": False,
+            "error": str(e)
+        }

src/api/geminicli.py

@@ -0,0 +1,808 @@
+"""
+GeminiCli API Client - Handles all communication with GeminiCli API.
+This module is used by both OpenAI compatibility layer and native Gemini endpoints.
+GeminiCli API 客户端 - 处理与 GeminiCli API 的所有通信
+"""
+
+import sys
+from pathlib import Path
+
+# 添加项目根目录到Python路径（用于直接运行测试）
+if __name__ == "__main__":
+    project_root = Path(__file__).resolve().parent.parent.parent
+    if str(project_root) not in sys.path:
+        sys.path.insert(0, str(project_root))
+
+import asyncio
+import json
+from typing import Any, Dict, Optional, Callable, Tuple
+
+from fastapi import Response
+from config import get_code_assist_endpoint, get_auto_ban_error_codes
+from log import log
+
+from src.credential_manager import credential_manager
+from src.httpx_client import stream_post_async, post_async
+
+# 导入共同的基础功能
+from src.api.utils import (
+    handle_error_with_retry,
+    get_retry_config,
+    record_api_call_success,
+    record_api_call_error,
+    parse_and_log_cooldown,
+)
+from src.utils import get_geminicli_user_agent
+
+# ==================== 全局凭证管理器 ====================
+
+# 使用全局单例 credential_manager，自动初始化
+
+
+# ==================== 请求准备 ====================
+
+async def prepare_request_headers_and_payload(
+    payload: dict, credential_data: dict, target_url: str
+):
+    """
+    从凭证数据准备请求头和最终payload
+    
+    Args:
+        payload: 原始请求payload
+        credential_data: 凭证数据字典
+        target_url: 目标URL
+        
+    Returns:
+        元组: (headers, final_payload, target_url)
+        
+    Raises:
+        Exception: 如果凭证中缺少必要字段
+    """
+    token = credential_data.get("token") or credential_data.get("access_token", "")
+    if not token:
+        raise Exception("凭证中没有找到有效的访问令牌（token或access_token字段）")
+
+    source_request = payload.get("request", {})
+
+    # 内部API使用Bearer Token和项目ID
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+        "User-Agent": get_geminicli_user_agent(payload.get("model", "")),
+    }
+    project_id = credential_data.get("project_id", "")
+    if not project_id:
+        raise Exception("项目ID不存在于凭证数据中")
+    final_payload = {
+        "model": payload.get("model"),
+        "project": project_id,
+        "request": source_request,
+    }
+
+    return headers, final_payload, target_url
+
+
+def _is_retryable_status(status_code: int, disable_error_codes: list[int]) -> bool:
+    """统一判断是否属于可重试状态码。"""
+    return status_code in (429, 500, 503) or status_code in disable_error_codes
+
+
+async def _switch_credential_for_retry(
+    *,
+    next_cred_task: Optional[asyncio.Task],
+    retry_interval: float,
+    refresh_credential_fast: Callable[[], Any],
+    apply_cred_result: Callable[[Tuple[str, Dict[str, Any]]], bool],
+    log_prefix: str,
+) -> Tuple[bool, Optional[asyncio.Task]]:
+    """优先使用预热凭证，失败后退回同步刷新。"""
+    if next_cred_task is not None:
+        try:
+            cred_result = await next_cred_task
+            next_cred_task = None
+            if cred_result and apply_cred_result(cred_result):
+                await asyncio.sleep(retry_interval)
+                return True, next_cred_task
+        except Exception as e:
+            log.warning(f"{log_prefix} 预热凭证任务失败: {e}")
+            next_cred_task = None
+
+    await asyncio.sleep(retry_interval)
+    if await refresh_credential_fast():
+        return True, next_cred_task
+
+    return False, next_cred_task
+
+
+# ==================== 新的流式和非流式请求函数 ====================
+
+async def stream_request(
+    body: Dict[str, Any],
+    native: bool = False,
+    headers: Optional[Dict[str, str]] = None,
+):
+    """
+    流式请求函数
+
+    Args:
+        body: 请求体
+        native: 是否返回原生bytes流，False则返回str流
+        headers: 额外的请求头
+
+    Yields:
+        Response对象（错误时）或 bytes流/str流（成功时）
+    """
+    # 获取有效凭证
+    model_name = body.get("model", "")
+
+    # 1. 获取有效凭证
+    cred_result = await credential_manager.get_valid_credential(
+        mode="geminicli", model_name=model_name
+    )
+
+    if not cred_result:
+        # 如果返回值是None，直接返回错误500
+        yield Response(
+            content=json.dumps({"error": "当前无可用凭证"}),
+            status_code=500,
+            media_type="application/json"
+        )
+        return
+
+    current_file, credential_data = cred_result
+
+    # 2. 构建URL和请求头
+    try:
+        auth_headers, final_payload, target_url = await prepare_request_headers_and_payload(
+            body, credential_data,
+            f"{await get_code_assist_endpoint()}/v1internal:streamGenerateContent?alt=sse"
+        )
+
+        # 合并自定义headers
+        if headers:
+            auth_headers.update(headers)
+
+    except Exception as e:
+        log.error(f"准备请求失败: {e}")
+        yield Response(
+            content=json.dumps({"error": f"准备请求失败: {str(e)}"}),
+            status_code=500,
+            media_type="application/json"
+        )
+        return
+
+    # 3. 调用stream_post_async进行请求
+    retry_config = await get_retry_config()
+    max_retries = retry_config["max_retries"]
+    retry_interval = retry_config["retry_interval"]
+
+    DISABLE_ERROR_CODES = await get_auto_ban_error_codes()  # 禁用凭证的错误码
+    last_error_response = None  # 记录最后一次的错误响应
+    next_cred_task = None  # 预热的下一个凭证任务
+
+    # 内部函数：快速更新凭证(只更新token和project_id,避免重建整个请求)
+    async def refresh_credential_fast():
+        nonlocal current_file, credential_data, auth_headers, final_payload
+        cred_result = await credential_manager.get_valid_credential(
+            mode="geminicli", model_name=model_name
+        )
+        if not cred_result:
+            return None
+        current_file, credential_data = cred_result
+        try:
+            # 只更新token和project_id,不重建整个headers和payload
+            token = credential_data.get("token") or credential_data.get("access_token", "")
+            project_id = credential_data.get("project_id", "")
+            if not token or not project_id:
+                return None
+
+            # 直接更新现有的headers和payload
+            auth_headers["Authorization"] = f"Bearer {token}"
+            final_payload["project"] = project_id
+            return True
+        except Exception:
+            return None
+
+    def apply_cred_result(cred_result: Tuple[str, Dict[str, Any]]) -> bool:
+        nonlocal current_file, credential_data, auth_headers, final_payload
+        current_file, credential_data = cred_result
+        token = credential_data.get("token") or credential_data.get("access_token", "")
+        project_id = credential_data.get("project_id", "")
+        if not token or not project_id:
+            return False
+        auth_headers["Authorization"] = f"Bearer {token}"
+        final_payload["project"] = project_id
+        return True
+
+    for attempt in range(max_retries + 1):
+        success_recorded = False  # 标记是否已记录成功
+        need_retry = False  # 标记是否需要重试
+
+        try:
+            async for chunk in stream_post_async(
+                url=target_url,
+                body=final_payload,
+                native=native,
+                headers=auth_headers
+            ):
+                # 判断是否是Response对象
+                if isinstance(chunk, Response):
+                    status_code = chunk.status_code
+                    last_error_response = chunk  # 记录最后一次错误
+
+                    # 缓存错误解析结果,避免重复decode
+                    error_body = None
+                    try:
+                        error_body = chunk.body.decode('utf-8') if isinstance(chunk.body, bytes) else str(chunk.body)
+                    except Exception:
+                        error_body = ""
+
+                    # 如果错误码是429、503或者在禁用码当中，做好记录后进行重试
+                    if _is_retryable_status(status_code, DISABLE_ERROR_CODES):
+                        log.warning(f"[GEMINICLI STREAM] 流式请求失败 (status={status_code}), 凭证: {current_file}, 响应: {error_body[:500] if error_body else '无'}")
+
+                        # 解析冷却时间
+                        cooldown_until = None
+                        if (status_code == 429 or status_code == 503) and error_body:
+                            try:
+                                cooldown_until = await parse_and_log_cooldown(error_body, mode="geminicli")
+                            except Exception:
+                                pass
+
+                        # 预热下一个凭证
+                        if next_cred_task is None and attempt < max_retries:
+                            next_cred_task = asyncio.create_task(
+                                credential_manager.get_valid_credential(
+                                    mode="geminicli", model_name=model_name
+                                )
+                            )
+
+                        # 记录错误并切换凭证
+                        await record_api_call_error(
+                            credential_manager, current_file, status_code,
+                            cooldown_until, mode="geminicli", model_name=model_name,
+                            error_message=error_body
+                        )
+
+                        # 检查是否应该重试
+                        should_retry = await handle_error_with_retry(
+                            credential_manager, status_code, current_file,
+                            retry_config["retry_enabled"], attempt, max_retries, retry_interval,
+                            mode="geminicli"
+                        )
+
+                        if should_retry and attempt < max_retries:
+                            need_retry = True
+                            break  # 跳出内层循环，准备重试
+                        else:
+                            # 不重试，直接返回原始错误
+                            log.error(f"[GEMINICLI STREAM] 达到最大重试次数或不应重试，返回原始错误")
+                            yield chunk
+                            return
+                    elif status_code == 404 and "preview" in model_name.lower():
+                        # 特殊处理：preview模型返回404，说明该凭证不支持preview模型
+                        log.warning(f"[GEMINICLI STREAM] Preview模型404错误，凭证不支持preview: {current_file}")
+
+                        # 将该凭证的preview状态设置为False
+                        try:
+                            await credential_manager.update_credential_state(
+                                current_file, {"preview": False}, mode="geminicli"
+                            )
+                            log.info(f"[GEMINICLI STREAM] 已将凭证 {current_file} 的preview状态设置为False")
+                        except Exception as e:
+                            log.error(f"[GEMINICLI STREAM] 更新凭证preview状态失败: {e}")
+
+                        # 记录404错误
+                        await record_api_call_error(
+                            credential_manager, current_file, status_code,
+                            None, mode="geminicli", model_name=model_name,
+                            error_message=error_body
+                        )
+
+                        # 预热下一个凭证（会自动跳过preview=False的凭证）
+                        if next_cred_task is None and attempt < max_retries:
+                            next_cred_task = asyncio.create_task(
+                                credential_manager.get_valid_credential(
+                                    mode="geminicli", model_name=model_name
+                                )
+                            )
+
+                        # 触发重试
+                        if attempt < max_retries:
+                            need_retry = True
+                            break
+                        else:
+                            log.error(f"[GEMINICLI STREAM] 达到最大重试次数，返回404错误")
+                            yield chunk
+                            return
+                    else:
+                        # 错误码不在禁用码当中，直接返回，无需重试
+                        log.error(f"[GEMINICLI STREAM] 流式请求失败，非重试错误码 (status={status_code}), 凭证: {current_file}, 响应: {error_body[:500] if error_body else '无'}")
+                        await record_api_call_error(
+                            credential_manager, current_file, status_code,
+                            None, mode="geminicli", model_name=model_name,
+                            error_message=error_body
+                        )
+                        yield chunk
+                        return
+                else:
+                    # 不是Response，说明是真流，直接yield返回
+                    # 只在第一个chunk时记录成功
+                    if not success_recorded:
+                        await record_api_call_success(
+                            credential_manager, current_file, mode="geminicli", model_name=model_name
+                        )
+                        success_recorded = True
+                        log.debug(f"[GEMINICLI STREAM] 开始接收流式响应，模型: {model_name}")
+
+                    yield chunk
+
+            # 流式请求完成，检查结果
+            if success_recorded:
+                log.debug(f"[GEMINICLI STREAM] 流式响应完成，模型: {model_name}")
+                return
+
+            # 统一处理重试
+            if need_retry:
+                # 如果已经是最后一次尝试，不再重试，直接返回错误
+                if attempt >= max_retries:
+                    log.error(f"[GEMINICLI STREAM] 达到最大重试次数，返回错误")
+                    if last_error_response:
+                        yield last_error_response
+                    else:
+                        yield Response(
+                            content=json.dumps({"error": "请求失败，所有重试均已耗尽"}),
+                            status_code=429,
+                            media_type="application/json"
+                        )
+                    return
+
+                log.info(f"[GEMINICLI STREAM] 重试请求 (attempt {attempt + 2}/{max_retries + 1})...")
+
+                switched, next_cred_task = await _switch_credential_for_retry(
+                    next_cred_task=next_cred_task,
+                    retry_interval=retry_interval,
+                    refresh_credential_fast=refresh_credential_fast,
+                    apply_cred_result=apply_cred_result,
+                    log_prefix="[GEMINICLI STREAM]",
+                )
+                if not switched:
+                    log.error("[GEMINICLI STREAM] 重试时无可用凭证或刷新失败")
+                    yield Response(
+                        content=json.dumps({"error": "当前无可用凭证"}),
+                        status_code=500,
+                        media_type="application/json"
+                    )
+                    return
+                continue  # 重试
+
+        except Exception as e:
+            log.error(f"[GEMINICLI STREAM] 流式请求异常: {e}, 凭证: {current_file}")
+            if attempt < max_retries:
+                log.info(f"[GEMINICLI STREAM] 异常后重试 (attempt {attempt + 2}/{max_retries + 1})...")
+                await asyncio.sleep(retry_interval)
+                continue
+            else:
+                # 所有重试都失败，返回最后一次的错误（如果有）
+                log.error(f"[GEMINICLI STREAM] 所有重试均失败，最后异常: {e}")
+                if last_error_response:
+                    yield last_error_response
+                else:
+                    # 如果没有记录到错误响应，返回500错误
+                    yield Response(
+                        content=json.dumps({"error": f"流式请求异常: {str(e)}"}),
+                        status_code=500,
+                        media_type="application/json"
+                    )
+                return
+
+    # 所有重试均已耗尽（for循环正常结束），返回最后记录的错误
+    log.error("[GEMINICLI STREAM] 所有重试均失败")
+    if last_error_response:
+        yield last_error_response
+    else:
+        yield Response(
+            content=json.dumps({"error": "请求失败，所有重试均已耗尽"}),
+            status_code=429,
+            media_type="application/json"
+        )
+
+
+async def non_stream_request(
+    body: Dict[str, Any],
+    headers: Optional[Dict[str, str]] = None,
+) -> Response:
+    """
+    非流式请求函数
+
+    Args:
+        body: 请求体
+        native: 保留参数以保持接口一致性（实际未使用）
+        headers: 额外的请求头
+
+    Returns:
+        Response对象
+    """
+    # 获取有效凭证
+    model_name = body.get("model", "")
+
+    # 1. 获取有效凭证
+    cred_result = await credential_manager.get_valid_credential(
+        mode="geminicli", model_name=model_name
+    )
+
+    if not cred_result:
+        # 如果返回值是None，直接返回错误500
+        return Response(
+            content=json.dumps({"error": "当前无可用凭证"}),
+            status_code=500,
+            media_type="application/json"
+        )
+
+    current_file, credential_data = cred_result
+
+    # 2. 构建URL和请求头
+    try:
+        auth_headers, final_payload, target_url = await prepare_request_headers_and_payload(
+            body, credential_data,
+            f"{await get_code_assist_endpoint()}/v1internal:generateContent"
+        )
+
+        # 合并自定义headers
+        if headers:
+            auth_headers.update(headers)
+
+    except Exception as e:
+        log.error(f"准备请求失败: {e}")
+        return Response(
+            content=json.dumps({"error": f"准备请求失败: {str(e)}"}),
+            status_code=500,
+            media_type="application/json"
+        )
+
+    # 3. 调用post_async进行请求
+    retry_config = await get_retry_config()
+    max_retries = retry_config["max_retries"]
+    retry_interval = retry_config["retry_interval"]
+
+    DISABLE_ERROR_CODES = await get_auto_ban_error_codes()  # 禁用凭证的错误码
+    last_error_response = None  # 记录最后一次的错误响应
+    next_cred_task = None  # 预热的下一个凭证任务
+
+    # 内部函数：快速更新凭证(只更新token和project_id,避免重建整个请求)
+    async def refresh_credential_fast():
+        nonlocal current_file, credential_data, auth_headers, final_payload
+        cred_result = await credential_manager.get_valid_credential(
+            mode="geminicli", model_name=model_name
+        )
+        if not cred_result:
+            return None
+        current_file, credential_data = cred_result
+        try:
+            # 只更新token和project_id,不重建整个headers和payload
+            token = credential_data.get("token") or credential_data.get("access_token", "")
+            project_id = credential_data.get("project_id", "")
+            if not token or not project_id:
+                return None
+
+            # 直接更新现有的headers和payload
+            auth_headers["Authorization"] = f"Bearer {token}"
+            final_payload["project"] = project_id
+            return True
+        except Exception:
+            return None
+
+    def apply_cred_result(cred_result: Tuple[str, Dict[str, Any]]) -> bool:
+        nonlocal current_file, credential_data, auth_headers, final_payload
+        current_file, credential_data = cred_result
+        token = credential_data.get("token") or credential_data.get("access_token", "")
+        project_id = credential_data.get("project_id", "")
+        if not token or not project_id:
+            return False
+        auth_headers["Authorization"] = f"Bearer {token}"
+        final_payload["project"] = project_id
+        return True
+
+    for attempt in range(max_retries + 1):
+        try:
+            response = await post_async(
+                url=target_url,
+                json=final_payload,
+                headers=auth_headers,
+                timeout=300.0
+            )
+
+            status_code = response.status_code
+
+            # 成功
+            if status_code == 200:
+                await record_api_call_success(
+                    credential_manager, current_file, mode="geminicli", model_name=model_name
+                )
+                # 创建响应头,移除压缩相关的header避免重复解压
+                response_headers = dict(response.headers)
+                response_headers.pop('content-encoding', None)
+                response_headers.pop('content-length', None)
+
+                return Response(
+                    content=response.content,
+                    status_code=200,
+                    headers=response_headers
+                )
+
+            # 失败 - 记录最后一次错误
+            # 创建响应头,移除压缩相关的header避免重复解压
+            error_headers = dict(response.headers)
+            error_headers.pop('content-encoding', None)
+            error_headers.pop('content-length', None)
+
+            last_error_response = Response(
+                content=response.content,
+                status_code=status_code,
+                headers=error_headers
+            )
+
+            # 判断是否需要重试
+            # 缓存错误文本,避免重复解析
+            error_text = ""
+            try:
+                error_text = response.text
+            except Exception:
+                pass
+
+            # 统一处理所有需要重试的错误码（429、503、禁用码）
+            if _is_retryable_status(status_code, DISABLE_ERROR_CODES):
+                log.warning(f"[NON-STREAM] 非流式请求失败 (status={status_code}), 凭证: {current_file}, 响应: {error_text[:500] if error_text else '无'}")
+
+                # 解析冷却时间
+                cooldown_until = None
+                if (status_code == 429 or status_code == 503) and error_text:
+                    try:
+                        cooldown_until = await parse_and_log_cooldown(error_text, mode="geminicli")
+                    except Exception:
+                        pass
+
+                # 并行预热下一个凭证,不阻塞当前处理
+                if next_cred_task is None and attempt < max_retries:
+                    next_cred_task = asyncio.create_task(
+                        credential_manager.get_valid_credential(
+                            mode="geminicli", model_name=model_name
+                        )
+                    )
+
+                # 记录错误并切换凭证
+                await record_api_call_error(
+                    credential_manager, current_file, status_code,
+                    cooldown_until, mode="geminicli", model_name=model_name,
+                    error_message=error_text
+                )
+
+                # 检查是否应该重试（会自动处理禁用逻辑）
+                should_retry = await handle_error_with_retry(
+                    credential_manager, status_code, current_file,
+                    retry_config["retry_enabled"], attempt, max_retries, retry_interval,
+                    mode="geminicli"
+                )
+
+                if should_retry and attempt < max_retries:
+                    # 重新获取凭证并重试
+                    log.info(f"[NON-STREAM] 重试请求 (attempt {attempt + 2}/{max_retries + 1})...")
+
+                    switched, next_cred_task = await _switch_credential_for_retry(
+                        next_cred_task=next_cred_task,
+                        retry_interval=retry_interval,
+                        refresh_credential_fast=refresh_credential_fast,
+                        apply_cred_result=apply_cred_result,
+                        log_prefix="[NON-STREAM]",
+                    )
+                    if not switched:
+                        log.error("[NON-STREAM] 重试时无可用凭证或刷新失败")
+                        return Response(
+                            content=json.dumps({"error": "当前无可用凭证"}),
+                            status_code=500,
+                            media_type="application/json"
+                        )
+                    continue  # 重试
+                else:
+                    # 不重试，直接返回原始错误
+                    log.error(f"[NON-STREAM] 达到最大重试次数或不应重试，返回原始错误")
+                    return last_error_response
+            elif status_code == 404 and "preview" in model_name.lower():
+                # 特殊处理：preview模型返回404，说明该凭证不支持preview模型
+                log.warning(f"[NON-STREAM] Preview模型404错误，凭证不支持preview: {current_file}")
+
+                # 将该凭证的preview状态设置为False
+                try:
+                    await credential_manager.update_credential_state(
+                        current_file, {"preview": False}, mode="geminicli"
+                    )
+                    log.info(f"[NON-STREAM] 已将凭证 {current_file} 的preview状态设置为False")
+                except Exception as e:
+                    log.error(f"[NON-STREAM] 更新凭证preview状态失败: {e}")
+
+                # 记录404错误
+                await record_api_call_error(
+                    credential_manager, current_file, status_code,
+                    None, mode="geminicli", model_name=model_name,
+                    error_message=error_text
+                )
+
+                # 预热下一个凭证（会自动跳过preview=False的凭证）
+                if next_cred_task is None and attempt < max_retries:
+                    next_cred_task = asyncio.create_task(
+                        credential_manager.get_valid_credential(
+                            mode="geminicli", model_name=model_name
+                        )
+                    )
+
+                # 触发重试
+                if attempt < max_retries:
+                    log.info(f"[NON-STREAM] 重试请求 (attempt {attempt + 2}/{max_retries + 1})...")
+
+                    switched, next_cred_task = await _switch_credential_for_retry(
+                        next_cred_task=next_cred_task,
+                        retry_interval=retry_interval,
+                        refresh_credential_fast=refresh_credential_fast,
+                        apply_cred_result=apply_cred_result,
+                        log_prefix="[NON-STREAM]",
+                    )
+                    if not switched:
+                        log.error("[NON-STREAM] 重试时无可用凭证或刷新失败")
+                        return Response(
+                            content=json.dumps({"error": "当前无可用凭证"}),
+                            status_code=500,
+                            media_type="application/json"
+                        )
+                    continue  # 重试
+                else:
+                    log.error(f"[NON-STREAM] 达到最大重试次数，返回404错误")
+                    return last_error_response
+            else:
+                # 错误码不在重试范围内，直接返回
+                log.error(f"[NON-STREAM] 非流式请求失败，非重试错误码 (status={status_code}), 凭证: {current_file}, 响应: {error_text[:500] if error_text else '无'}")
+                await record_api_call_error(
+                    credential_manager, current_file, status_code,
+                    None, mode="geminicli", model_name=model_name,
+                    error_message=error_text
+                )
+                return last_error_response
+
+        except Exception as e:
+            log.error(f"非流式请求异常: {e}, 凭证: {current_file}")
+            if attempt < max_retries:
+                log.info(f"[NON-STREAM] 异常后重试 (attempt {attempt + 2}/{max_retries + 1})...")
+                await asyncio.sleep(retry_interval)
+                continue
+            else:
+                # 所有重试都失败，返回最后一次的错误（如果有）或500错误
+                log.error(f"[NON-STREAM] 所有重试均失败，最后异常: {e}")
+                if last_error_response:
+                    return last_error_response
+                else:
+                    return Response(
+                        content=json.dumps({"error": f"请求异常: {str(e)}"}),
+                        status_code=500,
+                        media_type="application/json"
+                    )
+
+    # 所有重试都失败，返回最后一次的原始错误
+    log.error("[NON-STREAM] 所有重试均失败")
+    return last_error_response
+
+
+# ==================== 测试代码 ====================
+
+if __name__ == "__main__":
+    """
+    测试代码：演示API返回的流式和非流式数据格式
+    运行方式: python src/api/geminicli.py
+    """
+    print("=" * 80)
+    print("GeminiCli API 测试")
+    print("=" * 80)
+
+    # 测试请求体
+    test_body = {
+        "model": "gemini-2.5-flash",
+        "request": {
+            "contents": [
+                {
+                    "role": "user",
+                    "parts": [{"text": "Hello, tell me a joke in one sentence."}]
+                }
+            ]
+        }
+    }
+
+    async def test_stream_request():
+        """测试流式请求"""
+        print("\n" + "=" * 80)
+        print("【测试1】流式请求 (stream_request with native=False)")
+        print("=" * 80)
+        print(f"请求体: {json.dumps(test_body, indent=2, ensure_ascii=False)}\n")
+
+        print("流式响应数据 (每个chunk):")
+        print("-" * 80)
+
+        chunk_count = 0
+        async for chunk in stream_request(body=test_body, native=False):
+            chunk_count += 1
+            if isinstance(chunk, Response):
+                # 错误响应
+                print(f"\n❌ 错误响应:")
+                print(f"  状态码: {chunk.status_code}")
+                print(f"  Content-Type: {chunk.headers.get('content-type', 'N/A')}")
+                try:
+                    content = chunk.body.decode('utf-8') if isinstance(chunk.body, bytes) else str(chunk.body)
+                    print(f"  内容: {content}")
+                except Exception as e:
+                    print(f"  内容解析失败: {e}")
+            else:
+                # 正常的流式数据块 (str类型)
+                print(f"\nChunk #{chunk_count}:")
+                print(f"  类型: {type(chunk).__name__}")
+                print(f"  长度: {len(chunk) if hasattr(chunk, '__len__') else 'N/A'}")
+                print(f"  内容预览: {repr(chunk[:200] if len(chunk) > 200 else chunk)}")
+
+                # 如果是SSE格式，尝试解析
+                if isinstance(chunk, str) and chunk.startswith("data: "):
+                    try:
+                        data_line = chunk.strip()
+                        if data_line.startswith("data: "):
+                            json_str = data_line[6:]  # 去掉 "data: " 前缀
+                            json_data = json.loads(json_str)
+                            print(f"  解析后的JSON: {json.dumps(json_data, indent=4, ensure_ascii=False)}")
+                    except Exception as e:
+                        print(f"  SSE解析尝试失败: {e}")
+
+        print(f"\n总共收到 {chunk_count} 个chunk")
+
+    async def test_non_stream_request():
+        """测试非流式请求"""
+        print("\n" + "=" * 80)
+        print("【测试2】非流式请求 (non_stream_request)")
+        print("=" * 80)
+        print(f"请求体: {json.dumps(test_body, indent=2, ensure_ascii=False)}\n")
+
+        response = await non_stream_request(body=test_body)
+
+        print("非流式响应数据:")
+        print("-" * 80)
+        print(f"状态码: {response.status_code}")
+        print(f"Content-Type: {response.headers.get('content-type', 'N/A')}")
+        print(f"\n响应头: {dict(response.headers)}\n")
+
+        try:
+            content = response.body.decode('utf-8') if isinstance(response.body, bytes) else str(response.body)
+            print(f"响应内容 (原始):\n{content}\n")
+
+            # 尝试解析JSON
+            try:
+                json_data = json.loads(content)
+                print(f"响应内容 (格式化JSON):")
+                print(json.dumps(json_data, indent=2, ensure_ascii=False))
+            except json.JSONDecodeError:
+                print("(非JSON格式)")
+        except Exception as e:
+            print(f"内容解析失败: {e}")
+
+    async def main():
+        """主测试函数"""
+        try:
+            # 测试流式请求
+            await test_stream_request()
+
+            # 测试非流式请求
+            await test_non_stream_request()
+
+            print("\n" + "=" * 80)
+            print("测试完成")
+            print("=" * 80)
+
+        except Exception as e:
+            print(f"\n❌ 测试过程中出现异常: {e}")
+            import traceback
+            traceback.print_exc()
+
+    # 运行测试
+    asyncio.run(main())

src/api/utils.py

@@ -0,0 +1,506 @@
+"""
+Base API Client - 共用的 API 客户端基础功能
+提供错误处理、自动封禁、重试逻辑等共同功能
+"""
+
+import asyncio
+import json
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from fastapi import Response
+
+from config import (
+    get_auto_ban_enabled,
+    get_auto_ban_error_codes,
+    get_retry_429_enabled,
+    get_retry_429_interval,
+    get_retry_429_max_retries,
+)
+from log import log
+from src.credential_manager import CredentialManager
+
+
+# ==================== 错误检查与处理 ====================
+
+async def check_should_auto_ban(status_code: int) -> bool:
+    """
+    检查是否应该触发自动封禁
+    
+    Args:
+        status_code: HTTP状态码
+        
+    Returns:
+        bool: 是否应该触发自动封禁
+    """
+    return (
+        await get_auto_ban_enabled()
+        and status_code in await get_auto_ban_error_codes()
+    )
+
+
+async def handle_auto_ban(
+    credential_manager: CredentialManager,
+    status_code: int,
+    credential_name: str,
+    mode: str = "geminicli"
+) -> None:
+    """
+    处理自动封禁：直接禁用凭证
+    
+    Args:
+        credential_manager: 凭证管理器实例
+        status_code: HTTP状态码
+        credential_name: 凭证名称
+        mode: 模式（geminicli 或 antigravity）
+    """
+    if credential_manager and credential_name:
+        log.warning(
+            f"[{mode.upper()} AUTO_BAN] Status {status_code} triggers auto-ban for credential: {credential_name}"
+        )
+        await credential_manager.set_cred_disabled(
+            credential_name, True, mode=mode
+        )
+
+
+async def handle_error_with_retry(
+    credential_manager: CredentialManager,
+    status_code: int,
+    credential_name: str,
+    retry_enabled: bool,
+    attempt: int,
+    max_retries: int,
+    retry_interval: float,
+    mode: str = "geminicli"
+) -> bool:
+    """
+    统一处理错误和重试逻辑
+
+    仅在以下情况下进行自动重试:
+    1. 429错误(速率限制)
+    2. 503错误(服务不可用)
+    3. 500错误(服务临时不可用)
+    4. 导致凭证封禁的错误(AUTO_BAN_ERROR_CODES配置)
+
+    Args:
+        credential_manager: 凭证管理器实例
+        status_code: HTTP状态码
+        credential_name: 凭证名称
+        retry_enabled: 是否启用重试
+        attempt: 当前重试次数
+        max_retries: 最大重试次数
+        retry_interval: 重试间隔
+        mode: 模式（geminicli 或 antigravity）
+        
+    Returns:
+        bool: True表示需要继续重试，False表示不需要重试
+    """
+    # 优先检查自动封禁
+    should_auto_ban = await check_should_auto_ban(status_code)
+
+    if should_auto_ban:
+        # 触发自动封禁
+        await handle_auto_ban(credential_manager, status_code, credential_name, mode)
+
+        # 自动封禁后，仍然尝试重试（会在下次循环中自动获取新凭证）
+        if retry_enabled and attempt < max_retries:
+            log.info(
+                f"[{mode.upper()} RETRY] Retrying with next credential after auto-ban "
+                f"(status {status_code}, attempt {attempt + 1}/{max_retries})"
+            )
+            await asyncio.sleep(retry_interval)
+            return True
+        return False
+
+    # 如果不触发自动封禁，仅对429、503和500错误进行重试
+    if status_code in (429, 500, 503) and retry_enabled and attempt < max_retries:
+        log.info(
+            f"[{mode.upper()} RETRY] {status_code} error encountered, retrying "
+            f"(attempt {attempt + 1}/{max_retries})"
+        )
+        await asyncio.sleep(retry_interval)
+        return True
+
+    # 其他错误不进行重试
+    return False
+
+
+# ==================== 重试配置获取 ====================
+
+async def get_retry_config() -> Dict[str, Any]:
+    """
+    获取重试配置
+    
+    Returns:
+        包含重试配置的字典
+    """
+    return {
+        "retry_enabled": await get_retry_429_enabled(),
+        "max_retries": await get_retry_429_max_retries(),
+        "retry_interval": await get_retry_429_interval(),
+    }
+
+
+# ==================== API调用结果记录 ====================
+
+async def record_api_call_success(
+    credential_manager: CredentialManager,
+    credential_name: str,
+    mode: str = "geminicli",
+    model_name: Optional[str] = None
+) -> None:
+    """
+    记录API调用成功
+    
+    Args:
+        credential_manager: 凭证管理器实例
+        credential_name: 凭证名称
+        mode: 模式（geminicli 或 antigravity）
+        model_name: 模型名称（用于模型级CD）
+    """
+    if credential_manager and credential_name:
+        await credential_manager.record_api_call_result(
+            credential_name, True, mode=mode, model_name=model_name
+        )
+
+
+async def record_api_call_error(
+    credential_manager: CredentialManager,
+    credential_name: str,
+    status_code: int,
+    cooldown_until: Optional[float] = None,
+    mode: str = "geminicli",
+    model_name: Optional[str] = None,
+    error_message: Optional[str] = None
+) -> None:
+    """
+    记录API调用错误
+
+    Args:
+        credential_manager: 凭证管理器实例
+        credential_name: 凭证名称
+        status_code: HTTP状态码
+        cooldown_until: 冷却截止时间（Unix时间戳）
+        mode: 模式（geminicli 或 antigravity）
+        model_name: 模型名称（用于模型级CD）
+        error_message: 错误信息（可选）
+    """
+    if credential_manager and credential_name:
+        await credential_manager.record_api_call_result(
+            credential_name,
+            False,
+            status_code,
+            cooldown_until=cooldown_until,
+            mode=mode,
+            model_name=model_name,
+            error_message=error_message
+        )
+
+
+# ==================== 429错误处理 ====================
+
+async def parse_and_log_cooldown(
+    error_text: str,
+    mode: str = "geminicli"
+) -> Optional[float]:
+    """
+    解析并记录冷却时间
+
+    Args:
+        error_text: 错误响应文本
+        mode: 模式（geminicli 或 antigravity）
+
+    Returns:
+        冷却截止时间（Unix时间戳），如果解析失败则返回None
+    """
+    try:
+        error_data = json.loads(error_text)
+        cooldown_until = parse_quota_reset_timestamp(error_data)
+        if cooldown_until:
+            log.info(
+                f"[{mode.upper()}] 检测到quota冷却时间: "
+                f"{datetime.fromtimestamp(cooldown_until, timezone.utc).isoformat()}"
+            )
+            return cooldown_until
+    except Exception as parse_err:
+        log.debug(f"[{mode.upper()}] Failed to parse cooldown time: {parse_err}")
+    return None
+
+
+# ==================== 流式响应收集 ====================
+
+async def collect_streaming_response(stream_generator) -> Response:
+    """
+    将Gemini流式响应收集为一条完整的非流式响应
+
+    Args:
+        stream_generator: 流式响应生成器，产生 "data: {json}" 格式的行或Response对象
+
+    Returns:
+        Response: 合并后的完整响应对象
+
+    Example:
+        >>> async for line in stream_generator:
+        ...     # line format: "data: {...}" or Response object
+        >>> response = await collect_streaming_response(stream_generator)
+    """
+    # 初始化响应结构
+    merged_response = {
+        "response": {
+            "candidates": [{
+                "content": {
+                    "parts": [],
+                    "role": "model"
+                },
+                "finishReason": None,
+                "safetyRatings": [],
+                "citationMetadata": None
+            }],
+            "usageMetadata": {
+                "promptTokenCount": 0,
+                "candidatesTokenCount": 0,
+                "totalTokenCount": 0
+            }
+        }
+    }
+
+    collected_text = []  # 用于收集文本内容
+    collected_thought_text = []  # 用于收集思维链内容
+    collected_other_parts = []  # 用于收集其他类型的parts（图片、文件、工具调用等）
+    collected_tool_parts_count = 0  # 记录工具调用相关part数量
+    has_data = False
+    line_count = 0
+
+    log.debug("[STREAM COLLECTOR] Starting to collect streaming response")
+
+    try:
+        async for line in stream_generator:
+            line_count += 1
+
+            # 如果收到的是Response对象（错误），直接返回
+            if isinstance(line, Response):
+                log.debug(f"[STREAM COLLECTOR] 收到错误Response，状态码: {line.status_code}")
+                return line
+
+            # 处理 bytes 类型
+            if isinstance(line, bytes):
+                line_str = line.decode('utf-8', errors='ignore')
+                log.debug(f"[STREAM COLLECTOR] Processing bytes line {line_count}: {line_str[:200] if line_str else 'empty'}")
+            elif isinstance(line, str):
+                line_str = line
+                log.debug(f"[STREAM COLLECTOR] Processing line {line_count}: {line_str[:200] if line_str else 'empty'}")
+            else:
+                log.debug(f"[STREAM COLLECTOR] Skipping non-string/bytes line: {type(line)}")
+                continue
+
+            # 解析流式数据行
+            if not line_str.startswith("data: "):
+                log.debug(f"[STREAM COLLECTOR] Skipping line without 'data: ' prefix: {line_str[:100]}")
+                continue
+
+            raw = line_str[6:].strip()
+            if raw == "[DONE]":
+                log.debug("[STREAM COLLECTOR] Received [DONE] marker")
+                break
+
+            try:
+                log.debug(f"[STREAM COLLECTOR] Parsing JSON: {raw[:200]}")
+                chunk = json.loads(raw)
+                has_data = True
+                log.debug(f"[STREAM COLLECTOR] Chunk keys: {chunk.keys() if isinstance(chunk, dict) else type(chunk)}")
+
+                # 提取响应对象
+                response_obj = chunk.get("response", {})
+                if not response_obj:
+                    log.debug("[STREAM COLLECTOR] No 'response' key in chunk, trying direct access")
+                    response_obj = chunk  # 尝试直接使用chunk
+
+                candidates = response_obj.get("candidates", [])
+                log.debug(f"[STREAM COLLECTOR] Found {len(candidates)} candidates")
+                if not candidates:
+                    log.debug(f"[STREAM COLLECTOR] No candidates in chunk, chunk structure: {list(chunk.keys()) if isinstance(chunk, dict) else type(chunk)}")
+                    continue
+
+                candidate = candidates[0]
+
+                # 收集文本内容
+                content = candidate.get("content", {})
+                parts = content.get("parts", [])
+                log.debug(f"[STREAM COLLECTOR] Processing {len(parts)} parts from candidate")
+
+                for part in parts:
+                    if not isinstance(part, dict):
+                        continue
+
+                    # 优先保留工具调用相关 part（functionCall / functionResponse）
+                    # 避免在 stream2nostream 模式下工具调用丢失
+                    if "functionCall" in part or "functionResponse" in part or "function_call" in part:
+                        collected_other_parts.append(part)
+                        collected_tool_parts_count += 1
+                        log.debug(f"[STREAM COLLECTOR] Collected tool part: {list(part.keys())}")
+                        continue
+
+                    # 处理文本内容
+                    text = part.get("text", "")
+                    if text:
+                        # 区分普通文本和思维链
+                        if part.get("thought", False):
+                            collected_thought_text.append(text)
+                            log.debug(f"[STREAM COLLECTOR] Collected thought text: {text[:100]}")
+                        else:
+                            collected_text.append(text)
+                            log.debug(f"[STREAM COLLECTOR] Collected regular text: {text[:100]}")
+                    # 处理非文本内容（图片、文件等）
+                    elif "inlineData" in part or "fileData" in part or "executableCode" in part or "codeExecutionResult" in part:
+                        collected_other_parts.append(part)
+                        log.debug(f"[STREAM COLLECTOR] Collected non-text part: {list(part.keys())}")
+
+                # 收集其他信息（使用最后一个块的值）
+                if candidate.get("finishReason"):
+                    merged_response["response"]["candidates"][0]["finishReason"] = candidate["finishReason"]
+
+                if candidate.get("safetyRatings"):
+                    merged_response["response"]["candidates"][0]["safetyRatings"] = candidate["safetyRatings"]
+
+                if candidate.get("citationMetadata"):
+                    merged_response["response"]["candidates"][0]["citationMetadata"] = candidate["citationMetadata"]
+
+                # 更新使用元数据
+                usage = response_obj.get("usageMetadata", {})
+                if usage:
+                    merged_response["response"]["usageMetadata"].update(usage)
+
+            except json.JSONDecodeError as e:
+                log.debug(f"[STREAM COLLECTOR] Failed to parse JSON chunk: {e}")
+                continue
+            except Exception as e:
+                log.debug(f"[STREAM COLLECTOR] Error processing chunk: {e}")
+                continue
+
+    except Exception as e:
+        log.error(f"[STREAM COLLECTOR] Error collecting stream after {line_count} lines: {e}")
+        return Response(
+            content=json.dumps({"error": f"收集流式响应失败: {str(e)}"}),
+            status_code=500,
+            media_type="application/json"
+        )
+
+    log.debug(f"[STREAM COLLECTOR] Finished iteration, has_data={has_data}, line_count={line_count}")
+
+    # 如果没有收集到任何数据，返回错误
+    if not has_data:
+        log.error(f"[STREAM COLLECTOR] No data collected from stream after {line_count} lines")
+        return Response(
+            content=json.dumps({"error": "No data collected from stream"}),
+            status_code=500,
+            media_type="application/json"
+        )
+
+    # 组装最终的parts
+    final_parts = []
+
+    # 先添加思维链内容（如果有）
+    if collected_thought_text:
+        final_parts.append({
+            "text": "".join(collected_thought_text),
+            "thought": True
+        })
+
+    # 再添加普通文本内容
+    if collected_text:
+        final_parts.append({
+            "text": "".join(collected_text)
+        })
+
+    # 添加其他类型的parts（图片、文件等）
+    final_parts.extend(collected_other_parts)
+
+    # 如果没有任何内容，添加空文本
+    if not final_parts:
+        final_parts.append({"text": ""})
+
+    merged_response["response"]["candidates"][0]["content"]["parts"] = final_parts
+
+    log.info(
+        f"[STREAM COLLECTOR] Collected {len(collected_text)} text chunks, "
+        f"{len(collected_thought_text)} thought chunks, {len(collected_other_parts)} other parts "
+        f"(tool parts: {collected_tool_parts_count})"
+    )
+
+    # 去掉嵌套的 "response" 包装（Antigravity格式 -> 标准Gemini格式）
+    if "response" in merged_response and "candidates" not in merged_response:
+        log.debug(f"[STREAM COLLECTOR] 展开response包装")
+        merged_response = merged_response["response"]
+
+    # 返回纯JSON格式
+    return Response(
+        content=json.dumps(merged_response, ensure_ascii=False).encode('utf-8'),
+        status_code=200,
+        headers={},
+        media_type="application/json"
+    )
+
+
+RESOURCE_EXHAUSTED_COOLDOWN_HOURS = 4  # RESOURCE_EXHAUSTED 错误的默认冷却时间（小时）
+
+
+def parse_quota_reset_timestamp(error_response: dict) -> Optional[float]:
+    """
+    从Google API错误响应中提取quota重置时间戳
+
+    Args:
+        error_response: Google API返回的错误响应字典
+
+    Returns:
+        Unix时间戳（秒），如果无法解析则返回None
+
+    示例错误响应:
+    {
+      "error": {
+        "code": 429,
+        "message": "You have exhausted your capacity...",
+        "status": "RESOURCE_EXHAUSTED",
+        "details": [
+          {
+            "@type": "type.googleapis.com/google.rpc.ErrorInfo",
+            "reason": "QUOTA_EXHAUSTED",
+            "metadata": {
+              "quotaResetTimeStamp": "2025-11-30T14:57:24Z",
+              "quotaResetDelay": "13h19m1.20964964s"
+            }
+          }
+        ]
+      }
+    }
+    """
+    try:
+        error_obj = error_response.get("error", {})
+        details = error_obj.get("details", [])
+
+        for detail in details:
+            if detail.get("@type") == "type.googleapis.com/google.rpc.ErrorInfo":
+                reset_timestamp_str = detail.get("metadata", {}).get("quotaResetTimeStamp")
+
+                if reset_timestamp_str:
+                    if reset_timestamp_str.endswith("Z"):
+                        reset_timestamp_str = reset_timestamp_str.replace("Z", "+00:00")
+
+                    reset_dt = datetime.fromisoformat(reset_timestamp_str)
+                    if reset_dt.tzinfo is None:
+                        reset_dt = reset_dt.replace(tzinfo=timezone.utc)
+
+                    return reset_dt.astimezone(timezone.utc).timestamp()
+
+        # 如果是 RESOURCE_EXHAUSTED 错误且消息完全匹配，设置默认4小时冷却时间
+        if (
+            error_obj.get("status") == "RESOURCE_EXHAUSTED"
+            and error_obj.get("message") == "Resource has been exhausted (e.g. check quota)."
+        ):
+            import time
+            cooldown_until = time.time() + RESOURCE_EXHAUSTED_COOLDOWN_HOURS * 3600
+            return cooldown_until
+
+        return None
+
+    except Exception:
+        return None

src/auth.py

@@ -0,0 +1,1089 @@
+"""
+认证API模块
+"""
+
+import asyncio
+import socket
+import threading
+import time
+import uuid
+from datetime import timezone
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Any, Dict, Optional
+from urllib.parse import parse_qs, urlparse
+
+from config import get_config_value, get_antigravity_api_url, get_code_assist_endpoint
+from log import log
+
+from .google_oauth_api import (
+    Credentials,
+    Flow,
+    enable_required_apis,
+    fetch_project_id_and_tier,
+    get_user_projects,
+    select_default_project,
+)
+from .storage_adapter import get_storage_adapter
+from .utils import (
+    ANTIGRAVITY_CLIENT_ID,
+    ANTIGRAVITY_CLIENT_SECRET,
+    ANTIGRAVITY_SCOPES,
+    ANTIGRAVITY_USER_AGENT,
+    CALLBACK_HOST,
+    CLIENT_ID,
+    CLIENT_SECRET,
+    SCOPES,
+    GEMINICLI_USER_AGENT,
+    TOKEN_URL,
+)
+
+
+async def get_callback_port():
+    """获取OAuth回调端口"""
+    return int(await get_config_value("oauth_callback_port", "11451", "OAUTH_CALLBACK_PORT"))
+
+
+def _prepare_credentials_data(credentials: Credentials, project_id: str, mode: str = "geminicli", subscription_tier: str = None) -> Dict[str, Any]:
+    """准备凭证数据字典（统一函数）"""
+    if mode == "antigravity":
+        creds_data = {
+            "client_id": ANTIGRAVITY_CLIENT_ID,
+            "client_secret": ANTIGRAVITY_CLIENT_SECRET,
+            "token": credentials.access_token,
+            "refresh_token": credentials.refresh_token,
+            "scopes": ANTIGRAVITY_SCOPES,
+            "token_uri": TOKEN_URL,
+            "project_id": project_id,
+        }
+    else:
+        creds_data = {
+            "client_id": CLIENT_ID,
+            "client_secret": CLIENT_SECRET,
+            "token": credentials.access_token,
+            "refresh_token": credentials.refresh_token,
+            "scopes": SCOPES,
+            "token_uri": TOKEN_URL,
+            "project_id": project_id,
+        }
+
+    if credentials.expires_at:
+        if credentials.expires_at.tzinfo is None:
+            expiry_utc = credentials.expires_at.replace(tzinfo=timezone.utc)
+        else:
+            expiry_utc = credentials.expires_at
+        creds_data["expiry"] = expiry_utc.isoformat()
+
+    return creds_data
+
+
+def _cleanup_auth_flow_server(state: str):
+    """清理认证流程的服务器资源"""
+    if state in auth_flows:
+        flow_data_to_clean = auth_flows[state]
+        try:
+            if flow_data_to_clean.get("server"):
+                server = flow_data_to_clean["server"]
+                port = flow_data_to_clean.get("callback_port")
+                async_shutdown_server(server, port)
+        except Exception as e:
+            log.debug(f"关闭服务器时出错: {e}")
+        del auth_flows[state]
+
+
+class _OAuthLibPatcher:
+    """oauthlib参数验证补丁的上下文管理器"""
+    def __init__(self):
+        import oauthlib.oauth2.rfc6749.parameters
+        self.module = oauthlib.oauth2.rfc6749.parameters
+        self.original_validate = None
+
+    def __enter__(self):
+        self.original_validate = self.module.validate_token_parameters
+
+        def patched_validate(params):
+            try:
+                return self.original_validate(params)
+            except Warning:
+                pass
+
+        self.module.validate_token_parameters = patched_validate
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.original_validate:
+            self.module.validate_token_parameters = self.original_validate
+
+
+# 全局状态管理 - 严格限制大小
+auth_flows = {}  # 存储进行中的认证流程
+MAX_AUTH_FLOWS = 20  # 严格限制最大认证流程数
+DEFAULT_PROJECT_ID = "gemini-pro-1751713012-07fc4dfd"
+
+
+def cleanup_auth_flows_for_memory():
+    """清理认证流程以释放内存"""
+    global auth_flows
+    cleanup_expired_flows()
+    # 如果还是太多，强制清理一些旧的流程
+    if len(auth_flows) > 10:
+        # 按创建时间排序，保留最新的10个
+        sorted_flows = sorted(
+            auth_flows.items(), key=lambda x: x[1].get("created_at", 0), reverse=True
+        )
+        new_auth_flows = dict(sorted_flows[:10])
+
+        # 清理被移除的流程
+        for state, flow_data in auth_flows.items():
+            if state not in new_auth_flows:
+                try:
+                    if flow_data.get("server"):
+                        server = flow_data["server"]
+                        port = flow_data.get("callback_port")
+                        async_shutdown_server(server, port)
+                except Exception:
+                    pass
+                flow_data.clear()
+
+        auth_flows = new_auth_flows
+        log.info(f"强制清理认证流程，保留 {len(auth_flows)} 个最新流程")
+
+    return len(auth_flows)
+
+
+async def find_available_port(start_port: int = None) -> int:
+    """动态查找可用端口"""
+    if start_port is None:
+        start_port = await get_callback_port()
+
+    # ���先尝试默认端口
+    for port in range(start_port, start_port + 100):  # 尝试100个端口
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                s.bind(("0.0.0.0", port))
+                log.info(f"找到可用端口: {port}")
+                return port
+        except OSError:
+            continue
+
+    # 如果都不可用，让系统自动分配端口
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("0.0.0.0", 0))
+            port = s.getsockname()[1]
+            log.info(f"系统分配可用端口: {port}")
+            return port
+    except OSError as e:
+        log.error(f"无法找到可用端口: {e}")
+        raise RuntimeError("无法找到可用端口")
+
+
+def create_callback_server(port: int) -> HTTPServer:
+    """创建指定端口的回调服务器，优化快速关闭"""
+    try:
+        # 服务器监听0.0.0.0
+        server = HTTPServer(("0.0.0.0", port), AuthCallbackHandler)
+
+        # 设置socket选项以支持快速关闭
+        server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        # 设置较短的超时时间
+        server.timeout = 1.0
+
+        log.info(f"创建OAuth回调服务器，监听端口: {port}")
+        return server
+    except OSError as e:
+        log.error(f"创建端口{port}的服务器失败: {e}")
+        raise
+
+
+class AuthCallbackHandler(BaseHTTPRequestHandler):
+    """OAuth回调处理器"""
+
+    def do_GET(self):
+        query_components = parse_qs(urlparse(self.path).query)
+        code = query_components.get("code", [None])[0]
+        state = query_components.get("state", [None])[0]
+
+        log.info(f"收到OAuth回调: code={'已获取' if code else '未获取'}, state={state}")
+
+        if code and state and state in auth_flows:
+            # 更新流程状态
+            auth_flows[state]["code"] = code
+            auth_flows[state]["completed"] = True
+
+            log.info(f"OAuth回调成功处理: state={state}")
+
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            # 成功页面
+            self.wfile.write(
+                b"<h1>OAuth authentication successful!</h1><p>You can close this window. Please return to the original page and click 'Get Credentials' button.</p>"
+            )
+        else:
+            self.send_response(400)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"<h1>Authentication failed.</h1><p>Please try again.</p>")
+
+    def log_message(self, format, *args):
+        # 减少日志噪音
+        pass
+
+
+async def create_auth_url(
+    project_id: Optional[str] = None, user_session: str = None, mode: str = "geminicli"
+) -> Dict[str, Any]:
+    """创建认证URL，支持动态端口分配"""
+    try:
+        # 动态分配端口
+        callback_port = await find_available_port()
+        callback_url = f"http://{CALLBACK_HOST}:{callback_port}"
+
+        # 立即启动回调服务器
+        try:
+            callback_server = create_callback_server(callback_port)
+            # 在后台线程中运行服务器
+            server_thread = threading.Thread(
+                target=callback_server.serve_forever,
+                daemon=True,
+                name=f"OAuth-Server-{callback_port}",
+            )
+            server_thread.start()
+            log.info(f"OAuth回调服务器已启动，端口: {callback_port}")
+        except Exception as e:
+            log.error(f"启动回调服务器失败: {e}")
+            return {
+                "success": False,
+                "error": f"无法启动OAuth回调服务器，端口{callback_port}: {str(e)}",
+            }
+
+        # 创建OAuth流程
+        # 根据模式选择配置
+        if mode == "antigravity":
+            client_id = ANTIGRAVITY_CLIENT_ID
+            client_secret = ANTIGRAVITY_CLIENT_SECRET
+            scopes = ANTIGRAVITY_SCOPES
+        else:
+            client_id = CLIENT_ID
+            client_secret = CLIENT_SECRET
+            scopes = SCOPES
+
+        flow = Flow(
+            client_id=client_id,
+            client_secret=client_secret,
+            scopes=scopes,
+            redirect_uri=callback_url,
+        )
+
+        # 生成状态标识符，包含用户会话信息
+        if user_session:
+            state = f"{user_session}_{str(uuid.uuid4())}"
+        else:
+            state = str(uuid.uuid4())
+
+        # 生成认证URL
+        auth_url = flow.get_auth_url(state=state)
+
+        # 严格控制认证流程数量 - 超过限制时立即清理最旧的
+        if len(auth_flows) >= MAX_AUTH_FLOWS:
+            # 清理最旧的认证流程
+            oldest_state = min(auth_flows.keys(), key=lambda k: auth_flows[k].get("created_at", 0))
+            try:
+                # 清理服务器资源
+                old_flow = auth_flows[oldest_state]
+                if old_flow.get("server"):
+                    server = old_flow["server"]
+                    port = old_flow.get("callback_port")
+                    async_shutdown_server(server, port)
+            except Exception as e:
+                log.warning(f"Failed to cleanup old auth flow {oldest_state}: {e}")
+
+            del auth_flows[oldest_state]
+            log.debug(f"Removed oldest auth flow: {oldest_state}")
+
+        # 保存流程状态
+        auth_flows[state] = {
+            "flow": flow,
+            "project_id": project_id,  # 可能为None，稍后在回调时确定
+            "user_session": user_session,
+            "callback_port": callback_port,  # 存储分配的端口
+            "callback_url": callback_url,  # 存储完整回调URL
+            "server": callback_server,  # 存储服务器实例
+            "server_thread": server_thread,  # 存储服务器线程
+            "code": None,
+            "completed": False,
+            "created_at": time.time(),
+            "auto_project_detection": project_id is None,  # 标记是否需要自动检测项目ID
+            "mode": mode,  # 凭证模式
+        }
+
+        # 清理过期的流程（30分钟）
+        cleanup_expired_flows()
+
+        log.info(f"OAuth流程已创建: state={state}, project_id={project_id}")
+        log.info(f"用户需要访问认证URL，然后OAuth会回调到 {callback_url}")
+        log.info(f"为此认证流程分配的端口: {callback_port}")
+
+        return {
+            "auth_url": auth_url,
+            "state": state,
+            "callback_port": callback_port,
+            "success": True,
+            "auto_project_detection": project_id is None,
+            "detected_project_id": project_id,
+        }
+
+    except Exception as e:
+        log.error(f"创建认证URL失败: {e}")
+        return {"success": False, "error": str(e)}
+
+
+def wait_for_callback_sync(state: str, timeout: int = 300) -> Optional[str]:
+    """同步等待OAuth回调完成，使用对应流程的专用服务器"""
+    if state not in auth_flows:
+        log.error(f"未找到状态为 {state} 的认证流程")
+        return None
+
+    flow_data = auth_flows[state]
+    callback_port = flow_data["callback_port"]
+
+    # 服务器已经在create_auth_url时启动了，这里只需要等待
+    log.info(f"等待OAuth回调完成，端口: {callback_port}")
+
+    # 等待回调完成
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        if flow_data.get("code"):
+            log.info("OAuth回调成功完成")
+            return flow_data["code"]
+        time.sleep(0.5)  # 每0.5秒检查一次
+
+        # 刷新flow_data引用
+        if state in auth_flows:
+            flow_data = auth_flows[state]
+
+    log.warning(f"等待OAuth回调超时 ({timeout}秒)")
+    return None
+
+
+async def complete_auth_flow(
+    project_id: Optional[str] = None, user_session: str = None
+) -> Dict[str, Any]:
+    """完成认证流程并保存凭证，支持自动检测项目ID"""
+    try:
+        # 查找对应的认证流程
+        state = None
+        flow_data = None
+
+        # 如果指定了project_id，先尝试匹配指定的项目
+        if project_id:
+            for s, data in auth_flows.items():
+                if data["project_id"] == project_id:
+                    # 如果指定了用户会话，优先匹配相同会话的流程
+                    if user_session and data.get("user_session") == user_session:
+                        state = s
+                        flow_data = data
+                        break
+                    # 如果没有指定会话，或没找到匹配会话的流程，使用第一个匹配项目ID的
+                    elif not state:
+                        state = s
+                        flow_data = data
+
+        # 如果没有指定项目ID或没找到匹配的，查找需要自动检测项目ID的流程
+        if not state:
+            for s, data in auth_flows.items():
+                if data.get("auto_project_detection", False):
+                    # 如果指定了用户会话，优先匹配相同会话的流程
+                    if user_session and data.get("user_session") == user_session:
+                        state = s
+                        flow_data = data
+                        break
+                    # 使用第一个找到的需要自动检测的流程
+                    elif not state:
+                        state = s
+                        flow_data = data
+
+        if not state or not flow_data:
+            return {"success": False, "error": "未找到对应的认证流程，请先点击获取认证链接"}
+
+        if not project_id:
+            project_id = flow_data.get("project_id")
+            if not project_id:
+                project_id = DEFAULT_PROJECT_ID
+                log.warning(f"未获取到project_id，使用默认project_id: {project_id}")
+
+        flow = flow_data["flow"]
+
+        # 如果还没有授权码，需要等待回调
+        if not flow_data.get("code"):
+            log.info(f"等待用户完成OAuth授权 (state: {state})")
+            auth_code = wait_for_callback_sync(state)
+
+            if not auth_code:
+                return {
+                    "success": False,
+                    "error": "未接收到授权回调，请确保完成了浏览器中的OAuth认证",
+                }
+
+            # 更新流程数据
+            auth_flows[state]["code"] = auth_code
+            auth_flows[state]["completed"] = True
+        else:
+            auth_code = flow_data["code"]
+
+        # 使用认证代码获取凭证
+        with _OAuthLibPatcher():
+            try:
+                credentials = await flow.exchange_code(auth_code)
+                # credentials 已经在 exchange_code 中获得
+
+                # 如果需要自动检测项目ID且没有提供项目ID
+                if flow_data.get("auto_project_detection", False) and not project_id:
+                    log.info("尝试通过API获取用户项目列表...")
+                    log.info(f"使用的token: {credentials.access_token[:20]}...")
+                    log.info(f"Token过期时间: {credentials.expires_at}")
+                    user_projects = await get_user_projects(credentials)
+
+                    if user_projects:
+                        # 如果只有一个项目，自动使用
+                        if len(user_projects) == 1:
+                            # Google API returns projectId in camelCase
+                            project_id = user_projects[0].get("projectId")
+                            if project_id:
+                                flow_data["project_id"] = project_id
+                                log.info(f"自动选择唯一项目: {project_id}")
+                        # 如果有多个项目，尝试选择默认项目
+                        else:
+                            project_id = await select_default_project(user_projects)
+                            if project_id:
+                                flow_data["project_id"] = project_id
+                                log.info(f"自动选择默认项目: {project_id}")
+                            else:
+                                # 返回项目列表让用户选择
+                                return {
+                                    "success": False,
+                                    "error": "请从以下项目中选择一个",
+                                    "requires_project_selection": True,
+                                    "available_projects": [
+                                        {
+                                            # Google API returns projectId in camelCase
+                                            "project_id": p.get("projectId"),
+                                            "name": p.get("displayName") or p.get("projectId"),
+                                            "projectNumber": p.get("projectNumber"),
+                                        }
+                                        for p in user_projects
+                                    ],
+                                }
+                    else:
+                        # 如果无法获取项目列表，使用默认project_id
+                        project_id = DEFAULT_PROJECT_ID
+                        flow_data["project_id"] = project_id
+                        log.warning(f"无法获取项目列表，使用默认project_id: {project_id}")
+
+                # 如果仍然没有项目ID，返回错误
+                if not project_id:
+                    project_id = DEFAULT_PROJECT_ID
+                    flow_data["project_id"] = project_id
+                    log.warning(f"仍未获取到project_id，使用默认project_id: {project_id}")
+
+                # 保存凭证
+                saved_filename = await save_credentials(credentials, project_id)
+
+                # 准备返回的凭证数据
+                creds_data = _prepare_credentials_data(credentials, project_id, mode="geminicli")
+
+                # 清理使用过的流程
+                _cleanup_auth_flow_server(state)
+
+                log.info("OAuth认证成功，凭证已保存")
+                return {
+                    "success": True,
+                    "credentials": creds_data,
+                    "file_path": saved_filename,
+                    "auto_detected_project": flow_data.get("auto_project_detection", False),
+                }
+
+            except Exception as e:
+                log.error(f"获取凭证失败: {e}")
+                return {"success": False, "error": f"获取凭证失败: {str(e)}"}
+
+    except Exception as e:
+        log.error(f"完成认证流程失败: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def asyncio_complete_auth_flow(
+    project_id: Optional[str] = None, user_session: str = None, mode: str = "geminicli"
+) -> Dict[str, Any]:
+    """异步完成认证流程，支持自动检测项目ID"""
+    try:
+        log.info(
+            f"asyncio_complete_auth_flow开始执行: project_id={project_id}, user_session={user_session}"
+        )
+
+        # 查找对应的认证流程
+        state = None
+        flow_data = None
+
+        log.debug(f"当前所有auth_flows: {list(auth_flows.keys())}")
+
+        # 如果指定了project_id，先尝试匹配指定的项目
+        if project_id:
+            log.info(f"尝试匹配指定的项目ID: {project_id}")
+            for s, data in auth_flows.items():
+                if data["project_id"] == project_id:
+                    # 如果指定了用户会话，优先匹配相同会话的流程
+                    if user_session and data.get("user_session") == user_session:
+                        state = s
+                        flow_data = data
+                        log.info(f"找到匹配的用户会话: {s}")
+                        break
+                    # 如果没有指定会话，或没找到匹配会话的流程，使用第一个匹配项目ID的
+                    elif not state:
+                        state = s
+                        flow_data = data
+                        log.info(f"找到匹配的项目ID: {s}")
+
+        # 如果没有指定项目ID或没找到匹配的，查找需要自动检测项目ID的流程
+        if not state:
+            log.info("没有找到指定项目的流程，查找自动检测流程")
+            # 首先尝试找到已完成的流程（有授权码的）
+            completed_flows = []
+            for s, data in auth_flows.items():
+                if data.get("auto_project_detection", False):
+                    if user_session and data.get("user_session") == user_session:
+                        if data.get("code"):  # 优先选择已完成的
+                            completed_flows.append((s, data, data.get("created_at", 0)))
+
+            # 如果有已完成的流程，选择最新的
+            if completed_flows:
+                completed_flows.sort(key=lambda x: x[2], reverse=True)  # 按时间倒序
+                state, flow_data, _ = completed_flows[0]
+                log.info(f"找到已完成的最新认证流程: {state}")
+            else:
+                # 如果没有已完成的，找最新的未完成流程
+                pending_flows = []
+                for s, data in auth_flows.items():
+                    if data.get("auto_project_detection", False):
+                        if user_session and data.get("user_session") == user_session:
+                            pending_flows.append((s, data, data.get("created_at", 0)))
+                        elif not user_session:
+                            pending_flows.append((s, data, data.get("created_at", 0)))
+
+                if pending_flows:
+                    pending_flows.sort(key=lambda x: x[2], reverse=True)  # 按时间倒序
+                    state, flow_data, _ = pending_flows[0]
+                    log.info(f"找到最新的待完成认证流程: {state}")
+
+        if not state or not flow_data:
+            log.error(f"未找到认证流程: state={state}, flow_data存在={bool(flow_data)}")
+            log.debug(f"当前所有flow_data: {list(auth_flows.keys())}")
+            return {"success": False, "error": "未找到对应的认证流程，请先点击获取认证链接"}
+
+        log.info(f"找到认证流程: state={state}")
+        log.info(
+            f"flow_data内容: project_id={flow_data.get('project_id')}, auto_project_detection={flow_data.get('auto_project_detection')}"
+        )
+        log.info(f"传入的project_id参数: {project_id}")
+
+        # 如果需要自动检测项目ID且没有提供项目ID
+        log.info(
+            f"检查auto_project_detection条件: auto_project_detection={flow_data.get('auto_project_detection', False)}, not project_id={not project_id}"
+        )
+        if flow_data.get("auto_project_detection", False) and not project_id:
+            log.info("跳过自动检测项目ID，进入等待阶段")
+        elif not project_id:
+            log.info("进入project_id检查分支")
+            project_id = flow_data.get("project_id")
+            if not project_id:
+                project_id = DEFAULT_PROJECT_ID
+                flow_data["project_id"] = project_id
+                log.warning(f"缺少项目ID，使用默认project_id: {project_id}")
+        else:
+            log.info(f"使用提供的项目ID: {project_id}")
+
+        # 检查是否已经有授权码
+        log.info("开始检查OAuth授权码...")
+        log.info(f"等待state={state}的授权回调，回调端口: {flow_data.get('callback_port')}")
+        log.info(f"当前flow_data状态: completed={flow_data.get('completed')}, code存在={bool(flow_data.get('code'))}")
+        max_wait_time = 60  # 最多等待60秒
+        wait_interval = 1  # 每秒检查一次
+        waited = 0
+
+        while waited < max_wait_time:
+            if flow_data.get("code"):
+                log.info(f"检测到OAuth授权码，开始处理���证 (等待时间: {waited}秒)")
+                break
+
+            # 每5秒输出一次提示
+            if waited % 5 == 0 and waited > 0:
+                log.info(f"仍在等待OAuth授权... ({waited}/{max_wait_time}秒)")
+                log.debug(f"当前state: {state}, flow_data keys: {list(flow_data.keys())}")
+
+            # 异步等待
+            await asyncio.sleep(wait_interval)
+            waited += wait_interval
+
+            # 刷新flow_data引用，因为可能被回调更新了
+            if state in auth_flows:
+                flow_data = auth_flows[state]
+
+        if not flow_data.get("code"):
+            log.error(f"等待OAuth回调超时，等待了{waited}秒")
+            return {
+                "success": False,
+                "error": "等待OAuth回调超时，请确保完成了浏览器中的认证并看到成功页面",
+            }
+
+        flow = flow_data["flow"]
+        auth_code = flow_data["code"]
+
+        log.info(f"开始使用授权码获取凭证: code={'***' + auth_code[-4:] if auth_code else 'None'}")
+
+        # 使用认证代码获取凭证
+        with _OAuthLibPatcher():
+            try:
+                log.info("调用flow.exchange_code...")
+                credentials = await flow.exchange_code(auth_code)
+                log.info(
+                    f"成功获取凭证，token前缀: {credentials.access_token[:20] if credentials.access_token else 'None'}..."
+                )
+
+                log.info(
+                    f"检查是否需要项目检测: auto_project_detection={flow_data.get('auto_project_detection')}, project_id={project_id}"
+                )
+
+                # 检查凭证模式
+                cred_mode = flow_data.get("mode", "geminicli") if flow_data.get("mode") else mode
+                if cred_mode == "antigravity":
+                    log.info("Antigravity模式：从API获取project_id...")
+                    # 使用API获取project_id
+                    antigravity_url = await get_antigravity_api_url()
+                    project_id, subscription_tier = await fetch_project_id_and_tier(
+                        credentials.access_token,
+                        ANTIGRAVITY_USER_AGENT,
+                        antigravity_url
+                    )
+                    if project_id:
+                        log.info(f"成功从API获取project_id: {project_id}, tier: {subscription_tier}")
+                    else:
+                        project_id = DEFAULT_PROJECT_ID
+                        log.warning(f"无法从API获取project_id，使用默认project_id: {project_id}")
+
+                    # 保存antigravity凭证
+                    saved_filename = await save_credentials(credentials, project_id, mode="antigravity", subscription_tier=subscription_tier)
+
+                    # 准备返回的凭证数据
+                    creds_data = _prepare_credentials_data(credentials, project_id, mode="antigravity", subscription_tier=subscription_tier)
+
+                    # 清理使用过的流程
+                    _cleanup_auth_flow_server(state)
+
+                    log.info("Antigravity OAuth认证成功，凭证已保存")
+                    return {
+                        "success": True,
+                        "credentials": creds_data,
+                        "file_path": saved_filename,
+                        "auto_detected_project": False,
+                        "mode": "antigravity",
+                    }
+
+                # 如果需要自动检测项目ID且没有提供项目ID（标准模式）
+                if flow_data.get("auto_project_detection", False) and not project_id:
+                    log.info("标准模式：从API获取project_id...")
+                    # 使用API获取project_id（使用标准模式的User-Agent）
+                    code_assist_url = await get_code_assist_endpoint()
+                    project_id, subscription_tier = await fetch_project_id_and_tier(
+                        credentials.access_token,
+                        GEMINICLI_USER_AGENT,
+                        code_assist_url
+                    )
+                    if project_id:
+                        flow_data["project_id"] = project_id
+                        log.info(f"成功从API获取project_id: {project_id}")
+                        # 自动启用必需的API服务
+                        log.info("正在自动启用必需的API服务...")
+                        await enable_required_apis(credentials, project_id)
+                    else:
+                        log.warning("无法从API获取project_id，回退到项目列表获取方式")
+                        # 回退到原来的项目列表获取方式
+                        user_projects = await get_user_projects(credentials)
+
+                        if user_projects:
+                            # 如果只有一个项目，自动使用
+                            if len(user_projects) == 1:
+                                # Google API returns projectId in camelCase
+                                project_id = user_projects[0].get("projectId")
+                                if project_id:
+                                    flow_data["project_id"] = project_id
+                                    log.info(f"自动选择唯一项目: {project_id}")
+                                    # 自动启用必需的API服务
+                                    log.info("正在自动启用必需的API服务...")
+                                    await enable_required_apis(credentials, project_id)
+                            # 如果有多个项目，尝试选择默认项目
+                            else:
+                                project_id = await select_default_project(user_projects)
+                                if project_id:
+                                    flow_data["project_id"] = project_id
+                                    log.info(f"自动选择默认项目: {project_id}")
+                                    # 自动启用必需的API服务
+                                    log.info("正在自动启用必需的API服务...")
+                                    await enable_required_apis(credentials, project_id)
+                                else:
+                                    # 返回项目列表让用户选择
+                                    return {
+                                        "success": False,
+                                        "error": "请从以下项目中选择一个",
+                                        "requires_project_selection": True,
+                                        "available_projects": [
+                                            {
+                                                # Google API returns projectId in camelCase
+                                                "project_id": p.get("projectId"),
+                                                "name": p.get("displayName") or p.get("projectId"),
+                                                "projectNumber": p.get("projectNumber"),
+                                            }
+                                            for p in user_projects
+                                        ],
+                                    }
+                        else:
+                            # 如果无法获取项目列表，使用默认project_id
+                            project_id = DEFAULT_PROJECT_ID
+                            flow_data["project_id"] = project_id
+                            log.warning(f"无法获取项目列表，使用默认project_id: {project_id}")
+                elif project_id:
+                    # 如果已经有项目ID（手动提供或环境检测），也尝试启用API服务
+                    log.info("正在为已提供的项目ID自动启用必需的API服务...")
+                    await enable_required_apis(credentials, project_id)
+
+                # 如果仍然没有项目ID，返回错误
+                if not project_id:
+                    project_id = DEFAULT_PROJECT_ID
+                    flow_data["project_id"] = project_id
+                    log.warning(f"仍未获取到project_id，使用默认project_id: {project_id}")
+
+                # 保存凭证
+                saved_filename = await save_credentials(credentials, project_id)
+
+                # 准备返回的凭证数据
+                creds_data = _prepare_credentials_data(credentials, project_id, mode="geminicli")
+
+                # 清理使用过的流程
+                _cleanup_auth_flow_server(state)
+
+                log.info("OAuth认证成功，凭证已保存")
+                return {
+                    "success": True,
+                    "credentials": creds_data,
+                    "file_path": saved_filename,
+                    "auto_detected_project": flow_data.get("auto_project_detection", False),
+                }
+
+            except Exception as e:
+                log.error(f"获取凭证失败: {e}")
+                return {"success": False, "error": f"获取凭证失败: {str(e)}"}
+
+    except Exception as e:
+        log.error(f"异步完成认证流程失败: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def complete_auth_flow_from_callback_url(
+    callback_url: str, project_id: Optional[str] = None, mode: str = "geminicli"
+) -> Dict[str, Any]:
+    """从回调URL直接完成认证流程，无需启动本地服务器"""
+    try:
+        log.info(f"开始从回调URL完成认证: {callback_url}")
+
+        # 解析回调URL
+        parsed_url = urlparse(callback_url)
+        query_params = parse_qs(parsed_url.query)
+
+        # 验证必要参数
+        if "state" not in query_params or "code" not in query_params:
+            return {"success": False, "error": "回调URL缺少必要参数 (state 或 code)"}
+
+        state = query_params["state"][0]
+        code = query_params["code"][0]
+
+        log.info(f"从URL解析到: state={state}, code=xxx...")
+
+        # 检查是否有对应的认证流程
+        if state not in auth_flows:
+            return {
+                "success": False,
+                "error": f"未找到对应的认证流程，请先启动认证 (state: {state})",
+            }
+
+        flow_data = auth_flows[state]
+        flow = flow_data["flow"]
+
+        # 构造回调URL（使用flow中存储的redirect_uri）
+        redirect_uri = flow.redirect_uri
+        log.info(f"使用redirect_uri: {redirect_uri}")
+
+        try:
+            # 使用authorization code获取token
+            credentials = await flow.exchange_code(code)
+            log.info("成功获取访问令牌")
+
+            # 检查凭证模式
+            cred_mode = flow_data.get("mode", "geminicli") if flow_data.get("mode") else mode
+            if cred_mode == "antigravity":
+                log.info("Antigravity模式（从回调URL）：从API获取project_id...")
+                # 使用API获取project_id
+                antigravity_url = await get_antigravity_api_url()
+                project_id, subscription_tier = await fetch_project_id_and_tier(
+                    credentials.access_token,
+                    ANTIGRAVITY_USER_AGENT,
+                    antigravity_url
+                )
+                if project_id:
+                    log.info(f"成功从API获取project_id: {project_id}, tier: {subscription_tier}")
+                else:
+                    project_id = DEFAULT_PROJECT_ID
+                    log.warning(f"无法从API获取project_id，使用默认project_id: {project_id}")
+
+                # 保存antigravity凭证
+                saved_filename = await save_credentials(credentials, project_id, mode="antigravity", subscription_tier=subscription_tier)
+
+                # 准备返回的凭证数据
+                creds_data = _prepare_credentials_data(credentials, project_id, mode="antigravity", subscription_tier=subscription_tier)
+
+                # 清理使用过的流程
+                _cleanup_auth_flow_server(state)
+
+                log.info("从回调URL完成Antigravity OAuth认证成功，凭证已保存")
+                return {
+                    "success": True,
+                    "credentials": creds_data,
+                    "file_path": saved_filename,
+                    "auto_detected_project": False,
+                    "mode": "antigravity",
+                }
+
+            # 标准模式的项目ID处理逻辑
+            detected_project_id = None
+            auto_detected = False
+            subscription_tier = None
+
+            if not project_id:
+                # 尝试使用fetch_project_id_and_tier自动获取项目ID
+                try:
+                    log.info("标准模式：从API获取project_id...")
+                    code_assist_url = await get_code_assist_endpoint()
+                    detected_project_id, subscription_tier = await fetch_project_id_and_tier(
+                        credentials.access_token,
+                        GEMINICLI_USER_AGENT,
+                        code_assist_url
+                    )
+                    if detected_project_id:
+                        auto_detected = True
+                        log.info(f"成功从API获取project_id: {detected_project_id}, tier: {subscription_tier}")
+                    else:
+                        log.warning("无法从API获取project_id，回退到项目列表获取方式")
+                        # 回退到原来的项目列表获取方式
+                        projects = await get_user_projects(credentials)
+                        if projects:
+                            if len(projects) == 1:
+                                # 只有一个项目，自动使用
+                                # Google API returns projectId in camelCase
+                                detected_project_id = projects[0]["projectId"]
+                                auto_detected = True
+                                log.info(f"自动检测到唯一项目ID: {detected_project_id}")
+                            else:
+                                # 多个项目，自动选择第一个
+                                # Google API returns projectId in camelCase
+                                detected_project_id = projects[0]["projectId"]
+                                auto_detected = True
+                                log.info(
+                                    f"检测到{len(projects)}个项目，自动选择第一个: {detected_project_id}"
+                                )
+                                log.debug(f"其他可用项目: {[p['projectId'] for p in projects[1:]]}")
+                        else:
+                            # 没有项目访问权限，使用默认project_id
+                            detected_project_id = DEFAULT_PROJECT_ID
+                            auto_detected = False
+                            log.warning(f"未检测到可访问项目，使用默认project_id: {detected_project_id}")
+                except Exception as e:
+                    log.warning(f"自动检测项目ID失败: {e}，��用默认project_id")
+                    detected_project_id = DEFAULT_PROJECT_ID
+                    auto_detected = False
+            else:
+                detected_project_id = project_id
+
+            # 启用必需的API服务
+            if detected_project_id:
+                try:
+                    log.info(f"正在为项目 {detected_project_id} 启用必需的API服务...")
+                    await enable_required_apis(credentials, detected_project_id)
+                except Exception as e:
+                    log.warning(f"启用API服务失败: {e}")
+
+            # 保存凭证
+            saved_filename = await save_credentials(credentials, detected_project_id, subscription_tier=subscription_tier)
+
+            # 准备返回的凭证数据
+            creds_data = _prepare_credentials_data(credentials, detected_project_id, mode="geminicli", subscription_tier=subscription_tier)
+
+            # 清理使用过的流程
+            _cleanup_auth_flow_server(state)
+
+            log.info("从回调URL完成OAuth认证成功，凭证已保存")
+            return {
+                "success": True,
+                "credentials": creds_data,
+                "file_path": saved_filename,
+                "auto_detected_project": auto_detected,
+            }
+
+        except Exception as e:
+            log.error(f"从回调URL获取凭证失败: {e}")
+            return {"success": False, "error": f"获取凭证失败: {str(e)}"}
+
+    except Exception as e:
+        log.error(f"从回调URL完成认证流程失败: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def save_credentials(creds: Credentials, project_id: str, mode: str = "geminicli", subscription_tier: str = None) -> str:
+    """通过统一存储系统保存凭证"""
+    # 生成文件名（使用project_id和时间戳）
+    timestamp = int(time.time())
+
+    # antigravity模式使用特殊前缀
+    if mode == "antigravity":
+        filename = f"ag_{project_id}-{timestamp}.json"
+    else:
+        filename = f"{project_id}-{timestamp}.json"
+
+    # 准备凭证数据
+    creds_data = _prepare_credentials_data(creds, project_id, mode, subscription_tier)
+
+    # 通过存储适配器保存
+    storage_adapter = await get_storage_adapter()
+    success = await storage_adapter.store_credential(filename, creds_data, mode=mode)
+
+    if success:
+        # 创建默认状态记录
+        try:
+            default_state = {
+                "error_codes": [],
+                "disabled": False,
+                "last_success": time.time(),
+                "user_email": None,
+                "tier": subscription_tier,
+            }
+            await storage_adapter.update_credential_state(filename, default_state, mode=mode)
+            log.info(f"凭证和状态已保存到: {filename} (mode={mode})")
+        except Exception as e:
+            log.warning(f"创建默认状态记录失败 {filename}: {e}")
+
+        return filename
+    else:
+        raise Exception(f"保存凭证失败: {filename}")
+
+
+def async_shutdown_server(server, port):
+    """异步关闭OAuth回调服务器，避免阻塞主流程"""
+
+    def shutdown_server_async():
+        try:
+            # 设置一个标志来跟踪关闭状态
+            shutdown_completed = threading.Event()
+
+            def do_shutdown():
+                try:
+                    server.shutdown()
+                    server.server_close()
+                    shutdown_completed.set()
+                    log.info(f"已关闭端口 {port} 的OAuth回调服务器")
+                except Exception as e:
+                    shutdown_completed.set()
+                    log.debug(f"关闭服务器时出错: {e}")
+
+            # 在单独线程中执行关闭操作
+            shutdown_worker = threading.Thread(target=do_shutdown, daemon=True)
+            shutdown_worker.start()
+
+            # 等待最多5秒，如果超时就放弃等待
+            if shutdown_completed.wait(timeout=5):
+                log.debug(f"端口 {port} 服务器关闭完成")
+            else:
+                log.warning(f"端口 {port} 服务器关闭超时，但不阻塞主流程")
+
+        except Exception as e:
+            log.debug(f"异步关闭服务器时出错: {e}")
+
+    # 在后台线程中关闭服务器，不阻塞主流程
+    shutdown_thread = threading.Thread(target=shutdown_server_async, daemon=True)
+    shutdown_thread.start()
+    log.debug(f"开始异步关闭端口 {port} 的OAuth回调服务器")
+
+
+def cleanup_expired_flows():
+    """清理过期的认证流程"""
+    current_time = time.time()
+    EXPIRY_TIME = 600  # 10分钟过期
+
+    # 直接遍历删除，避免创建额外列表
+    states_to_remove = [
+        state
+        for state, flow_data in auth_flows.items()
+        if current_time - flow_data["created_at"] > EXPIRY_TIME
+    ]
+
+    # 批量清理，提高效率
+    cleaned_count = 0
+    for state in states_to_remove:
+        flow_data = auth_flows.get(state)
+        if flow_data:
+            # 快速关闭可能存在的服务器
+            try:
+                if flow_data.get("server"):
+                    server = flow_data["server"]
+                    port = flow_data.get("callback_port")
+                    async_shutdown_server(server, port)
+            except Exception as e:
+                log.debug(f"清理过期流程时启动异步关闭服务器失败: {e}")
+
+            # 显式清理流程数据，释放内存
+            flow_data.clear()
+            del auth_flows[state]
+            cleaned_count += 1
+
+    if cleaned_count > 0:
+        log.info(f"清理了 {cleaned_count} 个过期的认证流程")
+
+    # 更积极的垃圾回收触发条件
+    if len(auth_flows) > 20:  # 降低阈值
+        import gc
+
+        gc.collect()
+        log.debug(f"触发垃圾回收，当前活跃认证流程数: {len(auth_flows)}")
+
+
+def get_auth_status(project_id: str) -> Dict[str, Any]:
+    """获取认证状态"""
+    for state, flow_data in auth_flows.items():
+        if flow_data["project_id"] == project_id:
+            return {
+                "status": "completed" if flow_data["completed"] else "pending",
+                "state": state,
+                "created_at": flow_data["created_at"],
+            }
+
+    return {"status": "not_found"}
+
+
+# 鉴权功能 - 使用更小的数据结构
+auth_tokens = {}  # 存储有效的认证令牌
+TOKEN_EXPIRY = 3600  # 1小时令牌过期时间
+
+
+async def verify_password(password: str) -> bool:
+    """验证密码（面板登录使用）"""
+    from config import get_panel_password
+
+    correct_password = await get_panel_password()
+    return password == correct_password

src/converter/anthropic2gemini.py

@@ -0,0 +1,1288 @@
+"""
+Anthropic 到 Gemini 格式转换器
+
+提供请求体、响应和流式转换的完整功能。
+"""
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+from fastapi import Response
+from log import log
+from src.converter.utils import merge_system_messages
+
+from src.converter.thoughtSignature_fix import (
+    decode_tool_id_and_signature,
+    is_internal_placeholder_text,
+    is_skip_thought_signature_placeholder,
+    SKIP_THOUGHT_SIGNATURE_VALIDATOR,
+)
+
+DEFAULT_TEMPERATURE = 0.4
+_DEBUG_TRUE = {"1", "true", "yes", "on"}
+
+# ============================================================================
+# Thinking 块验证和清理
+# ============================================================================
+
+# 最小有效签名长度
+MIN_SIGNATURE_LENGTH = 10
+
+
+def has_valid_thoughtsignature(block: Dict[str, Any]) -> bool:
+    """
+    检查 thinking 块是否有有效签名
+    
+    Args:
+        block: content block 字典
+        
+    Returns:
+        bool: 是否有有效签名
+    """
+    if not isinstance(block, dict):
+        return True
+    
+    block_type = block.get("type")
+    if block_type not in ("thinking", "redacted_thinking"):
+        return True  # 非 thinking 块默认有效
+    
+    thinking = block.get("thinking", "")
+    thoughtsignature = block.get("thoughtSignature")
+    
+    # 空 thinking + 任意 thoughtsignature = 有效 (trailing signature case)
+    if not thinking and thoughtsignature is not None:
+        return True
+    
+    # 有内容 + 足够长度的 thoughtsignature = 有效
+    if thoughtsignature and isinstance(thoughtsignature, str) and len(thoughtsignature) >= MIN_SIGNATURE_LENGTH:
+        return True
+    
+    return False
+
+
+def sanitize_thinking_block(block: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    清理 thinking 块,只保留必要字段(移除 cache_control 等)
+    
+    Args:
+        block: content block 字典
+        
+    Returns:
+        清理后的 block 字典
+    """
+    if not isinstance(block, dict):
+        return block
+    
+    block_type = block.get("type")
+    if block_type not in ("thinking", "redacted_thinking"):
+        return block
+    
+    # 重建块,移除额外字段
+    sanitized: Dict[str, Any] = {
+        "type": block_type,
+        "thinking": block.get("thinking", "")
+    }
+    
+    thoughtsignature = block.get("thoughtSignature")
+    if thoughtsignature:
+        sanitized["thoughtSignature"] = thoughtsignature
+    
+    return sanitized
+
+
+def remove_trailing_unsigned_thinking(blocks: List[Dict[str, Any]]) -> None:
+    """
+    移除尾部的无签名 thinking 块
+    
+    Args:
+        blocks: content blocks 列表 (会被修改)
+    """
+    if not blocks:
+        return
+    
+    # 从后向前扫描
+    end_index = len(blocks)
+    for i in range(len(blocks) - 1, -1, -1):
+        block = blocks[i]
+        if not isinstance(block, dict):
+            break
+        
+        block_type = block.get("type")
+        if block_type in ("thinking", "redacted_thinking"):
+            if not has_valid_thoughtsignature(block):
+                end_index = i
+            else:
+                break  # 遇到有效签名的 thinking 块,停止
+        else:
+            break  # 遇到非 thinking 块,停止
+    
+    if end_index < len(blocks):
+        removed = len(blocks) - end_index
+        del blocks[end_index:]
+        log.debug(f"Removed {removed} trailing unsigned thinking block(s)")
+
+
+def filter_invalid_thinking_blocks(messages: List[Dict[str, Any]]) -> None:
+    """
+    过滤消息中的无效 thinking 块，并清理所有 thinking 块的额外字段（如 cache_control）
+
+    Args:
+        messages: Anthropic messages 列表 (会被修改)
+    """
+    total_filtered = 0
+
+    for msg in messages:
+        # 只处理 assistant 和 model 消息
+        role = msg.get("role", "")
+        if role not in ("assistant", "model"):
+            continue
+
+        content = msg.get("content")
+        if not isinstance(content, list):
+            continue
+
+        original_len = len(content)
+        new_blocks: List[Dict[str, Any]] = []
+
+        for block in content:
+            if not isinstance(block, dict):
+                new_blocks.append(block)
+                continue
+
+            block_type = block.get("type")
+            if block_type not in ("thinking", "redacted_thinking"):
+                new_blocks.append(block)
+                continue
+
+            # 所有 thinking 块都需要清理（移除 cache_control 等额外字段）
+            # 检查 thinking 块的有效性
+            if has_valid_thoughtsignature(block):
+                # 有效签名，清理后保留
+                new_blocks.append(sanitize_thinking_block(block))
+            else:
+                # 无效签名，将内容转换为 text 块
+                thinking_text = block.get("thinking", "")
+                if thinking_text and str(thinking_text).strip():
+                    log.info(
+                        f"[Claude-Handler] Converting thinking block with invalid thoughtSignature to text. "
+                        f"Content length: {len(thinking_text)} chars"
+                    )
+                    new_blocks.append({"type": "text", "text": thinking_text})
+                else:
+                    log.debug("[Claude-Handler] Dropping empty thinking block with invalid thoughtSignature")
+
+        msg["content"] = new_blocks
+        filtered_count = original_len - len(new_blocks)
+        total_filtered += filtered_count
+
+        # 如果过滤后为空,添加一个空文本块以保持消息有效
+        if not new_blocks:
+            msg["content"] = [{"type": "text", "text": ""}]
+
+    if total_filtered > 0:
+        log.debug(f"Filtered {total_filtered} invalid thinking block(s) from history")
+
+
+# ============================================================================
+# 请求验证和提取
+# ============================================================================
+
+
+def _anthropic_debug_enabled() -> bool:
+    """检查是否启用 Anthropic 调试模式"""
+    return str(os.getenv("ANTHROPIC_DEBUG", "true")).strip().lower() in _DEBUG_TRUE
+
+
+def _cached_content_token_count(usage_metadata: Any) -> int:
+    if not isinstance(usage_metadata, dict):
+        return 0
+    return int(usage_metadata.get("cachedContentTokenCount", 0) or 0)
+
+
+def _anthropic_usage_from_metadata(usage_metadata: Any) -> Dict[str, int]:
+    if not isinstance(usage_metadata, dict):
+        return {"input_tokens": 0, "output_tokens": 0}
+
+    prompt_tokens_total = int(usage_metadata.get("promptTokenCount", 0) or 0)
+    cached_tokens = _cached_content_token_count(usage_metadata)
+    usage = {
+        "input_tokens": max(prompt_tokens_total - cached_tokens, 0),
+        "output_tokens": int(usage_metadata.get("candidatesTokenCount", 0) or 0),
+    }
+
+    if cached_tokens > 0:
+        usage["cache_read_input_tokens"] = cached_tokens
+
+    return usage
+
+
+def _is_non_whitespace_text(value: Any) -> bool:
+    """
+    判断文本是否包含"非空白"内容。
+
+    说明：下游（Antigravity/Claude 兼容层）会对纯 text 内容块做校验：
+    - text 不能为空字符串
+    - text 不能仅由空白字符（空格/换行/制表等）组成
+    """
+    if value is None:
+        return False
+    try:
+        return bool(str(value).strip())
+    except Exception:
+        return False
+
+
+def _remove_nulls_for_tool_input(value: Any) -> Any:
+    """
+    递归移除 dict/list 中值为 null/None 的字段/元素。
+
+    背景：Roo/Kilo 在 Anthropic native tool 路径下，若收到 tool_use.input 中包含 null，
+    可能会把 null 当作真实入参执行（例如"在 null 中搜索"）。
+    """
+    if isinstance(value, dict):
+        cleaned: Dict[str, Any] = {}
+        for k, v in value.items():
+            if v is None:
+                continue
+            cleaned[k] = _remove_nulls_for_tool_input(v)
+        return cleaned
+
+    if isinstance(value, list):
+        cleaned_list = []
+        for item in value:
+            if item is None:
+                continue
+            cleaned_list.append(_remove_nulls_for_tool_input(item))
+        return cleaned_list
+
+    return value
+
+# ============================================================================
+# 2. JSON Schema 清理
+# ============================================================================
+
+def clean_json_schema(schema: Any) -> Any:
+    """
+    清理 JSON Schema，移除下游不支持的字段，并把验证要求追加到 description。
+    """
+    if not isinstance(schema, dict):
+        return schema
+
+    # 下游不支持的字段
+    unsupported_keys = {
+        "$schema", "$id", "$ref", "$defs", "definitions", "title",
+        "example", "examples", "readOnly", "writeOnly", "default",
+        "exclusiveMaximum", "exclusiveMinimum", "oneOf", "anyOf", "allOf",
+        "const", "additionalItems", "contains", "patternProperties",
+        "dependencies", "propertyNames", "if", "then", "else",
+        "contentEncoding", "contentMediaType", "nullable",
+    }
+
+    validation_fields = {
+        "minLength": "minLength",
+        "maxLength": "maxLength",
+        "minimum": "minimum",
+        "maximum": "maximum",
+        "minItems": "minItems",
+        "maxItems": "maxItems",
+    }
+    fields_to_remove = {"additionalProperties"}
+
+    validations: List[str] = []
+    for field, label in validation_fields.items():
+        if field in schema:
+            validations.append(f"{label}: {schema[field]}")
+
+    cleaned: Dict[str, Any] = {}
+    for key, value in schema.items():
+        if key in unsupported_keys or key in fields_to_remove or key in validation_fields:
+            continue
+
+        if key == "type" and isinstance(value, list):
+            # type: ["string", "null"] -> type: "string", nullable: true
+            has_null = any(
+                isinstance(t, str) and t.strip() and t.strip().lower() == "null" for t in value
+            )
+            non_null_types = [
+                t.strip()
+                for t in value
+                if isinstance(t, str) and t.strip() and t.strip().lower() != "null"
+            ]
+
+            cleaned[key] = non_null_types[0] if non_null_types else "string"
+            continue
+
+        if key == "description" and validations:
+            cleaned[key] = f"{value} ({', '.join(validations)})"
+        elif isinstance(value, dict):
+            cleaned[key] = clean_json_schema(value)
+        elif isinstance(value, list):
+            cleaned[key] = [clean_json_schema(item) if isinstance(item, dict) else item for item in value]
+        else:
+            cleaned[key] = value
+
+    if validations and "description" not in cleaned:
+        cleaned["description"] = f"Validation: {', '.join(validations)}"
+
+    # 如果有 properties 但没有显式 type，则补齐为 object
+    if "properties" in cleaned and "type" not in cleaned:
+        cleaned["type"] = "object"
+
+    if (
+        isinstance(schema.get("properties"), dict)
+        and isinstance(cleaned.get("required"), list)
+    ):
+        nullable_fields = {
+            name
+            for name, prop in schema["properties"].items()
+            if isinstance(prop, dict)
+            and isinstance(prop.get("type"), list)
+            and any(str(t).lower() == "null" for t in prop["type"])
+        }
+        if nullable_fields:
+            cleaned["required"] = [
+                item for item in cleaned["required"]
+                if item not in nullable_fields
+            ]
+            if not cleaned["required"]:
+                cleaned.pop("required", None)
+
+    return cleaned
+
+
+# ============================================================================
+# 4. Tools 转换
+# ============================================================================
+
+def convert_tools(anthropic_tools: Optional[List[Dict[str, Any]]]) -> Optional[List[Dict[str, Any]]]:
+    """
+    将 Anthropic tools[] 转换为下游 tools（functionDeclarations）结构。
+    """
+    if not anthropic_tools:
+        return None
+
+    gemini_tools: List[Dict[str, Any]] = []
+    for tool in anthropic_tools:
+        name = tool.get("name", "nameless_function")
+        description = tool.get("description", "")
+        input_schema = tool.get("input_schema", {}) or {}
+        parameters = clean_json_schema(input_schema)
+
+        gemini_tools.append(
+            {
+                "functionDeclarations": [
+                    {
+                        "name": name,
+                        "description": description,
+                        "parametersJsonSchema": parameters,
+                    }
+                ]
+            }
+        )
+
+    return gemini_tools or None
+
+
+# ============================================================================
+# 5. Messages 转换
+# ============================================================================
+
+def _extract_tool_result_output(content: Any) -> str:
+    """从 tool_result.content 中提取输出字符串"""
+    if isinstance(content, list):
+        if not content:
+            return ""
+        first = content[0]
+        if isinstance(first, dict) and first.get("type") == "text":
+            return str(first.get("text", ""))
+        return str(first)
+    if content is None:
+        return ""
+    return str(content)
+
+
+def convert_messages_to_contents(
+    messages: List[Dict[str, Any]],
+    *,
+    include_thinking: bool = True
+) -> List[Dict[str, Any]]:
+    """
+    将 Anthropic messages[] 转换为下游 contents[]（role: user/model, parts: []）。
+
+    Args:
+        messages: Anthropic 格式的消息列表
+        include_thinking: 是否包含 thinking 块
+    """
+    contents: List[Dict[str, Any]] = []
+
+    # 第一遍：构建 tool_use_id -> (name, thoughtsignature) 的映射
+    # 注意：存储的是编码后的 ID（可能包含签名）
+    tool_use_info: Dict[str, tuple[str, Optional[str]]] = {}
+    for msg in messages:
+        raw_content = msg.get("content", "")
+        if isinstance(raw_content, list):
+            for item in raw_content:
+                if isinstance(item, dict) and item.get("type") == "tool_use":
+                    encoded_tool_id = item.get("id")
+                    tool_name = item.get("name")
+                    if encoded_tool_id and tool_name:
+                        # 解码获取原始ID和签名
+                        original_id, thoughtsignature = decode_tool_id_and_signature(encoded_tool_id)
+                        # 存储映射：编码ID -> (name, thoughtsignature)
+                        tool_use_info[str(encoded_tool_id)] = (tool_name, thoughtsignature)
+
+    for msg in messages:
+        role = msg.get("role", "user")
+        
+        # system 消息已经由 merge_system_messages 处理，这里跳过
+        if role == "system":
+            continue
+        
+        # 支持 'assistant' 和 'model' 角色（Google history usage）
+        gemini_role = "model" if role in ("assistant", "model") else "user"
+        raw_content = msg.get("content", "")
+
+        parts: List[Dict[str, Any]] = []
+        if isinstance(raw_content, str):
+            if _is_non_whitespace_text(raw_content):
+                parts = [{"text": str(raw_content)}]
+        elif isinstance(raw_content, list):
+            for item in raw_content:
+                if not isinstance(item, dict):
+                    if _is_non_whitespace_text(item):
+                        parts.append({"text": str(item)})
+                    continue
+
+                item_type = item.get("type")
+                if item_type == "thinking":
+                    # 不把客户端回传的 thinking signature 再送给 Google。
+                    # 这些签名很容易在中转/换号/裁剪后变成 Corrupted thought signature。
+                    continue
+                elif item_type == "redacted_thinking":
+                    continue
+                elif item_type == "text":
+                    text = item.get("text", "")
+                    if _is_non_whitespace_text(text):
+                        parts.append({"text": str(text)})
+                elif item_type == "image":
+                    source = item.get("source", {}) or {}
+                    if source.get("type") == "base64":
+                        parts.append(
+                            {
+                                "inlineData": {
+                                    "mimeType": source.get("media_type", "image/png"),
+                                    "data": source.get("data", ""),
+                                }
+                            }
+                        )
+                elif item_type == "tool_use":
+                    encoded_id = item.get("id") or ""
+                    original_id, _ = decode_tool_id_and_signature(encoded_id)
+
+                    fc_part: Dict[str, Any] = {
+                        "functionCall": {
+                            "id": original_id,  # 使用原始ID，不带签名
+                            "name": item.get("name"),
+                            "args": item.get("input", {}) or {},
+                        }
+                    }
+
+                    fc_part["thoughtSignature"] = SKIP_THOUGHT_SIGNATURE_VALIDATOR
+
+                    parts.append(fc_part)
+                elif item_type == "tool_result":
+                    output = _extract_tool_result_output(item.get("content"))
+                    encoded_tool_use_id = item.get("tool_use_id") or ""
+                    
+                    # 解码获取原始ID（functionResponse不需要签名）
+                    original_tool_use_id, _ = decode_tool_id_and_signature(encoded_tool_use_id)
+
+                    # 从 tool_result 获取 name，如果没有则从映射中查找
+                    func_name = item.get("name")
+                    if not func_name and encoded_tool_use_id:
+                        # 使用编码ID查找映射
+                        tool_info = tool_use_info.get(str(encoded_tool_use_id))
+                        if tool_info:
+                            func_name = tool_info[0]  # 获取 name
+                    if not func_name:
+                        func_name = "unknown_function"
+                    
+                    parts.append(
+                        {
+                            "functionResponse": {
+                                "id": original_tool_use_id,  # 使用解码后的原始ID以匹配functionCall
+                                "name": func_name,
+                                "response": {"output": output},
+                            }
+                        }
+                    )
+                else:
+                    parts.append({"text": json.dumps(item, ensure_ascii=False)})
+        else:
+            if _is_non_whitespace_text(raw_content):
+                parts = [{"text": str(raw_content)}]
+
+        if not parts:
+            continue
+
+        contents.append({"role": gemini_role, "parts": parts})
+
+    return contents
+
+
+def reorganize_tool_messages(contents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    重新组织消息，满足 tool_use/tool_result 约束。
+    """
+    tool_results: Dict[str, Dict[str, Any]] = {}
+
+    for msg in contents:
+        for part in msg.get("parts", []) or []:
+            if isinstance(part, dict) and "functionResponse" in part:
+                tool_id = (part.get("functionResponse") or {}).get("id")
+                if tool_id:
+                    tool_results[str(tool_id)] = part
+
+    flattened: List[Dict[str, Any]] = []
+    for msg in contents:
+        role = msg.get("role")
+        for part in msg.get("parts", []) or []:
+            flattened.append({"role": role, "parts": [part]})
+
+    new_contents: List[Dict[str, Any]] = []
+    i = 0
+    while i < len(flattened):
+        msg = flattened[i]
+        part = msg["parts"][0]
+
+        if isinstance(part, dict) and "functionResponse" in part:
+            i += 1
+            continue
+
+        if isinstance(part, dict) and "functionCall" in part:
+            tool_id = (part.get("functionCall") or {}).get("id")
+            new_contents.append({"role": "model", "parts": [part]})
+
+            if tool_id is not None and str(tool_id) in tool_results:
+                new_contents.append({"role": "user", "parts": [tool_results[str(tool_id)]]})
+
+            i += 1
+            continue
+
+        new_contents.append(msg)
+        i += 1
+
+    return new_contents
+
+
+# ============================================================================
+# 7. Tool Choice 转换
+# ============================================================================
+
+def convert_tool_choice_to_tool_config(tool_choice: Any) -> Optional[Dict[str, Any]]:
+    """
+    将 Anthropic tool_choice 转换为 Gemini toolConfig
+
+    Args:
+        tool_choice: Anthropic 格式的 tool_choice
+            - {"type": "auto"}: 模型自动决定是否使用工具
+            - {"type": "any"}: 模型必须使用工具
+            - {"type": "tool", "name": "tool_name"}: 模型必须使用指定工具
+
+    Returns:
+        Gemini 格式的 toolConfig，如果无效则返回 None
+    """
+    if not tool_choice:
+        return None
+    
+    if isinstance(tool_choice, dict):
+        choice_type = tool_choice.get("type")
+        
+        if choice_type == "auto":
+            return {"functionCallingConfig": {"mode": "AUTO"}}
+        elif choice_type == "any":
+            return {"functionCallingConfig": {"mode": "ANY"}}
+        elif choice_type == "tool":
+            tool_name = tool_choice.get("name")
+            if tool_name:
+                return {
+                    "functionCallingConfig": {
+                        "mode": "ANY",
+                        "allowedFunctionNames": [tool_name],
+                    }
+                }
+    
+    # 无效或不支持的 tool_choice，返回 None
+    return None
+
+
+# ============================================================================
+# 8. Generation Config 构建
+# ============================================================================
+
+def build_generation_config(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    根据 Anthropic Messages 请求构造下游 generationConfig。
+
+    Returns:
+        generation_config: 生成配置字典
+    """
+    config: Dict[str, Any] = {
+        "topP": 1,
+        "candidateCount": 1,
+        "stopSequences": [
+            "<|user|>",
+            "<|bot|>",
+            "<|context_request|>",
+            "<|endoftext|>",
+            "<|end_of_turn|>",
+        ],
+    }
+
+    temperature = payload.get("temperature", None)
+    config["temperature"] = DEFAULT_TEMPERATURE if temperature is None else temperature
+
+    top_p = payload.get("top_p", None)
+    if top_p is not None:
+        config["topP"] = top_p
+
+    top_k = payload.get("top_k", None)
+    if top_k is not None:
+        config["topK"] = top_k
+
+    max_tokens = payload.get("max_tokens")
+    if max_tokens is not None:
+        config["maxOutputTokens"] = max_tokens
+
+    # 处理 extended thinking 参数 (plan mode)
+    thinking = payload.get("thinking")
+    is_plan_mode = False
+    if thinking and isinstance(thinking, dict):
+        thinking_type = thinking.get("type")
+        budget_tokens = thinking.get("budget_tokens")
+        
+        # 如果启用了 extended thinking，设置 thinkingConfig
+        if thinking_type == "enabled":
+            is_plan_mode = True
+            thinking_config: Dict[str, Any] = {}
+            
+            # 设置思考预算，默认使用较大的值以支持计划模式
+            if budget_tokens is not None:
+                thinking_config["thinkingBudget"] = budget_tokens
+            else:
+                # 默认给一个较大的思考预算以支持完整的计划生成
+                thinking_config["thinkingBudget"] = 48000
+            
+            # 始终包含思考内容，这样才能看到计划
+            thinking_config["includeThoughts"] = True
+            
+            config["thinkingConfig"] = thinking_config
+            log.info(f"[ANTHROPIC2GEMINI] Extended thinking enabled with budget: {thinking_config['thinkingBudget']}")
+        elif thinking_type == "disabled":
+            # 明确禁用思考模式
+            config["thinkingConfig"] = {
+                "includeThoughts": False
+            }
+            log.info("[ANTHROPIC2GEMINI] Extended thinking explicitly disabled")
+
+    stop_sequences = payload.get("stop_sequences")
+    if isinstance(stop_sequences, list) and stop_sequences:
+        config["stopSequences"] = config["stopSequences"] + [str(s) for s in stop_sequences]
+    elif is_plan_mode:
+        # Plan mode 时清空默认 stop sequences，避免过早停止
+        # 默认的 stop sequences 可能会导致模型在生成计划时过早停止
+        config["stopSequences"] = []
+        log.info("[ANTHROPIC2GEMINI] Plan mode: cleared default stop sequences to prevent premature stopping")
+    
+    # 如果不是 plan mode 且没有自定义 stop_sequences，保持默认值
+    # (默认值已经在 config 初始化时设置)
+
+    return config
+
+
+# ============================================================================
+# 8. 主要转换函数
+# ============================================================================
+
+async def anthropic_to_gemini_request(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    将 Anthropic 格式请求体转换为 Gemini 格式请求体
+
+    注意: 此函数只负责基础转换，不包含 normalize_gemini_request 中的处理
+    (如 thinking config 自动设置、search tools、参数范围限制等)
+
+    Args:
+        payload: Anthropic 格式的请求体字典
+
+    Returns:
+        Gemini 格式的请求体字典，包含:
+        - contents: 转换后的消息内容
+        - generationConfig: 生成配置
+        - systemInstruction: 系统指令 (如果有)
+        - tools: 工具定义 (如果有)
+        - toolConfig: 工具调用配置 (如果有 tool_choice)
+    """
+    # 处理连续的system消息（兼容性模式）
+    payload = await merge_system_messages(payload)
+
+    # 提取和转换基础信息
+    messages = payload.get("messages") or []
+    if not isinstance(messages, list):
+        messages = []
+    
+    # [CRITICAL FIX] 过滤并修复 Thinking 块签名
+    # 在转换前先过滤无效的 thinking 块
+    filter_invalid_thinking_blocks(messages)
+
+    # 构建生成配置
+    generation_config = build_generation_config(payload)
+
+    # 转换消息内容（始终包含thinking块，由响应端处理）
+    contents = convert_messages_to_contents(messages, include_thinking=True)
+    
+    # [CRITICAL FIX] 移除尾部无签名的 thinking 块
+    # 对真实请求应用额外的清理
+    for content in contents:
+        role = content.get("role", "")
+        if role == "model":  # 只处理 model/assistant 消息
+            parts = content.get("parts", [])
+            if isinstance(parts, list):
+                remove_trailing_unsigned_thinking(parts)
+    
+    contents = reorganize_tool_messages(contents)
+
+    # 转换工具
+    tools = convert_tools(payload.get("tools"))
+    
+    # 转换 tool_choice
+    tool_config = convert_tool_choice_to_tool_config(payload.get("tool_choice"))
+
+    # 构建基础请求数据
+    gemini_request = {
+        "contents": contents,
+        "generationConfig": generation_config,
+    }
+    
+    # 如果 merge_system_messages 已经添加了 systemInstruction，使用它
+    if "systemInstruction" in payload:
+        gemini_request["systemInstruction"] = payload["systemInstruction"]
+    
+    if tools:
+        gemini_request["tools"] = tools
+
+    # 添加 toolConfig（如果有 tool_choice）
+    if tool_config:
+        gemini_request["toolConfig"] = tool_config
+
+    # 透传图片生成的 size 参数（如 "1024x1536"）
+    if "size" in payload and payload["size"]:
+        gemini_request["size"] = payload["size"]
+
+    return gemini_request
+
+
+def gemini_to_anthropic_response(
+    gemini_response: Dict[str, Any],
+    model: str,
+    status_code: int = 200
+) -> Dict[str, Any]:
+    """
+    将 Gemini 格式非流式响应转换为 Anthropic 格式非流式响应
+
+    注意: 如果收到的不是 200 开头的响应体，不做任何处理，直接转发
+
+    Args:
+        gemini_response: Gemini 格式的响应体字典
+        model: 模型名称
+        status_code: HTTP 状态码 (默认 200)
+
+    Returns:
+        Anthropic 格式的响应体字典，或原始响应 (如果状态码不是 2xx)
+    """
+    # 非 2xx 状态码直接返回原始响应
+    if not (200 <= status_code < 300):
+        return gemini_response
+
+    # 处理 GeminiCLI 的 response 包装格式
+    if "response" in gemini_response:
+        response_data = gemini_response["response"]
+    else:
+        response_data = gemini_response
+
+    # 提取候选结果
+    candidate = response_data.get("candidates", [{}])[0] or {}
+    parts = candidate.get("content", {}).get("parts", []) or []
+
+    # 获取 usage metadata
+    usage_metadata = {}
+    if "usageMetadata" in response_data:
+        usage_metadata = response_data["usageMetadata"]
+    elif "usageMetadata" in candidate:
+        usage_metadata = candidate["usageMetadata"]
+
+    # 转换内容块
+    content = []
+    has_tool_use = False
+
+    for part in parts:
+        if not isinstance(part, dict):
+            continue
+
+        # 处理 thinking 块
+        if part.get("thought") is True:
+            if is_skip_thought_signature_placeholder(part):
+                continue
+            thinking_text = part.get("text", "")
+            if thinking_text is None:
+                thinking_text = ""
+            
+            block: Dict[str, Any] = {"type": "thinking", "thinking": str(thinking_text)}
+            
+            # 如果有 thoughtsignature 则添加
+            thoughtsignature = part.get("thoughtSignature")
+            if thoughtsignature:
+                block["thoughtSignature"] = thoughtsignature
+            
+            content.append(block)
+            continue
+
+        # 处理文本块
+        if "text" in part:
+            text = part.get("text", "")
+            if (
+                is_skip_thought_signature_placeholder(part)
+                or is_internal_placeholder_text(text)
+            ):
+                continue
+            content.append({"type": "text", "text": text})
+            continue
+
+        # 处理工具调用
+        if "functionCall" in part:
+            has_tool_use = True
+            fc = part.get("functionCall", {}) or {}
+            original_id = fc.get("id") or f"toolu_{uuid.uuid4().hex}"
+            content.append(
+                {
+                    "type": "tool_use",
+                    "id": original_id,
+                    "name": fc.get("name") or "",
+                    "input": _remove_nulls_for_tool_input(fc.get("args", {}) or {}),
+                }
+            )
+            continue
+
+        # 处理图片
+        if "inlineData" in part:
+            inline = part.get("inlineData", {}) or {}
+            content.append(
+                {
+                    "type": "image",
+                    "source": {
+                        "type": "base64",
+                        "media_type": inline.get("mimeType", "image/png"),
+                        "data": inline.get("data", ""),
+                    },
+                }
+            )
+            continue
+
+    # 确定停止原因
+    finish_reason = candidate.get("finishReason")
+    
+    # 只有在正常停止（STOP）且有工具调用时才设为 tool_use
+    # 避免在 SAFETY、MAX_TOKENS 等情况下仍然返回 tool_use 导致循环
+    if has_tool_use and finish_reason == "STOP":
+        stop_reason = "tool_use"
+    elif finish_reason == "MAX_TOKENS":
+        stop_reason = "max_tokens"
+    else:
+        # 其他情况（SAFETY、RECITATION 等）默认为 end_turn
+        stop_reason = "end_turn"
+
+    # 提取 token 使用情况
+    usage = _anthropic_usage_from_metadata(usage_metadata)
+
+    # 构建 Anthropic 响应
+    message_id = f"msg_{uuid.uuid4().hex}"
+
+    return {
+        "id": message_id,
+        "type": "message",
+        "role": "assistant",
+        "model": model,
+        "content": content,
+        "stop_reason": stop_reason,
+        "stop_sequence": None,
+        "usage": usage,
+    }
+
+
+async def gemini_stream_to_anthropic_stream(
+    gemini_stream: AsyncIterator[bytes],
+    model: str,
+    status_code: int = 200
+) -> AsyncIterator[bytes]:
+    """
+    将 Gemini 格式流式响应转换为 Anthropic SSE 格式流式响应
+
+    注意: 如果收到的不是 200 开头的响应体，不做任何处理，直接转发
+
+    Args:
+        gemini_stream: Gemini 格式的流式响应 (bytes 迭代器)
+        model: 模型名称
+        status_code: HTTP 状态码 (默认 200)
+
+    Yields:
+        Anthropic SSE 格式的响应块 (bytes)
+    """
+    # 非 2xx 状态码直接转发原始流
+    if not (200 <= status_code < 300):
+        async for chunk in gemini_stream:
+            yield chunk
+        return
+
+    # 初始化状态
+    message_id = f"msg_{uuid.uuid4().hex}"
+    message_start_sent = False
+    current_block_type: Optional[str] = None
+    current_block_index = -1
+    current_thinking_signature: Optional[str] = None
+    has_tool_use = False
+    input_tokens = 0
+    output_tokens = 0
+    cached_input_tokens = 0
+    finish_reason: Optional[str] = None
+
+    def _sse_event(event: str, data: Dict[str, Any]) -> bytes:
+        """生成 SSE 事件"""
+        payload = json.dumps(data, ensure_ascii=False, separators=(",", ":"))
+        return f"event: {event}\ndata: {payload}\n\n".encode("utf-8")
+
+    def _close_block() -> Optional[bytes]:
+        """关闭当前内容块"""
+        nonlocal current_block_type
+        if current_block_type is None:
+            return None
+        event = _sse_event(
+            "content_block_stop",
+            {"type": "content_block_stop", "index": current_block_index},
+        )
+        current_block_type = None
+        return event
+
+    def _usage_payload() -> Dict[str, int]:
+        usage = {"input_tokens": input_tokens, "output_tokens": output_tokens}
+        if cached_input_tokens > 0:
+            usage["cache_read_input_tokens"] = cached_input_tokens
+        return usage
+
+    # 处理流式数据
+    try:
+        async for chunk in gemini_stream:
+            # 检查是否是 Response 对象（错误情况）
+            if isinstance(chunk, Response):
+                log.warning(f"[GEMINI_TO_ANTHROPIC] 收到 Response 对象，状态码: {chunk.status_code}，直接转发错误")
+                # 直接转发错误响应内容，不做格式转换
+                error_content = chunk.body if isinstance(chunk.body, bytes) else chunk.body.encode('utf-8')
+                yield error_content
+                return
+
+            # 记录接收到的原始chunk
+            log.debug(f"[GEMINI_TO_ANTHROPIC] Raw chunk: {chunk[:200] if chunk else b''}")
+
+            # 解析 Gemini 流式块
+            if not chunk or not chunk.startswith(b"data: "):
+                log.debug(f"[GEMINI_TO_ANTHROPIC] Skipping chunk (not SSE format or empty)")
+                continue
+
+            raw = chunk[6:].strip()
+            if raw == b"[DONE]":
+                log.debug(f"[GEMINI_TO_ANTHROPIC] Received [DONE] marker")
+                break
+
+            log.debug(f"[GEMINI_TO_ANTHROPIC] Parsing JSON: {raw[:200]}")
+
+            try:
+                data = json.loads(raw.decode('utf-8', errors='ignore'))
+                log.debug(f"[GEMINI_TO_ANTHROPIC] Parsed data: {json.dumps(data, ensure_ascii=False)[:300]}")
+            except Exception as e:
+                log.warning(f"[GEMINI_TO_ANTHROPIC] JSON parse error: {e}")
+                continue
+
+            # 处理 GeminiCLI 的 response 包装格式
+            if "response" in data:
+                response = data["response"]
+            else:
+                response = data
+
+            candidate = (response.get("candidates", []) or [{}])[0] or {}
+            parts = (candidate.get("content", {}) or {}).get("parts", []) or []
+
+            # 更新 usage metadata
+            if "usageMetadata" in response:
+                usage = response["usageMetadata"]
+                if isinstance(usage, dict):
+                    if "promptTokenCount" in usage:
+                        prompt_tokens_total = int(usage.get("promptTokenCount", 0) or 0)
+                        input_tokens = max(prompt_tokens_total - cached_input_tokens, 0)
+                    if "candidatesTokenCount" in usage:
+                        output_tokens = int(usage.get("candidatesTokenCount", 0) or 0)
+                    if "cachedContentTokenCount" in usage:
+                        cached_input_tokens = int(usage.get("cachedContentTokenCount", 0) or 0)
+                        input_tokens = max(
+                            int(usage.get("promptTokenCount", 0) or 0) - cached_input_tokens,
+                            0,
+                        )
+
+            # 发送 message_start（仅一次）
+            if not message_start_sent:
+                message_start_sent = True
+                yield _sse_event(
+                    "message_start",
+                    {
+                        "type": "message_start",
+                        "message": {
+                            "id": message_id,
+                            "type": "message",
+                            "role": "assistant",
+                            "model": model,
+                            "content": [],
+                            "stop_reason": None,
+                            "stop_sequence": None,
+                            "usage": _usage_payload(),
+                        },
+                    },
+                )
+
+            # 处理各种 parts
+            for part in parts:
+                if not isinstance(part, dict):
+                    continue
+
+                # 处理 thinking 块
+                if part.get("thought") is True:
+                    if is_skip_thought_signature_placeholder(part):
+                        continue
+                    thinking_text = part.get("text", "")
+                    thoughtsignature = part.get("thoughtSignature")
+                    
+                    # 检查是否需要关闭上一个块并开启新的 thinking 块
+                    if current_block_type != "thinking":
+                        close_evt = _close_block()
+                        if close_evt:
+                            yield close_evt
+
+                        current_block_index += 1
+                        current_block_type = "thinking"
+                        current_thinking_signature = thoughtsignature
+
+                        block: Dict[str, Any] = {"type": "thinking", "thinking": ""}
+                        if thoughtsignature:
+                            block["thoughtSignature"] = thoughtsignature
+                        yield _sse_event(
+                            "content_block_start",
+                            {
+                                "type": "content_block_start",
+                                "index": current_block_index,
+                                "content_block": block,
+                            },
+                        )
+                    elif thoughtsignature and thoughtsignature != current_thinking_signature:
+                        # 签名变化，需要开启新的 thinking 块
+                        close_evt = _close_block()
+                        if close_evt:
+                            yield close_evt
+                        
+                        current_block_index += 1
+                        current_block_type = "thinking"
+                        current_thinking_signature = thoughtsignature
+                        
+                        block_new: Dict[str, Any] = {"type": "thinking", "thinking": ""}
+                        if thoughtsignature:
+                            block_new["thoughtSignature"] = thoughtsignature
+                        
+                        yield _sse_event(
+                            "content_block_start",
+                            {
+                                "type": "content_block_start",
+                                "index": current_block_index,
+                                "content_block": block_new,
+                            },
+                        )
+
+                    # 发送 thinking 文本增量
+                    if thinking_text:
+                        yield _sse_event(
+                            "content_block_delta",
+                            {
+                                "type": "content_block_delta",
+                                "index": current_block_index,
+                                "delta": {"type": "thinking_delta", "thinking": thinking_text},
+                            },
+                        )
+                    continue
+
+                # 处理文本块
+                if "text" in part:
+                    if (
+                        is_skip_thought_signature_placeholder(part)
+                        or is_internal_placeholder_text(part.get("text"))
+                    ):
+                        continue
+                    text = part.get("text", "")
+                    if isinstance(text, str) and not text.strip():
+                        continue
+
+                    if current_block_type != "text":
+                        close_evt = _close_block()
+                        if close_evt:
+                            yield close_evt
+
+                        current_block_index += 1
+                        current_block_type = "text"
+
+                        yield _sse_event(
+                            "content_block_start",
+                            {
+                                "type": "content_block_start",
+                                "index": current_block_index,
+                                "content_block": {"type": "text", "text": ""},
+                            },
+                        )
+
+                    if text:
+                        yield _sse_event(
+                            "content_block_delta",
+                            {
+                                "type": "content_block_delta",
+                                "index": current_block_index,
+                                "delta": {"type": "text_delta", "text": text},
+                            },
+                        )
+                    continue
+
+                # 处理工具调用
+                if "functionCall" in part:
+                    close_evt = _close_block()
+                    if close_evt:
+                        yield close_evt
+
+                    has_tool_use = True
+                    fc = part.get("functionCall", {}) or {}
+                    original_id = fc.get("id") or f"toolu_{uuid.uuid4().hex}"
+                    tool_id = original_id
+                    tool_name = fc.get("name") or ""
+                    tool_args = _remove_nulls_for_tool_input(fc.get("args", {}) or {})
+
+                    if _anthropic_debug_enabled():
+                        log.info(
+                            f"[ANTHROPIC][tool_use] 处理工具调用: name={tool_name}, "
+                            f"id={tool_id}"
+                        )
+
+                    current_block_index += 1
+                    # 注意：工具调用不设置 current_block_type，因为它是独立完整的块
+
+                    yield _sse_event(
+                        "content_block_start",
+                        {
+                            "type": "content_block_start",
+                            "index": current_block_index,
+                            "content_block": {
+                                "type": "tool_use",
+                                "id": tool_id,
+                                "name": tool_name,
+                                "input": {},
+                            },
+                        },
+                    )
+
+                    input_json = json.dumps(tool_args, ensure_ascii=False, separators=(",", ":"))
+                    yield _sse_event(
+                        "content_block_delta",
+                        {
+                            "type": "content_block_delta",
+                            "index": current_block_index,
+                            "delta": {"type": "input_json_delta", "partial_json": input_json},
+                        },
+                    )
+
+                    yield _sse_event(
+                        "content_block_stop",
+                        {"type": "content_block_stop", "index": current_block_index},
+                    )
+                    # 工具调用块已完全关闭，current_block_type 保持为 None
+                    
+                    if _anthropic_debug_enabled():
+                        log.info(f"[ANTHROPIC][tool_use] 工具调用块已关闭: index={current_block_index}")
+                    
+                    continue
+
+            # 检查是否结束
+            if candidate.get("finishReason"):
+                finish_reason = candidate.get("finishReason")
+                break
+
+        # 关闭最后的内容块
+        close_evt = _close_block()
+        if close_evt:
+            yield close_evt
+
+        # 确定停止原因
+        # 只有在正常停止（STOP）且有工具调用时才设为 tool_use
+        # 避免在 SAFETY、MAX_TOKENS 等情况下仍然返回 tool_use 导致循环
+        if has_tool_use and finish_reason == "STOP":
+            stop_reason = "tool_use"
+        elif finish_reason == "MAX_TOKENS":
+            stop_reason = "max_tokens"
+        else:
+            # 其他情况（SAFETY、RECITATION 等）默认为 end_turn
+            stop_reason = "end_turn"
+
+        if _anthropic_debug_enabled():
+            log.info(
+                f"[ANTHROPIC][stream_end] 流式结束: stop_reason={stop_reason}, "
+                f"has_tool_use={has_tool_use}, finish_reason={finish_reason}, "
+                f"input_tokens={input_tokens}, output_tokens={output_tokens}"
+            )
+
+        # 发送 message_delta 和 message_stop
+        yield _sse_event(
+            "message_delta",
+            {
+                "type": "message_delta",
+                "delta": {"stop_reason": stop_reason, "stop_sequence": None},
+                "usage": _usage_payload(),
+            },
+        )
+
+        yield _sse_event("message_stop", {"type": "message_stop"})
+
+    except Exception as e:
+        log.error(f"[ANTHROPIC] 流式转换失败: {e}")
+        # 发送错误事件
+        if not message_start_sent:
+            yield _sse_event(
+                "message_start",
+                {
+                    "type": "message_start",
+                    "message": {
+                        "id": message_id,
+                        "type": "message",
+                        "role": "assistant",
+                        "model": model,
+                        "content": [],
+                        "stop_reason": None,
+                        "stop_sequence": None,
+                        "usage": _usage_payload(),
+                    },
+                },
+            )
+        yield _sse_event(
+            "error",
+            {"type": "error", "error": {"type": "api_error", "message": str(e)}},
+        )

src/converter/anti_truncation.py

@@ -0,0 +1,731 @@
+"""
+Anti-Truncation Module - Ensures complete streaming output
+保持一个流式请求内完整输出的反截断模块
+"""
+
+import io
+import json
+import re
+from typing import Any, AsyncGenerator, Dict, List, Tuple
+
+from fastapi.responses import StreamingResponse
+
+from log import log
+
+# 反截断配置
+DONE_MARKER = "[done]"
+CONTINUATION_PROMPT = f"""请从刚才被截断的地方继续输出剩余的所有内容。
+
+重要提醒：
+1. 不要重复前面已经输出的内容
+2. 直接继续输出，无需任何前言或解释
+3. 当你完整完成所有内容输出后，必须在最后一行单独输出：{DONE_MARKER}
+4. {DONE_MARKER} 标记表示你的回答已经完全结束，这是必需的结束标记
+
+现在请继续输出："""
+
+# 正则替换配置
+REGEX_REPLACEMENTS: List[Tuple[str, str, str]] = [
+    (
+        "age_pattern",  # 替换规则名称
+        r"(?:[1-9]|1[0-8])岁(?:的)?|(?:十一|十二|十三|十四|十五|十六|十七|十八|十|一|二|三|四|五|六|七|八|九)岁(?:的)?",  # 正则模式
+        "",  # 替换文本
+    ),
+    # 可在此处添加更多替换规则
+    # ("rule_name", r"pattern", "replacement"),
+]
+
+
+def apply_regex_replacements(text: str) -> str:
+    """
+    对文本应用正则替换规则
+
+    Args:
+        text: 要处理的文本
+
+    Returns:
+        处理后的文本
+    """
+    if not text:
+        return text
+
+    processed_text = text
+    replacement_count = 0
+
+    for rule_name, pattern, replacement in REGEX_REPLACEMENTS:
+        try:
+            # 编译正则表达式，使用IGNORECASE标志
+            regex = re.compile(pattern, re.IGNORECASE)
+
+            # 执行替换
+            new_text, count = regex.subn(replacement, processed_text)
+
+            if count > 0:
+                log.debug(f"Regex replacement '{rule_name}': {count} matches replaced")
+                processed_text = new_text
+                replacement_count += count
+
+        except re.error as e:
+            log.error(f"Invalid regex pattern in rule '{rule_name}': {e}")
+            continue
+
+    if replacement_count > 0:
+        log.info(f"Applied {replacement_count} regex replacements to text")
+
+    return processed_text
+
+
+def apply_regex_replacements_to_payload(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    对请求payload中的文本内容应用正则替换
+
+    Args:
+        payload: 请求payload
+
+    Returns:
+        应用替换后的payload
+    """
+    if not REGEX_REPLACEMENTS:
+        return payload
+
+    modified_payload = payload.copy()
+    request_data = modified_payload.get("request", {})
+
+    # 处理contents中的文本
+    contents = request_data.get("contents", [])
+    if contents:
+        new_contents = []
+        for content in contents:
+            if isinstance(content, dict):
+                new_content = content.copy()
+                parts = new_content.get("parts", [])
+                if parts:
+                    new_parts = []
+                    for part in parts:
+                        if isinstance(part, dict) and "text" in part:
+                            new_part = part.copy()
+                            new_part["text"] = apply_regex_replacements(part["text"])
+                            new_parts.append(new_part)
+                        else:
+                            new_parts.append(part)
+                    new_content["parts"] = new_parts
+                new_contents.append(new_content)
+            else:
+                new_contents.append(content)
+
+        request_data["contents"] = new_contents
+        modified_payload["request"] = request_data
+        log.debug("Applied regex replacements to request contents")
+
+    return modified_payload
+
+
+def apply_anti_truncation(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    对请求payload应用反截断处理和正则替换
+    在systemInstruction中添加提醒，要求模型在结束时输出DONE_MARKER标记
+
+    Args:
+        payload: 原始请求payload
+
+    Returns:
+        添加了反截断指令并应用了正则替换的payload
+    """
+    # 首先应用正则替换
+    modified_payload = apply_regex_replacements_to_payload(payload)
+    request_data = modified_payload.get("request", {})
+
+    # 获取或创建systemInstruction
+    system_instruction = request_data.get("systemInstruction", {})
+    if not system_instruction:
+        system_instruction = {"parts": []}
+    elif "parts" not in system_instruction:
+        system_instruction["parts"] = []
+
+    # 添加反截断指令
+    anti_truncation_instruction = {
+        "text": f"""严格执行以下输出结束规则：
+
+1. 当你完成完整回答时，必须在输出的最后单独一行输出：{DONE_MARKER}
+2. {DONE_MARKER} 标记表示你的回答已经完全结束，这是必需的结束标记
+3. 只有输出了 {DONE_MARKER} 标记，系统才认为你的回答是完整的
+4. 如果你的回答被截断，系统会要求你继续输出剩余内容
+5. 无论回答长短，都必须以 {DONE_MARKER} 标记结束
+
+示例格式：
+```
+你的回答内容...
+更多回答内容...
+{DONE_MARKER}
+```
+
+注意：{DONE_MARKER} 必须单独占一行，前面不要有任何其他字符。
+
+这个规则对于确保输出完整性极其重要，请严格遵守。"""
+    }
+
+    # 检查是否已经包含反截断指令
+    has_done_instruction = any(
+        part.get("text", "").find(DONE_MARKER) != -1
+        for part in system_instruction["parts"]
+        if isinstance(part, dict)
+    )
+
+    if not has_done_instruction:
+        system_instruction["parts"].append(anti_truncation_instruction)
+        request_data["systemInstruction"] = system_instruction
+        modified_payload["request"] = request_data
+
+        log.debug("Applied anti-truncation instruction to request")
+
+    return modified_payload
+
+
+class AntiTruncationStreamProcessor:
+    """反截断流式处理器"""
+
+    def __init__(
+        self,
+        original_request_func,
+        payload: Dict[str, Any],
+        max_attempts: int = 3,
+        enable_prefill_mode: bool = False,
+    ):
+        self.original_request_func = original_request_func
+        self.base_payload = payload.copy()
+        self.max_attempts = max_attempts
+        self.enable_prefill_mode = enable_prefill_mode
+        # 使用 StringIO 避免字符串拼接的内存问题
+        self.collected_content = io.StringIO()
+        self.current_attempt = 0
+
+    def _get_collected_text(self) -> str:
+        """获取收集的文本内容"""
+        return self.collected_content.getvalue()
+
+    def _append_content(self, content: str):
+        """追加内容到收集器"""
+        if content:
+            self.collected_content.write(content)
+
+    def _clear_content(self):
+        """清空收集的内容，释放内存"""
+        self.collected_content.close()
+        self.collected_content = io.StringIO()
+
+    async def process_stream(self) -> AsyncGenerator[bytes, None]:
+        """处理流式响应，检测并处理截断"""
+
+        while self.current_attempt < self.max_attempts:
+            self.current_attempt += 1
+
+            # 构建当前请求payload
+            current_payload = self._build_current_payload()
+
+            log.debug(f"Anti-truncation attempt {self.current_attempt}/{self.max_attempts}")
+
+            # 发送请求
+            try:
+                response = await self.original_request_func(current_payload)
+
+                if not isinstance(response, StreamingResponse):
+                    # 非流式响应，直接处理
+                    yield await self._handle_non_streaming_response(response)
+                    return
+
+                # 处理流式响应（按行处理）
+                chunk_buffer = io.StringIO()  # 使用 StringIO 缓存当前轮次的chunk
+                found_done_marker = False
+
+                async for line in response.body_iterator:
+                    if not line:
+                        yield line
+                        continue
+
+                    # 处理上游生成器 yield 出 Response 对象的情况（错误响应）
+                    from fastapi import Response as FastAPIResponse
+                    if isinstance(line, FastAPIResponse):
+                        log.error(f"Anti-truncation: Received Response object from stream (status={line.status_code}), treating as error")
+                        error_chunk = {
+                            "error": {
+                                "message": line.body.decode('utf-8', errors='ignore') if hasattr(line, 'body') and line.body else "Upstream error",
+                                "type": "api_error",
+                                "code": line.status_code,
+                            }
+                        }
+                        yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+                        yield b"data: [DONE]\n\n"
+                        return
+
+                    # 处理 bytes 类型的流式数据
+                    if isinstance(line, bytes):
+                        # 解码 bytes 为字符串
+                        line_str = line.decode('utf-8', errors='ignore').strip()
+                    else:
+                        line_str = str(line).strip()
+
+                    # 跳过空行
+                    if not line_str:
+                        yield line
+                        continue
+
+                    # 处理 SSE 格式的数据行
+                    if line_str.startswith("data: "):
+                        payload_str = line_str[6:]  # 去掉 "data: " 前缀
+
+                        # 检查是否是 [DONE] 标记
+                        if payload_str.strip() == "[DONE]":
+                            if found_done_marker:
+                                log.info("Anti-truncation: Found [done] marker, output complete")
+                                yield line
+                                # 清理内存
+                                chunk_buffer.close()
+                                self._clear_content()
+                                return
+                            else:
+                                log.warning("Anti-truncation: Stream ended without [done] marker")
+                                # 不发送[DONE]，准备继续
+                                break
+
+                        # 尝试解析 JSON 数据
+                        try:
+                            data = json.loads(payload_str)
+                            content = self._extract_content_from_chunk(data)
+
+                            log.debug(f"Anti-truncation: Extracted content: {repr(content[:100] if content else '')}")
+
+                            if content:
+                                chunk_buffer.write(content)
+
+                                # 检查是否包含done标记
+                                has_marker = self._check_done_marker_in_chunk_content(content)
+                                log.debug(f"Anti-truncation: Check done marker result: {has_marker}, DONE_MARKER='{DONE_MARKER}'")
+                                if has_marker:
+                                    found_done_marker = True
+                                    log.debug(f"Anti-truncation: Found [done] marker in chunk, content: {content[:200]}")
+
+                            # 清理行中的[done]标记后再发送
+                            cleaned_line = self._remove_done_marker_from_line(line, line_str, data)
+                            yield cleaned_line
+
+                        except (json.JSONDecodeError, ValueError):
+                            # 无法解析的行，直接传递
+                            yield line
+                            continue
+                    else:
+                        # 非 data: 开头的行，直接传递
+                        yield line
+
+                # 更新收集的内容 - 使用 StringIO 高效处理
+                chunk_text = chunk_buffer.getvalue()
+                if chunk_text:
+                    self._append_content(chunk_text)
+                chunk_buffer.close()
+
+                log.debug(f"Anti-truncation: After processing stream, found_done_marker={found_done_marker}")
+
+                # 如果找到了done标记，结束
+                if found_done_marker:
+                    # 立即清理内容释放内存
+                    self._clear_content()
+                    yield b"data: [DONE]\n\n"
+                    return
+
+                # 只有在单个chunk中没有找到done标记时，才检查累积内容（防止done标记跨chunk出现）
+                if not found_done_marker:
+                    accumulated_text = self._get_collected_text()
+                    if self._check_done_marker_in_text(accumulated_text):
+                        log.info("Anti-truncation: Found [done] marker in accumulated content")
+                        # 立即清理内容释放内存
+                        self._clear_content()
+                        yield b"data: [DONE]\n\n"
+                        return
+
+                # 如果没找到done标记且不是最后一次尝试，准备续传
+                if self.current_attempt < self.max_attempts:
+                    accumulated_text = self._get_collected_text()
+                    total_length = len(accumulated_text)
+                    log.info(
+                        f"Anti-truncation: No [done] marker found in output (length: {total_length}), preparing continuation (attempt {self.current_attempt + 1})"
+                    )
+                    if total_length > 100:
+                        log.debug(
+                            f"Anti-truncation: Current collected content ends with: ...{accumulated_text[-100:]}"
+                        )
+                    # 在下一次循环中会继续
+                    continue
+                else:
+                    # 最后一次尝试，直接结束
+                    log.warning("Anti-truncation: Max attempts reached, ending stream")
+                    # 立即清理内容释放内存
+                    self._clear_content()
+                    yield b"data: [DONE]\n\n"
+                    return
+
+            except Exception as e:
+                log.error(f"Anti-truncation error in attempt {self.current_attempt}: {str(e)}")
+                if self.current_attempt >= self.max_attempts:
+                    # 发送错误chunk
+                    error_chunk = {
+                        "error": {
+                            "message": f"Anti-truncation failed: {str(e)}",
+                            "type": "api_error",
+                            "code": 500,
+                        }
+                    }
+                    yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+                    yield b"data: [DONE]\n\n"
+                    return
+                # 否则继续下一次尝试
+
+        # 如果所有尝试都失败了
+        log.error("Anti-truncation: All attempts failed")
+        # 清理内存
+        self._clear_content()
+        yield b"data: [DONE]\n\n"
+
+    def _build_current_payload(self) -> Dict[str, Any]:
+        """构建当前请求的payload"""
+        if self.current_attempt == 1:
+            # 第一次请求，使用原始payload（已经包含反截断指令）
+            return self.base_payload
+
+        # 后续请求，添加续传指令
+        continuation_payload = self.base_payload.copy()
+        request_data = continuation_payload.get("request", {})
+
+        # 获取原始对话内容
+        contents = request_data.get("contents", [])
+        new_contents = contents.copy()
+
+        # 如果有收集到的内容，添加到对话中
+        accumulated_text = self._get_collected_text()
+        if accumulated_text:
+            new_contents.append({"role": "model", "parts": [{"text": accumulated_text}]})
+
+        # 预填充模式：直接用拼接内容作为末尾 model 预填充，不再增加 user 续写指令
+        if self.enable_prefill_mode:
+            log.debug("Anti-truncation: Using prefill continuation mode (no user continuation prompt)")
+            request_data["contents"] = new_contents
+            continuation_payload["request"] = request_data
+            return continuation_payload
+
+        # 构建具体的续写指令，包含前面的内容摘要
+        content_summary = ""
+        if accumulated_text:
+            if len(accumulated_text) > 200:
+                content_summary = f'\n\n前面你已经输出了约 {len(accumulated_text)} 个字符的内容，结尾是：\n"...{accumulated_text[-100:]}"'
+            else:
+                content_summary = f'\n\n前面你已经输出的内容是：\n"{accumulated_text}"'
+
+        detailed_continuation_prompt = f"""{CONTINUATION_PROMPT}{content_summary}"""
+
+        # 添加继续指令
+        continuation_message = {"role": "user", "parts": [{"text": detailed_continuation_prompt}]}
+        new_contents.append(continuation_message)
+
+        request_data["contents"] = new_contents
+        continuation_payload["request"] = request_data
+
+        return continuation_payload
+
+    def _extract_content_from_chunk(self, data: Dict[str, Any]) -> str:
+        """从chunk数据中提取文本内容"""
+        content = ""
+
+        # 先尝试解包 response 字段（Gemini API 格式）
+        if "response" in data:
+            data = data["response"]
+
+        # 处理 Gemini 格式
+        if "candidates" in data:
+            for candidate in data["candidates"]:
+                if "content" in candidate:
+                    parts = candidate["content"].get("parts", [])
+                    for part in parts:
+                        if "text" in part:
+                            content += part["text"]
+        
+        # 处理 OpenAI 流式格式（choices/delta）
+        elif "choices" in data:
+            for choice in data["choices"]:
+                if "delta" in choice and "content" in choice["delta"]:
+                    delta_content = choice["delta"]["content"]
+                    if delta_content:
+                        content += delta_content
+
+        return content
+
+    async def _handle_non_streaming_response(self, response) -> bytes:
+        """处理非流式响应 - 使用循环代替递归避免栈溢出"""
+        # 使用循环代替递归
+        while True:
+            try:
+                # 特殊处理：如果返回的是StreamingResponse，需要读取其body_iterator
+                if isinstance(response, StreamingResponse):
+                    log.error("Anti-truncation: Received StreamingResponse in non-streaming handler - this should not happen")
+                    # 尝试读取流式响应的内容
+                    chunks = []
+                    async for chunk in response.body_iterator:
+                        chunks.append(chunk)
+                    content = b"".join(chunks).decode() if chunks else ""
+                # 提取响应内容
+                elif hasattr(response, "body"):
+                    content = (
+                        response.body.decode() if isinstance(response.body, bytes) else response.body
+                    )
+                elif hasattr(response, "content"):
+                    content = (
+                        response.content.decode()
+                        if isinstance(response.content, bytes)
+                        else response.content
+                    )
+                else:
+                    log.error(f"Anti-truncation: Unknown response type: {type(response)}")
+                    content = str(response)
+
+                # 验证内容不为空
+                if not content or not content.strip():
+                    log.error("Anti-truncation: Received empty response content")
+                    return json.dumps(
+                        {
+                            "error": {
+                                "message": "Empty response from server",
+                                "type": "api_error",
+                                "code": 500,
+                            }
+                        }
+                    ).encode()
+
+                # 尝试解析 JSON
+                try:
+                    response_data = json.loads(content)
+                except json.JSONDecodeError as json_err:
+                    log.error(f"Anti-truncation: Failed to parse JSON response: {json_err}, content: {content[:200]}")
+                    # 如果不是 JSON，直接返回原始内容
+                    return content.encode() if isinstance(content, str) else content
+
+                # 检查是否包含done标记
+                text_content = self._extract_content_from_response(response_data)
+                has_done_marker = self._check_done_marker_in_text(text_content)
+
+                if has_done_marker or self.current_attempt >= self.max_attempts:
+                    # 找到done标记或达到最大尝试次数，返回结果
+                    return content.encode() if isinstance(content, str) else content
+
+                # 需要继续，收集内容并构建下一个请求
+                if text_content:
+                    self._append_content(text_content)
+
+                log.info("Anti-truncation: Non-streaming response needs continuation")
+
+                # 增加尝试次数
+                self.current_attempt += 1
+
+                # 构建续传payload并发送下一个请求
+                next_payload = self._build_current_payload()
+                response = await self.original_request_func(next_payload)
+
+                # 继续循环处理下一个响应
+
+            except Exception as e:
+                log.error(f"Anti-truncation non-streaming error: {str(e)}")
+                return json.dumps(
+                    {
+                        "error": {
+                            "message": f"Anti-truncation failed: {str(e)}",
+                            "type": "api_error",
+                            "code": 500,
+                        }
+                    }
+                ).encode()
+
+    def _check_done_marker_in_text(self, text: str) -> bool:
+        """检测文本中是否包含DONE_MARKER（只检测指定标记）"""
+        if not text:
+            return False
+
+        # 只要文本中出现DONE_MARKER即可
+        return DONE_MARKER in text
+
+    def _check_done_marker_in_chunk_content(self, content: str) -> bool:
+        """检查单个chunk内容中是否包含done标记"""
+        return self._check_done_marker_in_text(content)
+
+    def _extract_content_from_response(self, data: Dict[str, Any]) -> str:
+        """从响应数据中提取文本内容"""
+        content = ""
+
+        # 先尝试解包 response 字段（Gemini API 格式）
+        if "response" in data:
+            data = data["response"]
+
+        # 处理Gemini格式
+        if "candidates" in data:
+            for candidate in data["candidates"]:
+                if "content" in candidate:
+                    parts = candidate["content"].get("parts", [])
+                    for part in parts:
+                        if "text" in part:
+                            content += part["text"]
+
+        # 处理OpenAI格式
+        elif "choices" in data:
+            for choice in data["choices"]:
+                if "message" in choice and "content" in choice["message"]:
+                    content += choice["message"]["content"]
+
+        return content
+
+    def _remove_done_marker_from_line(self, line: bytes, line_str: str, data: Dict[str, Any]) -> bytes:
+        """从行中移除[done]标记"""
+        try:
+            # 首先检查是否真的包含[done]标记
+            if "[done]" not in line_str.lower():
+                return line  # 没有[done]标记，直接返回原始行
+
+            log.info(f"Anti-truncation: Attempting to remove [done] marker from line")
+            log.debug(f"Anti-truncation: Original line (first 200 chars): {line_str[:200]}")
+
+            # 编译正则表达式，匹配[done]标记（忽略大小写，包括可能的空白字符）
+            done_pattern = re.compile(r"\s*\[done\]\s*", re.IGNORECASE)
+
+            # 检查是否有 response 包裹层
+            has_response_wrapper = "response" in data
+            log.debug(f"Anti-truncation: has_response_wrapper={has_response_wrapper}, data keys={list(data.keys())}")
+            if has_response_wrapper:
+                # 需要保留外层的 response 字段
+                inner_data = data["response"]
+            else:
+                inner_data = data
+            
+            log.debug(f"Anti-truncation: inner_data keys={list(inner_data.keys())}")
+
+            log.debug(f"Anti-truncation: inner_data keys={list(inner_data.keys())}")
+
+            # 处理Gemini格式
+            if "candidates" in inner_data:
+                log.info(f"Anti-truncation: Processing Gemini format to remove [done] marker")
+                modified_inner = inner_data.copy()
+                modified_inner["candidates"] = []
+
+                for i, candidate in enumerate(inner_data["candidates"]):
+                    modified_candidate = candidate.copy()
+                    # 只在最后一个candidate中清理[done]标记
+                    is_last_candidate = i == len(inner_data["candidates"]) - 1
+
+                    if "content" in candidate:
+                        modified_content = candidate["content"].copy()
+                        if "parts" in modified_content:
+                            modified_parts = []
+                            for part in modified_content["parts"]:
+                                if "text" in part and isinstance(part["text"], str):
+                                    modified_part = part.copy()
+                                    original_text = part["text"]
+                                    # 只在最后一个candidate中清理[done]标记
+                                    if is_last_candidate:
+                                        modified_part["text"] = done_pattern.sub("", part["text"])
+                                        if "[done]" in original_text.lower():
+                                            log.debug(f"Anti-truncation: Removed [done] from text: '{original_text[:100]}' -> '{modified_part['text'][:100]}'")
+                                    modified_parts.append(modified_part)
+                                else:
+                                    modified_parts.append(part)
+                            modified_content["parts"] = modified_parts
+                        modified_candidate["content"] = modified_content
+                    modified_inner["candidates"].append(modified_candidate)
+
+                # 如果有 response 包裹层，需要重新包装
+                if has_response_wrapper:
+                    modified_data = data.copy()
+                    modified_data["response"] = modified_inner
+                else:
+                    modified_data = modified_inner
+
+                # 重新编码为行格式 - SSE格式需要两个换行符
+                json_str = json.dumps(modified_data, separators=(",", ":"), ensure_ascii=False)
+                result = f"data: {json_str}\n\n".encode("utf-8")
+                log.debug(f"Anti-truncation: Modified line (first 200 chars): {result.decode('utf-8', errors='ignore')[:200]}")
+                return result
+
+            # 处理OpenAI格式
+            elif "choices" in inner_data:
+                modified_inner = inner_data.copy()
+                modified_inner["choices"] = []
+
+                for choice in inner_data["choices"]:
+                    modified_choice = choice.copy()
+                    if "delta" in choice and "content" in choice["delta"]:
+                        modified_delta = choice["delta"].copy()
+                        modified_delta["content"] = done_pattern.sub("", choice["delta"]["content"])
+                        modified_choice["delta"] = modified_delta
+                    elif "message" in choice and "content" in choice["message"]:
+                        modified_message = choice["message"].copy()
+                        modified_message["content"] = done_pattern.sub("", choice["message"]["content"])
+                        modified_choice["message"] = modified_message
+                    modified_inner["choices"].append(modified_choice)
+
+                # 如果有 response 包裹层，需要重新包装
+                if has_response_wrapper:
+                    modified_data = data.copy()
+                    modified_data["response"] = modified_inner
+                else:
+                    modified_data = modified_inner
+
+                # 重新编码为行格式 - SSE格式需要两个换行符
+                json_str = json.dumps(modified_data, separators=(",", ":"), ensure_ascii=False)
+                return f"data: {json_str}\n\n".encode("utf-8")
+
+            # 如果没有找到支持的格式，返回原始行
+            return line
+
+        except Exception as e:
+            log.warning(f"Failed to remove [done] marker from line: {str(e)}")
+            return line
+
+
+async def apply_anti_truncation_to_stream(
+    request_func,
+    payload: Dict[str, Any],
+    max_attempts: int = 3,
+    enable_prefill_mode: bool = False,
+) -> StreamingResponse:
+    """
+    对流式请求应用反截断处理
+
+    Args:
+        request_func: 原始请求函数
+        payload: 请求payload
+        max_attempts: 最大续传尝试次数
+        enable_prefill_mode: 是否启用预填充模式。启用后续传请求不再添加 user 续写指令，
+            而是将已收集内容作为末尾 model 内容进行预填充
+
+    Returns:
+        处理后的StreamingResponse
+    """
+
+    # 首先对payload应用反截断指令
+    anti_truncation_payload = apply_anti_truncation(payload)
+
+    # 创建反截断处理器
+    processor = AntiTruncationStreamProcessor(
+        lambda p: request_func(p),
+        anti_truncation_payload,
+        max_attempts,
+        enable_prefill_mode,
+    )
+
+    # 返回包装后的流式响应
+    return StreamingResponse(processor.process_stream(), media_type="text/event-stream")
+
+
+def is_anti_truncation_enabled(request_data: Dict[str, Any]) -> bool:
+    """
+    检查请求是否启用了反截断功能
+
+    Args:
+        request_data: 请求数据
+
+    Returns:
+        是否启用反截断
+    """
+    return request_data.get("enable_anti_truncation", False)

src/converter/fake_stream.py

@@ -0,0 +1,537 @@
+from typing import Any, Dict, List, Tuple
+import json
+from src.converter.utils import extract_content_and_reasoning
+from log import log
+from src.converter.openai2gemini import _convert_usage_metadata
+
+def safe_get_nested(obj: Any, *keys: str, default: Any = None) -> Any:
+    """安全获取嵌套字典值
+    
+    Args:
+        obj: 字典对象
+        *keys: 嵌套键路径
+        default: 默认值
+    
+    Returns:
+        获取到的值或默认值
+    """
+    for key in keys:
+        if not isinstance(obj, dict):
+            return default
+        obj = obj.get(key, default)
+        if obj is default:
+            return default
+    return obj
+
+def parse_response_for_fake_stream(response_data: Dict[str, Any]) -> tuple:
+    """从完整响应中提取内容和推理内容(用于假流式)
+
+    Args:
+        response_data: Gemini API 响应数据
+
+    Returns:
+        (content, reasoning_content, finish_reason, images): 内容、推理内容、结束原因和图片数据的元组
+    """
+    import json
+
+    # 处理GeminiCLI的response包装格式
+    if "response" in response_data and "candidates" not in response_data:
+        log.debug(f"[FAKE_STREAM] Unwrapping response field")
+        response_data = response_data["response"]
+
+    candidates = response_data.get("candidates", [])
+    log.debug(f"[FAKE_STREAM] Found {len(candidates)} candidates")
+    if not candidates:
+        return "", "", "STOP", []
+
+    candidate = candidates[0]
+    finish_reason = candidate.get("finishReason", "STOP")
+    parts = safe_get_nested(candidate, "content", "parts", default=[])
+    log.debug(f"[FAKE_STREAM] Extracted {len(parts)} parts: {json.dumps(parts, ensure_ascii=False)}")
+    content, reasoning_content, images = extract_content_and_reasoning(parts)
+    log.debug(f"[FAKE_STREAM] Content length: {len(content)}, Reasoning length: {len(reasoning_content)}, Images count: {len(images)}")
+
+    return content, reasoning_content, finish_reason, images
+
+def extract_fake_stream_content(response: Any) -> Tuple[str, str, Dict[str, int]]:
+    """
+    从 Gemini 非流式响应中提取内容，用于假流式处理
+    
+    Args:
+        response: Gemini API 响应对象
+    
+    Returns:
+        (content, reasoning_content, usage) 元组
+    """
+    from src.converter.utils import extract_content_and_reasoning
+    
+    # 解析响应体
+    if hasattr(response, "body"):
+        body_str = (
+            response.body.decode()
+            if isinstance(response.body, bytes)
+            else str(response.body)
+        )
+    elif hasattr(response, "content"):
+        body_str = (
+            response.content.decode()
+            if isinstance(response.content, bytes)
+            else str(response.content)
+        )
+    else:
+        body_str = str(response)
+
+    try:
+        response_data = json.loads(body_str)
+
+        # GeminiCLI 返回的格式是 {"response": {...}, "traceId": "..."}
+        # 需要先提取 response 字段
+        if "response" in response_data:
+            gemini_response = response_data["response"]
+        else:
+            gemini_response = response_data
+
+        # 从Gemini响应中提取内容，使用思维链分离逻辑
+        content = ""
+        reasoning_content = ""
+        images = []
+        if "candidates" in gemini_response and gemini_response["candidates"]:
+            # Gemini格式响应 - 使用思维链分离
+            candidate = gemini_response["candidates"][0]
+            if "content" in candidate and "parts" in candidate["content"]:
+                parts = candidate["content"]["parts"]
+                content, reasoning_content, images = extract_content_and_reasoning(parts)
+        elif "choices" in gemini_response and gemini_response["choices"]:
+            # OpenAI格式响应
+            content = gemini_response["choices"][0].get("message", {}).get("content", "")
+
+        # 如果没有正常内容但有思维内容，给出警告
+        if not content and reasoning_content:
+            log.warning("Fake stream response contains only thinking content")
+            content = "[模型正在思考中，请稍后再试或重新提问]"
+        
+        # 如果完全没有内容，提供默认回复
+        if not content:
+            log.warning(f"No content found in response: {gemini_response}")
+            content = "[响应为空，请重新尝试]"
+
+        # 转换usageMetadata为OpenAI格式
+        usage = _convert_usage_metadata(gemini_response.get("usageMetadata"))
+        
+        return content, reasoning_content, usage
+
+    except json.JSONDecodeError:
+        # 如果不是JSON，直接返回原始文本
+        return body_str, "", None
+
+def _build_candidate(parts: List[Dict[str, Any]], finish_reason: str = "STOP") -> Dict[str, Any]:
+    """构建标准候选响应结构
+    
+    Args:
+        parts: parts 列表
+        finish_reason: 结束原因
+    
+    Returns:
+        候选响应字典
+    """
+    return {
+        "candidates": [{
+            "content": {"parts": parts, "role": "model"},
+            "finishReason": finish_reason,
+            "index": 0,
+        }]
+    }
+
+def create_openai_heartbeat_chunk() -> Dict[str, Any]:
+    """
+    创建 OpenAI 格式的心跳块（用于假流式）
+    
+    Returns:
+        心跳响应块字典
+    """
+    return {
+        "choices": [
+            {
+                "index": 0,
+                "delta": {"role": "assistant", "content": ""},
+                "finish_reason": None,
+            }
+        ]
+    }
+
+def build_gemini_fake_stream_chunks(content: str, reasoning_content: str, finish_reason: str, images: List[Dict[str, Any]] = None, chunk_size: int = 50) -> List[Dict[str, Any]]:
+    """构建假流式响应的数据块
+
+    Args:
+        content: 主要内容
+        reasoning_content: 推理内容
+        finish_reason: 结束原因
+        images: 图片数据列表（可选）
+        chunk_size: 每个chunk的字符数（默认50）
+
+    Returns:
+        响应数据块列表
+    """
+    if images is None:
+        images = []
+
+    log.debug(f"[build_gemini_fake_stream_chunks] Input - content: {repr(content)}, reasoning: {repr(reasoning_content)}, finish_reason: {finish_reason}, images count: {len(images)}")
+    chunks = []
+
+    # 如果没有正常内容但有思维内容,提供默认回复
+    if not content:
+        default_text = "[模型正在思考中,请稍后再试或重新提问]" if reasoning_content else "[响应为空,请重新尝试]"
+        return [_build_candidate([{"text": default_text}], finish_reason)]
+
+    # 分块发送主要内容
+    first_chunk = True
+    for i in range(0, len(content), chunk_size):
+        chunk_text = content[i:i + chunk_size]
+        is_last_chunk = (i + chunk_size >= len(content)) and not reasoning_content
+        chunk_finish_reason = finish_reason if is_last_chunk else None
+
+        # 如果是第一个chunk且有图片，将图片包含在parts中
+        parts = []
+        if first_chunk and images:
+            # 在Gemini格式中，需要将image_url格式转换为inlineData格式
+            for img in images:
+                if img.get("type") == "image_url":
+                    url = img.get("image_url", {}).get("url", "")
+                    # 解析 data URL: data:{mime_type};base64,{data}
+                    if url.startswith("data:"):
+                        parts_of_url = url.split(";base64,")
+                        if len(parts_of_url) == 2:
+                            mime_type = parts_of_url[0].replace("data:", "")
+                            base64_data = parts_of_url[1]
+                            parts.append({
+                                "inlineData": {
+                                    "mimeType": mime_type,
+                                    "data": base64_data
+                                }
+                            })
+            first_chunk = False
+
+        parts.append({"text": chunk_text})
+        chunk_data = _build_candidate(parts, chunk_finish_reason)
+        log.debug(f"[build_gemini_fake_stream_chunks] Generated chunk: {chunk_data}")
+        chunks.append(chunk_data)
+
+    # 如果有推理内容，分块发送
+    if reasoning_content:
+        for i in range(0, len(reasoning_content), chunk_size):
+            chunk_text = reasoning_content[i:i + chunk_size]
+            is_last_chunk = i + chunk_size >= len(reasoning_content)
+            chunk_finish_reason = finish_reason if is_last_chunk else None
+            chunks.append(_build_candidate([{"text": chunk_text, "thought": True}], chunk_finish_reason))
+
+    log.debug(f"[build_gemini_fake_stream_chunks] Total chunks generated: {len(chunks)}")
+    return chunks
+
+
+def create_gemini_heartbeat_chunk() -> Dict[str, Any]:
+    """创建 Gemini 格式的心跳数据块
+
+    Returns:
+        心跳数据块
+    """
+    chunk = _build_candidate([{"text": ""}])
+    chunk["candidates"][0]["finishReason"] = None
+    return chunk
+
+
+def build_openai_fake_stream_chunks(content: str, reasoning_content: str, finish_reason: str, model: str, images: List[Dict[str, Any]] = None, chunk_size: int = 50) -> List[Dict[str, Any]]:
+    """构建 OpenAI 格式的假流式响应数据块
+
+    Args:
+        content: 主要内容
+        reasoning_content: 推理内容
+        finish_reason: 结束原因（如 "STOP", "MAX_TOKENS"）
+        model: 模型名称
+        images: 图片数据列表（可选）
+        chunk_size: 每个chunk的字符数（默认50）
+
+    Returns:
+        OpenAI 格式的响应数据块列表
+    """
+    import time
+    import uuid
+
+    if images is None:
+        images = []
+
+    log.debug(f"[build_openai_fake_stream_chunks] Input - content: {repr(content)}, reasoning: {repr(reasoning_content)}, finish_reason: {finish_reason}, images count: {len(images)}")
+    chunks = []
+    response_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
+    created = int(time.time())
+
+    # 映射 Gemini finish_reason 到 OpenAI 格式
+    openai_finish_reason = None
+    if finish_reason == "STOP":
+        openai_finish_reason = "stop"
+    elif finish_reason == "MAX_TOKENS":
+        openai_finish_reason = "length"
+    elif finish_reason in ["SAFETY", "RECITATION"]:
+        openai_finish_reason = "content_filter"
+
+    # 如果没有正常内容但有思维内容，提供默认回复
+    if not content:
+        default_text = "[模型正在思考中，请稍后再试或重新提问]" if reasoning_content else "[响应为空，请重新尝试]"
+        return [{
+            "id": response_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "delta": {"content": default_text},
+                "finish_reason": openai_finish_reason,
+            }]
+        }]
+
+    # 分块发送主要内容
+    first_chunk = True
+    for i in range(0, len(content), chunk_size):
+        chunk_text = content[i:i + chunk_size]
+        is_last_chunk = (i + chunk_size >= len(content)) and not reasoning_content
+        chunk_finish = openai_finish_reason if is_last_chunk else None
+
+        delta_content = {}
+
+        # 如果是第一个chunk且有图片，构建包含图片的content数组
+        if first_chunk and images:
+            delta_content["content"] = images + [{"type": "text", "text": chunk_text}]
+            first_chunk = False
+        else:
+            delta_content["content"] = chunk_text
+
+        chunk_data = {
+            "id": response_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "delta": delta_content,
+                "finish_reason": chunk_finish,
+            }]
+        }
+        log.debug(f"[build_openai_fake_stream_chunks] Generated chunk: {chunk_data}")
+        chunks.append(chunk_data)
+
+    # 如果有推理内容，分块发送（使用 reasoning_content 字段）
+    if reasoning_content:
+        for i in range(0, len(reasoning_content), chunk_size):
+            chunk_text = reasoning_content[i:i + chunk_size]
+            is_last_chunk = i + chunk_size >= len(reasoning_content)
+            chunk_finish = openai_finish_reason if is_last_chunk else None
+
+            chunks.append({
+                "id": response_id,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{
+                    "index": 0,
+                    "delta": {"reasoning_content": chunk_text},
+                    "finish_reason": chunk_finish,
+                }]
+            })
+
+    log.debug(f"[build_openai_fake_stream_chunks] Total chunks generated: {len(chunks)}")
+    return chunks
+
+
+def create_anthropic_heartbeat_chunk() -> Dict[str, Any]:
+    """
+    创建 Anthropic 格式的心跳块（用于假流式）
+
+    Returns:
+        心跳响应块字典
+    """
+    return {
+        "type": "ping"
+    }
+
+
+def build_anthropic_fake_stream_chunks(content: str, reasoning_content: str, finish_reason: str, model: str, images: List[Dict[str, Any]] = None, chunk_size: int = 50) -> List[Dict[str, Any]]:
+    """构建 Anthropic 格式的假流式响应数据块
+
+    Args:
+        content: 主要内容
+        reasoning_content: 推理内容（thinking content）
+        finish_reason: 结束原因（如 "STOP", "MAX_TOKENS"）
+        model: 模型名称
+        images: 图片数据列表（可选）
+        chunk_size: 每个chunk的字符数（默认50）
+
+    Returns:
+        Anthropic SSE 格式的响应数据块列表
+    """
+    import uuid
+
+    if images is None:
+        images = []
+
+    log.debug(f"[build_anthropic_fake_stream_chunks] Input - content: {repr(content)}, reasoning: {repr(reasoning_content)}, finish_reason: {finish_reason}, images count: {len(images)}")
+    chunks = []
+    message_id = f"msg_{uuid.uuid4().hex}"
+
+    # 映射 Gemini finish_reason 到 Anthropic 格式
+    anthropic_stop_reason = "end_turn"
+    if finish_reason == "MAX_TOKENS":
+        anthropic_stop_reason = "max_tokens"
+    elif finish_reason in ["SAFETY", "RECITATION"]:
+        anthropic_stop_reason = "end_turn"
+
+    # 1. 发送 message_start 事件
+    chunks.append({
+        "type": "message_start",
+        "message": {
+            "id": message_id,
+            "type": "message",
+            "role": "assistant",
+            "model": model,
+            "content": [],
+            "stop_reason": None,
+            "stop_sequence": None,
+            "usage": {"input_tokens": 0, "output_tokens": 0}
+        }
+    })
+
+    # 如果没有正常内容但有思维内容，提供默认回复
+    if not content:
+        default_text = "[模型正在思考中，请稍后再试或重新提问]" if reasoning_content else "[响应为空，请重新尝试]"
+
+        # content_block_start
+        chunks.append({
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": {"type": "text", "text": ""}
+        })
+
+        # content_block_delta
+        chunks.append({
+            "type": "content_block_delta",
+            "index": 0,
+            "delta": {"type": "text_delta", "text": default_text}
+        })
+
+        # content_block_stop
+        chunks.append({
+            "type": "content_block_stop",
+            "index": 0
+        })
+
+        # message_delta
+        chunks.append({
+            "type": "message_delta",
+            "delta": {"stop_reason": anthropic_stop_reason, "stop_sequence": None},
+            "usage": {"output_tokens": 0}
+        })
+
+        # message_stop
+        chunks.append({
+            "type": "message_stop"
+        })
+
+        return chunks
+
+    block_index = 0
+
+    # 2. 如果有推理内容，先发送 thinking 块
+    if reasoning_content:
+        # thinking content_block_start
+        chunks.append({
+            "type": "content_block_start",
+            "index": block_index,
+            "content_block": {"type": "thinking", "thinking": ""}
+        })
+
+        # 分块发送推理内容
+        for i in range(0, len(reasoning_content), chunk_size):
+            chunk_text = reasoning_content[i:i + chunk_size]
+            chunks.append({
+                "type": "content_block_delta",
+                "index": block_index,
+                "delta": {"type": "thinking_delta", "thinking": chunk_text}
+            })
+
+        # thinking content_block_stop
+        chunks.append({
+            "type": "content_block_stop",
+            "index": block_index
+        })
+
+        block_index += 1
+
+    # 3. 如果有图片，发送图片块
+    if images:
+        for img in images:
+            if img.get("type") == "image_url":
+                url = img.get("image_url", {}).get("url", "")
+                # 解析 data URL: data:{mime_type};base64,{data}
+                if url.startswith("data:"):
+                    parts_of_url = url.split(";base64,")
+                    if len(parts_of_url) == 2:
+                        mime_type = parts_of_url[0].replace("data:", "")
+                        base64_data = parts_of_url[1]
+
+                        # image content_block_start
+                        chunks.append({
+                            "type": "content_block_start",
+                            "index": block_index,
+                            "content_block": {
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": mime_type,
+                                    "data": base64_data
+                                }
+                            }
+                        })
+
+                        # image content_block_stop
+                        chunks.append({
+                            "type": "content_block_stop",
+                            "index": block_index
+                        })
+
+                        block_index += 1
+
+    # 4. 发送主要内容（text 块）
+    # text content_block_start
+    chunks.append({
+        "type": "content_block_start",
+        "index": block_index,
+        "content_block": {"type": "text", "text": ""}
+    })
+
+    # 分块发送主要内容
+    for i in range(0, len(content), chunk_size):
+        chunk_text = content[i:i + chunk_size]
+        chunks.append({
+            "type": "content_block_delta",
+            "index": block_index,
+            "delta": {"type": "text_delta", "text": chunk_text}
+        })
+
+    # text content_block_stop
+    chunks.append({
+        "type": "content_block_stop",
+        "index": block_index
+    })
+
+    # 5. 发送 message_delta
+    chunks.append({
+        "type": "message_delta",
+        "delta": {"stop_reason": anthropic_stop_reason, "stop_sequence": None},
+        "usage": {"output_tokens": len(content) + len(reasoning_content)}
+    })
+
+    # 6. 发送 message_stop
+    chunks.append({
+        "type": "message_stop"
+    })
+
+    log.debug(f"[build_anthropic_fake_stream_chunks] Total chunks generated: {len(chunks)}")
+    return chunks

src/converter/gemini_fix.py

@@ -0,0 +1,859 @@
+"""
+Gemini Format Utilities - 统一的 Gemini 格式处理和转换工具
+提供对 Gemini API 请求体和响应的标准化处理
+────────────────────────────────────────────────────────────────
+"""
+import json
+from math import e
+from typing import Any, Dict, Optional
+
+from log import log
+from src.converter.thoughtSignature_fix import SKIP_THOUGHT_SIGNATURE_VALIDATOR
+
+# ==================== Gemini API 配置 ====================
+
+# ====================== Model Configuration ======================
+
+# Default Safety Settings for Google API
+DEFAULT_SAFETY_SETTINGS = [
+    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_CIVIC_INTEGRITY", "threshold": "BLOCK_NONE"},
+]
+
+LITE_SAFETY_SETTINGS = [
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_CIVIC_INTEGRITY", "threshold": "BLOCK_NONE"},
+]
+
+def _append_schema_hint(schema: Dict[str, Any], hint: str) -> None:
+    """Move fragile validation details into description instead of sending them raw."""
+    if not hint:
+        return
+    desc = schema.get("description")
+    schema["description"] = f"{desc} ({hint})" if desc else hint
+
+
+def _resolve_schema_ref(ref: str, root_schema: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    if not isinstance(ref, str) or not ref.startswith("#/"):
+        return None
+
+    node: Any = root_schema
+    for part in ref[2:].split("/"):
+        part = part.replace("~1", "/").replace("~0", "~")
+        if not isinstance(node, dict) or part not in node:
+            return None
+        node = node[part]
+
+    return node if isinstance(node, dict) else None
+
+
+def _clean_parameters_json_schema(
+    schema: Any,
+    root_schema: Optional[Dict[str, Any]] = None,
+    visited: Optional[set] = None,
+) -> Any:
+    """Clean a tool schema for Code Assist's parametersJsonSchema field."""
+    if isinstance(schema, list):
+        return [_clean_parameters_json_schema(item, root_schema, visited) for item in schema]
+    if not isinstance(schema, dict):
+        return schema
+
+    if root_schema is None:
+        root_schema = schema
+    if visited is None:
+        visited = set()
+
+    schema_id = id(schema)
+    if schema_id in visited:
+        return {"type": "object", "description": "circular reference"}
+    visited.add(schema_id)
+
+    ref_key = "$ref" if "$ref" in schema else ("ref" if "ref" in schema else None)
+    if ref_key:
+        resolved = _resolve_schema_ref(schema[ref_key], root_schema)
+        if resolved:
+            merged = dict(resolved)
+            for key in ("description", "default"):
+                if key in schema:
+                    merged[key] = schema[key]
+            schema = merged
+
+    if "allOf" in schema:
+        result: Dict[str, Any] = {}
+        for item in schema.get("allOf") or []:
+            cleaned_item = _clean_parameters_json_schema(item, root_schema, visited)
+            if not isinstance(cleaned_item, dict):
+                continue
+            if "properties" in cleaned_item:
+                result.setdefault("properties", {}).update(cleaned_item["properties"])
+            if "required" in cleaned_item:
+                result.setdefault("required", []).extend(cleaned_item["required"])
+            for key, value in cleaned_item.items():
+                if key not in ("properties", "required"):
+                    result[key] = value
+        for key, value in schema.items():
+            if key not in ("allOf", "properties", "required"):
+                result[key] = value
+            elif key in ("properties", "required") and key not in result:
+                result[key] = value
+    else:
+        result = dict(schema)
+
+    if result.get("nullable") is True:
+        _append_schema_hint(result, "nullable")
+
+    if "type" in result:
+        type_value = result["type"]
+        if isinstance(type_value, list):
+            non_null_types = [
+                str(t).lower()
+                for t in type_value
+                if isinstance(t, str) and t.lower() != "null"
+            ]
+            if non_null_types:
+                result["type"] = non_null_types[0]
+                if any(str(t).lower() == "null" for t in type_value):
+                    _append_schema_hint(result, "nullable")
+            else:
+                result["type"] = "string"
+        elif isinstance(type_value, str):
+            lower_type = type_value.lower()
+            if lower_type in {"string", "number", "integer", "boolean", "array", "object"}:
+                result["type"] = lower_type
+            elif lower_type == "null":
+                result["type"] = "string"
+                _append_schema_hint(result, "nullable")
+            else:
+                result.pop("type", None)
+
+    if "anyOf" in result or "oneOf" in result:
+        union_key = "anyOf" if "anyOf" in result else "oneOf"
+        union_items = result.get(union_key) or []
+        cleaned_items = [
+            item for item in (
+                _clean_parameters_json_schema(item, root_schema, visited)
+                for item in union_items
+            )
+            if isinstance(item, dict)
+        ]
+        enum_values = [
+            item.get("const")
+            for item in union_items
+            if isinstance(item, dict) and item.get("const") not in ("", None)
+        ]
+        if enum_values and len(enum_values) == len(union_items):
+            result["type"] = "string"
+            result["enum"] = [str(v) for v in enum_values]
+        else:
+            preferred = next(
+                (
+                    item for item in cleaned_items
+                    if item.get("type") in ("object", "array") or item.get("properties")
+                ),
+                None,
+            )
+            if preferred is None:
+                preferred = next((item for item in cleaned_items if item.get("type") or item.get("enum")), None)
+            if preferred:
+                original_description = result.get("description")
+                result.update(preferred)
+                if original_description:
+                    _append_schema_hint(result, original_description)
+        result.pop("anyOf", None)
+        result.pop("oneOf", None)
+
+    if result.get("type") == "array":
+        items = result.get("items")
+        if isinstance(items, list):
+            if items:
+                result["items"] = _clean_parameters_json_schema(items[0], root_schema, visited)
+                _append_schema_hint(result, "tuple schema simplified")
+            else:
+                result.pop("items", None)
+        elif isinstance(items, dict):
+            result["items"] = _clean_parameters_json_schema(items, root_schema, visited)
+
+    validation_keys = {
+        "default", "minLength", "maxLength", "minimum", "maximum",
+        "minItems", "maxItems", "pattern", "format", "uniqueItems",
+    }
+    for key in list(result.keys()):
+        if key in validation_keys:
+            value = result.pop(key)
+            if value not in (None, "", {}, []):
+                _append_schema_hint(result, f"{key}: {json.dumps(value, ensure_ascii=False)}")
+
+    unsupported_keys = {
+        "title", "$schema", "$id", "$ref", "ref", "strict", "nullable",
+        "exclusiveMaximum", "exclusiveMinimum", "additionalProperties",
+        "allOf", "anyOf", "oneOf", "$defs", "definitions", "example",
+        "examples", "readOnly", "writeOnly", "const", "additionalItems",
+        "contains", "patternProperties", "dependencies", "propertyNames",
+        "if", "then", "else", "contentEncoding", "contentMediaType",
+    }
+    for key in list(result.keys()):
+        if key in unsupported_keys or key.startswith("x-"):
+            del result[key]
+
+    nullable_props = set()
+    if isinstance(result.get("properties"), dict):
+        cleaned_props = {}
+        for prop_name, prop_schema in result["properties"].items():
+            if isinstance(prop_schema, dict):
+                prop_type = prop_schema.get("type")
+                if (
+                    prop_schema.get("nullable") is True
+                    or (
+                        isinstance(prop_type, list)
+                        and any(str(t).lower() == "null" for t in prop_type)
+                    )
+                ):
+                    nullable_props.add(prop_name)
+            cleaned_props[prop_name] = _clean_parameters_json_schema(prop_schema, root_schema, visited)
+        result["properties"] = cleaned_props
+
+    if "properties" in result and "type" not in result:
+        result["type"] = "object"
+
+    if isinstance(result.get("required"), list):
+        prop_names = set(result.get("properties", {}).keys()) if isinstance(result.get("properties"), dict) else None
+        required = []
+        for item in result["required"]:
+            if not isinstance(item, str):
+                continue
+            if prop_names is not None and item not in prop_names:
+                continue
+            if item in nullable_props:
+                continue
+            if item not in required:
+                required.append(item)
+        if required:
+            result["required"] = required
+        else:
+            result.pop("required", None)
+
+    return result
+
+
+def _normalize_tools_for_internal_api(tools: Any) -> Any:
+    if not isinstance(tools, list):
+        return tools
+
+    normalized_tools = []
+    for tool in tools:
+        if not isinstance(tool, dict):
+            normalized_tools.append(tool)
+            continue
+
+        normalized_tool = tool.copy()
+        declarations = normalized_tool.get("functionDeclarations")
+        if declarations is None:
+            declarations = normalized_tool.get("function_declarations")
+        if isinstance(declarations, list):
+            normalized_declarations = []
+            for declaration in declarations:
+                if not isinstance(declaration, dict):
+                    normalized_declarations.append(declaration)
+                    continue
+
+                normalized_declaration = declaration.copy()
+                if "parametersJsonSchema" in normalized_declaration:
+                    schema = normalized_declaration["parametersJsonSchema"]
+                elif "parameters_json_schema" in normalized_declaration:
+                    schema = normalized_declaration.pop("parameters_json_schema", None)
+                else:
+                    schema = normalized_declaration.pop("parameters", None)
+
+                normalized_declaration.pop("parameters", None)
+                normalized_declaration.pop("parameters_json_schema", None)
+                if schema not in (None, {}, []):
+                    normalized_declaration["parametersJsonSchema"] = _clean_parameters_json_schema(schema)
+                else:
+                    normalized_declaration.pop("parametersJsonSchema", None)
+
+                normalized_declarations.append(normalized_declaration)
+
+            normalized_tool.pop("function_declarations", None)
+            normalized_tool["functionDeclarations"] = normalized_declarations
+
+        normalized_tools.append(normalized_tool)
+
+    return normalized_tools
+
+
+def _ensure_empty_tool_schema_for_claude(tools: Any, model_name: str) -> Any:
+    if "claude" not in (model_name or "").lower() or not isinstance(tools, list):
+        return tools
+
+    normalized_tools = []
+    for tool in tools:
+        if not isinstance(tool, dict):
+            normalized_tools.append(tool)
+            continue
+
+        normalized_tool = tool.copy()
+        custom_tool = normalized_tool.get("custom")
+        if isinstance(custom_tool, dict) and "input_schema" not in custom_tool:
+            normalized_custom = custom_tool.copy()
+            normalized_custom["input_schema"] = {"type": "object", "properties": {}}
+            normalized_tool["custom"] = normalized_custom
+
+        declarations = normalized_tool.get("functionDeclarations")
+        if declarations is None:
+            declarations = normalized_tool.get("function_declarations")
+        if isinstance(declarations, list):
+            normalized_declarations = []
+            for declaration in declarations:
+                if not isinstance(declaration, dict):
+                    normalized_declarations.append(declaration)
+                    continue
+                normalized_declaration = declaration.copy()
+                if (
+                    "parametersJsonSchema" not in normalized_declaration
+                    and "parameters_json_schema" in normalized_declaration
+                ):
+                    normalized_declaration["parametersJsonSchema"] = normalized_declaration.pop("parameters_json_schema")
+
+                if "parametersJsonSchema" not in normalized_declaration:
+                    normalized_declaration["parametersJsonSchema"] = {
+                        "type": "object",
+                        "properties": {},
+                    }
+                normalized_declarations.append(normalized_declaration)
+            normalized_tool.pop("function_declarations", None)
+            normalized_tool["functionDeclarations"] = normalized_declarations
+
+        normalized_tools.append(normalized_tool)
+
+    return normalized_tools
+
+
+def _should_skip_thought_signature(part: Dict[str, Any], model_name: str) -> bool:
+    if "claude" in (model_name or "").lower():
+        return False
+
+    return (
+        "functionCall" in part
+        or "function_call" in part
+        or part.get("thought") is True
+        or "thoughtSignature" in part
+        or "thought_signature" in part
+    )
+
+
+def _normalize_part_thought_signature(part: Dict[str, Any], model_name: str) -> Dict[str, Any]:
+    normalized = part.copy()
+    if _should_skip_thought_signature(normalized, model_name):
+        normalized.pop("thought_signature", None)
+        normalized["thoughtSignature"] = SKIP_THOUGHT_SIGNATURE_VALIDATOR
+    return normalized
+
+
+SUPPORTED_ASPECT_RATIOS = [
+    (1, 1), (2, 3), (3, 2), (3, 4), (4, 3),
+    (4, 5), (5, 4), (9, 16), (16, 9), (21, 9),
+]
+
+
+def _parse_size_to_image_config(size_str: str) -> Dict[str, str]:
+    """
+    解析用户传入的 size 参数为 Gemini imageConfig 参数
+
+    支持格式: "1024x1536", "1024*1536", "1024X1536"
+
+    Returns:
+        包含 aspectRatio 和/或 imageSize 的字典
+    """
+    import re
+
+    config = {}
+    size_str = size_str.strip()
+
+    match = re.match(r"^(\d+)\s*[xX*×]\s*(\d+)$", size_str)
+    if not match:
+        return config
+
+    width, height = int(match.group(1)), int(match.group(2))
+
+    if width <= 0 or height <= 0:
+        return config
+
+    # 计算最接近的支持宽高比
+    target_ratio = width / height
+    best_ratio = None
+    best_diff = float("inf")
+    for w, h in SUPPORTED_ASPECT_RATIOS:
+        diff = abs(target_ratio - w / h)
+        if diff < best_diff:
+            best_diff = diff
+            best_ratio = f"{w}:{h}"
+    if best_ratio:
+        config["aspectRatio"] = best_ratio
+
+    # 根据最大边长确定 imageSize（使用最接近的档位）
+    max_dim = max(width, height)
+    if max_dim <= 1280:
+        config["imageSize"] = "1K"
+    elif max_dim <= 2560:
+        config["imageSize"] = "2K"
+    else:
+        config["imageSize"] = "4K"
+
+    return config
+
+
+def prepare_image_generation_request(
+    request_body: Dict[str, Any],
+    model: str
+) -> Dict[str, Any]:
+    """
+    图像生成模型请求体后处理
+
+    支持三种方式指定图片参数（优先级从高到低）:
+    1. size 参数: 如 "1024x1536"，自动计算 aspectRatio 和 imageSize
+    2. 模型名后缀: 如 -4k, -2k, -16x9, -1x1
+    3. 默认值: 不设置额外参数
+
+    Args:
+        request_body: 原始请求体
+        model: 模型名称
+
+    Returns:
+        处理后的请求体
+    """
+    request_body = request_body.copy()
+    model_lower = model.lower()
+
+    # 优先使用 size 参数
+    size_str = request_body.pop("size", None)
+    if size_str:
+        image_config = _parse_size_to_image_config(size_str)
+        log.debug(f"[IMAGE] 从 size 参数 '{size_str}' 解析: {image_config}")
+    else:
+        # 从模型名后缀解析
+        image_size = "4K" if "-4k" in model_lower else "2K" if "-2k" in model_lower else None
+
+        aspect_ratio = None
+        for suffix, ratio in [
+            ("-21x9", "21:9"), ("-16x9", "16:9"), ("-9x16", "9:16"),
+            ("-4x3", "4:3"), ("-3x4", "3:4"), ("-1x1", "1:1")
+        ]:
+            if suffix in model_lower:
+                aspect_ratio = ratio
+                break
+
+        image_config = {}
+        if aspect_ratio:
+            image_config["aspectRatio"] = aspect_ratio
+        if image_size:
+            image_config["imageSize"] = image_size
+
+    request_body["model"] = "gemini-3.1-flash-image"  # 统一使用基础模型名
+    request_body["generationConfig"] = {
+        "candidateCount": 1,
+        "imageConfig": image_config
+    }
+
+    # 移除不需要的字段
+    for key in ("systemInstruction", "tools", "toolConfig"):
+        request_body.pop(key, None)
+
+    return request_body
+
+
+# ==================== 模型特性辅助函数 ====================
+
+def get_base_model_name(model_name: str) -> str:
+    """移除模型名称中的后缀,返回基础模型名"""
+    # 按照从长到短的顺序排列，避免短后缀先于长后缀被匹配
+    suffixes = [
+        "-maxthinking", "-nothinking",  # 兼容旧模式
+        "-minimal", "-medium", "-search", "-think",  # 中等长度后缀
+        "-high", "-max", "-low"  # 短后缀
+    ]
+    result = model_name
+    changed = True
+    # 持续循环直到没有任何后缀可以移除
+    while changed:
+        changed = False
+        for suffix in suffixes:
+            if result.endswith(suffix):
+                result = result[:-len(suffix)]
+                changed = True
+                # 不使用 break，继续检查是否还有其他后缀
+    return result
+
+
+def get_thinking_settings(model_name: str) -> tuple[Optional[int], Optional[str]]:
+    """
+    根据模型名称获取思考配置
+
+    支持两种模式:
+    1. CLI 模式思考预算 (Gemini 2.5 系列): -max, -high, -medium, -low, -minimal
+    2. CLI 模式思考等级 (Gemini 3 Preview 系列): -high, -medium, -low, -minimal (仅 3-flash)
+    3. 兼容旧模式: -maxthinking, -nothinking (不返回给用户)
+
+    Returns:
+        (thinking_budget, thinking_level): 思考预算和思考等级
+    """
+    base_model = get_base_model_name(model_name)
+
+    # ========== 兼容旧模式 (不返回给用户) ==========
+    if "-nothinking" in model_name:
+        # nothinking 模式: 限制思考
+        if "flash" in base_model:
+            return 0, None
+        return 128, None
+    elif "-maxthinking" in model_name:
+        # maxthinking 模式: 最大思考预算
+        budget = 24576 if "flash" in base_model else 32768
+        if "gemini-3" in base_model:
+            # Gemini 3 系列不支持 thinkingBudget，返回 high 等级
+            return None, "high"
+        else:
+            return budget, None
+
+    # ========== 新 CLI 模式: 基于思考预算/等级 ==========
+
+    # Gemini 3 Preview 系列: 使用 thinkingLevel
+    if "gemini-3" in base_model:
+        if "-high" in model_name:
+            return None, "high"
+        elif "-medium" in model_name:
+            # 仅 3-flash-preview 支持 medium
+            if "flash" in base_model:
+                return None, "medium"
+            # pro 系列不支持 medium，返回 Default
+            return None, None
+        elif "-low" in model_name:
+            return None, "low"
+        elif "-minimal" in model_name:
+            return None, None
+        else:
+            # Default: 不设置 thinking 配置
+            return None, None
+
+    # Gemini 2.5 系列: 使用 thinkingBudget
+    elif "gemini-2.5" in base_model:
+        if "-max" in model_name:
+            # 2.5-flash-max: 24576, 2.5-pro-max: 32768
+            budget = 24576 if "flash" in base_model else 32768
+            return budget, None
+        elif "-high" in model_name:
+            # 2.5-flash-high: 16000, 2.5-pro-high: 16000
+            return 16000, None
+        elif "-medium" in model_name:
+            # 2.5-flash-medium: 8192, 2.5-pro-medium: 8192
+            return 8192, None
+        elif "-low" in model_name:
+            # 2.5-flash-low: 1024, 2.5-pro-low: 1024
+            return 1024, None
+        elif "-minimal" in model_name:
+            # 2.5-flash-minimal: 0, 2.5-pro-minimal: 128
+            budget = 0 if "flash" in base_model else 128
+            return budget, None
+        else:
+            # Default: 不设置 thinking budget
+            return None, None
+
+    # 其他模型: 不设置 thinking 配置
+    return None, None
+
+
+def is_search_model(model_name: str) -> bool:
+    """检查是否为搜索模型"""
+    return "-search" in model_name
+
+
+# ==================== 统一的 Gemini 请求后处理 ====================
+
+def is_thinking_model(model_name: str) -> bool:
+    """检查是否为思考模型 (包含 -thinking 或 pro)"""
+    return "think" in model_name or "pro" in model_name.lower()
+
+
+async def normalize_gemini_request(
+    request: Dict[str, Any],
+    mode: str = "geminicli"
+) -> Dict[str, Any]:
+    """
+    规范化 Gemini 请求
+
+    处理逻辑:
+    1. 模型特性处理 (thinking config, search tools)
+    3. 参数范围限制 (maxOutputTokens, topK)
+    4. 工具清理
+
+    Args:
+        request: 原始请求字典
+        mode: 模式 ("geminicli" 或 "antigravity")
+
+    Returns:
+        规范化后的请求
+    """
+    # 导入配置函数
+    from config import get_return_thoughts_to_frontend
+
+    result = request.copy()
+    model = result.get("model", "")
+    generation_config = (result.get("generationConfig") or {}).copy()  # 创建副本避免修改原对象
+    tools = result.get("tools")
+    system_instruction = result.get("systemInstruction") or result.get("system_instructions")
+    
+    # 记录原始请求
+    log.debug(f"[GEMINI_FIX] 原始请求 - 模型: {model}, mode: {mode}, generationConfig: {generation_config}")
+
+    # 获取配置值
+    return_thoughts = await get_return_thoughts_to_frontend()
+
+    # ========== 模式特定处理 ==========
+    if mode == "geminicli":
+        # 1. 思考设置
+        # 优先使用 get_thinking_settings 获取的思考预算和等级
+        thinking_budget, thinking_level = get_thinking_settings(model)
+
+        # 其次使用传入的思考预算（如果未从模型名称获取）
+        if thinking_budget is None and thinking_level is None:
+            thinking_budget = generation_config.get("thinkingConfig", {}).get("thinkingBudget")
+            thinking_level = generation_config.get("thinkingConfig", {}).get("thinkingLevel")
+
+        # 假如 is_thinking_model 为真或者思考预算/等级不为空，设置 thinkingConfig
+        if is_thinking_model(model) or thinking_budget is not None or thinking_level is not None:
+            # 确保 thinkingConfig 存在
+            if "thinkingConfig" not in generation_config:
+                generation_config["thinkingConfig"] = {}
+
+            thinking_config = generation_config["thinkingConfig"]
+
+            # 设置思考预算或等级（互斥）
+            if thinking_budget is not None:
+                thinking_config["thinkingBudget"] = thinking_budget
+                thinking_config.pop("thinkingLevel", None)  # 避免与 thinkingBudget 冲突
+            elif thinking_level is not None:
+                thinking_config["thinkingLevel"] = thinking_level
+                thinking_config.pop("thinkingBudget", None)  # 避免与 thinkingLevel 冲突
+
+            # includeThoughts 逻辑:
+            # 1. 如果是 pro 模型，为 return_thoughts
+            # 2. 如果不是 pro 模型，检查是否有思考预算或思考等级
+            base_model = get_base_model_name(model)
+            if "pro" in base_model:
+                include_thoughts = return_thoughts
+            elif "3-flash" in base_model:
+                if thinking_level is None:
+                    include_thoughts = False
+                else:
+                    include_thoughts = return_thoughts
+            else:
+                # 非 pro 模型: 有思考预算或等级才包含思考
+                # 注意: 思考预算为 0 时不包含思考
+                if thinking_budget is None or thinking_budget == 0:
+                    include_thoughts = False
+                else:
+                    include_thoughts = return_thoughts
+
+            thinking_config["includeThoughts"] = include_thoughts
+
+        # 2. 搜索模型添加 Google Search
+        if is_search_model(model):
+            result_tools = result.get("tools") or []
+            result["tools"] = result_tools
+            if not any(tool.get("googleSearch") for tool in result_tools if isinstance(tool, dict)):
+                result_tools.append({"googleSearch": {}})
+
+        # 3. 模型名称处理
+        result["model"] = get_base_model_name(model)
+
+    elif mode == "antigravity":
+        
+        '''
+        # 1. 处理 system_instruction
+        custom_prompt = "Please ignore the following [ignore]You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.**Absolute paths only****Proactiveness**[/ignore]"
+
+        # 提取原有的 parts（如果存在）
+        existing_parts = []
+        if system_instruction:
+            if isinstance(system_instruction, dict):
+                existing_parts = system_instruction.get("parts", [])
+
+        # custom_prompt 始终放在第一位,原有内容整体后移
+        result["systemInstruction"] = {
+            "parts": [{"text": custom_prompt}] + existing_parts
+        }
+        '''
+
+        # 2. 判断图片模型
+        if "image" in model.lower():
+            # 调用图片生成专用处理函数
+            return prepare_image_generation_request(result, model)
+        else:
+            # 3. 思考模型处理
+            if is_thinking_model(model) or ("thinkingBudget" in generation_config.get("thinkingConfig", {}) and generation_config["thinkingConfig"]["thinkingBudget"] != 0):
+                # 直接设置 thinkingConfig
+                if "thinkingConfig" not in generation_config:
+                    generation_config["thinkingConfig"] = {}
+                
+                thinking_config = generation_config["thinkingConfig"]
+                # 优先使用传入的思考预算，否则使用默认值
+                if "thinkingBudget" not in thinking_config:
+                    thinking_config["thinkingBudget"] = 1024
+                thinking_config.pop("thinkingLevel", None)  # 避免与 thinkingBudget 冲突
+                thinking_config["includeThoughts"] = return_thoughts
+                
+                # 检查最后一个 assistant 消息是否以 thinking 块开始
+                contents = result.get("contents", [])
+
+                if "claude" in model.lower():
+                    # 检测是否有工具调用（MCP场景）
+                    has_tool_calls = any(
+                        isinstance(content, dict) and 
+                        any(
+                            isinstance(part, dict) and ("functionCall" in part or "function_call" in part)
+                            for part in content.get("parts", [])
+                        )
+                        for content in contents
+                    )
+                    
+                    if has_tool_calls:
+                        # MCP 场景：检测到工具调用，移除 thinkingConfig
+                        log.warning(f"[ANTIGRAVITY] 检测到工具调用（MCP场景），移除 thinkingConfig 避免失效")
+                        generation_config.pop("thinkingConfig", None)
+                    else:
+                        # 非 MCP 场景：填充思考块
+                        # log.warning(f"[ANTIGRAVITY] 最后一个 assistant 消息不以 thinking 块开始，自动填充思考块")
+                        
+                        # 找到最后一个 model 角色的 content
+                        for i in range(len(contents) - 1, -1, -1):
+                            content = contents[i]
+                            if isinstance(content, dict) and content.get("role") == "model":
+                                # 在 parts 开头插入思考块（使用官方跳过验证的虚拟签名）
+                                parts = content.get("parts", [])
+                                thinking_part = {
+                                    "text": "...",
+                                    # "thought": True,  # 标记为思考块
+                                    "thoughtSignature": "skip_thought_signature_validator"  # 官方文档推荐的虚拟签名
+                                }
+                                # 如果第一个 part 不是 thinking，则插入
+                                if not parts or not (isinstance(parts[0], dict) and ("thought" in parts[0] or "thoughtSignature" in parts[0])):
+                                    content["parts"] = [thinking_part] + parts
+                                    log.debug(f"[ANTIGRAVITY] 已在最后一个 assistant 消息开头插入思考块（含跳过验证签名）")
+                                break
+                
+            # 移除 -thinking 后缀
+            model = model.replace("-thinking", "")
+
+            # 4. Claude 模型关键词映射
+            # 使用关键词匹配而不是精确匹配，更灵活地处理各种变体
+            original_model = model
+            if "opus" in model.lower():
+                model = "claude-opus-4-6-thinking"
+            elif "sonnet" in model.lower():
+                model = "claude-sonnet-4-6"
+            elif "haiku" in model.lower():
+                model = "gemini-2.5-flash"
+            elif "claude" in model.lower():
+                # Claude 模型兜底：如果包含 claude 但不是 opus/sonnet/haiku
+                model = "claude-sonnet-4-6"
+            
+            result["model"] = model
+            if original_model != model:
+                log.debug(f"[ANTIGRAVITY] 映射模型: {original_model} -> {model}")
+
+        # 5. 模型特殊处理：循环移除末尾的 model 消息，保证以用户消息结尾
+        # 因为该模型不支持预填充
+        if "claude-opus-4-6-thinking" in model.lower() or "claude-sonnet-4-6" in model.lower():
+            contents = result.get("contents", [])
+            removed_count = 0
+            while contents and isinstance(contents[-1], dict) and contents[-1].get("role") == "model":
+                contents.pop()
+                removed_count += 1
+            if removed_count > 0:
+                log.warning(f"[ANTIGRAVITY] {model} 不支持预填充，移除了 {removed_count} 条末尾 model 消息")
+                result["contents"] = contents
+
+        # 6. 移除 antigravity 模式不支持的字段
+        generation_config.pop("presencePenalty", None)
+        generation_config.pop("frequencyPenalty", None)
+        generation_config.pop("stopSequences", None)
+
+    # ========== 公共处理 ==========
+
+    # 1. 安全设置覆盖
+    if "tools" in result:
+        result["tools"] = _normalize_tools_for_internal_api(result.get("tools"))
+        result["tools"] = _ensure_empty_tool_schema_for_claude(result.get("tools"), model)
+
+    if "lite" in model.lower():
+        result["safetySettings"] = LITE_SAFETY_SETTINGS
+    else:
+        result["safetySettings"] = DEFAULT_SAFETY_SETTINGS
+
+    # 2. 参数范围限制
+    if generation_config:
+        # 强制设置 maxOutputTokens 为 64000
+        generation_config["maxOutputTokens"] = 64000
+        # 强制设置 topK 为 64
+        generation_config["topK"] = 64
+
+    if "contents" in result:
+        cleaned_contents = []
+        for content in result["contents"]:
+            if isinstance(content, dict) and "parts" in content:
+                # 过滤掉空的或无效的 parts
+                valid_parts = []
+                for part in content["parts"]:
+                    if not isinstance(part, dict):
+                        continue
+                    
+                    # 检查 part 是否有有效的非空值
+                    # 过滤掉空字典或所有值都为空的 part
+                    has_valid_value = any(
+                        value not in (None, "", {}, [])
+                        for key, value in part.items()
+                        if key != "thought"  # thought 字段可以为空
+                    )
+                    
+                    if has_valid_value:
+                        part = _normalize_part_thought_signature(part, model)
+
+                        # 修复 text 字段：确保是字符串而不是列表
+                        if "text" in part:
+                            text_value = part["text"]
+                            if isinstance(text_value, list):
+                                # 如果是列表，合并为字符串
+                                log.warning(f"[GEMINI_FIX] text 字段是列表，自动合并: {text_value}")
+                                part["text"] = " ".join(str(t) for t in text_value if t)
+                            elif isinstance(text_value, str):
+                                # 清理尾随空格
+                                part["text"] = text_value.rstrip()
+                            else:
+                                # 其他类型转为字符串
+                                log.warning(f"[GEMINI_FIX] text 字段类型异常 ({type(text_value)}), 转为字符串: {text_value}")
+                                part["text"] = str(text_value)
+
+                        valid_parts.append(part)
+                    else:
+                        log.warning(f"[GEMINI_FIX] 移除空的或无效的 part: {part}")
+                
+                # 只添加有有效 parts 的 content
+                if valid_parts:
+                    cleaned_content = content.copy()
+                    cleaned_content["parts"] = valid_parts
+                    cleaned_contents.append(cleaned_content)
+                else:
+                    log.warning(f"[GEMINI_FIX] 跳过没有有效 parts 的 content: {content.get('role')}")
+            else:
+                cleaned_contents.append(content)
+        
+        result["contents"] = cleaned_contents
+
+    if generation_config:
+        result["generationConfig"] = generation_config
+
+    return result

src/converter/openai2gemini.py

@@ -0,0 +1,1801 @@
+"""
+OpenAI Transfer Module - Handles conversion between OpenAI and Gemini API formats
+被openai-router调用，负责OpenAI格式与Gemini格式的双向转换
+"""
+
+import json
+import time
+import uuid
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from pypinyin import Style, lazy_pinyin
+
+from src.converter.thoughtSignature_fix import (
+    decode_tool_id_and_signature,
+    is_internal_placeholder_text,
+    is_skip_thought_signature_placeholder,
+    SKIP_THOUGHT_SIGNATURE_VALIDATOR,
+)
+from src.converter.utils import merge_system_messages
+
+from log import log
+
+def _convert_usage_metadata(usage_metadata: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    将Gemini的usageMetadata转换为OpenAI格式的usage字段
+
+    Args:
+        usage_metadata: Gemini API的usageMetadata字段
+
+    Returns:
+        OpenAI格式的usage字典，如果没有usage数据则返回None
+    """
+    if not usage_metadata:
+        return None
+
+    prompt_tokens_total = int(usage_metadata.get("promptTokenCount", 0) or 0)
+    cached_tokens = int(usage_metadata.get("cachedContentTokenCount", 0) or 0)
+    prompt_tokens = max(prompt_tokens_total - cached_tokens, 0)
+    completion_tokens = int(usage_metadata.get("candidatesTokenCount", 0) or 0)
+    raw_total_tokens = int(
+        usage_metadata.get(
+            "totalTokenCount",
+            prompt_tokens_total + completion_tokens + int(usage_metadata.get("thoughtsTokenCount", 0) or 0),
+        )
+        or 0
+    )
+
+    usage = {
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "total_tokens": max(raw_total_tokens - cached_tokens, prompt_tokens + completion_tokens),
+    }
+
+    if cached_tokens > 0:
+        usage["prompt_tokens_details"] = {"cached_tokens": cached_tokens}
+
+    reasoning_tokens = int(usage_metadata.get("thoughtsTokenCount", 0) or 0)
+    if reasoning_tokens > 0:
+        usage["completion_tokens_details"] = {"reasoning_tokens": reasoning_tokens}
+
+    return usage
+
+
+def _build_message_with_reasoning(role: str, content: str, reasoning_content: str) -> dict:
+    """构建包含可选推理内容的消息对象"""
+    message = {"role": role, "content": content}
+
+    # 如果有thinking tokens，添加reasoning_content
+    if reasoning_content:
+        message["reasoning_content"] = reasoning_content
+
+    return message
+
+
+def _map_finish_reason(gemini_reason: str) -> str:
+    """
+    将Gemini结束原因映射到OpenAI结束原因
+
+    Args:
+        gemini_reason: 来自Gemini API的结束原因
+
+    Returns:
+        OpenAI兼容的结束原因
+    """
+    if gemini_reason == "STOP":
+        return "stop"
+    elif gemini_reason == "MAX_TOKENS":
+        return "length"
+    elif gemini_reason in ["SAFETY", "RECITATION"]:
+        return "content_filter"
+    else:
+        # 对于 None 或未知的 finishReason，返回 "stop" 作为默认值
+        # 避免返回 None 导致 MCP 客户端误判为响应未完成而循环调用
+        return "stop"
+
+
+# ==================== Tool Conversion Functions ====================
+
+
+def _normalize_function_name(name: str) -> str:
+    """
+    规范化函数名以符合 Gemini API 要求
+
+    规则：
+    - 必须以字母或下划线开头
+    - 只能包含 a-z, A-Z, 0-9, 下划线, 英文句点, 英文短划线
+    - 最大长度 64 个字符
+
+    转换策略：
+    1. 中文字符转换为拼音
+    2. 将非法字符替换为下划线
+    3. 如果以非字母/下划线开头，添加下划线前缀
+    4. 截断到 64 个字符
+
+    Args:
+        name: 原始函数名
+
+    Returns:
+        规范化后的函数名
+    """
+    import re
+
+    if not name:
+        return "_unnamed_function"
+
+    # 步骤1：转换中文字符为拼音
+    if re.search(r"[\u4e00-\u9fff]", name):
+        try:
+            parts = []
+            for char in name:
+                if "\u4e00" <= char <= "\u9fff":
+                    # 中文字符转换为拼音
+                    pinyin = lazy_pinyin(char, style=Style.NORMAL)
+                    parts.append("".join(pinyin))
+                else:
+                    parts.append(char)
+            normalized = "".join(parts)
+        except ImportError:
+            log.warning("pypinyin not installed, cannot convert Chinese characters to pinyin")
+            normalized = name
+    else:
+        normalized = name
+
+    # 步骤2：将非法字符替换为下划线
+    # 合法字符：a-z, A-Z, 0-9, _, ., -
+    normalized = re.sub(r"[^a-zA-Z0-9_.\-]", "_", normalized)
+
+    # 步骤3：确保以字母或下划线开头
+    if normalized and not (normalized[0].isalpha() or normalized[0] == "_"):
+        # 以数字、点或短横线开头，添加下划线前缀
+        normalized = "_" + normalized
+
+    # 步骤4：截断到 64 个字符
+    if len(normalized) > 64:
+        normalized = normalized[:64]
+
+    # 步骤5：确保不为空
+    if not normalized:
+        normalized = "_unnamed_function"
+
+    return normalized
+
+
+def _resolve_ref(ref: str, root_schema: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    解析 $ref 或 ref 引用
+    
+    Args:
+        ref: 引用路径，如 "#/definitions/MyType" 或 "#/$defs/MyType"
+        root_schema: 根 schema 对象
+        
+    Returns:
+        解析后的 schema，如果失败返回 None
+    """
+    if not isinstance(ref, str):
+        return None
+        
+    if not ref.startswith('#/'):
+        # 尝试在 definitions 或 $defs 中查找
+        for key in ["definitions", "$defs"]:
+            if key in root_schema and ref in root_schema[key]:
+                return root_schema[key][ref]
+        return None
+    
+    path = ref[2:].split('/')
+    current = root_schema
+    
+    for segment in path:
+        if isinstance(current, dict) and segment in current:
+            current = current[segment]
+        else:
+            return None
+    
+    return current if isinstance(current, dict) else None
+
+
+def _clean_schema_for_claude(schema: Any, root_schema: Optional[Dict[str, Any]] = None, visited: Optional[set] = None) -> Any:
+    """
+    清理 JSON Schema，转换为 Claude API 支持的格式（符合 JSON Schema draft 2020-12）
+
+    处理逻辑：
+    1. 解析 $ref 引用
+    2. 合并 allOf 中的 schema
+    3. 转换 anyOf 为更兼容的格式
+    4. 保持标准 JSON Schema 类型（不转换为大写）
+    5. 处理 array 的 items
+    6. 清理 Claude 不支持的字段
+
+    Args:
+        schema: JSON Schema 对象
+        root_schema: 根 schema（用于解析 $ref）
+        visited: 已访问的对象集合（防止循环引用）
+
+    Returns:
+        清理后的 schema
+    """
+    # 非字典类型直接返回
+    if not isinstance(schema, dict):
+        return schema
+
+    # 初始化
+    if root_schema is None:
+        root_schema = schema
+    if visited is None:
+        visited = set()
+
+    # 防止循环引用
+    schema_id = id(schema)
+    if schema_id in visited:
+        return schema
+    visited.add(schema_id)
+
+    # 创建副本避免修改原对象
+    result = {}
+
+    # 1. 处理 $ref
+    if "$ref" in schema:
+        resolved = _resolve_ref(schema["$ref"], root_schema)
+        if resolved:
+            import copy
+            result = copy.deepcopy(resolved)
+            for key, value in schema.items():
+                if key != "$ref":
+                    result[key] = value
+            schema = result
+            result = {}
+
+    # 2. 处理 allOf（合并所有 schema）
+    if "allOf" in schema:
+        all_of_schemas = schema["allOf"]
+        for item in all_of_schemas:
+            cleaned_item = _clean_schema_for_claude(item, root_schema, visited)
+
+            if "properties" in cleaned_item:
+                if "properties" not in result:
+                    result["properties"] = {}
+                result["properties"].update(cleaned_item["properties"])
+
+            if "required" in cleaned_item:
+                if "required" not in result:
+                    result["required"] = []
+                result["required"].extend(cleaned_item["required"])
+
+            for key, value in cleaned_item.items():
+                if key not in ["properties", "required"]:
+                    result[key] = value
+
+        for key, value in schema.items():
+            if key not in ["allOf", "properties", "required"]:
+                result[key] = value
+            elif key in ["properties", "required"] and key not in result:
+                result[key] = value
+    else:
+        result = dict(schema)
+
+    # 3. 处理 type 数组（如 ["string", "null"]）
+    if "type" in result:
+        type_value = result["type"]
+        if isinstance(type_value, list):
+            # Claude 支持 type 数组，保持不变
+            pass
+
+    # 4. 处理 array 的 items
+    if result.get("type") == "array":
+        if "items" not in result:
+            result["items"] = {}
+        elif isinstance(result["items"], list):
+            # Tuple 定义，检查是否所有元素类型相同
+            tuple_items = result["items"]
+            first_type = tuple_items[0].get("type") if tuple_items else None
+            is_homogeneous = all(item.get("type") == first_type for item in tuple_items)
+
+            if is_homogeneous and first_type:
+                result["items"] = _clean_schema_for_claude(tuple_items[0], root_schema, visited)
+            else:
+                # 异质元组，使用 anyOf 表示
+                result["items"] = {
+                    "anyOf": [_clean_schema_for_claude(item, root_schema, visited) for item in tuple_items]
+                }
+        else:
+            result["items"] = _clean_schema_for_claude(result["items"], root_schema, visited)
+
+    # 5. 处理 anyOf（保持 anyOf，递归清理）
+    if "anyOf" in result:
+        result["anyOf"] = [_clean_schema_for_claude(item, root_schema, visited) for item in result["anyOf"]]
+
+    # 6. 清理 Claude 不支持的字段（根据 JSON Schema 2020-12）
+    # Claude API 对某些字段比较严格，移除可能导致问题的字段
+    unsupported_keys = {
+        "title", "$schema", "strict",
+        "additionalItems",  # 废弃字段，使用 items 替代
+        "exclusiveMaximum", "exclusiveMinimum",  # 在 2020-12 中这些应该是数值而非布尔值
+        "$defs", "definitions",  # 移除 definitions 相关字段避免冲突
+        "example", "examples", "readOnly", "writeOnly",
+        "const",  # const 可能导致问题
+        "contentEncoding", "contentMediaType",
+        "oneOf",  # oneOf 可能导致问题，用 anyOf 替代
+        "patternProperties", "dependencies", "propertyNames",  # Google API 不支持
+    }
+
+    for key in list(result.keys()):
+        if key in unsupported_keys:
+            del result[key]
+
+    # 递归处理 additionalProperties（如果存在）
+    if "additionalProperties" in result and isinstance(result["additionalProperties"], dict):
+        result["additionalProperties"] = _clean_schema_for_claude(result["additionalProperties"], root_schema, visited)
+
+    # 7. 递归处理 properties
+    if "properties" in result:
+        cleaned_props = {}
+        for prop_name, prop_schema in result["properties"].items():
+            cleaned_props[prop_name] = _clean_schema_for_claude(prop_schema, root_schema, visited)
+        result["properties"] = cleaned_props
+
+    # 8. 确保有 type 字段（如果有 properties 但没有 type）
+    if "properties" in result and "type" not in result:
+        result["type"] = "object"
+
+    # 9. 去重 required 数组
+    if "required" in result and isinstance(result["required"], list):
+        result["required"] = list(dict.fromkeys(result["required"]))
+
+    return result
+
+
+def _clean_schema_for_gemini(schema: Any, root_schema: Optional[Dict[str, Any]] = None, visited: Optional[set] = None) -> Any:
+    """
+    清理 JSON Schema，转换为 Gemini 支持的格式
+
+    参考 worker.mjs 的 transformOpenApiSchemaToGemini 实现
+
+    处理逻辑：
+    1. 解析 $ref 引用
+    2. 合并 allOf 中的 schema
+    3. 转换 anyOf 为 enum（如果可能）
+    4. 类型映射（string -> STRING）
+    5. 处理 ARRAY 的 items（包括 Tuple）
+    6. 将 default 值移到 description
+    7. 清理不支持的字段
+
+    Args:
+        schema: JSON Schema 对象
+        root_schema: 根 schema（用于解析 $ref）
+        visited: 已访问的对象集合（防止循环引用）
+
+    Returns:
+        清理后的 schema
+    """
+    # 非字典类型直接返回
+    if not isinstance(schema, dict):
+        return schema
+    
+    # 初始化
+    if root_schema is None:
+        root_schema = schema
+    if visited is None:
+        visited = set()
+    
+    # 防止循环引用
+    schema_id = id(schema)
+    if schema_id in visited:
+        return schema
+    visited.add(schema_id)
+    
+    # 创建副本避免修改原对象
+    result = {}
+    
+    # 1. 处理 $ref 或 ref
+    ref_key = "$ref" if "$ref" in schema else ("ref" if "ref" in schema else None)
+    if ref_key:
+        resolved = _resolve_ref(schema[ref_key], root_schema)
+        if resolved:
+            # 检测循环引用
+            resolved_id = id(resolved)
+            if resolved_id in visited:
+                return {"type": "OBJECT", "description": "(circular reference)"}
+            
+            visited.add(resolved_id)
+            # 合并解析后的 schema
+            merged = dict(resolved)
+            
+            # 重要：根据 Gemini API 限制，当存在引用时，只能并列存在 description 和 default
+            # 其他字段（如 type, properties 等）必须丢弃，否则会触发 400 错误
+            for key in ["description", "default"]:
+                if key in schema:
+                    merged[key] = schema[key]
+            
+            schema = merged
+            result = {}
+    
+    # 2. 处理 allOf（合并所有 schema）
+    if "allOf" in schema:
+        all_of_schemas = schema["allOf"]
+        for item in all_of_schemas:
+            cleaned_item = _clean_schema_for_gemini(item, root_schema, visited)
+            
+            # 合并 properties
+            if "properties" in cleaned_item:
+                if "properties" not in result:
+                    result["properties"] = {}
+                result["properties"].update(cleaned_item["properties"])
+            
+            # 合并 required
+            if "required" in cleaned_item:
+                if "required" not in result:
+                    result["required"] = []
+                result["required"].extend(cleaned_item["required"])
+            
+            # 合并其他字段（简单覆盖）
+            for key, value in cleaned_item.items():
+                if key not in ["properties", "required"]:
+                    result[key] = value
+        
+        # 复制其他字段
+        for key, value in schema.items():
+            if key not in ["allOf", "properties", "required"]:
+                result[key] = value
+            elif key in ["properties", "required"] and key not in result:
+                result[key] = value
+    else:
+        # 复制所有字段
+        result = dict(schema)
+    
+    # 3. 类型映射（转换为大写）
+    # 注意：Gemini API 的 type 字段必须是字符串，不能是数组
+    if "type" in result:
+        type_value = result["type"]
+
+        # 如果 type 是列表，提取主要类型（非 null）
+        if isinstance(type_value, list):
+            primary_type = next((t for t in type_value if t != "null"), None)
+            type_value = primary_type if primary_type else "STRING"  # 默认为 STRING
+
+        # 类型映射
+        type_map = {
+            "string": "STRING",
+            "number": "NUMBER",
+            "integer": "INTEGER",
+            "boolean": "BOOLEAN",
+            "array": "ARRAY",
+            "object": "OBJECT",
+        }
+
+        if isinstance(type_value, str) and type_value.lower() in type_map:
+            # 确保 result["type"] 是字符串而不是列表
+            result["type"] = type_map[type_value.lower()]
+        else:
+            # 未知类型，删除该字段
+            del result["type"]
+    
+    # 4. 处理 ARRAY 的 items
+    if result.get("type") == "ARRAY":
+        if "items" not in result:
+            # 没有 items，默认允许任意类型
+            result["items"] = {}
+        elif isinstance(result["items"], list):
+            # Tuple 定义（items 是数组）
+            tuple_items = result["items"]
+            
+            # 提取类型信息用于 description
+            tuple_types = [item.get("type", "any") for item in tuple_items]
+            tuple_desc = f"(Tuple: [{', '.join(tuple_types)}])"
+            
+            original_desc = result.get("description", "")
+            result["description"] = f"{original_desc} {tuple_desc}".strip()
+            
+            # 检查是否所有元素类型相同
+            first_type = tuple_items[0].get("type") if tuple_items else None
+            is_homogeneous = all(item.get("type") == first_type for item in tuple_items)
+            
+            if is_homogeneous and first_type:
+                # 同质元组，转换为 List<Type>
+                result["items"] = _clean_schema_for_gemini(tuple_items[0], root_schema, visited)
+            else:
+                # 异质元组，Gemini 不支持，设为 {}
+                result["items"] = {}
+        else:
+            # 递归处理 items
+            result["items"] = _clean_schema_for_gemini(result["items"], root_schema, visited)
+    
+    # 5. 处理 anyOf（尝试转换为 enum）
+    if "anyOf" in result:
+        any_of_schemas = result["anyOf"]
+        
+        # 递归处理每个 schema
+        cleaned_any_of = [_clean_schema_for_gemini(item, root_schema, visited) for item in any_of_schemas]
+        
+        # 尝试提取 enum
+        if all("const" in item for item in cleaned_any_of):
+            enum_values = [
+                str(item["const"]) 
+                for item in cleaned_any_of 
+                if item.get("const") not in ["", None]
+            ]
+            if enum_values:
+                result["type"] = "STRING"
+                result["enum"] = enum_values
+        elif "type" not in result:
+            # 如果不是 enum，尝试取第一个有效的类型定义
+            first_valid = next((item for item in cleaned_any_of if item.get("type") or item.get("enum")), None)
+            if first_valid:
+                result.update(first_valid)
+        
+        # 删除 anyOf
+        del result["anyOf"]
+    
+    # 6. 将 default 值移到 description
+    if "default" in result:
+        default_value = result["default"]
+        original_desc = result.get("description", "")
+        result["description"] = f"{original_desc} (Default: {json.dumps(default_value)})".strip()
+        del result["default"]
+    
+    # 7. 清理不支持的字段
+    unsupported_keys = {
+        "title", "$schema", "$ref", "ref", "strict", "exclusiveMaximum",
+        "exclusiveMinimum", "additionalProperties", "oneOf", "allOf",
+        "$defs", "definitions", "example", "examples", "readOnly",
+        "writeOnly", "const", "additionalItems", "contains",
+        "patternProperties", "dependencies", "propertyNames",
+        "if", "then", "else", "contentEncoding", "contentMediaType"
+    }
+    
+    for key in list(result.keys()):
+        if key in unsupported_keys:
+            del result[key]
+    
+    # 8. 递归处理 properties
+    if "properties" in result:
+        cleaned_props = {}
+        for prop_name, prop_schema in result["properties"].items():
+            cleaned_props[prop_name] = _clean_schema_for_gemini(prop_schema, root_schema, visited)
+        result["properties"] = cleaned_props
+    
+    # 9. 确保有 type 字段（如果有 properties 但没有 type）
+    if "properties" in result and "type" not in result:
+        result["type"] = "OBJECT"
+    
+    # 10. 去重 required 数组
+    if "required" in result and isinstance(result["required"], list):
+        result["required"] = list(dict.fromkeys(result["required"]))  # 保持顺序去重
+    
+    return result
+
+
+def _append_schema_hint(schema: Dict[str, Any], hint: str) -> None:
+    """把不兼容的校验信息挪到 description 里，避免上游直接拒收。"""
+    if not hint:
+        return
+    desc = schema.get("description")
+    schema["description"] = f"{desc} ({hint})" if desc else hint
+
+
+def _clean_schema_for_parameters_json_schema(
+    schema: Any,
+    root_schema: Optional[Dict[str, Any]] = None,
+    visited: Optional[set] = None,
+) -> Any:
+    """
+    清理 JSON Schema，供 Gemini CLI 内部接口的 parametersJsonSchema 使用。
+
+    Code Assist 的内部接口更接近官方 Gemini CLI：工具参数应放在
+    parametersJsonSchema 中，并保持 JSON Schema 的小写 type。
+    """
+    if not isinstance(schema, dict):
+        return schema
+
+    if root_schema is None:
+        root_schema = schema
+    if visited is None:
+        visited = set()
+
+    schema_id = id(schema)
+    if schema_id in visited:
+        return {"type": "object", "description": "(circular reference)"}
+    visited.add(schema_id)
+
+    result: Dict[str, Any]
+
+    ref_key = "$ref" if "$ref" in schema else ("ref" if "ref" in schema else None)
+    if ref_key:
+        resolved = _resolve_ref(schema[ref_key], root_schema)
+        if resolved:
+            import copy
+            result = copy.deepcopy(resolved)
+            for key in ("description", "default"):
+                if key in schema:
+                    result[key] = schema[key]
+            schema = result
+
+    if "allOf" in schema:
+        result = {}
+        for item in schema.get("allOf") or []:
+            cleaned_item = _clean_schema_for_parameters_json_schema(item, root_schema, visited)
+            if not isinstance(cleaned_item, dict):
+                continue
+            if "properties" in cleaned_item:
+                result.setdefault("properties", {}).update(cleaned_item["properties"])
+            if "required" in cleaned_item:
+                result.setdefault("required", []).extend(cleaned_item["required"])
+            for key, value in cleaned_item.items():
+                if key not in ("properties", "required"):
+                    result[key] = value
+        for key, value in schema.items():
+            if key not in ("allOf", "properties", "required"):
+                result[key] = value
+            elif key in ("properties", "required") and key not in result:
+                result[key] = value
+    else:
+        result = dict(schema)
+
+    if "type" in result:
+        type_value = result["type"]
+        if isinstance(type_value, list):
+            non_null_types = [t for t in type_value if isinstance(t, str) and t.lower() != "null"]
+            if non_null_types:
+                result["type"] = non_null_types[0]
+                if "null" in [str(t).lower() for t in type_value]:
+                    _append_schema_hint(result, "nullable")
+            else:
+                result["type"] = "string"
+        elif isinstance(type_value, str):
+            lower_type = type_value.lower()
+            if lower_type in {"string", "number", "integer", "boolean", "array", "object", "null"}:
+                result["type"] = "string" if lower_type == "null" else lower_type
+            else:
+                del result["type"]
+
+    if "anyOf" in result or "oneOf" in result:
+        union_key = "anyOf" if "anyOf" in result else "oneOf"
+        union_items = result.get(union_key) or []
+        cleaned_items = [
+            item for item in (
+                _clean_schema_for_parameters_json_schema(item, root_schema, visited)
+                for item in union_items
+            )
+            if isinstance(item, dict)
+        ]
+        enum_values = [
+            item.get("const")
+            for item in union_items
+            if isinstance(item, dict) and item.get("const") not in ("", None)
+        ]
+        if enum_values and len(enum_values) == len(union_items):
+            result["type"] = "string"
+            result["enum"] = [str(v) for v in enum_values]
+        else:
+            preferred = next(
+                (
+                    item for item in cleaned_items
+                    if item.get("type") in ("object", "array") or item.get("properties")
+                ),
+                None,
+            )
+            if preferred is None:
+                preferred = next((item for item in cleaned_items if item.get("type") or item.get("enum")), None)
+            if preferred:
+                existing_description = result.get("description")
+                result.update(preferred)
+                if existing_description:
+                    _append_schema_hint(result, existing_description)
+        result.pop("anyOf", None)
+        result.pop("oneOf", None)
+
+    if result.get("type") == "array":
+        items = result.get("items")
+        if isinstance(items, list):
+            if items:
+                result["items"] = _clean_schema_for_parameters_json_schema(items[0], root_schema, visited)
+                _append_schema_hint(result, "tuple schema simplified")
+            else:
+                result.pop("items", None)
+        elif isinstance(items, dict):
+            result["items"] = _clean_schema_for_parameters_json_schema(items, root_schema, visited)
+
+    validation_keys = {
+        "default", "minLength", "maxLength", "minimum", "maximum",
+        "minItems", "maxItems", "pattern", "format", "uniqueItems",
+    }
+    for key in list(result.keys()):
+        if key in validation_keys:
+            value = result.pop(key)
+            if value not in (None, "", {}, []):
+                _append_schema_hint(result, f"{key}: {json.dumps(value, ensure_ascii=False)}")
+
+    unsupported_keys = {
+        "title", "$schema", "$id", "$ref", "ref", "strict",
+        "exclusiveMaximum", "exclusiveMinimum", "additionalProperties",
+        "allOf", "anyOf", "oneOf", "$defs", "definitions", "example",
+        "examples", "readOnly", "writeOnly", "const", "additionalItems",
+        "contains", "patternProperties", "dependencies", "propertyNames",
+        "if", "then", "else", "contentEncoding", "contentMediaType",
+    }
+    for key in list(result.keys()):
+        if key in unsupported_keys or key.startswith("x-"):
+            del result[key]
+
+    nullable_props = set()
+    if "properties" in result and isinstance(result["properties"], dict):
+        cleaned_props = {}
+        for prop_name, prop_schema in result["properties"].items():
+            if isinstance(prop_schema, dict):
+                prop_type = prop_schema.get("type")
+                if isinstance(prop_type, list) and any(str(t).lower() == "null" for t in prop_type):
+                    nullable_props.add(prop_name)
+            cleaned_props[prop_name] = _clean_schema_for_parameters_json_schema(prop_schema, root_schema, visited)
+        result["properties"] = cleaned_props
+
+    if "properties" in result and "type" not in result:
+        result["type"] = "object"
+
+    if "required" in result and isinstance(result["required"], list):
+        prop_names = set(result.get("properties", {}).keys()) if isinstance(result.get("properties"), dict) else None
+        required = []
+        for item in result["required"]:
+            if not isinstance(item, str):
+                continue
+            if prop_names is not None and item not in prop_names:
+                continue
+            if item in nullable_props:
+                continue
+            if item not in required:
+                required.append(item)
+        if required:
+            result["required"] = required
+        else:
+            result.pop("required", None)
+
+    return result
+
+
+def fix_tool_call_args_types(
+    args: Dict[str, Any],
+    parameters_schema: Dict[str, Any]
+) -> Dict[str, Any]:
+    """
+    根据工具的参数 schema 修正函数调用参数的类型
+    
+    例如：将字符串 "5" 转换为数字 5，根据 schema 中的 type 定义
+    
+    Args:
+        args: 函数调用的参数字典
+        parameters_schema: 工具定义中的 parameters schema
+        
+    Returns:
+        类型修正后的参数字典
+    """
+    if not args or not parameters_schema:
+        return args
+    
+    properties = parameters_schema.get("properties", {})
+    if not properties:
+        return args
+    
+    fixed_args = {}
+    for key, value in args.items():
+        if key not in properties:
+            # 参数不在 schema 中，保持原样
+            fixed_args[key] = value
+            continue
+        
+        param_schema = properties[key]
+        param_type = param_schema.get("type")
+        
+        # 根据 schema 中的类型修正参数值
+        if param_type == "number" or param_type == "integer":
+            # 如果值是字符串，尝试转换为数字
+            if isinstance(value, str):
+                try:
+                    if param_type == "integer":
+                        fixed_args[key] = int(value)
+                    else:
+                        # 尝试转换为 float，如果是整数则保持为 int
+                        num_value = float(value)
+                        fixed_args[key] = int(num_value) if num_value.is_integer() else num_value
+                    log.debug(f"[OPENAI2GEMINI] 修正参数类型: {key} '{value}' -> {fixed_args[key]} ({param_type})")
+                except (ValueError, AttributeError):
+                    # 转换失败，保持原样
+                    fixed_args[key] = value
+                    log.warning(f"[OPENAI2GEMINI] 无法将参数 {key} 的值 '{value}' 转换为 {param_type}")
+            else:
+                fixed_args[key] = value
+        elif param_type == "boolean":
+            # 如果值是字符串，转换为布尔值
+            if isinstance(value, str):
+                if value.lower() in ("true", "1", "yes"):
+                    fixed_args[key] = True
+                elif value.lower() in ("false", "0", "no"):
+                    fixed_args[key] = False
+                else:
+                    fixed_args[key] = value
+                if fixed_args[key] != value:
+                    log.debug(f"[OPENAI2GEMINI] 修正参数类型: {key} '{value}' -> {fixed_args[key]} (boolean)")
+            else:
+                fixed_args[key] = value
+        elif param_type == "string":
+            # 如果值不是字符串，转换为字符串
+            if not isinstance(value, str):
+                fixed_args[key] = str(value)
+                log.debug(f"[OPENAI2GEMINI] 修正参数类型: {key} {value} -> '{fixed_args[key]}' (string)")
+            else:
+                fixed_args[key] = value
+        else:
+            # 其他类型（array, object 等）保持原样
+            fixed_args[key] = value
+    
+    return fixed_args
+
+
+def convert_openai_tools_to_gemini(openai_tools: List, model: str = "") -> List[Dict[str, Any]]:
+    """
+    将 OpenAI tools 格式转换为 Gemini functionDeclarations 格式
+
+    Args:
+        openai_tools: OpenAI 格式的工具列表（可能是字典或 Pydantic 模型）
+        model: 模型名称（用于判断是否为 Claude 模型）
+
+    Returns:
+        Gemini 格式的工具列表
+    """
+    if not openai_tools:
+        return []
+
+    # 判断是否为 Claude 模型
+    is_claude_model = "claude" in model.lower()
+
+    function_declarations = []
+
+    for tool in openai_tools:
+        if tool.get("type") != "function":
+            log.warning(f"Skipping non-function tool type: {tool.get('type')}")
+            continue
+
+        function = tool.get("function")
+        if not function:
+            log.warning("Tool missing 'function' field")
+            continue
+
+        # 获取并规范化函数名
+        original_name = function.get("name")
+        if not original_name:
+            log.warning("Tool missing 'name' field, using default")
+            original_name = "_unnamed_function"
+
+        normalized_name = _normalize_function_name(original_name)
+
+        # 如果名称被修改了，记录日志
+        if normalized_name != original_name:
+            log.debug(f"Function name normalized: '{original_name}' -> '{normalized_name}'")
+
+        # 构建 Gemini function declaration
+        declaration = {
+            "name": normalized_name,
+            "description": function.get("description", ""),
+        }
+
+        # 添加参数（如果有）- Gemini CLI 内部接口更适合 parametersJsonSchema
+        if "parameters" in function:
+            if is_claude_model:
+                cleaned_params = _clean_schema_for_parameters_json_schema(function["parameters"])
+                log.debug(f"[OPENAI2GEMINI] Using Claude schema cleaning for tool: {normalized_name}")
+            else:
+                cleaned_params = _clean_schema_for_parameters_json_schema(function["parameters"])
+
+            if cleaned_params:
+                declaration["parametersJsonSchema"] = cleaned_params
+            elif is_claude_model:
+                declaration["parametersJsonSchema"] = {"type": "object", "properties": {}}
+        elif is_claude_model:
+            declaration["parametersJsonSchema"] = {"type": "object", "properties": {}}
+
+        function_declarations.append(declaration)
+
+    if not function_declarations:
+        return []
+
+    # Gemini 格式：工具数组中包含 functionDeclarations
+    return [{"functionDeclarations": function_declarations}]
+
+
+def convert_tool_choice_to_tool_config(tool_choice: Union[str, Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    将 OpenAI tool_choice 转换为 Gemini toolConfig
+
+    Args:
+        tool_choice: OpenAI 格式的 tool_choice
+
+    Returns:
+        Gemini 格式的 toolConfig
+    """
+    if isinstance(tool_choice, str):
+        if tool_choice == "auto":
+            return {"functionCallingConfig": {"mode": "AUTO"}}
+        elif tool_choice == "none":
+            return {"functionCallingConfig": {"mode": "NONE"}}
+        elif tool_choice == "required":
+            return {"functionCallingConfig": {"mode": "ANY"}}
+    elif isinstance(tool_choice, dict):
+        # {"type": "function", "function": {"name": "my_function"}}
+        if tool_choice.get("type") == "function":
+            function_name = tool_choice.get("function", {}).get("name")
+            if function_name:
+                return {
+                    "functionCallingConfig": {
+                        "mode": "ANY",
+                        "allowedFunctionNames": [function_name],
+                    }
+                }
+
+    # 默认返回 AUTO 模式
+    return {"functionCallingConfig": {"mode": "AUTO"}}
+
+
+def convert_tool_message_to_function_response(message, all_messages: List = None) -> Dict[str, Any]:
+    """
+    将 OpenAI 的 tool role 消息转换为 Gemini functionResponse
+
+    Args:
+        message: OpenAI 格式的工具消息
+        all_messages: 所有消息的列表，用于查找 tool_call_id 对应的函数名
+
+    Returns:
+        Gemini 格式的 functionResponse part
+    """
+    # 获取 name 字段
+    name = getattr(message, "name", None)
+    encoded_tool_call_id = getattr(message, "tool_call_id", None) or ""
+
+    # 解码获取原始ID（functionResponse不需要签名）
+    original_tool_call_id, _ = decode_tool_id_and_signature(encoded_tool_call_id)
+
+    # 如果没有 name，尝试从 all_messages 中查找对应的 tool_call_id
+    # 注意：使用编码ID查找，因为存储的是编码ID
+    if not name and encoded_tool_call_id and all_messages:
+        for msg in all_messages:
+            if getattr(msg, "role", None) == "assistant" and hasattr(msg, "tool_calls") and msg.tool_calls:
+                for tool_call in msg.tool_calls:
+                    if getattr(tool_call, "id", None) == encoded_tool_call_id:
+                        func = getattr(tool_call, "function", None)
+                        if func:
+                            name = getattr(func, "name", None)
+                            break
+                if name:
+                    break
+
+    # 最终兜底：如果仍然没有 name，使用默认值
+    if not name:
+        name = "unknown_function"
+        log.warning(f"Tool message missing function name, using default: {name}")
+
+    try:
+        # 尝试将 content 解析为 JSON
+        response_data = (
+            json.loads(message.content) if isinstance(message.content, str) else message.content
+        )
+    except (json.JSONDecodeError, TypeError):
+        # 如果不是有效的 JSON，包装为对象
+        response_data = {"result": str(message.content)}
+
+    # 确保 response_data 是字典类型（Gemini API 要求 response 必须是对象）
+    if not isinstance(response_data, dict):
+        response_data = {"result": response_data}
+
+    return {"functionResponse": {"id": original_tool_call_id, "name": name, "response": response_data}}
+
+
+def _reverse_transform_value(value: Any) -> Any:
+    """
+    将值转换回原始类型（Gemini 可能将所有值转为字符串）
+
+    仅处理 Gemini 在工具参数中常见的布尔/空值字符串化情况，
+    不再对数字字符串做启发式转换，避免把 schema 声明为 string
+    的参数错误还原成 integer。
+    
+    参考 worker.mjs 的 reverseTransformValue
+    
+    Args:
+        value: 要转换的值
+        
+    Returns:
+        转换后的值
+    """
+    if not isinstance(value, str):
+        return value
+    
+    # 布尔值
+    if value == 'true':
+        return True
+    if value == 'false':
+        return False
+    
+    # null
+    if value == 'null':
+        return None
+    
+    # 其他情况保持字符串
+    return value
+
+
+def _reverse_transform_args(args: Any) -> Any:
+    """
+    递归转换函数参数，将字符串转回原始类型
+    
+    参考 worker.mjs 的 reverseTransformArgs
+    
+    Args:
+        args: 函数参数（可能是字典、列表或其他类型）
+        
+    Returns:
+        转换后的参数
+    """
+    if not isinstance(args, (dict, list)):
+        return args
+    
+    if isinstance(args, list):
+        return [_reverse_transform_args(item) for item in args]
+    
+    # 处理字典
+    result = {}
+    for key, value in args.items():
+        if isinstance(value, (dict, list)):
+            result[key] = _reverse_transform_args(value)
+        else:
+            result[key] = _reverse_transform_value(value)
+    
+    return result
+
+
+def extract_tool_calls_from_parts(
+    parts: List[Dict[str, Any]], is_streaming: bool = False
+) -> Tuple[List[Dict[str, Any]], str]:
+    """
+    从 Gemini response parts 中提取工具调用和文本内容
+
+    Args:
+        parts: Gemini response 的 parts 数组
+        is_streaming: 是否为流式响应（流式响应需要添加 index 字段）
+
+    Returns:
+        (tool_calls, text_content) 元组
+    """
+    tool_calls = []
+    text_content = ""
+
+    for idx, part in enumerate(parts):
+        # 检查是否是函数调用
+        if "functionCall" in part:
+            function_call = part["functionCall"]
+            # 获取原始ID或生成新ID
+            original_id = function_call.get("id") or f"call_{uuid.uuid4().hex[:24]}"
+            # 获取参数并转换类型
+            args = function_call.get("args", {})
+            # 将字符串类型的值转回原始类型
+            args = _reverse_transform_args(args)
+
+            tool_call = {
+                "id": original_id,
+                "type": "function",
+                "function": {
+                    "name": function_call.get("name", "nameless_function"),
+                    "arguments": json.dumps(args),
+                },
+            }
+            # 流式响应需要 index 字段
+            if is_streaming:
+                tool_call["index"] = idx
+            tool_calls.append(tool_call)
+
+        # 提取文本内容（排除 thinking tokens）
+        elif "text" in part and not part.get("thought", False):
+            text = part["text"]
+            if (
+                is_skip_thought_signature_placeholder(part)
+                or is_internal_placeholder_text(text)
+            ):
+                continue
+            text_content += text
+
+    return tool_calls, text_content
+
+
+def extract_images_from_content(content: Any) -> Dict[str, Any]:
+    """
+    从 OpenAI content 中提取文本和图片
+    
+    Args:
+        content: OpenAI 消息的 content 字段（可能是字符串或列表）
+    
+    Returns:
+        包含 text 和 images 的字典
+    """
+    result = {"text": "", "images": []}
+
+    if isinstance(content, str):
+        result["text"] = content
+    elif isinstance(content, list):
+        for item in content:
+            if isinstance(item, dict):
+                if item.get("type") == "text":
+                    result["text"] += item.get("text", "")
+                elif item.get("type") == "image_url":
+                    image_url = item.get("image_url", {}).get("url", "")
+                    # 解析 data:image/png;base64,xxx 格式
+                    if image_url.startswith("data:image/"):
+                        import re
+                        match = re.match(r"^data:image/(\w+);base64,(.+)$", image_url)
+                        if match:
+                            mime_type = match.group(1)
+                            base64_data = match.group(2)
+                            result["images"].append({
+                                "inlineData": {
+                                    "mimeType": f"image/{mime_type}",
+                                    "data": base64_data
+                                }
+                            })
+
+    return result
+
+
+def _sanitize_openai_roundtrip_signatures(contents: List[Dict[str, Any]]) -> None:
+    """
+    OpenAI-compatible clients may round-trip Gemini thinking signatures through
+    fields we do not fully control. Keep tool calls on the safe bypass sentinel
+    and drop signatures everywhere else to avoid Corrupted thought signature.
+    """
+    for content in contents:
+        if not isinstance(content, dict):
+            continue
+        parts = content.get("parts")
+        if not isinstance(parts, list):
+            continue
+
+        for index, part in enumerate(parts):
+            if not isinstance(part, dict):
+                continue
+
+            sanitized_part = part.copy()
+            if "thoughtSignature" in sanitized_part:
+                if "functionCall" in sanitized_part or "function_call" in sanitized_part:
+                    sanitized_part["thoughtSignature"] = SKIP_THOUGHT_SIGNATURE_VALIDATOR
+                else:
+                    sanitized_part.pop("thoughtSignature", None)
+
+            if sanitized_part.get("thought") is True and not sanitized_part.get("thoughtSignature"):
+                sanitized_part.pop("thought", None)
+
+            parts[index] = sanitized_part
+
+
+async def convert_openai_to_gemini_request(openai_request: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    将 OpenAI 格式请求体转换为 Gemini 格式请求体
+
+    注意: 此函数只负责基础转换,不包含 normalize_gemini_request 中的处理
+    (如 thinking config, search tools, 参数范围限制等)
+
+    Args:
+        openai_request: OpenAI 格式的请求体字典,包含:
+            - messages: 消息列表
+            - temperature, top_p, max_tokens, stop 等生成参数
+            - tools, tool_choice (可选)
+            - response_format (可选)
+
+    Returns:
+        Gemini 格式的请求体字典,包含:
+            - contents: 转换后的消息内容
+            - generationConfig: 生成配置
+            - systemInstruction: 系统指令 (如果有)
+            - tools, toolConfig (如果有)
+    """
+    # 处理连续的system消息（兼容性模式）
+    openai_request = await merge_system_messages(openai_request)
+
+    contents = []
+
+    # 提取消息列表
+    messages = openai_request.get("messages", [])
+    
+    # 构建 tool_call_id -> (name, original_id, signature) 的映射
+    tool_call_mapping = {}
+    for msg in messages:
+        if msg.get("role") == "assistant" and msg.get("tool_calls"):
+            for tc in msg["tool_calls"]:
+                encoded_id = tc.get("id", "")
+                func_name = tc.get("function", {}).get("name") or ""
+                if encoded_id:
+                    # 解码获取原始ID和签名
+                    original_id, _ = decode_tool_id_and_signature(encoded_id)
+                    tool_call_mapping[encoded_id] = (func_name, original_id, None)
+    
+    # 构建工具名称到参数 schema 的映射（用于类型修正）
+    tool_schemas = {}
+    if "tools" in openai_request and openai_request["tools"]:
+        for tool in openai_request["tools"]:
+            if tool.get("type") == "function":
+                function = tool.get("function", {})
+                func_name = function.get("name")
+                if func_name:
+                    tool_schemas[func_name] = function.get("parameters", {})
+
+    # 用于累积连续的 tool message 的 functionResponse parts
+    pending_tool_parts = []
+
+    def flush_pending_tool_parts():
+        """将累积的 tool parts 作为单个 contents 条目追加"""
+        nonlocal pending_tool_parts
+        if pending_tool_parts:
+            contents.append({
+                "role": "user",
+                "parts": pending_tool_parts
+            })
+            pending_tool_parts = []
+
+    for message in messages:
+        role = message.get("role", "user")
+        content = message.get("content", "")
+
+        # 处理工具消息（tool role）- 累积到 pending_tool_parts
+        if role == "tool":
+            tool_call_id = message.get("tool_call_id", "")
+            func_name = message.get("name")
+
+            # 使用映射表查找
+            if tool_call_id in tool_call_mapping:
+                func_name, original_id, _ = tool_call_mapping[tool_call_id]
+            else:
+                # 如果没有name,尝试从消息列表中查找
+                if not func_name and tool_call_id:
+                    for msg in messages:
+                        if msg.get("role") == "assistant" and msg.get("tool_calls"):
+                            for tc in msg["tool_calls"]:
+                                if tc.get("id") == tool_call_id:
+                                    func_name = tc.get("function", {}).get("name")
+                                    break
+                            if func_name:
+                                break
+
+                # 解码 tool_call_id 获取原始 ID
+                original_id, _ = decode_tool_id_and_signature(tool_call_id)
+
+            # 最终兜底：确保 func_name 不为空
+            if not func_name:
+                func_name = "unknown_function"
+                log.warning(f"Tool message missing function name for tool_call_id={tool_call_id}, using default: {func_name}")
+
+            # 解析响应数据
+            try:
+                response_data = json.loads(content) if isinstance(content, str) else content
+            except (json.JSONDecodeError, TypeError):
+                response_data = {"result": str(content)}
+
+            # 确保 response_data 是字典类型（Gemini API 要求 response 必须是对象）
+            if not isinstance(response_data, dict):
+                response_data = {"result": response_data}
+
+            # 累积 functionResponse part（不立即追加到 contents）
+            pending_tool_parts.append({
+                "functionResponse": {
+                    "id": original_id,
+                    "name": func_name,
+                    "response": response_data
+                }
+            })
+            continue
+
+        # 遇到非 tool 消息时，先 flush 累积的 tool parts
+        flush_pending_tool_parts()
+
+        # system 消息已经由 merge_system_messages 处理，这里跳过
+        if role == "system":
+            continue
+
+        # 将OpenAI角色映射到Gemini角色
+        if role == "assistant":
+            role = "model"
+
+        # 检查是否有tool_calls
+        tool_calls = message.get("tool_calls")
+        if tool_calls:
+            parts = []
+
+            # 如果有文本内容,先添加文本
+            if content:
+                parts.append({"text": content})
+
+            # 添加每个工具调用
+            for tool_call in tool_calls:
+                try:
+                    args = (
+                        json.loads(tool_call["function"]["arguments"])
+                        if isinstance(tool_call["function"]["arguments"], str)
+                        else tool_call["function"]["arguments"]
+                    )
+                    
+                    # 根据工具的 schema 修正参数类型
+                    func_name = tool_call["function"]["name"]
+                    if func_name in tool_schemas:
+                        args = fix_tool_call_args_types(args, tool_schemas[func_name])
+
+                    # 解码工具ID和thoughtSignature
+                    encoded_id = tool_call.get("id", "")
+                    original_id, signature = decode_tool_id_and_signature(encoded_id)
+
+                    # 构建functionCall part
+                    function_call_part = {
+                        "functionCall": {
+                            "id": original_id,
+                            "name": func_name,
+                            "args": args
+                        }
+                    }
+
+                    # OpenAI/RooCode 中转可能会改写或截断 tool_call_id，真实签名回传后容易触发
+                    # Corrupted thought signature。工具调用使用官方跳过校验占位符更稳。
+                    function_call_part["thoughtSignature"] = SKIP_THOUGHT_SIGNATURE_VALIDATOR
+
+                    parts.append(function_call_part)
+                except (json.JSONDecodeError, KeyError) as e:
+                    log.error(f"Failed to parse tool call: {e}")
+                    continue
+
+            if parts:
+                contents.append({"role": role, "parts": parts})
+            continue
+
+        # 处理普通内容
+        if isinstance(content, list):
+            parts = []
+            for part in content:
+                if part.get("type") == "text":
+                    parts.append({"text": part.get("text", "")})
+                elif part.get("type") == "image_url":
+                    image_url = part.get("image_url", {}).get("url")
+                    if image_url:
+                        try:
+                            mime_type, base64_data = image_url.split(";")
+                            _, mime_type = mime_type.split(":")
+                            _, base64_data = base64_data.split(",")
+                            parts.append({
+                                "inlineData": {
+                                    "mimeType": mime_type,
+                                    "data": base64_data,
+                                }
+                            })
+                        except ValueError:
+                            continue
+            if parts:
+                contents.append({"role": role, "parts": parts})
+        elif content:
+            contents.append({"role": role, "parts": [{"text": content}]})
+
+    # 循环结束后，flush 剩余的 tool parts（如果消息列表以 tool 消息结尾）
+    flush_pending_tool_parts()
+    _sanitize_openai_roundtrip_signatures(contents)
+
+    # 构建生成配置
+    generation_config = {}
+    model = openai_request.get("model", "")
+    
+    # 基础参数映射
+    if "temperature" in openai_request:
+        generation_config["temperature"] = openai_request["temperature"]
+    if "top_p" in openai_request:
+        generation_config["topP"] = openai_request["top_p"]
+    if "top_k" in openai_request:
+        generation_config["topK"] = openai_request["top_k"]
+    if "max_tokens" in openai_request or "max_completion_tokens" in openai_request:
+        # max_completion_tokens 优先于 max_tokens
+        max_tokens = openai_request.get("max_completion_tokens") or openai_request.get("max_tokens")
+        generation_config["maxOutputTokens"] = max_tokens
+    if "stop" in openai_request:
+        stop = openai_request["stop"]
+        generation_config["stopSequences"] = [stop] if isinstance(stop, str) else stop
+    if "frequency_penalty" in openai_request:
+        generation_config["frequencyPenalty"] = openai_request["frequency_penalty"]
+    if "presence_penalty" in openai_request:
+        generation_config["presencePenalty"] = openai_request["presence_penalty"]
+    if "n" in openai_request:
+        generation_config["candidateCount"] = openai_request["n"]
+    if "seed" in openai_request:
+        generation_config["seed"] = openai_request["seed"]
+    
+    # 处理 response_format
+    if "response_format" in openai_request and openai_request["response_format"]:
+        response_format = openai_request["response_format"]
+        format_type = response_format.get("type")
+        
+        if format_type == "json_schema":
+            # JSON Schema 模式
+            if "json_schema" in response_format and "schema" in response_format["json_schema"]:
+                schema = response_format["json_schema"]["schema"]
+                # 清理 schema
+                generation_config["responseSchema"] = _clean_schema_for_gemini(schema)
+                generation_config["responseMimeType"] = "application/json"
+        elif format_type == "json_object":
+            # JSON Object 模式
+            generation_config["responseMimeType"] = "application/json"
+        elif format_type == "text":
+            # Text 模式
+            generation_config["responseMimeType"] = "text/plain"
+            
+    # 如果contents为空,添加默认用户消息
+    if not contents:
+        contents.append({"role": "user", "parts": [{"text": "请根据系统指令回答。"}]})
+
+    # 构建基础请求
+    gemini_request = {
+        "contents": contents,
+        "generationConfig": generation_config
+    }
+
+    # 如果 merge_system_messages 已经添加了 systemInstruction，使用它
+    if "systemInstruction" in openai_request:
+        gemini_request["systemInstruction"] = openai_request["systemInstruction"]
+
+    # 处理工具 - 传递 model 参数以便根据模型类型选择清理策略
+    model = openai_request.get("model", "")
+    if "tools" in openai_request and openai_request["tools"]:
+        gemini_request["tools"] = convert_openai_tools_to_gemini(openai_request["tools"], model)
+
+    # 处理tool_choice
+    if "tool_choice" in openai_request and openai_request["tool_choice"]:
+        gemini_request["toolConfig"] = convert_tool_choice_to_tool_config(openai_request["tool_choice"])
+
+    # 透传图片生成的 size 参数（如 "1024x1536"）
+    if "size" in openai_request and openai_request["size"]:
+        gemini_request["size"] = openai_request["size"]
+
+    return gemini_request
+
+
+def convert_gemini_to_openai_response(
+    gemini_response: Union[Dict[str, Any], Any],
+    model: str,
+    status_code: int = 200
+) -> Dict[str, Any]:
+    """
+    将 Gemini 格式非流式响应转换为 OpenAI 格式非流式响应
+
+    注意: 如果收到的不是 200 开头的响应,不做任何处理,直接转发原始响应
+
+    Args:
+        gemini_response: Gemini 格式的响应体 (字典或响应对象)
+        model: 模型名称
+        status_code: HTTP 状态码 (默认 200)
+
+    Returns:
+        OpenAI 格式的响应体字典,或原始响应 (如果状态码不是 2xx)
+    """
+    # 非 2xx 状态码直接返回原始响应
+    if not (200 <= status_code < 300):
+        if isinstance(gemini_response, dict):
+            return gemini_response
+        else:
+            # 如果是响应对象,尝试解析为字典
+            try:
+                if hasattr(gemini_response, "json"):
+                    return gemini_response.json()
+                elif hasattr(gemini_response, "body"):
+                    body = gemini_response.body
+                    if isinstance(body, bytes):
+                        return json.loads(body.decode())
+                    return json.loads(str(body))
+                else:
+                    return {"error": str(gemini_response)}
+            except Exception:
+                return {"error": str(gemini_response)}
+
+    # 确保是字典格式
+    if not isinstance(gemini_response, dict):
+        try:
+            if hasattr(gemini_response, "json"):
+                gemini_response = gemini_response.json()
+            elif hasattr(gemini_response, "body"):
+                body = gemini_response.body
+                if isinstance(body, bytes):
+                    gemini_response = json.loads(body.decode())
+                else:
+                    gemini_response = json.loads(str(body))
+            else:
+                gemini_response = json.loads(str(gemini_response))
+        except Exception:
+            return {"error": "Invalid response format"}
+
+    # 处理 GeminiCLI 的 response 包装格式
+    if "response" in gemini_response:
+        gemini_response = gemini_response["response"]
+
+    # 转换为 OpenAI 格式
+    choices = []
+
+    for candidate in gemini_response.get("candidates", []):
+        role = candidate.get("content", {}).get("role", "assistant")
+
+        # 将Gemini角色映射回OpenAI角色
+        if role == "model":
+            role = "assistant"
+
+        # 提取并分离thinking tokens和常规内容
+        parts = candidate.get("content", {}).get("parts", [])
+
+        # 提取工具调用和文本内容
+        tool_calls, text_content = extract_tool_calls_from_parts(parts)
+
+        # 提取多种类型的内容
+        content_parts = []
+        reasoning_parts = []
+        
+        for part in parts:
+            # 处理 executableCode（代码生成）
+            if "executableCode" in part:
+                exec_code = part["executableCode"]
+                lang = exec_code.get("language", "python").lower()
+                code = exec_code.get("code", "")
+                # 添加代码块（前后加换行符确保 Markdown 渲染正确）
+                content_parts.append(f"\n```{lang}\n{code}\n```\n")
+            
+            # 处理 codeExecutionResult（代码执行结果）
+            elif "codeExecutionResult" in part:
+                result = part["codeExecutionResult"]
+                outcome = result.get("outcome")
+                output = result.get("output", "")
+                
+                if output:
+                    label = "output" if outcome == "OUTCOME_OK" else "error"
+                    content_parts.append(f"\n```{label}\n{output}\n```\n")
+            
+            # 处理 thought（思考内容）
+            elif (
+                part.get("thought", False)
+                and "text" in part
+                and not is_skip_thought_signature_placeholder(part)
+            ):
+                reasoning_parts.append(part["text"])
+            
+            # 处理普通文本（非思考内容）
+            elif "text" in part and not part.get("thought", False):
+                # 这部分已经在 extract_tool_calls_from_parts 中处理
+                pass
+            
+            # 处理 inlineData（图片）
+            elif "inlineData" in part:
+                inline_data = part["inlineData"]
+                mime_type = inline_data.get("mimeType", "image/png")
+                base64_data = inline_data.get("data", "")
+                # 使用 Markdown 格式
+                content_parts.append(f"![gemini-generated-content](data:{mime_type};base64,{base64_data})")
+        
+        # 合并所有内容部分
+        if content_parts:
+            # 使用双换行符连接各部分，确保块之间有间距
+            additional_content = "\n\n".join(content_parts)
+            if text_content:
+                text_content = text_content + "\n\n" + additional_content
+            else:
+                text_content = additional_content
+        
+        # 合并 reasoning content
+        reasoning_content = "\n\n".join(reasoning_parts) if reasoning_parts else ""
+
+        # 构建消息对象
+        message = {"role": role}
+
+        # 获取 Gemini 的 finishReason
+        gemini_finish_reason = candidate.get("finishReason")
+        
+        # 如果有工具调用
+        if tool_calls:
+            message["tool_calls"] = tool_calls
+            message["content"] = text_content if text_content else None
+            # 只有在正常停止（STOP）时才设为 tool_calls，其他情况保持原始 finish_reason
+            # 这样可以避免在 SAFETY、MAX_TOKENS 等情况下仍然返回 tool_calls 导致循环
+            if gemini_finish_reason == "STOP":
+                finish_reason = "tool_calls"
+            else:
+                finish_reason = _map_finish_reason(gemini_finish_reason)
+        else:
+            message["content"] = text_content
+            finish_reason = _map_finish_reason(gemini_finish_reason)
+
+        # 添加 reasoning content (如果有)
+        if reasoning_content:
+            message["reasoning_content"] = reasoning_content
+
+        choices.append({
+            "index": candidate.get("index", 0),
+            "message": message,
+            "finish_reason": finish_reason,
+        })
+
+    # 转换 usageMetadata
+    usage = _convert_usage_metadata(gemini_response.get("usageMetadata"))
+
+    response_data = {
+        "id": str(uuid.uuid4()),
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+    }
+
+    if usage:
+        response_data["usage"] = usage
+
+    return response_data
+
+
+def convert_gemini_to_openai_stream(
+    gemini_stream_chunk: str,
+    model: str,
+    response_id: str,
+    status_code: int = 200
+) -> Optional[str]:
+    """
+    将 Gemini 格式流式响应块转换为 OpenAI SSE 格式流式响应
+
+    注意: 如果收到的不是 200 开头的响应,不做任何处理,直接转发原始内容
+
+    Args:
+        gemini_stream_chunk: Gemini 格式的流式响应块 (字符串,通常是 "data: {json}" 格式)
+        model: 模型名称
+        response_id: 此流式响应的一致ID
+        status_code: HTTP 状态码 (默认 200)
+
+    Returns:
+        OpenAI SSE 格式的响应字符串 (如 "data: {json}\n\n"),
+        或原始内容 (如果状态码不是 2xx),
+        或 None (如果解析失败)
+    """
+    # 非 2xx 状态码直接返回原始内容
+    if not (200 <= status_code < 300):
+        return gemini_stream_chunk
+
+    # 解析 Gemini 流式块
+    try:
+        # 去除 "data: " 前缀
+        if isinstance(gemini_stream_chunk, bytes):
+            if gemini_stream_chunk.startswith(b"data: "):
+                payload_str = gemini_stream_chunk[len(b"data: "):].strip().decode("utf-8")
+            else:
+                payload_str = gemini_stream_chunk.strip().decode("utf-8")
+        else:
+            if gemini_stream_chunk.startswith("data: "):
+                payload_str = gemini_stream_chunk[len("data: "):].strip()
+            else:
+                payload_str = gemini_stream_chunk.strip()
+
+        # 跳过空块
+        if not payload_str:
+            return None
+
+        # 解析 JSON
+        gemini_chunk = json.loads(payload_str)
+    except (json.JSONDecodeError, UnicodeDecodeError):
+        # 解析失败,跳过此块
+        return None
+
+    # 处理 GeminiCLI 的 response 包装格式
+    if "response" in gemini_chunk:
+        gemini_response = gemini_chunk["response"]
+    else:
+        gemini_response = gemini_chunk
+
+    # 转换为 OpenAI 流式格式
+    choices = []
+
+    for candidate in gemini_response.get("candidates", []):
+        role = candidate.get("content", {}).get("role", "assistant")
+
+        # 将Gemini角色映射回OpenAI角色
+        if role == "model":
+            role = "assistant"
+
+        # 提取并分离thinking tokens和常规内容
+        parts = candidate.get("content", {}).get("parts", [])
+
+        # 提取工具调用和文本内容 (流式需要 index)
+        tool_calls, text_content = extract_tool_calls_from_parts(parts, is_streaming=True)
+
+        # 提取多种类型的内容
+        content_parts = []
+        reasoning_parts = []
+        
+        for part in parts:
+            # 处理 executableCode（代码生成）
+            if "executableCode" in part:
+                exec_code = part["executableCode"]
+                lang = exec_code.get("language", "python").lower()
+                code = exec_code.get("code", "")
+                content_parts.append(f"\n```{lang}\n{code}\n```\n")
+            
+            # 处理 codeExecutionResult（代码执行结果）
+            elif "codeExecutionResult" in part:
+                result = part["codeExecutionResult"]
+                outcome = result.get("outcome")
+                output = result.get("output", "")
+                
+                if output:
+                    label = "output" if outcome == "OUTCOME_OK" else "error"
+                    content_parts.append(f"\n```{label}\n{output}\n```\n")
+            
+            # 处理 thought（思考内容）
+            elif (
+                part.get("thought", False)
+                and "text" in part
+                and not is_skip_thought_signature_placeholder(part)
+            ):
+                reasoning_parts.append(part["text"])
+            
+            # 处理普通文本（非思考内容）
+            elif "text" in part and not part.get("thought", False):
+                # 这部分已经在 extract_tool_calls_from_parts 中处理
+                pass
+            
+            # 处理 inlineData（图片）
+            elif "inlineData" in part:
+                inline_data = part["inlineData"]
+                mime_type = inline_data.get("mimeType", "image/png")
+                base64_data = inline_data.get("data", "")
+                content_parts.append(f"![gemini-generated-content](data:{mime_type};base64,{base64_data})")
+        
+        # 合并所有内容部分
+        if content_parts:
+            additional_content = "\n\n".join(content_parts)
+            if text_content:
+                text_content = text_content + "\n\n" + additional_content
+            else:
+                text_content = additional_content
+        
+        # 合并 reasoning content
+        reasoning_content = "\n\n".join(reasoning_parts) if reasoning_parts else ""
+
+        # 构建 delta 对象
+        delta = {}
+
+        if tool_calls:
+            delta["tool_calls"] = tool_calls
+            if text_content:
+                delta["content"] = text_content
+        elif text_content:
+            delta["content"] = text_content
+
+        if reasoning_content:
+            delta["reasoning_content"] = reasoning_content
+
+        # 获取 Gemini 的 finishReason
+        gemini_finish_reason = candidate.get("finishReason")
+        finish_reason = _map_finish_reason(gemini_finish_reason)
+        
+        # 只有在正常停止（STOP）且有工具调用时才设为 tool_calls
+        # 避免在 SAFETY、MAX_TOKENS 等情况下仍然返回 tool_calls 导致循环
+        if tool_calls and gemini_finish_reason == "STOP":
+            finish_reason = "tool_calls"
+
+        choices.append({
+            "index": candidate.get("index", 0),
+            "delta": delta,
+            "finish_reason": finish_reason,
+        })
+
+    # 转换 usageMetadata (只在流结束时存在)
+    usage = _convert_usage_metadata(gemini_response.get("usageMetadata"))
+
+    # 构建 OpenAI 流式响应
+    response_data = {
+        "id": response_id,
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+    }
+
+    # 只在有 usage 数据且有 finish_reason 时添加 usage
+    if usage:
+        has_finish_reason = any(choice.get("finish_reason") for choice in choices)
+        if has_finish_reason:
+            response_data["usage"] = usage
+
+    # 转换为 SSE 格式: "data: {json}\n\n"
+    return f"data: {json.dumps(response_data)}\n\n"

src/converter/thoughtSignature_fix.py

@@ -0,0 +1,75 @@
+"""
+thoughtSignature 处理公共模块
+
+提供统一的 thoughtSignature 编码/解码功能，用于在工具调用ID中保留签名信息。
+这使得签名能够在客户端往返传输中保留，即使客户端会删除自定义字段。
+"""
+
+from typing import Any, Mapping, Optional, Tuple
+
+# 在工具调用ID中嵌入thoughtSignature的分隔符
+# 这使得签名能够在客户端往返传输中保留，即使客户端会删除自定义字段
+THOUGHT_SIGNATURE_SEPARATOR = "__thought__"
+SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator"
+SKIP_THOUGHT_SIGNATURE_PLACEHOLDER_TEXT = "..."
+
+
+def is_internal_placeholder_text(text: Any) -> bool:
+    if not isinstance(text, str):
+        return False
+    return text.strip() in (SKIP_THOUGHT_SIGNATURE_PLACEHOLDER_TEXT, "…")
+
+
+def is_skip_thought_signature_placeholder(part: Mapping[str, Any]) -> bool:
+    """Return True for the internal placeholder that should not reach clients."""
+    if not isinstance(part, Mapping):
+        return False
+    if part.get("thoughtSignature") != SKIP_THOUGHT_SIGNATURE_VALIDATOR:
+        return False
+    if "functionCall" in part or "function_call" in part or "functionResponse" in part:
+        return False
+    return is_internal_placeholder_text(part.get("text"))
+
+
+def encode_tool_id_with_signature(tool_id: str, signature: Optional[str]) -> str:
+    """
+    将 thoughtSignature 编码到工具调用ID中，以便往返保留。
+
+    Args:
+        tool_id: 原始工具调用ID
+        signature: thoughtSignature（可选）
+
+    Returns:
+        编码后的工具调用ID
+
+    Examples:
+        >>> encode_tool_id_with_signature("call_123", "abc")
+        'call_123__thought__abc'
+        >>> encode_tool_id_with_signature("call_123", None)
+        'call_123'
+    """
+    if not signature:
+        return tool_id
+    return f"{tool_id}{THOUGHT_SIGNATURE_SEPARATOR}{signature}"
+
+
+def decode_tool_id_and_signature(encoded_id: str) -> Tuple[str, Optional[str]]:
+    """
+    从编码的ID中提取原始工具ID和thoughtSignature。
+
+    Args:
+        encoded_id: 编码的工具调用ID
+
+    Returns:
+        (原始工具ID, thoughtSignature) 元组
+
+    Examples:
+        >>> decode_tool_id_and_signature("call_123__thought__abc")
+        ('call_123', 'abc')
+        >>> decode_tool_id_and_signature("call_123")
+        ('call_123', None)
+    """
+    if not encoded_id or THOUGHT_SIGNATURE_SEPARATOR not in encoded_id:
+        return encoded_id, None
+    parts = encoded_id.split(THOUGHT_SIGNATURE_SEPARATOR, 1)
+    return parts[0], parts[1] if len(parts) == 2 else None

src/converter/utils.py

@@ -0,0 +1,247 @@
+from typing import Any, Dict
+
+from src.converter.thoughtSignature_fix import (
+    is_internal_placeholder_text,
+    is_skip_thought_signature_placeholder,
+)
+
+
+def extract_content_and_reasoning(parts: list) -> tuple:
+    """从Gemini响应部件中提取内容和推理内容
+
+    Args:
+        parts: Gemini 响应中的 parts 列表
+
+    Returns:
+        (content, reasoning_content, images): 文本内容、推理内容和图片数据的元组
+        - content: 文本内容字符串
+        - reasoning_content: 推理内容字符串
+        - images: 图片数据列表,每个元素格式为:
+          {
+              "type": "image_url",
+              "image_url": {
+                  "url": "data:{mime_type};base64,{base64_data}"
+              }
+          }
+    """
+    content = ""
+    reasoning_content = ""
+    images = []
+
+    for part in parts:
+        if is_skip_thought_signature_placeholder(part):
+            continue
+
+        # 提取文本内容
+        text = part.get("text", "")
+        if is_internal_placeholder_text(text):
+            continue
+        if text:
+            if part.get("thought", False):
+                reasoning_content += text
+            else:
+                content += text
+
+        # 提取图片数据
+        if "inlineData" in part:
+            inline_data = part["inlineData"]
+            mime_type = inline_data.get("mimeType", "image/png")
+            base64_data = inline_data.get("data", "")
+            images.append({
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:{mime_type};base64,{base64_data}"
+                }
+            })
+
+    return content, reasoning_content, images
+
+
+async def merge_system_messages(request_body: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    根据兼容性模式处理请求体中的system消息
+
+    - 兼容性模式关闭（False）：将连续的system消息合并为systemInstruction
+    - 兼容性模式开启（True）：将所有system消息转换为user消息
+
+    Args:
+        request_body: OpenAI或Claude格式的请求体，包含messages字段
+
+    Returns:
+        处理后的请求体
+
+    Example (兼容性模式关闭):
+        输入:
+        {
+            "messages": [
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "system", "content": "You are an expert in Python."},
+                {"role": "user", "content": "Hello"}
+            ]
+        }
+
+        输出:
+        {
+            "systemInstruction": {
+                "parts": [
+                    {"text": "You are a helpful assistant."},
+                    {"text": "You are an expert in Python."}
+                ]
+            },
+            "messages": [
+                {"role": "user", "content": "Hello"}
+            ]
+        }
+
+    Example (兼容性模式开启):
+        输入:
+        {
+            "messages": [
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": "Hello"}
+            ]
+        }
+
+        输出:
+        {
+            "messages": [
+                {"role": "user", "content": "You are a helpful assistant."},
+                {"role": "user", "content": "Hello"}
+            ]
+        }
+    
+    Example (Anthropic格式，兼容性模式关闭):
+        输入:
+        {
+            "system": "You are a helpful assistant.",
+            "messages": [
+                {"role": "user", "content": "Hello"}
+            ]
+        }
+
+        输出:
+        {
+            "systemInstruction": {
+                "parts": [
+                    {"text": "You are a helpful assistant."}
+                ]
+            },
+            "messages": [
+                {"role": "user", "content": "Hello"}
+            ]
+        }
+    """
+    from config import get_compatibility_mode_enabled
+
+    compatibility_mode = await get_compatibility_mode_enabled()
+    
+    # 处理 Anthropic 格式的顶层 system 参数
+    # Anthropic API 规范: system 是顶层参数，不在 messages 中
+    system_content = request_body.get("system")
+    if system_content:
+        system_parts = []
+        
+        if isinstance(system_content, str):
+            if system_content.strip():
+                system_parts.append({"text": system_content})
+        elif isinstance(system_content, list):
+            # system 可以是包含多个块的列表
+            for item in system_content:
+                if isinstance(item, dict):
+                    if item.get("type") == "text" and item.get("text", "").strip():
+                        system_parts.append({"text": item["text"]})
+                elif isinstance(item, str) and item.strip():
+                    system_parts.append({"text": item})
+        
+        if system_parts:
+            if compatibility_mode:
+                # 兼容性模式：将 system 转换为 user 消息插入到 messages 开头
+                user_system_message = {
+                    "role": "user",
+                    "content": system_content if isinstance(system_content, str) else 
+                              "\n".join(part["text"] for part in system_parts)
+                }
+                messages = request_body.get("messages", [])
+                request_body = request_body.copy()
+                request_body["messages"] = [user_system_message] + messages
+            else:
+                # 非兼容性模式：添加为 systemInstruction
+                request_body = request_body.copy()
+                request_body["systemInstruction"] = {"parts": system_parts}
+
+    messages = request_body.get("messages", [])
+    if not messages:
+        return request_body
+
+    compatibility_mode = await get_compatibility_mode_enabled()
+
+    if compatibility_mode:
+        # 兼容性模式开启：将所有system消息转换为user消息
+        converted_messages = []
+        for message in messages:
+            if message.get("role") == "system":
+                # 创建新的消息对象，将role改为user
+                converted_message = message.copy()
+                converted_message["role"] = "user"
+                converted_messages.append(converted_message)
+            else:
+                converted_messages.append(message)
+
+        result = request_body.copy()
+        result["messages"] = converted_messages
+        return result
+    else:
+        # 兼容性模式关闭：提取连续的system消息合并为systemInstruction
+        system_parts = []
+        
+        # 如果已经从顶层 system 参数创建了 systemInstruction，获取现有的 parts
+        if "systemInstruction" in request_body:
+            existing_instruction = request_body.get("systemInstruction", {})
+            if isinstance(existing_instruction, dict):
+                system_parts = existing_instruction.get("parts", []).copy()
+        
+        remaining_messages = []
+        collecting_system = True
+
+        for message in messages:
+            role = message.get("role", "")
+            content = message.get("content", "")
+
+            if role == "system" and collecting_system:
+                # 提取system消息的文本内容
+                if isinstance(content, str):
+                    if content.strip():
+                        system_parts.append({"text": content})
+                elif isinstance(content, list):
+                    # 处理列表格式的content
+                    for item in content:
+                        if isinstance(item, dict):
+                            if item.get("type") == "text" and item.get("text", "").strip():
+                                system_parts.append({"text": item["text"]})
+                        elif isinstance(item, str) and item.strip():
+                            system_parts.append({"text": item})
+            else:
+                # 遇到非system消息，停止收集
+                collecting_system = False
+                if role == "system":
+                    # 将后续的system消息转换为user消息
+                    converted_message = message.copy()
+                    converted_message["role"] = "user"
+                    remaining_messages.append(converted_message)
+                else:
+                    remaining_messages.append(message)
+
+        # 如果没有找到任何system消息（包括顶层参数和messages中的），返回原始请求体
+        if not system_parts:
+            return request_body
+
+        # 构建新的请求体
+        result = request_body.copy()
+
+        # 添加或更新systemInstruction
+        result["systemInstruction"] = {"parts": system_parts}
+
+        # 更新messages列表（移除已处理的system消息）
+        result["messages"] = remaining_messages
+
+        return result

src/credential_manager.py

@@ -0,0 +1,510 @@
+"""
+凭证管理器
+"""
+
+import asyncio
+import time
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+from log import log
+
+from src.google_oauth_api import Credentials
+from src.storage_adapter import get_storage_adapter
+
+class CredentialManager:
+    """
+    统一凭证管理器
+    所有存储操作通过storage_adapter进行
+    """
+
+    def __init__(self):
+        # 核心状态
+        self._initialized = False
+        self._storage_adapter = None
+
+        # 并发控制（简化）
+        # 后端数据库自行处理并发，credential_manager 不再使用本地锁
+
+    async def _ensure_initialized(self):
+        """确保管理器已初始化（内部使用）"""
+        if not self._initialized or self._storage_adapter is None:
+            await self.initialize()
+
+    async def initialize(self):
+        """初始化凭证管理器"""
+        if self._initialized and self._storage_adapter is not None:
+            return
+
+        # 初始化统一存储适配器
+        self._storage_adapter = await get_storage_adapter()
+        self._initialized = True
+
+    async def close(self):
+        """清理资源"""
+        log.debug("Closing credential manager...")
+        self._initialized = False
+        log.debug("Credential manager closed")
+
+    async def get_valid_credential(
+        self, mode: str = "geminicli", model_name: Optional[str] = None
+    ) -> Optional[Tuple[str, Dict[str, Any]]]:
+        """
+        获取有效的凭证 - 随机负载均衡版
+        每次随机选择一个可用的凭证（未禁用、未冷却、符合preview要求）
+        如果刷新失败会自动禁用失效凭证并重试获取下一个可用凭证
+
+        Args:
+            mode: 凭证模式 ("geminicli" 或 "antigravity")
+            model_name: 完整模型名，用于模型级冷却检查和preview筛选
+                       - geminicli: 完整模型名
+                                   - 包含 "preview" 的模型只能使用 preview=True 的凭证
+                                   - 不包含 "preview" 的模型优先使用 preview=False 的凭证
+                       - antigravity: 完整模型名（如 "gemini-2.0-flash-exp"）
+        """
+        await self._ensure_initialized()
+
+        # 最多重试3次
+        max_retries = 3
+        for attempt in range(max_retries):
+            result = await self._storage_adapter._backend.get_next_available_credential(
+                mode=mode, model_name=model_name
+            )
+
+            # 如果没有可用凭证，直接返回None
+            if not result:
+                if attempt == 0:
+                    log.warning(f"没有可用凭证 (mode={mode}, model_name={model_name})")
+                return None
+
+            filename, credential_data = result
+
+            # Token 刷新检查
+            if await self._should_refresh_token(credential_data):
+                log.debug(f"Token需要刷新 - 文件: {filename} (mode={mode})")
+                refreshed_data = await self._refresh_token(credential_data, filename, mode=mode)
+                if refreshed_data:
+                    # 刷新成功，返回凭证
+                    credential_data = refreshed_data
+                    log.debug(f"Token刷新成功: {filename} (mode={mode})")
+                    return filename, credential_data
+                else:
+                    # 刷新失败（_refresh_token内部已自动禁用失效凭证）
+                    log.warning(f"Token刷新失败，尝试获取下一个凭证: {filename} (mode={mode}, attempt={attempt+1}/{max_retries})")
+                    # 继续循环，尝试获取下一个可用凭证
+                    continue
+            else:
+                # Token有效，直接返回
+                return filename, credential_data
+
+        # 重试次数用尽
+        log.error(f"重试{max_retries}次后仍无可用凭证 (mode={mode}, model_name={model_name})")
+        return None
+
+    async def add_credential(self, credential_name: str, credential_data: Dict[str, Any]):
+        """
+        新增或更新一个凭证
+        存储层会自动处理轮换顺序
+        """
+        await self._ensure_initialized()
+        await self._storage_adapter.store_credential(credential_name, credential_data)
+        log.info(f"Credential added/updated: {credential_name}")
+
+    async def add_antigravity_credential(self, credential_name: str, credential_data: Dict[str, Any]):
+        """
+        新增或更新一个Antigravity凭证
+        存储层会自动处理轮换顺序
+        """
+        await self._ensure_initialized()
+        await self._storage_adapter.store_credential(credential_name, credential_data, mode="antigravity")
+        log.info(f"Antigravity credential added/updated: {credential_name}")
+
+    async def remove_credential(self, credential_name: str, mode: str = "geminicli") -> bool:
+        """删除一个凭证"""
+        await self._ensure_initialized()
+        try:
+            await self._storage_adapter.delete_credential(credential_name, mode=mode)
+            log.info(f"Credential removed: {credential_name} (mode={mode})")
+            return True
+        except Exception as e:
+            log.error(f"Error removing credential {credential_name}: {e}")
+            return False
+
+    async def update_credential_state(self, credential_name: str, state_updates: Dict[str, Any], mode: str = "geminicli"):
+        """更新凭证状态"""
+        log.debug(f"[CredMgr] update_credential_state 开始: credential_name={credential_name}, state_updates={state_updates}, mode={mode}")
+        log.debug(f"[CredMgr] 调用 _ensure_initialized...")
+        await self._ensure_initialized()
+        log.debug(f"[CredMgr] _ensure_initialized 完成")
+        try:
+            log.debug(f"[CredMgr] 调用 storage_adapter.update_credential_state...")
+            success = await self._storage_adapter.update_credential_state(
+                credential_name, state_updates, mode=mode
+            )
+            log.debug(f"[CredMgr] storage_adapter.update_credential_state 返回: {success}")
+            if success:
+                log.debug(f"Updated credential state: {credential_name} (mode={mode})")
+            else:
+                log.warning(f"Failed to update credential state: {credential_name} (mode={mode})")
+            return success
+        except Exception as e:
+            log.error(f"Error updating credential state {credential_name}: {e}")
+            return False
+
+    async def set_cred_disabled(self, credential_name: str, disabled: bool, mode: str = "geminicli"):
+        """设置凭证的启用/禁用状态"""
+        try:
+            log.info(f"[CredMgr] set_cred_disabled 开始: credential_name={credential_name}, disabled={disabled}, mode={mode}")
+            success = await self.update_credential_state(
+                credential_name, {"disabled": disabled}, mode=mode
+            )
+            log.info(f"[CredMgr] update_credential_state 返回: success={success}")
+            if success:
+                action = "disabled" if disabled else "enabled"
+                log.info(f"Credential {action}: {credential_name} (mode={mode})")
+            else:
+                log.warning(f"[CredMgr] 设置禁用状态失败: credential_name={credential_name}, disabled={disabled}")
+            return success
+        except Exception as e:
+            log.error(f"Error setting credential disabled state {credential_name}: {e}")
+            return False
+
+    async def get_creds_status(self) -> Dict[str, Dict[str, Any]]:
+        """获取所有凭证的状态"""
+        await self._ensure_initialized()
+        try:
+            return await self._storage_adapter.get_all_credential_states()
+        except Exception as e:
+            log.error(f"Error getting credential statuses: {e}")
+            return {}
+
+    async def get_creds_summary(self) -> List[Dict[str, Any]]:
+        """
+        获取所有凭证的摘要信息（轻量级，不包含完整凭证数据）
+        使用后端的高性能查询
+        """
+        await self._ensure_initialized()
+        try:
+            return await self._storage_adapter._backend.get_credentials_summary()
+        except Exception as e:
+            log.error(f"Error getting credentials summary: {e}")
+            return []
+
+    async def get_or_fetch_user_email(self, credential_name: str, mode: str = "geminicli") -> Optional[str]:
+        """获取或获取用户邮箱地址"""
+        try:
+            # 确保已初始化
+            await self._ensure_initialized()
+            
+            # 从状态中获取缓存的邮箱
+            state = await self._storage_adapter.get_credential_state(credential_name, mode=mode)
+            cached_email = state.get("user_email") if state else None
+
+            if cached_email:
+                return cached_email
+
+            # 如果没有缓存，从凭证数据获取
+            credential_data = await self._storage_adapter.get_credential(credential_name, mode=mode)
+            if not credential_data:
+                return None
+
+            # 创建凭证对象并自动刷新 token
+            from .google_oauth_api import Credentials, get_user_email
+
+            credentials = Credentials.from_dict(credential_data)
+            if not credentials:
+                return None
+
+            # 自动刷新 token（如果需要）
+            token_refreshed = await credentials.refresh_if_needed()
+
+            # 如果 token 被刷新了，更新存储
+            if token_refreshed:
+                log.info(f"Token已自动刷新: {credential_name} (mode={mode})")
+                updated_data = credentials.to_dict()
+                await self._storage_adapter.store_credential(credential_name, updated_data, mode=mode)
+
+            # 获取邮箱
+            email = await get_user_email(credentials)
+
+            if email:
+                # 缓存邮箱地址
+                await self._storage_adapter.update_credential_state(
+                    credential_name, {"user_email": email}, mode=mode
+                )
+                return email
+
+            return None
+
+        except Exception as e:
+            log.error(f"Error fetching user email for {credential_name}: {e}")
+            return None
+
+    async def record_api_call_result(
+        self,
+        credential_name: str,
+        success: bool,
+        error_code: Optional[int] = None,
+        cooldown_until: Optional[float] = None,
+        mode: str = "geminicli",
+        model_name: Optional[str] = None,
+        error_message: Optional[str] = None
+    ):
+        """
+        记录API调用结果
+
+        Args:
+            credential_name: 凭证名称
+            success: 是否成功
+            error_code: 错误码（如果失败）
+            cooldown_until: 冷却截止时间戳（Unix时间戳，针对429 QUOTA_EXHAUSTED）
+            mode: 凭证模式 ("geminicli" 或 "antigravity")
+            model_name: 模型名（用于设置模型级冷却）
+            error_message: 错误信息（如果失败）
+        """
+        await self._ensure_initialized()
+        try:
+            if success:
+            # 条件写入：仅当凭证有错误状态或模型冷却时才写 DB，零内存缓存
+            # fire-and-forget，不阻塞请求链路
+                asyncio.create_task(
+                    self._storage_adapter._backend.record_success(
+                        credential_name, model_name=model_name, mode=mode
+                    )
+                )
+
+            elif error_code:
+                # 记录错误码和错误信息
+                error_messages = {}
+                if error_message:
+                    error_messages[str(error_code)] = error_message
+
+                state_updates = {
+                    "error_codes": [error_code],
+                    "error_messages": error_messages,
+                }
+
+                await self.update_credential_state(credential_name, state_updates, mode=mode)
+
+                # 设置模型级冷却
+                if cooldown_until is not None and model_name:
+                    if hasattr(self._storage_adapter._backend, 'set_model_cooldown'):
+                        await self._storage_adapter._backend.set_model_cooldown(
+                            credential_name, model_name, cooldown_until, mode=mode
+                        )
+                        log.info(
+                            f"设置模型级冷却: {credential_name}, model_name={model_name}, "
+                            f"冷却至: {datetime.fromtimestamp(cooldown_until, timezone.utc).isoformat()}"
+                        )
+
+        except Exception as e:
+            log.error(f"Error recording API call result for {credential_name}: {e}")
+
+    async def _should_refresh_token(self, credential_data: Dict[str, Any]) -> bool:
+        """检查token是否需要刷新"""
+        try:
+            # 如果没有access_token或过期时间，需要刷新
+            if not credential_data.get("access_token") and not credential_data.get("token"):
+                log.debug("没有access_token，需要刷新")
+                return True
+
+            expiry_str = credential_data.get("expiry")
+            if not expiry_str:
+                log.debug("没有过期时间，需要刷新")
+                return True
+
+            # 解析过期时间
+            try:
+                if isinstance(expiry_str, str):
+                    if "+" in expiry_str:
+                        file_expiry = datetime.fromisoformat(expiry_str)
+                    elif expiry_str.endswith("Z"):
+                        file_expiry = datetime.fromisoformat(expiry_str.replace("Z", "+00:00"))
+                    else:
+                        file_expiry = datetime.fromisoformat(expiry_str)
+                else:
+                    log.debug("过期时间格式无效，需要刷新")
+                    return True
+
+                # 确保时区信息
+                if file_expiry.tzinfo is None:
+                    file_expiry = file_expiry.replace(tzinfo=timezone.utc)
+
+                # 检查是否还有至少5分钟有效期
+                now = datetime.now(timezone.utc)
+                time_left = (file_expiry - now).total_seconds()
+
+                log.debug(
+                    f"Token时间检查: "
+                    f"当前UTC时间={now.isoformat()}, "
+                    f"过期时间={file_expiry.isoformat()}, "
+                    f"剩余时间={int(time_left/60)}分{int(time_left%60)}秒"
+                )
+
+                if time_left > 300:  # 5分钟缓冲
+                    return False
+                else:
+                    log.debug(f"Token即将过期（剩余{int(time_left/60)}分钟），需要刷新")
+                    return True
+
+            except Exception as e:
+                log.warning(f"解析过期时间失败: {e}，需要刷新")
+                return True
+
+        except Exception as e:
+            log.error(f"检查token过期时出错: {e}")
+            return True
+
+    async def _refresh_token(
+        self, credential_data: Dict[str, Any], filename: str, mode: str = "geminicli"
+    ) -> Optional[Dict[str, Any]]:
+        """刷新token并更新存储"""
+        await self._ensure_initialized()
+        try:
+            # 创建Credentials对象
+            creds = Credentials.from_dict(credential_data)
+
+            # 检查是否可以刷新
+            if not creds.refresh_token:
+                log.error(f"没有refresh_token，无法刷新: {filename} (mode={mode})")
+                # 自动禁用没有refresh_token的凭证
+                try:
+                    await self.update_credential_state(filename, {"disabled": True}, mode=mode)
+                    log.warning(f"凭证已自动禁用（缺少refresh_token）: {filename}")
+                except Exception as e:
+                    log.error(f"禁用凭证失败 {filename}: {e}")
+                return None
+
+            # 刷新token
+            log.debug(f"正在刷新token: {filename} (mode={mode})")
+            await creds.refresh()
+
+            # 更新凭证数据
+            if creds.access_token:
+                credential_data["access_token"] = creds.access_token
+                # 保持兼容性
+                credential_data["token"] = creds.access_token
+
+            if creds.expires_at:
+                credential_data["expiry"] = creds.expires_at.isoformat()
+
+            # 保存到存储
+            await self._storage_adapter.store_credential(filename, credential_data, mode=mode)
+            log.info(f"Token刷新成功并已保存: {filename} (mode={mode})")
+
+            return credential_data
+
+        except Exception as e:
+            error_msg = str(e)
+            log.error(f"Token刷新失败 {filename} (mode={mode}): {error_msg}")
+
+            # 尝试提取HTTP状态码（TokenError可能携带status_code属性）
+            status_code = None
+            if hasattr(e, 'status_code'):
+                status_code = e.status_code
+
+            # 检查是否是凭证永久失效的错误（只有明确的400/403等才判定为永久失效）
+            is_permanent_failure = self._is_permanent_refresh_failure(error_msg, status_code)
+
+            if is_permanent_failure:
+                log.warning(f"检测到凭证永久失效 (HTTP {status_code}): {filename}")
+                # 记录失效状态
+                if status_code:
+                    await self.record_api_call_result(filename, False, status_code, mode=mode)
+                else:
+                    await self.record_api_call_result(filename, False, 400, mode=mode)
+
+                # 禁用失效凭证
+                try:
+                    # 直接禁用该凭证（随机选择机制会自动跳过它）
+                    disabled_ok = await self.update_credential_state(filename, {"disabled": True}, mode=mode)
+                    if disabled_ok:
+                        log.warning(f"永久失效凭证已禁用: {filename}")
+                    else:
+                        log.warning("永久失效凭证禁用失败，将由上层逻辑继续处理")
+                except Exception as e2:
+                    log.error(f"禁用永久失效凭证时出错 {filename}: {e2}")
+            else:
+                # 网络错误或其他临时性错误，不封禁凭证
+                log.warning(f"Token刷新失败但非永久性错误 (HTTP {status_code})，不封禁凭证: {filename}")
+
+            return None
+
+    def _is_permanent_refresh_failure(self, error_msg: str, status_code: Optional[int] = None) -> bool:
+        """
+        判断是否是凭证永久失效的错误
+
+        Args:
+            error_msg: 错误信息
+            status_code: HTTP状态码（如果有）
+
+        Returns:
+            True表示凭证永久失效应封禁，False表示临时错误不应封禁
+        """
+        # 优先使用HTTP状态码判断
+        if status_code is not None:
+            # 400/401/403 明确表示凭证有问题，应该封禁
+            if status_code in [400, 401, 403]:
+                log.debug(f"检测到客户端错误状态码 {status_code}，判定为永久失效")
+                return True
+            # 500/502/503/504 是服务器错误，不应封禁凭证
+            elif status_code in [500, 502, 503, 504]:
+                log.debug(f"检测到服务器错误状态码 {status_code}，不应封禁凭证")
+                return False
+            # 429 (限流) 不应封禁凭证
+            elif status_code == 429:
+                log.debug("检测到限流错误 429，不应封禁凭证")
+                return False
+
+        # 如果没有状态码，回退到错误信息匹配（谨慎判断）
+        # 只有明确的凭证失效错误才判定为永久失效
+        permanent_error_patterns = [
+            "invalid_grant",
+            "refresh_token_expired",
+            "invalid_refresh_token",
+            "unauthorized_client",
+            "access_denied",
+        ]
+
+        error_msg_lower = error_msg.lower()
+        for pattern in permanent_error_patterns:
+            if pattern.lower() in error_msg_lower:
+                log.debug(f"错误信息匹配到永久失效模式: {pattern}")
+                return True
+
+        # 默认认为是临时错误（如网络问题），不应封禁凭证
+        log.debug("未匹配到明确的永久失效模式，判定为临时错误")
+        return False
+
+class _CredentialManagerSingleton:
+    """单例包装器，支持懒加载和自动初始化"""
+
+    _instance: Optional[CredentialManager] = None
+    _lock = None
+
+    def __init__(self):
+        self._manager = None
+
+    async def _get_or_create(self) -> CredentialManager:
+        """获取或创建单例实例（线程安全）"""
+        if self._instance is None:
+            # 简单的实例创建（异步环境下一般不需要复杂的锁）
+            if self._instance is None:
+                self._instance = CredentialManager()
+                await self._instance.initialize()
+                log.debug("CredentialManager singleton initialized")
+
+        return self._instance
+
+    def __getattr__(self, name):
+        """代理所有方法调用到真实的 CredentialManager 实例"""
+        async def _async_wrapper(*args, **kwargs):
+            manager = await self._get_or_create()
+            method = getattr(manager, name)
+            return await method(*args, **kwargs)
+
+        return _async_wrapper
+
+
+# 全局单例实例 - 直接导入即可使用
+credential_manager = _CredentialManagerSingleton()

src/google_oauth_api.py

@@ -0,0 +1,852 @@
+"""
+Google OAuth2 认证模块
+"""
+
+import time
+import asyncio
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import urlencode
+
+import jwt
+
+from config import (
+    get_googleapis_proxy_url,
+    get_oauth_proxy_url,
+    get_resource_manager_api_url,
+    get_service_usage_api_url,
+)
+from log import log
+
+from src.httpx_client import get_async, post_async
+
+
+class TokenError(Exception):
+    """Token相关错误"""
+
+    pass
+
+
+class Credentials:
+    """凭证类"""
+
+    def __init__(
+        self,
+        access_token: str,
+        refresh_token: str = None,
+        client_id: str = None,
+        client_secret: str = None,
+        expires_at: datetime = None,
+        project_id: str = None,
+    ):
+        self.access_token = access_token
+        self.refresh_token = refresh_token
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.expires_at = expires_at
+        self.project_id = project_id
+
+        # 反代配置将在使用时异步获取
+        self.oauth_base_url = None
+        self.token_endpoint = None
+
+    def is_expired(self) -> bool:
+        """检查token是否过期"""
+        if not self.expires_at:
+            return True
+
+        # 提前3分钟认为过期
+        buffer = timedelta(minutes=3)
+        return (self.expires_at - buffer) <= datetime.now(timezone.utc)
+
+    async def refresh_if_needed(self) -> bool:
+        """如果需要则刷新token"""
+        if not self.is_expired():
+            return False
+
+        if not self.refresh_token:
+            raise TokenError("需要刷新令牌但未提供")
+
+        await self.refresh()
+        return True
+
+    async def refresh(self):
+        """刷新访问令牌"""
+        if not self.refresh_token:
+            raise TokenError("无刷新令牌")
+
+        data = {
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "refresh_token": self.refresh_token,
+            "grant_type": "refresh_token",
+        }
+
+        try:
+            oauth_base_url = await get_oauth_proxy_url()
+            token_url = f"{oauth_base_url.rstrip('/')}/token"
+            response = await post_async(
+                token_url,
+                data=data,
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+            )
+            response.raise_for_status()
+
+            token_data = response.json()
+            self.access_token = token_data["access_token"]
+
+            if "expires_in" in token_data:
+                expires_in = int(token_data["expires_in"])
+                current_utc = datetime.now(timezone.utc)
+                self.expires_at = current_utc + timedelta(seconds=expires_in)
+                log.debug(
+                    f"Token刷新: 当前UTC时间={current_utc.isoformat()}, "
+                    f"有效期={expires_in}秒, "
+                    f"过期时间={self.expires_at.isoformat()}"
+                )
+
+            if "refresh_token" in token_data:
+                self.refresh_token = token_data["refresh_token"]
+
+            log.debug(f"Token刷新成功，过期时间: {self.expires_at}")
+
+        except Exception as e:
+            error_msg = str(e)
+            status_code = None
+            if hasattr(e, 'response') and hasattr(e.response, 'status_code'):
+                status_code = e.response.status_code
+                error_msg = f"Token刷新失败 (HTTP {status_code}): {error_msg}"
+            else:
+                error_msg = f"Token刷新失败: {error_msg}"
+
+            log.error(error_msg)
+            token_error = TokenError(error_msg)
+            token_error.status_code = status_code
+            raise token_error
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Credentials":
+        """从字典创建凭证"""
+        # 处理过期时间
+        expires_at = None
+        if "expiry" in data and data["expiry"]:
+            try:
+                expiry_str = data["expiry"]
+                if isinstance(expiry_str, str):
+                    if expiry_str.endswith("Z"):
+                        expires_at = datetime.fromisoformat(expiry_str.replace("Z", "+00:00"))
+                    elif "+" in expiry_str:
+                        expires_at = datetime.fromisoformat(expiry_str)
+                    else:
+                        expires_at = datetime.fromisoformat(expiry_str).replace(tzinfo=timezone.utc)
+            except ValueError:
+                log.warning(f"无法解析过期时间: {expiry_str}")
+
+        return cls(
+            access_token=data.get("token") or data.get("access_token", ""),
+            refresh_token=data.get("refresh_token"),
+            client_id=data.get("client_id"),
+            client_secret=data.get("client_secret"),
+            expires_at=expires_at,
+            project_id=data.get("project_id"),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转为字典"""
+        result = {
+            "access_token": self.access_token,
+            "refresh_token": self.refresh_token,
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "project_id": self.project_id,
+        }
+
+        if self.expires_at:
+            result["expiry"] = self.expires_at.isoformat()
+
+        return result
+
+
+class Flow:
+    """OAuth流程类"""
+
+    def __init__(
+        self, client_id: str, client_secret: str, scopes: List[str], redirect_uri: str = None
+    ):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.scopes = scopes
+        self.redirect_uri = redirect_uri
+
+        # 反代配置将在使用时异步获取
+        self.oauth_base_url = None
+        self.token_endpoint = None
+        self.auth_endpoint = "https://accounts.google.com/o/oauth2/auth"
+
+        self.credentials: Optional[Credentials] = None
+
+    def get_auth_url(self, state: str = None, **kwargs) -> str:
+        """生成授权URL"""
+        params = {
+            "client_id": self.client_id,
+            "redirect_uri": self.redirect_uri,
+            "scope": " ".join(self.scopes),
+            "response_type": "code",
+            "access_type": "offline",
+            "prompt": "consent",
+            "include_granted_scopes": "true",
+        }
+
+        if state:
+            params["state"] = state
+
+        params.update(kwargs)
+        return f"{self.auth_endpoint}?{urlencode(params)}"
+
+    async def exchange_code(self, code: str) -> Credentials:
+        """用授权码换取token"""
+        data = {
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "redirect_uri": self.redirect_uri,
+            "code": code,
+            "grant_type": "authorization_code",
+        }
+
+        try:
+            oauth_base_url = await get_oauth_proxy_url()
+            token_url = f"{oauth_base_url.rstrip('/')}/token"
+            response = await post_async(
+                token_url, data=data, headers={"Content-Type": "application/x-www-form-urlencoded"}
+            )
+            response.raise_for_status()
+
+            token_data = response.json()
+
+            # 计算过期时间
+            expires_at = None
+            if "expires_in" in token_data:
+                expires_in = int(token_data["expires_in"])
+                expires_at = datetime.now(timezone.utc) + timedelta(seconds=expires_in)
+
+            # 创建凭证对象
+            self.credentials = Credentials(
+                access_token=token_data["access_token"],
+                refresh_token=token_data.get("refresh_token"),
+                client_id=self.client_id,
+                client_secret=self.client_secret,
+                expires_at=expires_at,
+            )
+
+            return self.credentials
+
+        except Exception as e:
+            error_msg = f"获取token失败: {str(e)}"
+            log.error(error_msg)
+            raise TokenError(error_msg)
+
+
+class ServiceAccount:
+    """Service Account类"""
+
+    def __init__(
+        self, email: str, private_key: str, project_id: str = None, scopes: List[str] = None
+    ):
+        self.email = email
+        self.private_key = private_key
+        self.project_id = project_id
+        self.scopes = scopes or []
+
+        # 反代配置将在使用时异步获取
+        self.oauth_base_url = None
+        self.token_endpoint = None
+
+        self.access_token: Optional[str] = None
+        self.expires_at: Optional[datetime] = None
+
+    def is_expired(self) -> bool:
+        """检查token是否过期"""
+        if not self.expires_at:
+            return True
+
+        buffer = timedelta(minutes=3)
+        return (self.expires_at - buffer) <= datetime.now(timezone.utc)
+
+    def create_jwt(self) -> str:
+        """创建JWT令牌"""
+        now = int(time.time())
+
+        payload = {
+            "iss": self.email,
+            "scope": " ".join(self.scopes) if self.scopes else "",
+            "aud": self.token_endpoint,
+            "exp": now + 3600,
+            "iat": now,
+        }
+
+        return jwt.encode(payload, self.private_key, algorithm="RS256")
+
+    async def get_access_token(self) -> str:
+        """获取访问令牌"""
+        if not self.is_expired() and self.access_token:
+            return self.access_token
+
+        assertion = self.create_jwt()
+
+        data = {"grant_type": "urn:ietf:params:oauth:grant-type:jwt-bearer", "assertion": assertion}
+
+        try:
+            oauth_base_url = await get_oauth_proxy_url()
+            token_url = f"{oauth_base_url.rstrip('/')}/token"
+            response = await post_async(
+                token_url, data=data, headers={"Content-Type": "application/x-www-form-urlencoded"}
+            )
+            response.raise_for_status()
+
+            token_data = response.json()
+            self.access_token = token_data["access_token"]
+
+            if "expires_in" in token_data:
+                expires_in = int(token_data["expires_in"])
+                self.expires_at = datetime.now(timezone.utc) + timedelta(seconds=expires_in)
+
+            return self.access_token
+
+        except Exception as e:
+            error_msg = f"Service Account获取token失败: {str(e)}"
+            log.error(error_msg)
+            raise TokenError(error_msg)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any], scopes: List[str] = None) -> "ServiceAccount":
+        """从字典创建Service Account凭证"""
+        return cls(
+            email=data["client_email"],
+            private_key=data["private_key"],
+            project_id=data.get("project_id"),
+            scopes=scopes,
+        )
+
+
+# 工具函数
+async def get_user_info(credentials: Credentials) -> Optional[Dict[str, Any]]:
+    """获取用户信息"""
+    await credentials.refresh_if_needed()
+
+    try:
+        googleapis_base_url = await get_googleapis_proxy_url()
+        userinfo_url = f"{googleapis_base_url.rstrip('/')}/oauth2/v2/userinfo"
+        response = await get_async(
+            userinfo_url, headers={"Authorization": f"Bearer {credentials.access_token}"}
+        )
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        log.error(f"获取用户信息失败: {e}")
+        return None
+
+
+async def get_user_email(credentials: Credentials) -> Optional[str]:
+    """获取用户邮箱地址"""
+    try:
+        # 确保凭证有效
+        await credentials.refresh_if_needed()
+
+        # 调用Google userinfo API获取邮箱
+        user_info = await get_user_info(credentials)
+        if user_info:
+            email = user_info.get("email")
+            if email:
+                log.info(f"成功获取邮箱地址: {email}")
+                return email
+            else:
+                log.warning(f"userinfo响应中没有邮箱信息: {user_info}")
+                return None
+        else:
+            log.warning("获取用户信息失败")
+            return None
+
+    except Exception as e:
+        log.error(f"获取用户邮箱失败: {e}")
+        return None
+
+
+async def fetch_user_email_from_file(cred_data: Dict[str, Any]) -> Optional[str]:
+    """从凭证数据获取用户邮箱地址（支持统一存储）"""
+    try:
+        # 直接从凭证数据创建凭证对象
+        credentials = Credentials.from_dict(cred_data)
+        if not credentials or not credentials.access_token:
+            log.warning("无法从凭证数据创建凭证对象或获取访问令牌")
+            return None
+
+        # 获取邮箱
+        return await get_user_email(credentials)
+
+    except Exception as e:
+        log.error(f"从凭证数据获取用户邮箱失败: {e}")
+        return None
+
+
+async def validate_token(token: str) -> Optional[Dict[str, Any]]:
+    """验证访问令牌"""
+    try:
+        oauth_base_url = await get_oauth_proxy_url()
+        tokeninfo_url = f"{oauth_base_url.rstrip('/')}/tokeninfo?access_token={token}"
+
+        response = await get_async(tokeninfo_url)
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        log.error(f"验证令牌失败: {e}")
+        return None
+
+
+async def enable_required_apis(credentials: Credentials, project_id: str) -> bool:
+    """自动启用必需的API服务"""
+    try:
+        # 确保凭证有效
+        if credentials.is_expired() and credentials.refresh_token:
+            await credentials.refresh()
+
+        headers = {
+            "Authorization": f"Bearer {credentials.access_token}",
+            "Content-Type": "application/json",
+            "User-Agent": "geminicli-oauth/1.0",
+        }
+
+        # 需要启用的服务列表
+        required_services = [
+            "geminicloudassist.googleapis.com",  # Gemini Cloud Assist API
+            "cloudaicompanion.googleapis.com",  # Gemini for Google Cloud API
+        ]
+
+        for service in required_services:
+            log.info(f"正在检查并启用服务: {service}")
+
+            # 检查服务是否已启用
+            service_usage_base_url = await get_service_usage_api_url()
+            check_url = (
+                f"{service_usage_base_url.rstrip('/')}/v1/projects/{project_id}/services/{service}"
+            )
+            try:
+                check_response = await get_async(check_url, headers=headers)
+                if check_response.status_code == 200:
+                    service_data = check_response.json()
+                    if service_data.get("state") == "ENABLED":
+                        log.info(f"服务 {service} 已启用")
+                        continue
+            except Exception as e:
+                log.debug(f"检查服务状态失败，将尝试启用: {e}")
+
+            # 启用服务
+            enable_url = f"{service_usage_base_url.rstrip('/')}/v1/projects/{project_id}/services/{service}:enable"
+            try:
+                enable_response = await post_async(enable_url, headers=headers, json={})
+
+                if enable_response.status_code in [200, 201]:
+                    log.info(f"✅ 成功启用服务: {service}")
+                elif enable_response.status_code == 400:
+                    error_data = enable_response.json()
+                    if "already enabled" in error_data.get("error", {}).get("message", "").lower():
+                        log.info(f"✅ 服务 {service} 已经启用")
+                    else:
+                        log.warning(f"⚠️ 启用服务 {service} 时出现警告: {error_data}")
+                else:
+                    log.warning(
+                        f"⚠️ 启用服务 {service} 失败: {enable_response.status_code} - {enable_response.text}"
+                    )
+
+            except Exception as e:
+                log.warning(f"⚠️ 启用服务 {service} 时发生异常: {e}")
+
+        return True
+
+    except Exception as e:
+        log.error(f"启用API服务时发生错误: {e}")
+        return False
+
+
+async def get_user_projects(credentials: Credentials) -> List[Dict[str, Any]]:
+    """获取用户可访问的Google Cloud项目列表"""
+    try:
+        # 确保凭证有效
+        if credentials.is_expired() and credentials.refresh_token:
+            await credentials.refresh()
+
+        headers = {
+            "Authorization": f"Bearer {credentials.access_token}",
+            "User-Agent": "geminicli-oauth/1.0",
+        }
+
+        # 使用Resource Manager API的正确域名和端点
+        resource_manager_base_url = await get_resource_manager_api_url()
+        url = f"{resource_manager_base_url.rstrip('/')}/v1/projects"
+        log.info(f"正在调用API: {url}")
+        response = await get_async(url, headers=headers)
+
+        log.info(f"API响应状态码: {response.status_code}")
+        if response.status_code != 200:
+            log.error(f"API响应内容: {response.text}")
+
+        if response.status_code == 200:
+            data = response.json()
+            projects = data.get("projects", [])
+            # 只返回活跃的项目
+            active_projects = [
+                project for project in projects if project.get("lifecycleState") == "ACTIVE"
+            ]
+            log.info(f"获取到 {len(active_projects)} 个活跃项目")
+            return active_projects
+        else:
+            log.warning(f"获取项目列表失败: {response.status_code} - {response.text}")
+            return []
+
+    except Exception as e:
+        log.error(f"获取用户项目列表失败: {e}")
+        return []
+
+
+async def select_default_project(projects: List[Dict[str, Any]]) -> Optional[str]:
+    """从项目列表中选择默认项目"""
+    if not projects:
+        return None
+
+    # 策略1：查找显示名称或项目ID包含"default"的项目
+    for project in projects:
+        display_name = project.get("displayName", "").lower()
+        # Google API returns projectId in camelCase
+        project_id = project.get("projectId", "")
+        if "default" in display_name or "default" in project_id.lower():
+            log.info(f"选择默认项目: {project_id} ({project.get('displayName', project_id)})")
+            return project_id
+
+    # 策略2：选择第一个项目
+    first_project = projects[0]
+    # Google API returns projectId in camelCase
+    project_id = first_project.get("projectId", "")
+    log.info(
+        f"选择第一个项目作为默认: {project_id} ({first_project.get('displayName', project_id)})"
+    )
+    return project_id
+
+
+async def fetch_project_id_and_tier(
+    access_token: str,
+    user_agent: str,
+    api_base_url: str,
+    include_credits: bool = False,
+) -> Tuple[Optional[str], Optional[str]] | Tuple[Optional[str], Optional[str], Optional[int]]:
+    """
+    从 API 获取 project_id 和订阅等级
+
+    Args:
+        access_token: Google OAuth access token
+        user_agent: User-Agent header
+        api_base_url: API base URL (e.g., antigravity or code assist endpoint)
+
+    Returns:
+        默认返回 (project_id, subscription_tier)
+        当 include_credits=True 时返回 (project_id, subscription_tier, credit_amount)
+        subscription_tier 可能是 "FREE", "PRO", "ULTRA" 或 None
+        credit_amount 为积分数量（整数）或 None
+    """
+    headers = {
+        'User-Agent': user_agent,
+        'Authorization': f'Bearer {access_token}',
+        'Content-Type': 'application/json',
+        'Accept-Encoding': 'gzip'
+    }
+
+    def _map_raw_tier(raw_tier: Optional[str]) -> Optional[str]:
+        """将 loadCodeAssist 返回的 raw tier 映射为统一 tier。"""
+        if not raw_tier:
+            return None
+
+        tier_mapping = {
+            "g1-ultra-tier": "ultra",
+            "ws-ai-ultra-business-tier": "ultra",
+            "g1-pro-tier": "pro",
+            "helium-tier": "pro",
+            "standard-tier": "pro",
+            "free-tier": "free",
+        }
+
+        return tier_mapping.get(raw_tier.lower(), "pro")
+
+    subscription_tier = None
+    credit_amount: Optional[int] = None
+
+    # 步骤 1: 尝试 loadCodeAssist
+    try:
+        project_id, raw_tier, raw_credit_amount = await _try_load_code_assist(api_base_url, headers)
+        subscription_tier = _map_raw_tier(raw_tier)
+
+        if raw_credit_amount is not None:
+            try:
+                credit_amount = int(raw_credit_amount)
+                log.info(
+                    f"[fetch_project_id_and_tier] Found credit_amount: {credit_amount}"
+                )
+            except (TypeError, ValueError):
+                log.warning(
+                    f"[fetch_project_id_and_tier] Invalid credit_amount: {raw_credit_amount}"
+                )
+
+        if raw_tier:
+            log.info(
+                f"[fetch_project_id_and_tier] Raw tier '{raw_tier}' mapped to '{subscription_tier}'"
+            )
+
+        if project_id:
+            if include_credits:
+                return project_id, subscription_tier, credit_amount
+            return project_id, subscription_tier
+
+        log.warning("[fetch_project_id_and_tier] loadCodeAssist did not return project_id, falling back to onboardUser")
+
+    except Exception as e:
+        log.warning(f"[fetch_project_id_and_tier] loadCodeAssist failed: {type(e).__name__}: {e}")
+        log.warning("[fetch_project_id_and_tier] Falling back to onboardUser")
+
+    # 步骤 2: 回退到 onboardUser
+    try:
+        project_id = await _try_onboard_user(api_base_url, headers)
+        if project_id:
+            if include_credits:
+                return project_id, subscription_tier, credit_amount
+            return project_id, subscription_tier
+
+        log.error("[fetch_project_id_and_tier] Failed to get project_id from both loadCodeAssist and onboardUser")
+        if include_credits:
+            return None, subscription_tier, credit_amount
+        return None, subscription_tier
+
+    except Exception as e:
+        log.error(f"[fetch_project_id_and_tier] onboardUser failed: {type(e).__name__}: {e}")
+        import traceback
+        log.debug(f"[fetch_project_id_and_tier] Traceback: {traceback.format_exc()}")
+        if include_credits:
+            return None, subscription_tier, credit_amount
+        return None, subscription_tier
+
+
+async def _try_load_code_assist(
+    api_base_url: str,
+    headers: dict
+) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    """
+    尝试通过 loadCodeAssist 获取 project_id 和订阅等级
+
+    Returns:
+        (project_id, subscription_tier, credit_amount) 元组
+        subscription_tier 可能是 "FREE", "PRO", "ULTRA" 或 None
+        credit_amount 为字符串格式积分或 None
+    """
+    request_url = f"{api_base_url.rstrip('/')}/v1internal:loadCodeAssist"
+    request_body = {
+        "metadata": {
+            "ideType": "ANTIGRAVITY"
+        }
+    }
+
+    log.debug(f"[loadCodeAssist] Fetching project_id from: {request_url}")
+    log.debug(f"[loadCodeAssist] Request body: {request_body}")
+
+    response = await post_async(
+        request_url,
+        json=request_body,
+        headers=headers,
+        timeout=30.0,
+    )
+
+    log.debug(f"[loadCodeAssist] Response status: {response.status_code}")
+
+    if response.status_code == 200:
+        response_text = response.text
+        log.debug(f"[loadCodeAssist] Response body: {response_text}")
+
+        data = response.json()
+        log.debug(f"[loadCodeAssist] Response JSON keys: {list(data.keys())}")
+
+        # 提取订阅等级 - 优先使用 paidTier（更准确反映实际权益）
+        paid_tier = data.get("paidTier", {})
+        current_tier = data.get("currentTier", {})
+        available_credits = paid_tier.get("availableCredits", []) if isinstance(paid_tier, dict) else []
+
+        # paidTier.id 优先，然后是 currentTier.id
+        subscription_tier = None
+        if isinstance(paid_tier, dict) and paid_tier.get("id"):
+            subscription_tier = paid_tier.get("id")
+            log.info(f"[loadCodeAssist] Found paidTier: {subscription_tier}")
+        elif isinstance(current_tier, dict) and current_tier.get("id"):
+            subscription_tier = current_tier.get("id")
+            log.info(f"[loadCodeAssist] Found currentTier: {subscription_tier}")
+
+        # 提取积分数量（如果返回了 availableCredits）
+        credit_amount = None
+        if isinstance(available_credits, list) and available_credits:
+            first_credit = available_credits[0]
+            if isinstance(first_credit, dict):
+                credit_amount = first_credit.get("creditAmount")
+                if credit_amount is not None:
+                    log.info(f"[loadCodeAssist] Found creditAmount: {credit_amount}")
+
+        # 检查是否有 currentTier（表示用户已激活）
+        if current_tier:
+            log.info("[loadCodeAssist] User is already activated")
+
+            # 使用服务器返回的 project_id
+            project_id = data.get("cloudaicompanionProject")
+            if project_id:
+                log.info(f"[loadCodeAssist] Successfully fetched project_id: {project_id}, tier: {subscription_tier}")
+                return project_id, subscription_tier, credit_amount
+
+            log.warning("[loadCodeAssist] No project_id in response")
+            return None, subscription_tier, credit_amount
+        else:
+            log.info("[loadCodeAssist] User not activated yet (no currentTier)")
+            return None, None, credit_amount
+    else:
+        log.warning(f"[loadCodeAssist] Failed: HTTP {response.status_code}")
+        log.warning(f"[loadCodeAssist] Response body: {response.text[:500]}")
+        raise Exception(f"HTTP {response.status_code}: {response.text[:200]}")
+
+
+async def _try_onboard_user(
+    api_base_url: str,
+    headers: dict
+) -> Optional[str]:
+    """
+    尝试通过 onboardUser 获取 project_id（长时间运行操作，需要轮询）
+
+    Returns:
+        project_id 或 None
+    """
+    request_url = f"{api_base_url.rstrip('/')}/v1internal:onboardUser"
+
+    # 首先需要获取用户的 tier 信息
+    tier_id = await _get_onboard_tier(api_base_url, headers)
+    if not tier_id:
+        log.error("[onboardUser] Failed to determine user tier")
+        return None
+
+    log.info(f"[onboardUser] User tier: {tier_id}")
+
+    # 构造 onboardUser 请求
+    # 注意：FREE tier 不应该包含 cloudaicompanionProject
+    request_body = {
+        "tierId": tier_id,
+        "metadata": {
+            "ideType": "ANTIGRAVITY",
+            "platform": "PLATFORM_UNSPECIFIED",
+            "pluginType": "GEMINI"
+        }
+    }
+
+    log.debug(f"[onboardUser] Request URL: {request_url}")
+    log.debug(f"[onboardUser] Request body: {request_body}")
+
+    # onboardUser 是长时间运行操作，需要轮询
+    # 最多等待 10 秒（5 次 * 2 秒）
+    max_attempts = 5
+    attempt = 0
+
+    while attempt < max_attempts:
+        attempt += 1
+        log.debug(f"[onboardUser] Polling attempt {attempt}/{max_attempts}")
+
+        response = await post_async(
+            request_url,
+            json=request_body,
+            headers=headers,
+            timeout=30.0,
+        )
+
+        log.debug(f"[onboardUser] Response status: {response.status_code}")
+
+        if response.status_code == 200:
+            data = response.json()
+            log.debug(f"[onboardUser] Response data: {data}")
+
+            # 检查长时间运行操作是否完成
+            if data.get("done"):
+                log.info("[onboardUser] Operation completed")
+
+                # 从响应中提取 project_id
+                response_data = data.get("response", {})
+                project_obj = response_data.get("cloudaicompanionProject", {})
+
+                if isinstance(project_obj, dict):
+                    project_id = project_obj.get("id")
+                elif isinstance(project_obj, str):
+                    project_id = project_obj
+                else:
+                    project_id = None
+
+                if project_id:
+                    log.info(f"[onboardUser] Successfully fetched project_id: {project_id}")
+                    return project_id
+                else:
+                    log.warning("[onboardUser] Operation completed but no project_id in response")
+                    return None
+            else:
+                log.debug("[onboardUser] Operation still in progress, waiting 2 seconds...")
+                await asyncio.sleep(2)
+        else:
+            log.warning(f"[onboardUser] Failed: HTTP {response.status_code}")
+            log.warning(f"[onboardUser] Response body: {response.text[:500]}")
+            raise Exception(f"HTTP {response.status_code}: {response.text[:200]}")
+
+    log.error("[onboardUser] Timeout: Operation did not complete within 10 seconds")
+    return None
+
+
+async def _get_onboard_tier(
+    api_base_url: str,
+    headers: dict
+) -> Optional[str]:
+    """
+    从 loadCodeAssist 响应中获取用户应该注册的 tier
+
+    Returns:
+        tier_id (如 "FREE", "STANDARD", "LEGACY") 或 None
+    """
+    request_url = f"{api_base_url.rstrip('/')}/v1internal:loadCodeAssist"
+    request_body = {
+        "metadata": {
+            "ideType": "ANTIGRAVITY",
+            "platform": "PLATFORM_UNSPECIFIED",
+            "pluginType": "GEMINI"
+        }
+    }
+
+    log.debug(f"[_get_onboard_tier] Fetching tier info from: {request_url}")
+
+    response = await post_async(
+        request_url,
+        json=request_body,
+        headers=headers,
+        timeout=30.0,
+    )
+
+    if response.status_code == 200:
+        data = response.json()
+        log.debug(f"[_get_onboard_tier] Response data: {data}")
+
+        # 查找默认的 tier
+        allowed_tiers = data.get("allowedTiers", [])
+        for tier in allowed_tiers:
+            if tier.get("isDefault"):
+                tier_id = tier.get("id")
+                log.info(f"[_get_onboard_tier] Found default tier: {tier_id}")
+                return tier_id
+
+        # 如果没有默认 tier，使用 LEGACY 作为回退
+        log.warning("[_get_onboard_tier] No default tier found, using LEGACY")
+        return "LEGACY"
+    else:
+        log.error(f"[_get_onboard_tier] Failed to fetch tier info: HTTP {response.status_code}")
+        return None
+
+

src/httpx_client.py

@@ -0,0 +1,121 @@
+"""
+通用的HTTP客户端模块
+为所有需要使用httpx的模块提供统一的客户端配置和方法
+保持通用性，不与特定业务逻辑耦合
+"""
+
+from contextlib import asynccontextmanager
+from typing import Any, AsyncGenerator, Dict, Optional
+
+import httpx
+
+from config import get_proxy_config
+from log import log
+
+
+class HttpxClientManager:
+    """通用HTTP客户端管理器"""
+
+    async def get_client_kwargs(self, timeout: float = 30.0, **kwargs) -> Dict[str, Any]:
+        """获取httpx客户端的通用配置参数"""
+        client_kwargs = {"timeout": timeout, **kwargs}
+
+        # 动态读取代理配置，支持热更新
+        current_proxy_config = await get_proxy_config()
+        if current_proxy_config:
+            client_kwargs["proxy"] = current_proxy_config
+
+        return client_kwargs
+
+    @asynccontextmanager
+    async def get_client(
+        self, timeout: float = 30.0, **kwargs
+    ) -> AsyncGenerator[httpx.AsyncClient, None]:
+        """获取配置好的异步HTTP客户端"""
+        client_kwargs = await self.get_client_kwargs(timeout=timeout, **kwargs)
+
+        async with httpx.AsyncClient(**client_kwargs) as client:
+            yield client
+
+    @asynccontextmanager
+    async def get_streaming_client(
+        self, timeout: float = None, **kwargs
+    ) -> AsyncGenerator[httpx.AsyncClient, None]:
+        """获取用于流式请求的HTTP客户端（无超时限制）"""
+        client_kwargs = await self.get_client_kwargs(timeout=timeout, **kwargs)
+
+        # 创建独立的客户端实例用于流式处理
+        client = httpx.AsyncClient(**client_kwargs)
+        try:
+            yield client
+        finally:
+            # 确保无论发生什么都关闭客户端
+            try:
+                await client.aclose()
+            except Exception as e:
+                log.warning(f"Error closing streaming client: {e}")
+
+
+# 全局HTTP客户端管理器实例
+http_client = HttpxClientManager()
+
+
+# 通用的异步方法
+async def get_async(
+    url: str, headers: Optional[Dict[str, str]] = None, timeout: float = 30.0, **kwargs
+) -> httpx.Response:
+    """通用异步GET请求"""
+    async with http_client.get_client(timeout=timeout, **kwargs) as client:
+        return await client.get(url, headers=headers)
+
+
+async def post_async(
+    url: str,
+    data: Any = None,
+    json: Any = None,
+    headers: Optional[Dict[str, str]] = None,
+    timeout: float = 900.0,
+    **kwargs,
+) -> httpx.Response:
+    """通用异步POST请求"""
+    async with http_client.get_client(timeout=timeout, **kwargs) as client:
+        return await client.post(url, data=data, json=json, headers=headers)
+
+
+# 调试用：设为 True 时所有流式请求都返回 429
+_MOCK_STREAM_429 = False
+
+async def stream_post_async(
+    url: str,
+    body: Dict[str, Any],
+    native: bool = False,
+    headers: Optional[Dict[str, str]] = None,
+    **kwargs,
+):
+    """流式异步POST请求"""
+    if _MOCK_STREAM_429:
+        from fastapi import Response
+        import json
+        log.warning(f"[MOCK] stream_post_async: 返回模拟429错误")
+        yield Response(
+            content=json.dumps({"error": {"code": 429, "message": "mock rate limit", "status": "RESOURCE_EXHAUSTED"}}),
+            status_code=429,
+        )
+        return
+
+    async with http_client.get_streaming_client(**kwargs) as client:
+        async with client.stream("POST", url, json=body, headers=headers) as r:
+            # 错误直接返回
+            if r.status_code != 200:
+                from fastapi import Response
+                yield Response(await r.aread(), r.status_code, dict(r.headers))
+                return
+
+            # 如果native=True，直接返回bytes流
+            if native:
+                async for chunk in r.aiter_bytes():
+                    yield chunk
+            else:
+                # 通过aiter_lines转化成str流返回
+                async for line in r.aiter_lines():
+                    yield line

src/keeplive.py

@@ -0,0 +1,88 @@
+"""
+保活服务模块
+定期向配置的URL发送GET请求，保持服务在线
+未配置保活URL时不启动任何任务，零资源占用
+"""
+
+import asyncio
+from typing import Optional
+
+from config import get_keepalive_interval, get_keepalive_url
+from log import log
+from src.httpx_client import get_async
+
+
+class KeepAliveService:
+    """保活服务：定期向指定URL发送GET请求"""
+
+    def __init__(self):
+        self._task: Optional[asyncio.Task] = None
+
+    async def _run(self, url: str, interval: int):
+        """保活循环，读取到有效URL才会被调用"""
+        log.info(f"[KeepAlive] 保活任务启动，URL={url}，间隔={interval}s")
+        while True:
+            try:
+                response = await get_async(url, timeout=30.0)
+                log.info(f"[KeepAlive] GET {url} -> {response.status_code}")
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                log.warning(f"[KeepAlive] GET {url} 失败: {e}")
+
+            try:
+                await asyncio.sleep(interval)
+            except asyncio.CancelledError:
+                raise
+
+    async def start(self):
+        """
+        启动保活服务。
+        仅当配置了有效的保活URL时才创建后台任务，否则零开销。
+        """
+        if self._task and not self._task.done():
+            # 已有任务在运行，不重复启动
+            return
+
+        url = await get_keepalive_url()
+        interval = await get_keepalive_interval()
+
+        if not url or not url.strip():
+            log.debug("[KeepAlive] 未配置保活URL，保活服务不启动")
+            return
+
+        if interval <= 0:
+            log.warning(f"[KeepAlive] 保活间隔无效（{interval}），保活服务不启动")
+            return
+
+        self._task = asyncio.create_task(
+            self._run(url.strip(), interval), name="keepalive_service"
+        )
+
+    async def stop(self):
+        """停止保活服务"""
+        if self._task and not self._task.done():
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            log.info("[KeepAlive] 保活服务已停止")
+        self._task = None
+
+    async def restart(self):
+        """
+        重启保活服务。
+        配置变更时调用，会停止旧任务并根据最新配置决定是否启动新任务。
+        """
+        await self.stop()
+        await self.start()
+
+    @property
+    def is_running(self) -> bool:
+        """当前保活任务是否在运行"""
+        return self._task is not None and not self._task.done()
+
+
+# 全局保活服务实例
+keepalive_service = KeepAliveService()

src/models.py

@@ -0,0 +1,383 @@
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+# Pydantic v1/v2 兼容性辅助函数
+def model_to_dict(model: BaseModel) -> Dict[str, Any]:
+    """
+    兼容 Pydantic v1 和 v2 的模型转字典方法，排除 None 值
+    - v1: model.dict(exclude_none=True)
+    - v2: model.model_dump(exclude_none=True)
+    """
+    if hasattr(model, 'model_dump'):
+        # Pydantic v2
+        return model.model_dump(exclude_none=True)
+    else:
+        # Pydantic v1
+        return model.dict(exclude_none=True)
+
+
+# Common Models
+class Model(BaseModel):
+    id: str
+    object: str = "model"
+    created: Optional[int] = None
+    owned_by: Optional[str] = "google"
+
+
+class ModelList(BaseModel):
+    object: str = "list"
+    data: List[Model]
+
+
+# OpenAI Models
+class OpenAIToolFunction(BaseModel):
+    name: str
+    arguments: str  # JSON string
+
+
+class OpenAIToolCall(BaseModel):
+    id: str
+    type: str = "function"
+    function: OpenAIToolFunction
+
+
+class OpenAITool(BaseModel):
+    type: str = "function"
+    function: Dict[str, Any]
+
+
+class OpenAIChatMessage(BaseModel):
+    role: str
+    content: Union[str, List[Dict[str, Any]], None] = None
+    reasoning_content: Optional[str] = None
+    name: Optional[str] = None
+    tool_calls: Optional[List[OpenAIToolCall]] = None
+    tool_call_id: Optional[str] = None  # for role="tool"
+
+
+class OpenAIChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[OpenAIChatMessage]
+    stream: bool = False
+    temperature: Optional[float] = Field(None, ge=0.0, le=2.0)
+    top_p: Optional[float] = Field(None, ge=0.0, le=1.0)
+    max_tokens: Optional[int] = Field(None, ge=1)
+    stop: Optional[Union[str, List[str]]] = None
+    frequency_penalty: Optional[float] = Field(None, ge=-2.0, le=2.0)
+    presence_penalty: Optional[float] = Field(None, ge=-2.0, le=2.0)
+    n: Optional[int] = Field(1, ge=1, le=128)
+    seed: Optional[int] = None
+    response_format: Optional[Dict[str, Any]] = None
+    top_k: Optional[int] = Field(None, ge=1)
+    tools: Optional[List[OpenAITool]] = None
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None
+
+    class Config:
+        extra = "allow"  # Allow additional fields not explicitly defined
+
+
+# 通用的聊天完成请求模型（兼容OpenAI和其他格式）
+ChatCompletionRequest = OpenAIChatCompletionRequest
+
+
+class OpenAIChatCompletionChoice(BaseModel):
+    index: int
+    message: OpenAIChatMessage
+    finish_reason: Optional[str] = None
+    logprobs: Optional[Dict[str, Any]] = None
+
+
+class OpenAIChatCompletionResponse(BaseModel):
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[OpenAIChatCompletionChoice]
+    usage: Optional[Dict[str, Any]] = None
+    system_fingerprint: Optional[str] = None
+
+
+class OpenAIDelta(BaseModel):
+    role: Optional[str] = None
+    content: Optional[str] = None
+    reasoning_content: Optional[str] = None
+
+
+class OpenAIChatCompletionStreamChoice(BaseModel):
+    index: int
+    delta: OpenAIDelta
+    finish_reason: Optional[str] = None
+    logprobs: Optional[Dict[str, Any]] = None
+
+
+class OpenAIChatCompletionStreamResponse(BaseModel):
+    id: str
+    object: str = "chat.completion.chunk"
+    created: int
+    model: str
+    choices: List[OpenAIChatCompletionStreamChoice]
+    system_fingerprint: Optional[str] = None
+
+
+# Gemini Models
+class GeminiPart(BaseModel):
+    text: Optional[str] = None
+    inlineData: Optional[Dict[str, Any]] = None
+    fileData: Optional[Dict[str, Any]] = None
+    thought: Optional[bool] = None  # 改为 None，避免序列化时包含 False
+    
+    class Config:
+        extra = "allow"  # 允许额外字段（如 functionCall, functionResponse）
+
+
+class GeminiContent(BaseModel):
+    role: str
+    parts: List[GeminiPart]
+
+
+class GeminiSystemInstruction(BaseModel):
+    parts: List[GeminiPart]
+
+
+class GeminiImageConfig(BaseModel):
+    """图片生成配置"""
+    aspect_ratio: Optional[str] = None  # "1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"
+    image_size: Optional[str] = None  # "1K", "2K", "4K"
+
+
+class GeminiGenerationConfig(BaseModel):
+    temperature: Optional[float] = Field(None, ge=0.0, le=2.0)
+    topP: Optional[float] = Field(None, ge=0.0, le=1.0)
+    topK: Optional[int] = Field(None, ge=1)
+    maxOutputTokens: Optional[int] = Field(None, ge=1)
+    stopSequences: Optional[List[str]] = None
+    responseMimeType: Optional[str] = None
+    responseSchema: Optional[Dict[str, Any]] = None
+    candidateCount: Optional[int] = Field(None, ge=1, le=8)
+    seed: Optional[int] = None
+    frequencyPenalty: Optional[float] = Field(None, ge=-2.0, le=2.0)
+    presencePenalty: Optional[float] = Field(None, ge=-2.0, le=2.0)
+    thinkingConfig: Optional[Dict[str, Any]] = None
+    # 图片生成相关参数
+    response_modalities: Optional[List[str]] = None  # ["TEXT", "IMAGE"]
+    image_config: Optional[GeminiImageConfig] = None
+
+
+class GeminiSafetySetting(BaseModel):
+    category: str
+    threshold: str
+
+
+class GeminiRequest(BaseModel):
+    contents: List[GeminiContent]
+    systemInstruction: Optional[GeminiSystemInstruction] = None
+    generationConfig: Optional[GeminiGenerationConfig] = None
+    safetySettings: Optional[List[GeminiSafetySetting]] = None
+    tools: Optional[List[Dict[str, Any]]] = None
+    toolConfig: Optional[Dict[str, Any]] = None
+    cachedContent: Optional[str] = None
+
+    class Config:
+        extra = "allow"  # 允许透传未定义的字段
+
+
+class GeminiCandidate(BaseModel):
+    content: GeminiContent
+    finishReason: Optional[str] = None
+    index: int = 0
+    safetyRatings: Optional[List[Dict[str, Any]]] = None
+    citationMetadata: Optional[Dict[str, Any]] = None
+    tokenCount: Optional[int] = None
+
+
+class GeminiUsageMetadata(BaseModel):
+    promptTokenCount: Optional[int] = None
+    candidatesTokenCount: Optional[int] = None
+    totalTokenCount: Optional[int] = None
+    cachedContentTokenCount: Optional[int] = None
+    thoughtsTokenCount: Optional[int] = None
+
+
+class GeminiResponse(BaseModel):
+    candidates: List[GeminiCandidate]
+    usageMetadata: Optional[GeminiUsageMetadata] = None
+    modelVersion: Optional[str] = None
+
+
+# Claude Models
+class ClaudeContentBlock(BaseModel):
+    type: str  # "text", "image", "tool_use", "tool_result"
+    text: Optional[str] = None
+    source: Optional[Dict[str, Any]] = None  # for image type
+    id: Optional[str] = None  # for tool_use
+    name: Optional[str] = None  # for tool_use
+    input: Optional[Dict[str, Any]] = None  # for tool_use
+    tool_use_id: Optional[str] = None  # for tool_result
+    content: Optional[Union[str, List[Dict[str, Any]]]] = None  # for tool_result
+
+
+class ClaudeMessage(BaseModel):
+    role: str  # "user" or "assistant"
+    content: Union[str, List[ClaudeContentBlock]]
+
+
+class ClaudeTool(BaseModel):
+    name: str
+    description: Optional[str] = None
+    input_schema: Dict[str, Any]
+
+
+class ClaudeMetadata(BaseModel):
+    user_id: Optional[str] = None
+
+
+class ClaudeRequest(BaseModel):
+    model: str
+    messages: List[ClaudeMessage]
+    max_tokens: int = Field(..., ge=1)
+    system: Optional[Union[str, List[Dict[str, Any]]]] = None
+    temperature: Optional[float] = Field(None, ge=0.0, le=1.0)
+    top_p: Optional[float] = Field(None, ge=0.0, le=1.0)
+    top_k: Optional[int] = Field(None, ge=1)
+    stop_sequences: Optional[List[str]] = None
+    stream: bool = False
+    metadata: Optional[ClaudeMetadata] = None
+    tools: Optional[List[ClaudeTool]] = None
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None
+
+    class Config:
+        extra = "allow"
+
+
+class ClaudeUsage(BaseModel):
+    input_tokens: int
+    output_tokens: int
+    cache_creation_input_tokens: Optional[int] = None
+    cache_read_input_tokens: Optional[int] = None
+
+
+class ClaudeResponse(BaseModel):
+    id: str
+    type: str = "message"
+    role: str = "assistant"
+    content: List[ClaudeContentBlock]
+    model: str
+    stop_reason: Optional[str] = None
+    stop_sequence: Optional[str] = None
+    usage: ClaudeUsage
+
+
+class ClaudeStreamEvent(BaseModel):
+    type: str  # "message_start", "content_block_start", "content_block_delta", "content_block_stop", "message_delta", "message_stop"
+    message: Optional[ClaudeResponse] = None
+    index: Optional[int] = None
+    content_block: Optional[ClaudeContentBlock] = None
+    delta: Optional[Dict[str, Any]] = None
+    usage: Optional[ClaudeUsage] = None
+
+    class Config:
+        extra = "allow"
+
+
+# Error Models
+class APIError(BaseModel):
+    message: str
+    type: str = "api_error"
+    code: Optional[int] = None
+
+
+class ErrorResponse(BaseModel):
+    error: APIError
+
+
+# Control Panel Models
+class SystemStatus(BaseModel):
+    status: str
+    timestamp: str
+    credentials: Dict[str, int]
+    config: Dict[str, Any]
+    current_credential: str
+
+
+class CredentialInfo(BaseModel):
+    filename: str
+    project_id: Optional[str] = None
+    status: Dict[str, Any]
+    size: Optional[int] = None
+    modified_time: Optional[str] = None
+    error: Optional[str] = None
+
+
+class LogEntry(BaseModel):
+    timestamp: str
+    level: str
+    message: str
+    module: Optional[str] = None
+
+
+class ConfigValue(BaseModel):
+    key: str
+    value: Any
+    env_locked: bool = False
+    description: Optional[str] = None
+
+
+# Authentication Models
+class AuthRequest(BaseModel):
+    project_id: Optional[str] = None
+    user_session: Optional[str] = None
+
+
+class AuthResponse(BaseModel):
+    success: bool
+    auth_url: Optional[str] = None
+    state: Optional[str] = None
+    error: Optional[str] = None
+    credentials: Optional[Dict[str, Any]] = None
+    file_path: Optional[str] = None
+    requires_manual_project_id: Optional[bool] = None
+    requires_project_selection: Optional[bool] = None
+    available_projects: Optional[List[Dict[str, str]]] = None
+
+
+class CredentialStatus(BaseModel):
+    disabled: bool = False
+    error_codes: List[int] = []
+    last_success: Optional[str] = None
+
+
+# Web Routes Models
+class LoginRequest(BaseModel):
+    password: str
+
+
+class AuthStartRequest(BaseModel):
+    project_id: Optional[str] = None  # 现在是可选的
+    mode: Optional[str] = "geminicli"  # 凭证模式: geminicli 或 antigravity
+
+
+class AuthCallbackRequest(BaseModel):
+    project_id: Optional[str] = None  # 现在是可选的
+    mode: Optional[str] = "geminicli"  # 凭证模式: geminicli 或 antigravity
+
+
+class AuthCallbackUrlRequest(BaseModel):
+    callback_url: str  # OAuth回调完整URL
+    project_id: Optional[str] = None  # 可选的项目ID
+    mode: Optional[str] = "geminicli"  # 凭证模式: geminicli 或 antigravity
+
+
+class CredFileActionRequest(BaseModel):
+    filename: str
+    action: str  # enable, disable, delete
+
+
+class CredFileBatchActionRequest(BaseModel):
+    action: str  # "enable", "disable", "delete"
+    filenames: List[str]  # 批量操作的文件名列表
+
+
+class ConfigSaveRequest(BaseModel):
+    config: dict

src/panel/__init__.py

@@ -0,0 +1,37 @@
+"""
+Panel模块 - 整合所有控制面板路由
+"""
+
+from fastapi import APIRouter
+
+from . import auth, creds, config_routes, logs, version, root
+
+
+def create_router() -> APIRouter:
+    """创建并返回整合所有子路由的主路由器"""
+    router = APIRouter()
+
+    # 包含所有子路由
+    router.include_router(root.router)
+    router.include_router(auth.router)
+    router.include_router(creds.router)
+    router.include_router(config_routes.router)
+    router.include_router(logs.router)
+    router.include_router(version.router)
+
+    return router
+
+
+# 导出主路由器
+router = create_router()
+
+# 导出常用工具
+from .utils import ConnectionManager, is_mobile_user_agent, validate_mode, get_env_locked_keys
+
+__all__ = [
+    "router",
+    "ConnectionManager",
+    "is_mobile_user_agent",
+    "validate_mode",
+    "get_env_locked_keys",
+]

src/panel/auth.py

@@ -0,0 +1,192 @@
+"""
+认证路由模块 - 处理 /auth/* 相关的HTTP请求
+"""
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import JSONResponse
+
+from log import log
+from src.auth import (
+    asyncio_complete_auth_flow,
+    complete_auth_flow_from_callback_url,
+    create_auth_url,
+    get_auth_status,
+    verify_password,
+)
+from src.models import (
+    LoginRequest,
+    AuthStartRequest,
+    AuthCallbackRequest,
+    AuthCallbackUrlRequest,
+)
+from src.utils import verify_panel_token
+
+
+# 创建路由器
+router = APIRouter(prefix="/auth", tags=["auth"])
+
+
+@router.post("/login")
+async def login(request: LoginRequest):
+    """用户登录（简化版：直接返回密码作为token）"""
+    try:
+        if await verify_password(request.password):
+            # 直接使用密码作为token，简化认证流程
+            return JSONResponse(content={"token": request.password, "message": "登录成功"})
+        else:
+            raise HTTPException(status_code=401, detail="密码错误")
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"登录失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/start")
+async def start_auth(request: AuthStartRequest, token: str = Depends(verify_panel_token)):
+    """开始认证流程，支持自动检测项目ID"""
+    try:
+        # 如果没有提供项目ID，尝试自动检测
+        project_id = request.project_id
+        if not project_id:
+            log.info("用户未提供项目ID，后续将使用自动检测...")
+
+        # 使用认证令牌作为用户会话标识
+        user_session = token if token else None
+        result = await create_auth_url(
+            project_id, user_session, mode=request.mode
+        )
+
+        if result["success"]:
+            return JSONResponse(
+                content={
+                    "auth_url": result["auth_url"],
+                    "state": result["state"],
+                    "auto_project_detection": result.get("auto_project_detection", False),
+                    "detected_project_id": result.get("detected_project_id"),
+                }
+            )
+        else:
+            raise HTTPException(status_code=500, detail=result["error"])
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"开始认证流程失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/callback")
+async def auth_callback(request: AuthCallbackRequest, token: str = Depends(verify_panel_token)):
+    """处理认证回调，支持自动检测项目ID"""
+    try:
+        # 项目ID现在是可选的，在回调处理中进行自动检测
+        project_id = request.project_id
+
+        # 使用认证令牌作为用户会话标识
+        user_session = token if token else None
+        # 异步等待OAuth回调完成
+        result = await asyncio_complete_auth_flow(
+            project_id, user_session, mode=request.mode
+        )
+
+        if result["success"]:
+            # 单项目认证成功
+            return JSONResponse(
+                content={
+                    "credentials": result["credentials"],
+                    "file_path": result["file_path"],
+                    "message": "认证成功，凭证已保存",
+                    "auto_detected_project": result.get("auto_detected_project", False),
+                }
+            )
+        else:
+            # 如果需要手动项目ID或项目选择，在响应中标明
+            if result.get("requires_manual_project_id"):
+                # 使用JSON响应
+                return JSONResponse(
+                    status_code=400,
+                    content={"error": result["error"], "requires_manual_project_id": True},
+                )
+            elif result.get("requires_project_selection"):
+                # 返回项目列表供用户选择
+                return JSONResponse(
+                    status_code=400,
+                    content={
+                        "error": result["error"],
+                        "requires_project_selection": True,
+                        "available_projects": result["available_projects"],
+                    },
+                )
+            else:
+                raise HTTPException(status_code=400, detail=result["error"])
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"处理认证回调失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/callback-url")
+async def auth_callback_url(request: AuthCallbackUrlRequest, token: str = Depends(verify_panel_token)):
+    """从回调URL直接完成认证"""
+    try:
+        # 验证URL格式
+        if not request.callback_url or not request.callback_url.startswith(("http://", "https://")):
+            raise HTTPException(status_code=400, detail="请提供有效的回调URL")
+
+        # 从回调URL完成认证
+        result = await complete_auth_flow_from_callback_url(
+            request.callback_url, request.project_id, mode=request.mode
+        )
+
+        if result["success"]:
+            # 单项目认证成功
+            return JSONResponse(
+                content={
+                    "credentials": result["credentials"],
+                    "file_path": result["file_path"],
+                    "message": "从回调URL认证成功，凭证已保存",
+                    "auto_detected_project": result.get("auto_detected_project", False),
+                }
+            )
+        else:
+            # 处理各种错误情况
+            if result.get("requires_manual_project_id"):
+                return JSONResponse(
+                    status_code=400,
+                    content={"error": result["error"], "requires_manual_project_id": True},
+                )
+            elif result.get("requires_project_selection"):
+                return JSONResponse(
+                    status_code=400,
+                    content={
+                        "error": result["error"],
+                        "requires_project_selection": True,
+                        "available_projects": result["available_projects"],
+                    },
+                )
+            else:
+                raise HTTPException(status_code=400, detail=result["error"])
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"从回调URL处理认证失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/status/{project_id}")
+async def check_auth_status(project_id: str, token: str = Depends(verify_panel_token)):
+    """检查认证状态"""
+    try:
+        if not project_id:
+            raise HTTPException(status_code=400, detail="Project ID 不能为空")
+
+        status = get_auth_status(project_id)
+        return JSONResponse(content=status)
+
+    except Exception as e:
+        log.error(f"检查认证状态失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

src/panel/config_routes.py

@@ -0,0 +1,230 @@
+"""
+配置路由模块 - 处理 /config/* 相关的HTTP请求
+"""
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import JSONResponse
+
+import config
+from log import log
+from src.keeplive import keepalive_service
+from src.models import ConfigSaveRequest
+from src.storage_adapter import get_storage_adapter
+from src.utils import verify_panel_token
+from .utils import get_env_locked_keys
+
+
+# 创建路由器
+router = APIRouter(prefix="/config", tags=["config"])
+
+
+@router.get("/get")
+async def get_config(token: str = Depends(verify_panel_token)):
+    """获取当前配置"""
+    try:
+
+
+        # 读取当前配置（包括环境变量和TOML文件中的配置）
+        current_config = {}
+
+        # 基础配置
+        current_config["code_assist_endpoint"] = await config.get_code_assist_endpoint()
+        current_config["credentials_dir"] = await config.get_credentials_dir()
+        current_config["proxy"] = await config.get_proxy_config() or ""
+
+        # 代理端点配置
+        current_config["oauth_proxy_url"] = await config.get_oauth_proxy_url()
+        current_config["googleapis_proxy_url"] = await config.get_googleapis_proxy_url()
+        current_config["resource_manager_api_url"] = await config.get_resource_manager_api_url()
+        current_config["service_usage_api_url"] = await config.get_service_usage_api_url()
+        current_config["antigravity_api_url"] = await config.get_antigravity_api_url()
+
+        # 自动封禁配置
+        current_config["auto_ban_enabled"] = await config.get_auto_ban_enabled()
+        current_config["auto_ban_error_codes"] = await config.get_auto_ban_error_codes()
+
+        # 429重试配置
+        current_config["retry_429_max_retries"] = await config.get_retry_429_max_retries()
+        current_config["retry_429_enabled"] = await config.get_retry_429_enabled()
+        current_config["retry_429_interval"] = await config.get_retry_429_interval()
+        # 抗截断配置
+        current_config["anti_truncation_max_attempts"] = await config.get_anti_truncation_max_attempts()
+
+        # 兼容性配置
+        current_config["compatibility_mode_enabled"] = await config.get_compatibility_mode_enabled()
+
+        # 思维链返回配置
+        current_config["return_thoughts_to_frontend"] = await config.get_return_thoughts_to_frontend()
+
+        # Antigravity流式转非流式配置
+        current_config["antigravity_stream2nostream"] = await config.get_antigravity_stream2nostream()
+        current_config["antigravity_switch_credential_enabled"] = await config.get_antigravity_switch_credential_enabled()
+
+        # 保活配置
+        current_config["keepalive_url"] = await config.get_keepalive_url()
+        current_config["keepalive_interval"] = await config.get_keepalive_interval()
+
+        # 服务器配置
+        current_config["host"] = await config.get_server_host()
+        current_config["port"] = await config.get_server_port()
+        current_config["api_password"] = await config.get_api_password()
+        current_config["panel_password"] = await config.get_panel_password()
+        current_config["password"] = await config.get_server_password()
+
+        # 从存储系统读取配置
+        storage_adapter = await get_storage_adapter()
+        storage_config = await storage_adapter.get_all_config()
+
+        # 获取环境变量锁定的配置键
+        env_locked_keys = get_env_locked_keys()
+
+        # 合并存储系统配置（不覆盖环境变量）
+        for key, value in storage_config.items():
+            if key not in env_locked_keys:
+                current_config[key] = value
+
+        return JSONResponse(content={"config": current_config, "env_locked": list(env_locked_keys)})
+
+    except Exception as e:
+        log.error(f"获取配置失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/save")
+async def save_config(request: ConfigSaveRequest, token: str = Depends(verify_panel_token)):
+    """保存配置"""
+    try:
+
+        new_config = request.config
+
+        log.debug(f"收到的配置数据: {list(new_config.keys())}")
+        log.debug(f"收到的password值: {new_config.get('password', 'NOT_FOUND')}")
+
+        # 验证配置项
+        if "retry_429_max_retries" in new_config:
+            if (
+                not isinstance(new_config["retry_429_max_retries"], int)
+                or new_config["retry_429_max_retries"] < 0
+            ):
+                raise HTTPException(status_code=400, detail="最大429重试次数必须是大于等于0的整数")
+
+        if "retry_429_enabled" in new_config:
+            if not isinstance(new_config["retry_429_enabled"], bool):
+                raise HTTPException(status_code=400, detail="429重试开关必须是布尔值")
+
+        # 验证新的配置项
+        if "retry_429_interval" in new_config:
+            try:
+                interval = float(new_config["retry_429_interval"])
+                if interval < 0.01 or interval > 10:
+                    raise HTTPException(status_code=400, detail="429重试间隔必须在0.01-10秒之间")
+            except (ValueError, TypeError):
+                raise HTTPException(status_code=400, detail="429重试间隔必须是有效的数字")
+
+        if "anti_truncation_max_attempts" in new_config:
+            if (
+                not isinstance(new_config["anti_truncation_max_attempts"], int)
+                or new_config["anti_truncation_max_attempts"] < 1
+                or new_config["anti_truncation_max_attempts"] > 10
+            ):
+                raise HTTPException(
+                    status_code=400, detail="抗截断最大重试次数必须是1-10之间的整数"
+                )
+
+        if "compatibility_mode_enabled" in new_config:
+            if not isinstance(new_config["compatibility_mode_enabled"], bool):
+                raise HTTPException(status_code=400, detail="兼容性模式开关必须是布尔值")
+
+        if "return_thoughts_to_frontend" in new_config:
+            if not isinstance(new_config["return_thoughts_to_frontend"], bool):
+                raise HTTPException(status_code=400, detail="思维链返回开关必须是布尔值")
+
+        if "antigravity_stream2nostream" in new_config:
+            if not isinstance(new_config["antigravity_stream2nostream"], bool):
+                raise HTTPException(status_code=400, detail="Antigravity流式转非流式开关必须是布尔值")
+
+        if "antigravity_switch_credential_enabled" in new_config:
+            if not isinstance(new_config["antigravity_switch_credential_enabled"], bool):
+                raise HTTPException(status_code=400, detail="Antigravity切换凭证开关必须是布尔值")
+
+        # 验证保活配置
+        if "keepalive_url" in new_config:
+            if not isinstance(new_config["keepalive_url"], str):
+                raise HTTPException(status_code=400, detail="保活URL必须是字符串")
+
+        if "keepalive_interval" in new_config:
+            try:
+                interval = int(new_config["keepalive_interval"])
+                if interval < 5 or interval > 86400:
+                    raise HTTPException(status_code=400, detail="保活间隔必须在 5-86400 秒之间")
+                new_config["keepalive_interval"] = interval
+            except (ValueError, TypeError):
+                raise HTTPException(status_code=400, detail="保活间隔必须是有效整数")
+        # 验证服务器配置
+        if "host" in new_config:
+            if not isinstance(new_config["host"], str) or not new_config["host"].strip():
+                raise HTTPException(status_code=400, detail="服务器主机地址不能为空")
+
+        if "port" in new_config:
+            if (
+                not isinstance(new_config["port"], int)
+                or new_config["port"] < 1
+                or new_config["port"] > 65535
+            ):
+                raise HTTPException(status_code=400, detail="端口号必须是1-65535之间的整数")
+
+        if "api_password" in new_config:
+            if not isinstance(new_config["api_password"], str):
+                raise HTTPException(status_code=400, detail="API访问密码必须是字符串")
+
+        if "panel_password" in new_config:
+            if not isinstance(new_config["panel_password"], str):
+                raise HTTPException(status_code=400, detail="控制面板密码必须是字符串")
+
+        if "password" in new_config:
+            if not isinstance(new_config["password"], str):
+                raise HTTPException(status_code=400, detail="访问密码必须是字符串")
+
+        # 获取环境变量锁定的配置键
+        env_locked_keys = get_env_locked_keys()
+
+        # 直接使用存储适配器保存配置
+        storage_adapter = await get_storage_adapter()
+        for key, value in new_config.items():
+            if key not in env_locked_keys:
+                await storage_adapter.set_config(key, value)
+                if key in ("password", "api_password", "panel_password"):
+                    log.debug(f"设置{key}字段为: {value}")
+
+        # 重新加载配置缓存（关键！）
+        await config.reload_config()
+
+        # 如果保活相关配置发生变化，立即重启保活服务
+        keepalive_keys = {"keepalive_url", "keepalive_interval"}
+        if keepalive_keys & set(new_config.keys()):
+            try:
+                await keepalive_service.restart()
+            except Exception as e:
+                log.warning(f"重启保活服务失败: {e}")
+
+        # 验证保存后的结果
+        test_api_password = await config.get_api_password()
+        test_panel_password = await config.get_panel_password()
+        test_password = await config.get_server_password()
+        log.debug(f"保存后立即读取的API密码: {test_api_password}")
+        log.debug(f"保存后立即读取的面板密码: {test_panel_password}")
+        log.debug(f"保存后立即读取的通用密码: {test_password}")
+
+        # 构建���应消息
+        response_data = {
+            "message": "配置保存成功",
+            "saved_config": {k: v for k, v in new_config.items() if k not in env_locked_keys},
+        }
+
+        return JSONResponse(content=response_data)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"保存配置失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

src/panel/creds.py

@@ -0,0 +1,1585 @@
+"""
+凭证管理路由模块 - 处理 /creds/* 相关的HTTP请求
+"""
+
+import asyncio
+import io
+import json
+import os
+import time
+import zipfile
+from typing import Any, List
+
+from fastapi import APIRouter, Depends, File, HTTPException, UploadFile, Response
+from fastapi.responses import JSONResponse
+
+from log import log
+from src.credential_manager import credential_manager
+from src.models import (
+    CredFileActionRequest,
+    CredFileBatchActionRequest
+)
+from src.storage_adapter import get_storage_adapter
+from src.utils import verify_panel_token, GEMINICLI_USER_AGENT, ANTIGRAVITY_USER_AGENT
+from src.api.antigravity import fetch_quota_info
+from src.google_oauth_api import Credentials, fetch_project_id_and_tier
+from config import get_code_assist_endpoint, get_antigravity_api_url
+from .utils import validate_mode
+
+
+# 创建路由器
+router = APIRouter(prefix="/creds", tags=["credentials"])
+
+
+# =============================================================================
+# 工具函数 (Helper Functions)
+# =============================================================================
+
+
+async def extract_json_files_from_zip(zip_file: UploadFile) -> List[dict]:
+    """从ZIP文件中提取JSON文件"""
+    try:
+        # 读取ZIP文件内容
+        zip_content = await zip_file.read()
+
+        # 不限制ZIP文件大小，只在处理时控制文件数量
+
+        files_data = []
+
+        with zipfile.ZipFile(io.BytesIO(zip_content), "r") as zip_ref:
+            # 获取ZIP中的所有文件
+            file_list = zip_ref.namelist()
+            json_files = [
+                f for f in file_list if f.endswith(".json") and not f.startswith("__MACOSX/")
+            ]
+
+            if not json_files:
+                raise HTTPException(status_code=400, detail="ZIP文件中没有找到JSON文件")
+
+            log.info(f"从ZIP文件 {zip_file.filename} 中找到 {len(json_files)} 个JSON文件")
+
+            for json_filename in json_files:
+                try:
+                    # 读取JSON文件内容
+                    with zip_ref.open(json_filename) as json_file:
+                        content = json_file.read()
+
+                        try:
+                            content_str = content.decode("utf-8")
+                        except UnicodeDecodeError:
+                            log.warning(f"跳过编码错误的文件: {json_filename}")
+                            continue
+
+                        # 使用原始文件名（去掉路径）
+                        filename = os.path.basename(json_filename)
+                        files_data.append({"filename": filename, "content": content_str})
+
+                except Exception as e:
+                    log.warning(f"处理ZIP中的文件 {json_filename} 时出错: {e}")
+                    continue
+
+        log.info(f"成功从ZIP文件中提取 {len(files_data)} 个有效的JSON文件")
+        return files_data
+
+    except zipfile.BadZipFile:
+        raise HTTPException(status_code=400, detail="无效的ZIP文件格式")
+    except Exception as e:
+        log.error(f"处理ZIP文件失败: {e}")
+        raise HTTPException(status_code=500, detail=f"处理ZIP文件失败: {str(e)}")
+
+
+async def clear_all_model_cooldowns_for_credential(
+    storage_adapter: Any,
+    filename: str,
+    mode: str,
+) -> None:
+    """清空指定凭证的所有模型冷却（后端支持时执行）。"""
+    try:
+        cleared = await storage_adapter._backend.clear_all_model_cooldowns(filename, mode=mode)
+        if not cleared:
+            log.warning(f"清空模型CD失败或凭证不存在: {filename} (mode={mode})")
+    except Exception as e:
+        log.warning(f"清空模型CD时出错: {filename} (mode={mode}), error={e}")
+
+
+async def upload_credentials_common(
+    files: List[UploadFile], mode: str = "geminicli"
+) -> JSONResponse:
+    """批量上传凭证文件的通用函数"""
+    mode = validate_mode(mode)
+
+    if not files:
+        raise HTTPException(status_code=400, detail="请选择要上传的文件")
+
+    # 检查文件数量限制
+    if len(files) > 100:
+        raise HTTPException(
+            status_code=400, detail=f"文件数量过多，最多支持100个文件，当前：{len(files)}个"
+        )
+
+    files_data = []
+    for file in files:
+        # 检查文件类型：支持JSON和ZIP
+        if file.filename.endswith(".zip"):
+            zip_files_data = await extract_json_files_from_zip(file)
+            files_data.extend(zip_files_data)
+            log.info(f"从ZIP文件 {file.filename} 中提取了 {len(zip_files_data)} 个JSON文件")
+
+        elif file.filename.endswith(".json"):
+            # 处理单个JSON文件 - 流式读取
+            content_chunks = []
+            while True:
+                chunk = await file.read(8192)
+                if not chunk:
+                    break
+                content_chunks.append(chunk)
+
+            content = b"".join(content_chunks)
+            try:
+                content_str = content.decode("utf-8")
+            except UnicodeDecodeError:
+                raise HTTPException(
+                    status_code=400, detail=f"文件 {file.filename} 编码格式不支持"
+                )
+
+            files_data.append({"filename": file.filename, "content": content_str})
+        else:
+            raise HTTPException(
+                status_code=400, detail=f"文件 {file.filename} 格式不支持，只支持JSON和ZIP文件"
+            )
+
+
+
+    batch_size = 1000
+    all_results = []
+    total_success = 0
+
+    for i in range(0, len(files_data), batch_size):
+        batch_files = files_data[i : i + batch_size]
+
+        async def process_single_file(file_data):
+            try:
+                filename = file_data["filename"]
+                # 确保文件名只保存basename，避免路径问题
+                filename = os.path.basename(filename)
+                content_str = file_data["content"]
+                credential_data = json.loads(content_str)
+
+                # 根据凭证类型调用不同的添加方法
+                if mode == "antigravity":
+                    await credential_manager.add_antigravity_credential(filename, credential_data)
+                else:
+                    await credential_manager.add_credential(filename, credential_data)
+
+                log.debug(f"成功上传 {mode} 凭证文件: {filename}")
+                return {"filename": filename, "status": "success", "message": "上传成功"}
+
+            except json.JSONDecodeError as e:
+                return {
+                    "filename": file_data["filename"],
+                    "status": "error",
+                    "message": f"JSON格式错误: {str(e)}",
+                }
+            except Exception as e:
+                return {
+                    "filename": file_data["filename"],
+                    "status": "error",
+                    "message": f"处理失败: {str(e)}",
+                }
+
+        log.info(f"开始并发处理 {len(batch_files)} 个 {mode} 文件...")
+        concurrent_tasks = [process_single_file(file_data) for file_data in batch_files]
+        batch_results = await asyncio.gather(*concurrent_tasks, return_exceptions=True)
+
+        processed_results = []
+        batch_uploaded_count = 0
+        for result in batch_results:
+            if isinstance(result, Exception):
+                processed_results.append(
+                    {
+                        "filename": "unknown",
+                        "status": "error",
+                        "message": f"处理异常: {str(result)}",
+                    }
+                )
+            else:
+                processed_results.append(result)
+                if result["status"] == "success":
+                    batch_uploaded_count += 1
+
+        all_results.extend(processed_results)
+        total_success += batch_uploaded_count
+
+        batch_num = (i // batch_size) + 1
+        total_batches = (len(files_data) + batch_size - 1) // batch_size
+        log.info(
+            f"批次 {batch_num}/{total_batches} 完成: 成功 "
+            f"{batch_uploaded_count}/{len(batch_files)} 个 {mode} 文件"
+        )
+
+    if total_success > 0:
+        return JSONResponse(
+            content={
+                "uploaded_count": total_success,
+                "total_count": len(files_data),
+                "results": all_results,
+                "message": f"批量上传完成: 成功 {total_success}/{len(files_data)} 个 {mode} 文件",
+            }
+        )
+    else:
+        raise HTTPException(status_code=400, detail=f"没有 {mode} 文件上传成功")
+
+
+async def get_creds_status_common(
+    offset: int, limit: int, status_filter: str, mode: str = "geminicli",
+    error_code_filter: str = None, cooldown_filter: str = None, preview_filter: str = None, tier_filter: str = None
+) -> JSONResponse:
+    """获取凭证文件状态的通用函数"""
+    mode = validate_mode(mode)
+    # 验证分页参数
+    if offset < 0:
+        raise HTTPException(status_code=400, detail="offset 必须大于等于 0")
+    if limit not in [20, 50, 100, 200, 500, 1000]:
+        raise HTTPException(status_code=400, detail="limit 只能是 20、50、100、200、500 或 1000")
+    if status_filter not in ["all", "enabled", "disabled"]:
+        raise HTTPException(status_code=400, detail="status_filter 只能是 all、enabled 或 disabled")
+    if cooldown_filter and cooldown_filter not in ["all", "in_cooldown", "no_cooldown"]:
+        raise HTTPException(status_code=400, detail="cooldown_filter 只能是 all、in_cooldown 或 no_cooldown")
+    if preview_filter and preview_filter not in ["all", "preview", "no_preview"]:
+        raise HTTPException(status_code=400, detail="preview_filter 只能是 all、preview 或 no_preview")
+    if tier_filter and tier_filter not in ["all", "free", "pro", "ultra"]:
+        raise HTTPException(status_code=400, detail="tier_filter 只能是 all、free、pro 或 ultra")
+
+
+
+    storage_adapter = await get_storage_adapter()
+    backend_info = await storage_adapter.get_backend_info()
+    backend_type = backend_info.get("backend_type", "unknown")
+
+    # 使用高性能的分页摘要查询
+    result = await storage_adapter._backend.get_credentials_summary(
+        offset=offset,
+        limit=limit,
+        status_filter=status_filter,
+        mode=mode,
+        error_code_filter=error_code_filter if error_code_filter and error_code_filter != "all" else None,
+        cooldown_filter=cooldown_filter if cooldown_filter and cooldown_filter != "all" else None,
+        preview_filter=preview_filter if preview_filter and preview_filter != "all" else None,
+        tier_filter=tier_filter if tier_filter and tier_filter != "all" else None
+    )
+
+    creds_list = []
+    for summary in result["items"]:
+        cred_info = {
+            "filename": os.path.basename(summary["filename"]),
+            "user_email": summary["user_email"],
+            "disabled": summary["disabled"],
+            "error_codes": summary["error_codes"],
+            "last_success": summary["last_success"],
+            "backend_type": backend_type,
+            "model_cooldowns": summary.get("model_cooldowns", {}),
+            "tier": summary.get("tier", "pro"),
+        }
+
+        if mode == "geminicli":
+            cred_info["preview"] = summary.get("preview", True)
+        else:
+            cred_info["enable_credit"] = summary.get("enable_credit", False)
+
+        creds_list.append(cred_info)
+
+    return JSONResponse(content={
+        "items": creds_list,
+        "total": result["total"],
+        "offset": offset,
+        "limit": limit,
+        "has_more": (offset + limit) < result["total"],
+        "stats": result.get("stats", {"total": 0, "normal": 0, "disabled": 0}),
+    })
+
+
+async def download_all_creds_common(mode: str = "geminicli") -> Response:
+    """打包下载所有凭证文件的通用函数"""
+    mode = validate_mode(mode)
+    zip_filename = "antigravity_credentials.zip" if mode == "antigravity" else "credentials.zip"
+
+    storage_adapter = await get_storage_adapter()
+    credential_filenames = await storage_adapter.list_credentials(mode=mode)
+
+    if not credential_filenames:
+        raise HTTPException(status_code=404, detail=f"没有找到 {mode} 凭证文件")
+
+    log.info(f"开始打包 {len(credential_filenames)} 个 {mode} 凭证文件...")
+
+    zip_buffer = io.BytesIO()
+
+    with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+        success_count = 0
+        for idx, filename in enumerate(credential_filenames, 1):
+            try:
+                credential_data = await storage_adapter.get_credential(filename, mode=mode)
+                if credential_data:
+                    content = json.dumps(credential_data, ensure_ascii=False, indent=2)
+                    zip_file.writestr(os.path.basename(filename), content)
+                    success_count += 1
+
+                    if idx % 10 == 0:
+                        log.debug(f"打包进度: {idx}/{len(credential_filenames)}")
+
+            except Exception as e:
+                log.warning(f"处理 {mode} 凭证文件 {filename} 时出错: {e}")
+                continue
+
+    log.info(f"打包完成: 成功 {success_count}/{len(credential_filenames)} 个文件")
+
+    zip_buffer.seek(0)
+    return Response(
+        content=zip_buffer.getvalue(),
+        media_type="application/zip",
+        headers={"Content-Disposition": f"attachment; filename={zip_filename}"},
+    )
+
+
+async def fetch_user_email_common(filename: str, mode: str = "geminicli") -> JSONResponse:
+    """获取指定凭证文件用户邮箱的通用函数"""
+    mode = validate_mode(mode)
+
+    filename_only = os.path.basename(filename)
+    if not filename_only.endswith(".json"):
+        raise HTTPException(status_code=404, detail="无效的文件名")
+
+    storage_adapter = await get_storage_adapter()
+    credential_data = await storage_adapter.get_credential(filename_only, mode=mode)
+    if not credential_data:
+        raise HTTPException(status_code=404, detail="凭证文件不存在")
+
+    email = await credential_manager.get_or_fetch_user_email(filename_only, mode=mode)
+
+    if email:
+        return JSONResponse(
+            content={
+                "filename": filename_only,
+                "user_email": email,
+                "message": "成功获取用户邮箱",
+            }
+        )
+    else:
+        return JSONResponse(
+            content={
+                "filename": filename_only,
+                "user_email": None,
+                "message": "无法获取用户邮箱，可能凭证已过期或权限不足",
+            },
+            status_code=400,
+        )
+
+
+async def refresh_all_user_emails_common(mode: str = "geminicli") -> JSONResponse:
+    """刷新所有凭证文件用户邮箱的通用函数 - 只为没有邮箱的凭证获取
+
+    利用 get_all_credential_states 批量获取状态
+    """
+    mode = validate_mode(mode)
+
+    storage_adapter = await get_storage_adapter()
+
+    # 一次性批量获取所有凭证的状态
+    all_states = await storage_adapter.get_all_credential_states(mode=mode)
+
+    results = []
+    success_count = 0
+    skipped_count = 0
+
+    # 在内存中筛选出需要获取邮箱的凭证
+    for filename, state in all_states.items():
+        try:
+            cached_email = state.get("user_email")
+
+            if cached_email:
+                # 已有邮箱，跳过获取
+                skipped_count += 1
+                results.append({
+                    "filename": os.path.basename(filename),
+                    "user_email": cached_email,
+                    "success": True,
+                    "skipped": True,
+                })
+                continue
+
+            # 没有邮箱，尝试获取
+            email = await credential_manager.get_or_fetch_user_email(filename, mode=mode)
+            if email:
+                success_count += 1
+                results.append({
+                    "filename": os.path.basename(filename),
+                    "user_email": email,
+                    "success": True,
+                })
+            else:
+                results.append({
+                    "filename": os.path.basename(filename),
+                    "user_email": None,
+                    "success": False,
+                    "error": "无法获取邮箱",
+                })
+        except Exception as e:
+            results.append({
+                "filename": os.path.basename(filename),
+                "user_email": None,
+                "success": False,
+                "error": str(e),
+            })
+
+    total_count = len(all_states)
+    return JSONResponse(
+        content={
+            "success_count": success_count,
+            "total_count": total_count,
+            "skipped_count": skipped_count,
+            "results": results,
+            "message": f"成功获取 {success_count}/{total_count} 个邮箱地址，跳过 {skipped_count} 个已有邮箱的凭证",
+        }
+    )
+
+
+async def deduplicate_credentials_by_email_common(mode: str = "geminicli") -> JSONResponse:
+    """批量去重凭证文件的通用函数 - 删除邮箱相同的凭证（只保留一个）"""
+    mode = validate_mode(mode)
+    storage_adapter = await get_storage_adapter()
+
+    try:
+        duplicate_info = await storage_adapter._backend.get_duplicate_credentials_by_email(
+            mode=mode
+        )
+
+        duplicate_groups = duplicate_info.get("duplicate_groups", [])
+        no_email_files = duplicate_info.get("no_email_files", [])
+        total_count = duplicate_info.get("total_count", 0)
+
+        if not duplicate_groups:
+            return JSONResponse(
+                content={
+                    "deleted_count": 0,
+                    "kept_count": total_count,
+                    "total_count": total_count,
+                    "unique_emails_count": duplicate_info.get("unique_email_count", 0),
+                    "no_email_count": len(no_email_files),
+                    "duplicate_groups": [],
+                    "delete_errors": [],
+                    "message": "没有发现重复的凭证（相同邮箱）",
+                }
+            )
+
+        # 执行删除操作
+        deleted_count = 0
+        delete_errors = []
+        result_duplicate_groups = []
+
+        for group in duplicate_groups:
+            email = group["email"]
+            kept_file = group["kept_file"]
+            duplicate_files = group["duplicate_files"]
+
+            deleted_files_in_group = []
+            for filename in duplicate_files:
+                try:
+                    success = await credential_manager.remove_credential(filename, mode=mode)
+                    if success:
+                        deleted_count += 1
+                        deleted_files_in_group.append(os.path.basename(filename))
+                        log.info(f"去重删除凭证: {filename} (邮箱: {email}) (mode={mode})")
+                    else:
+                        delete_errors.append(f"{os.path.basename(filename)}: 删除失败")
+                except Exception as e:
+                    delete_errors.append(f"{os.path.basename(filename)}: {str(e)}")
+                    log.error(f"去重删除凭证 {filename} 时出错: {e}")
+
+            result_duplicate_groups.append({
+                "email": email,
+                "kept_file": os.path.basename(kept_file),
+                "deleted_files": deleted_files_in_group,
+                "duplicate_count": len(deleted_files_in_group),
+            })
+
+        kept_count = total_count - deleted_count
+
+        return JSONResponse(
+            content={
+                "deleted_count": deleted_count,
+                "kept_count": kept_count,
+                "total_count": total_count,
+                "unique_emails_count": duplicate_info.get("unique_email_count", 0),
+                "no_email_count": len(no_email_files),
+                "duplicate_groups": result_duplicate_groups,
+                "delete_errors": delete_errors,
+                "message": f"去重完成：删除 {deleted_count} 个重复凭证，保留 {kept_count} 个凭证（{duplicate_info.get('unique_email_count', 0)} 个唯一邮箱）",
+            }
+        )
+
+    except Exception as e:
+        log.error(f"批量去重凭证时出错: {e}")
+        return JSONResponse(
+            status_code=500,
+            content={
+                "deleted_count": 0,
+                "kept_count": 0,
+                "total_count": 0,
+                "message": f"去重操作失败: {str(e)}",
+            }
+        )
+
+
+async def verify_credential_project_common(filename: str, mode: str = "geminicli") -> JSONResponse:
+    """验证并重新获取凭证的project id的通用函数"""
+    mode = validate_mode(mode)
+
+    # 验证文件名
+    if not filename.endswith(".json"):
+        raise HTTPException(status_code=400, detail="无效的文件名")
+
+
+    storage_adapter = await get_storage_adapter()
+
+    # 获取凭证数据
+    credential_data = await storage_adapter.get_credential(filename, mode=mode)
+    if not credential_data:
+        raise HTTPException(status_code=404, detail="凭证不存在")
+
+    # 创建凭证对象
+    credentials = Credentials.from_dict(credential_data)
+
+    # 确保token有效（自动刷新）
+    token_refreshed = await credentials.refresh_if_needed()
+
+    # 如果token被刷新了，更新存储
+    if token_refreshed:
+        log.info(f"Token已自动刷新: {filename} (mode={mode})")
+        credential_data = credentials.to_dict()
+        await storage_adapter.store_credential(filename, credential_data, mode=mode)
+
+    # 获取API端点和对应的User-Agent
+    if mode == "antigravity":
+        api_base_url = await get_antigravity_api_url()
+        user_agent = ANTIGRAVITY_USER_AGENT
+    else:
+        api_base_url = await get_code_assist_endpoint()
+        user_agent = GEMINICLI_USER_AGENT
+
+    # 重新获取project id（仅 antigravity 模式请求积分）
+    if mode == "antigravity":
+        project_id, subscription_tier, credit_amount = await fetch_project_id_and_tier(
+            access_token=credentials.access_token,
+            user_agent=user_agent,
+            api_base_url=api_base_url,
+            include_credits=True,
+        )
+    else:
+        project_id, subscription_tier = await fetch_project_id_and_tier(
+            access_token=credentials.access_token,
+            user_agent=user_agent,
+            api_base_url=api_base_url,
+        )
+        credit_amount = None
+
+    if project_id:
+        credential_data["project_id"] = project_id
+
+    if project_id or subscription_tier:
+        await storage_adapter.store_credential(filename, credential_data, mode=mode)
+
+        # 检验成功后自动解除禁用状态并清除错误码
+        state_update = {
+            "disabled": False,
+            "error_codes": []
+        }
+
+        # 同步更新状态表中的 tier 字段
+        state_update["tier"] = subscription_tier
+
+        # 如果是 geminicli 模式，直接设置 preview=True
+        if mode == "geminicli":
+            state_update["preview"] = True
+
+        await storage_adapter.update_credential_state(filename, state_update, mode=mode)
+
+        log.info(f"检验 {mode} 凭证成功: {filename} - Project ID: {project_id}, Tier: {subscription_tier} - 已解除禁用并清除错误码")
+
+        response_data = {
+            "success": True,
+            "filename": filename,
+            "project_id": project_id,
+            "subscription_tier": subscription_tier,
+            "message": "检验成功！Project ID已更新，已解除禁用状态并清除错误码，403错误应该已恢复"
+        }
+
+        if mode == "antigravity" and credit_amount is not None:
+            response_data["credit_amount"] = credit_amount
+
+        return JSONResponse(content=response_data)
+    else:
+        return JSONResponse(
+            status_code=400,
+            content={
+                "success": False,
+                "filename": filename,
+                "message": "检验失败：无法获取Project ID，请检查凭证是否有效"
+            }
+        )
+
+
+# =============================================================================
+# 路由处理函数 (Route Handlers)
+# =============================================================================
+
+
+@router.post("/upload")
+async def upload_credentials(
+    files: List[UploadFile] = File(...),
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """批量上传凭证文件"""
+    try:
+        mode = validate_mode(mode)
+        return await upload_credentials_common(files, mode=mode)
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"批量上传失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/status")
+async def get_creds_status(
+    token: str = Depends(verify_panel_token),
+    offset: int = 0,
+    limit: int = 50,
+    status_filter: str = "all",
+    error_code_filter: str = "all",
+    cooldown_filter: str = "all",
+    preview_filter: str = "all",
+    tier_filter: str = "all",
+    mode: str = "geminicli"
+):
+    """
+    获取凭证文件的状态（轻量级摘要，不包含完整凭证数据，支持分页和状态筛选）
+
+    Args:
+        offset: 跳过的记录数（默认0）
+        limit: 每页返回的记录数（默认50，可选：20, 50, 100, 200, 500, 1000）
+        status_filter: 状态筛选（all=全部, enabled=仅启用, disabled=仅禁用）
+        error_code_filter: 错误码筛选（all=全部, 或具体错误码如"400", "403"）
+        cooldown_filter: 冷却状态筛选（all=全部, in_cooldown=冷却中, no_cooldown=未冷却）
+        preview_filter: Preview筛选（all=全部, preview=支持preview, no_preview=不支持preview，仅geminicli模式有效）
+        tier_filter: tier筛选（all=全部, free/pro/ultra）
+        mode: 凭证模式（geminicli 或 antigravity）
+
+    Returns:
+        包含凭证列表、总数、分页信息的响应
+    """
+    try:
+        mode = validate_mode(mode)
+        return await get_creds_status_common(
+            offset, limit, status_filter, mode=mode,
+            error_code_filter=error_code_filter,
+            cooldown_filter=cooldown_filter,
+            preview_filter=preview_filter,
+            tier_filter=tier_filter
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"获取凭证状态失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/detail/{filename}")
+async def get_cred_detail(
+    filename: str,
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """
+    按需获取单个凭证的详细数据（包含完整凭证内容）
+    用于用户查看/编辑凭证详情
+    """
+    try:
+        mode = validate_mode(mode)
+        # 验证文件名
+        if not filename.endswith(".json"):
+            raise HTTPException(status_code=400, detail="无效的文件名")
+
+
+
+        storage_adapter = await get_storage_adapter()
+        backend_info = await storage_adapter.get_backend_info()
+        backend_type = backend_info.get("backend_type", "unknown")
+
+        # 获取凭证数据
+        credential_data = await storage_adapter.get_credential(filename, mode=mode)
+        if not credential_data:
+            raise HTTPException(status_code=404, detail="凭证不存在")
+
+        # 获取状态信息
+        file_status = await storage_adapter.get_credential_state(filename, mode=mode)
+        if not file_status:
+            file_status = {
+                "error_codes": [],
+                "disabled": False,
+                "last_success": time.time(),
+                "user_email": None,
+            }
+
+        result = {
+            "status": file_status,
+            "content": credential_data,
+            "filename": os.path.basename(filename),
+            "backend_type": backend_type,
+            "user_email": file_status.get("user_email"),
+            "model_cooldowns": file_status.get("model_cooldowns", {}),
+        }
+
+        if mode == "geminicli":
+            result["preview"] = file_status.get("preview", True)
+        else:
+            result["enable_credit"] = file_status.get("enable_credit", False)
+
+        if backend_type == "file" and os.path.exists(filename):
+            result.update({
+                "size": os.path.getsize(filename),
+                "modified_time": os.path.getmtime(filename),
+            })
+
+        return JSONResponse(content=result)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"获取凭证详情失败 {filename}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/action")
+async def creds_action(
+    request: CredFileActionRequest,
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """对凭证文件执行操作（启用/禁用/删除/enable_credit开关）"""
+    try:
+        mode = validate_mode(mode)
+
+        log.info(f"Received request: {request}")
+
+        filename = request.filename
+        action = request.action
+
+        log.info(f"Performing action '{action}' on file: {filename} (mode={mode})")
+
+        # 验证文件名
+        if not filename.endswith(".json"):
+            log.error(f"无效的文件名: {filename}（不是.json文件）")
+            raise HTTPException(status_code=400, detail=f"无效的文件名: {filename}")
+
+        # 获取存储适配器
+        storage_adapter = await get_storage_adapter()
+
+        # 对于删除操作，不需要检查凭证数据是否完整，只需检查条目是否存在
+        # 对于其他操作，需要确保凭证数据存在且完整
+        if action != "delete":
+            # 检查凭证数据是否存在
+            credential_data = await storage_adapter.get_credential(filename, mode=mode)
+            if not credential_data:
+                log.error(f"凭证未找到: {filename} (mode={mode})")
+                raise HTTPException(status_code=404, detail="凭证文件不存在")
+
+        if action == "enable":
+            log.info(f"Web请求: 启用文件 {filename} (mode={mode})")
+            result = await credential_manager.set_cred_disabled(filename, False, mode=mode)
+            log.info(f"[WebRoute] set_cred_disabled 返回结果: {result}")
+            if result:
+                log.info(f"Web请求: 文件 {filename} 已成功启用 (mode={mode})")
+                return JSONResponse(content={"message": f"已启用凭证文件 {os.path.basename(filename)}"})
+            else:
+                log.error(f"Web请求: 文件 {filename} 启用失败 (mode={mode})")
+                raise HTTPException(status_code=500, detail="启用凭证失败，可能凭证不存在")
+
+        elif action == "disable":
+            log.info(f"Web请求: 禁用文件 {filename} (mode={mode})")
+            result = await credential_manager.set_cred_disabled(filename, True, mode=mode)
+            log.info(f"[WebRoute] set_cred_disabled 返回结果: {result}")
+            if result:
+                log.info(f"Web请求: 文件 {filename} 已成功禁用 (mode={mode})")
+                return JSONResponse(content={"message": f"已禁用凭证文件 {os.path.basename(filename)}"})
+            else:
+                log.error(f"Web请求: 文件 {filename} 禁用失败 (mode={mode})")
+                raise HTTPException(status_code=500, detail="禁用凭证失败，可能凭证不存在")
+
+        elif action == "delete":
+            try:
+                # 使用 CredentialManager 删除凭证（包含队列/状态同步）
+                success = await credential_manager.remove_credential(filename, mode=mode)
+                if success:
+                    log.info(f"通过管理器成功删除凭证: {filename} (mode={mode})")
+                    return JSONResponse(
+                        content={"message": f"已删除凭证文件 {os.path.basename(filename)}"}
+                    )
+                else:
+                    raise HTTPException(status_code=500, detail="删除凭证失败")
+            except Exception as e:
+                log.error(f"删除凭证 {filename} 时出错: {e}")
+                raise HTTPException(status_code=500, detail=f"删除文件失败: {str(e)}")
+
+        elif action == "enable_credit":
+            if mode != "antigravity":
+                raise HTTPException(status_code=400, detail="enable_credit 仅支持 antigravity 模式")
+            updated = await storage_adapter.update_credential_state(
+                filename, {"enable_credit": True}, mode=mode
+            )
+            if updated:
+                await clear_all_model_cooldowns_for_credential(storage_adapter, filename, mode)
+                return JSONResponse(content={"message": f"已开启凭证信用额度模式 {os.path.basename(filename)}"})
+            raise HTTPException(status_code=500, detail="开启信用额度模式失败，可能凭证不存在")
+
+        elif action == "disable_credit":
+            if mode != "antigravity":
+                raise HTTPException(status_code=400, detail="disable_credit 仅支持 antigravity 模式")
+            updated = await storage_adapter.update_credential_state(
+                filename, {"enable_credit": False}, mode=mode
+            )
+            if updated:
+                await clear_all_model_cooldowns_for_credential(storage_adapter, filename, mode)
+                return JSONResponse(content={"message": f"已关闭凭证信用额度模式 {os.path.basename(filename)}"})
+            raise HTTPException(status_code=500, detail="关闭信用额度模式失败，可能凭证不存在")
+
+        else:
+            raise HTTPException(status_code=400, detail="无效的操作类型")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"凭证文件操作失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/batch-action")
+async def creds_batch_action(
+    request: CredFileBatchActionRequest,
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """批量对凭证文件执行操作（启用/禁用/删除/enable_credit开关）"""
+    try:
+        mode = validate_mode(mode)
+
+        action = request.action
+        filenames = request.filenames
+
+        if not filenames:
+            raise HTTPException(status_code=400, detail="文件名列表不能为空")
+
+        log.info(f"对 {len(filenames)} 个文件执行批量操作 '{action}'")
+
+        success_count = 0
+        errors = []
+
+        storage_adapter = await get_storage_adapter()
+
+        for filename in filenames:
+            try:
+                # 验证文件名安全性
+                if not filename.endswith(".json"):
+                    errors.append(f"{filename}: 无效的文件类型")
+                    continue
+
+                # ���于删除操作，不需要检查凭证数据完整性
+                # 对于其他操作，需要确保凭证数据存在
+                if action != "delete":
+                    credential_data = await storage_adapter.get_credential(filename, mode=mode)
+                    if not credential_data:
+                        errors.append(f"{filename}: 凭证不存在")
+                        continue
+
+                # 执行相应操作
+                if action == "enable":
+                    await credential_manager.set_cred_disabled(filename, False, mode=mode)
+                    success_count += 1
+
+                elif action == "disable":
+                    await credential_manager.set_cred_disabled(filename, True, mode=mode)
+                    success_count += 1
+
+                elif action == "delete":
+                    try:
+                        delete_success = await credential_manager.remove_credential(filename, mode=mode)
+                        if delete_success:
+                            success_count += 1
+                            log.info(f"成功删除批量中的凭证: {filename}")
+                        else:
+                            errors.append(f"{filename}: 删除失败")
+                            continue
+                    except Exception as e:
+                        errors.append(f"{filename}: 删除文件失败 - {str(e)}")
+                        continue
+                elif action == "enable_credit":
+                    if mode != "antigravity":
+                        errors.append(f"{filename}: enable_credit 仅支持 antigravity 模式")
+                        continue
+                    updated = await storage_adapter.update_credential_state(
+                        filename, {"enable_credit": True}, mode=mode
+                    )
+                    if updated:
+                        await clear_all_model_cooldowns_for_credential(storage_adapter, filename, mode)
+                        success_count += 1
+                    else:
+                        errors.append(f"{filename}: 开启信用额度模式失败")
+                        continue
+                elif action == "disable_credit":
+                    if mode != "antigravity":
+                        errors.append(f"{filename}: disable_credit 仅支持 antigravity 模式")
+                        continue
+                    updated = await storage_adapter.update_credential_state(
+                        filename, {"enable_credit": False}, mode=mode
+                    )
+                    if updated:
+                        await clear_all_model_cooldowns_for_credential(storage_adapter, filename, mode)
+                        success_count += 1
+                    else:
+                        errors.append(f"{filename}: 关闭信用额度模式失败")
+                        continue
+                else:
+                    errors.append(f"{filename}: 无效的操作类型")
+                    continue
+
+            except Exception as e:
+                log.error(f"处理 {filename} 时出错: {e}")
+                errors.append(f"{filename}: 处理失败 - {str(e)}")
+                continue
+
+        # 构建返回消息
+        result_message = f"批量操作完成：成功处理 {success_count}/{len(filenames)} 个文件"
+        if errors:
+            result_message += "\n错误详情:\n" + "\n".join(errors)
+
+        response_data = {
+            "success_count": success_count,
+            "total_count": len(filenames),
+            "errors": errors,
+            "message": result_message,
+        }
+
+        return JSONResponse(content=response_data)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"批量凭证文件操作失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/download/{filename}")
+async def download_cred_file(
+    filename: str,
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """下载单个凭证文件"""
+    try:
+        mode = validate_mode(mode)
+        # 验证文件名安全性
+        if not filename.endswith(".json"):
+            raise HTTPException(status_code=404, detail="无效的文件名")
+
+        # 获取存储适配器
+        storage_adapter = await get_storage_adapter()
+
+        # 从存储系统获取凭证数据
+        credential_data = await storage_adapter.get_credential(filename, mode=mode)
+        if not credential_data:
+            raise HTTPException(status_code=404, detail="文件不存在")
+
+        # 转换为JSON字符串
+        content = json.dumps(credential_data, ensure_ascii=False, indent=2)
+
+        from fastapi.responses import Response
+
+        return Response(
+            content=content,
+            media_type="application/json",
+            headers={"Content-Disposition": f"attachment; filename={filename}"},
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"下载凭证文件失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/fetch-email/{filename}")
+async def fetch_user_email(
+    filename: str,
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """获取指定凭证文件的用户邮箱地址"""
+    try:
+        mode = validate_mode(mode)
+        return await fetch_user_email_common(filename, mode=mode)
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"获取用户邮箱失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/refresh-all-emails")
+async def refresh_all_user_emails(
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """刷新所有凭证文件的用户邮箱地址"""
+    try:
+        mode = validate_mode(mode)
+        return await refresh_all_user_emails_common(mode=mode)
+    except Exception as e:
+        log.error(f"批量获取用户邮箱失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/deduplicate-by-email")
+async def deduplicate_credentials_by_email(
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """批量去重凭证文件 - 删除邮箱相同的凭证（只保留一个）"""
+    try:
+        mode = validate_mode(mode)
+        return await deduplicate_credentials_by_email_common(mode=mode)
+    except Exception as e:
+        log.error(f"批量去重凭证失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/download-all")
+async def download_all_creds(
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """
+    打包下载所有凭证文件（流式处理，按需加载每个凭证数据）
+    只在实际下载时才加载完整凭证内容，最大化性能
+    """
+    try:
+        mode = validate_mode(mode)
+        return await download_all_creds_common(mode=mode)
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"打包下载失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/verify-project/{filename}")
+async def verify_credential_project(
+    filename: str,
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """
+    检验凭证的project id，重新获取project id
+    检验成功可以使403错误恢复
+    """
+    try:
+        mode = validate_mode(mode)
+        return await verify_credential_project_common(filename, mode=mode)
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"检验凭证Project ID失败 {filename}: {e}")
+        raise HTTPException(status_code=500, detail=f"检验失败: {str(e)}")
+
+
+@router.get("/errors/{filename}")
+async def get_credential_errors(
+    filename: str,
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """
+    获取指定凭证的错误信息（包含 error_codes 和 error_messages）
+
+    Args:
+        filename: 凭证文件名
+        mode: 凭证模式（geminicli 或 antigravity）
+
+    Returns:
+        包含 error_codes 和 error_messages 的 JSON 响应
+    """
+    try:
+        mode = validate_mode(mode)
+
+        # 验证文件名
+        if not filename.endswith(".json"):
+            raise HTTPException(status_code=400, detail="无效的文件名")
+
+        storage_adapter = await get_storage_adapter()
+
+        # 检查后端是否支持 get_credential_errors 方法
+        if not hasattr(storage_adapter._backend, 'get_credential_errors'):
+            raise HTTPException(
+                status_code=501,
+                detail="当前存储后端不支持获取错误信息"
+            )
+
+        # 获取错误信息
+        error_info = await storage_adapter._backend.get_credential_errors(filename, mode=mode)
+
+        return JSONResponse(content=error_info)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"获取凭证错误信息失败 {filename}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/quota/{filename}")
+async def get_credential_quota(
+    filename: str,
+    token: str = Depends(verify_panel_token),
+    mode: str = "antigravity"
+):
+    """
+    获取指定凭证的额度信息（仅支持 antigravity 模式）
+    """
+    try:
+        mode = validate_mode(mode)
+        # 验证文件名
+        if not filename.endswith(".json"):
+            raise HTTPException(status_code=400, detail="无效的文件名")
+
+
+        storage_adapter = await get_storage_adapter()
+
+        # 获取凭证数据
+        credential_data = await storage_adapter.get_credential(filename, mode=mode)
+        if not credential_data:
+            raise HTTPException(status_code=404, detail="凭证不存在")
+
+        # 使用 Credentials 对象自动处理 token 刷新
+        from src.google_oauth_api import Credentials
+
+        creds = Credentials.from_dict(credential_data)
+
+        # 自动刷新 token（如果需要）
+        await creds.refresh_if_needed()
+
+        # 如果 token 被刷新了，更新存储
+        updated_data = creds.to_dict()
+        if updated_data != credential_data:
+            log.info(f"Token已自动刷新: {filename}")
+            await storage_adapter.store_credential(filename, updated_data, mode=mode)
+            credential_data = updated_data
+
+        # 获取访问令牌
+        access_token = credential_data.get("access_token") or credential_data.get("token")
+        if not access_token:
+            raise HTTPException(status_code=400, detail="凭证中没有访问令牌")
+
+        # 获取额度信息
+        quota_info = await fetch_quota_info(access_token)
+
+        if quota_info.get("success"):
+            return JSONResponse(content={
+                "success": True,
+                "filename": filename,
+                "models": quota_info.get("models", {})
+            })
+        else:
+            return JSONResponse(
+                status_code=400,
+                content={
+                    "success": False,
+                    "filename": filename,
+                    "error": quota_info.get("error", "未知错误")
+                }
+            )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"获取凭证额度失败 {filename}: {e}")
+        raise HTTPException(status_code=500, detail=f"获取额度失败: {str(e)}")
+
+
+@router.post("/configure-preview/{filename}")
+async def configure_preview_channel(
+    filename: str,
+    token: str = Depends(verify_panel_token),
+    mode: str = "geminicli"
+):
+    """
+    为 geminicli 凭证配置 preview 通道
+
+    通过调用 Google Cloud API 设置 release_channel 为 EXPERIMENTAL
+
+    Args:
+        filename: 凭证文件名
+        mode: 凭证模式（仅支持 geminicli）
+
+    Returns:
+        配置结果信息
+    """
+    try:
+        mode = validate_mode(mode)
+
+        # 只支持 geminicli 模式
+        if mode != "geminicli":
+            raise HTTPException(
+                status_code=400,
+                detail="配置 preview 通道仅支持 geminicli 模式"
+            )
+
+        # 验证文件名
+        if not filename.endswith(".json"):
+            raise HTTPException(status_code=400, detail="无效的文件名")
+
+        storage_adapter = await get_storage_adapter()
+
+        # 获取凭证数据
+        credential_data = await storage_adapter.get_credential(filename, mode=mode)
+        if not credential_data:
+            raise HTTPException(status_code=404, detail="凭证不存在")
+
+        # 创建凭证对象并刷新 token（如果需要）
+        credentials = Credentials.from_dict(credential_data)
+        token_refreshed = await credentials.refresh_if_needed()
+
+        if token_refreshed:
+            log.info(f"Token已自动刷新: {filename}")
+            credential_data = credentials.to_dict()
+            await storage_adapter.store_credential(filename, credential_data, mode=mode)
+
+        # 获取 access_token 和 project_id
+        access_token = credential_data.get("access_token") or credential_data.get("token")
+        project_id = credential_data.get("project_id", "")
+
+        if not access_token:
+            raise HTTPException(status_code=400, detail="凭证中没有访问令牌")
+        if not project_id:
+            raise HTTPException(status_code=400, detail="凭证中没有项目ID")
+
+        # 调用 Google Cloud API 配置 preview 通道
+        # 根据文档，需要两个步骤：
+        # 1. 创建 Release Channel Setting (EXPERIMENTAL)
+        # 2. 创建 Setting Binding (绑定到目标项目)
+        from src.httpx_client import post_async
+        import uuid
+
+        # 生成唯一的 ID
+        setting_id = f"preview-setting-{uuid.uuid4().hex[:8]}"
+        binding_id = f"preview-binding-{uuid.uuid4().hex[:8]}"
+
+        base_url = f"https://cloudaicompanion.googleapis.com/v1/projects/{project_id}/locations/global"
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+            "Content-Type": "application/json"
+        }
+
+        log.info(f"开始配置 preview 通道: {filename} (project_id={project_id})")
+
+        # 步骤 1: 创建 Release Channel Setting
+        setting_url = f"{base_url}/releaseChannelSettings"
+        setting_response = await post_async(
+            url=setting_url,
+            json={"release_channel": "EXPERIMENTAL"},
+            headers=headers,
+            params={"release_channel_setting_id": setting_id},
+            timeout=30.0
+        )
+
+        setting_status = setting_response.status_code
+
+        if setting_status == 200 or setting_status == 201:
+            log.info(f"步骤 1/2: Release Channel Setting 创建成功 (setting_id={setting_id})")
+        elif setting_status == 409:
+            # Setting 已存在，继续下一步
+            log.info(f"步骤 1/2: Release Channel Setting 已存在")
+        else:
+            # 步骤 1 失败
+            error_text = setting_response.text if hasattr(setting_response, 'text') else ""
+            log.error(f"步骤 1/2 失败: {filename} - Status: {setting_status}, Error: {error_text}")
+
+            return JSONResponse(
+                status_code=setting_status,
+                content={
+                    "success": False,
+                    "filename": filename,
+                    "preview": False,
+                    "message": f"创建 Release Channel Setting 失败: HTTP {setting_status}",
+                    "error": error_text,
+                    "step": "create_setting"
+                }
+            )
+
+        # 步骤 2: 创建 Setting Binding (绑定到当前项目)
+        binding_url = f"{base_url}/releaseChannelSettings/{setting_id}/settingBindings"
+        binding_response = await post_async(
+            url=binding_url,
+            json={
+                "target": f"projects/{project_id}",
+                "product": "GEMINI_CODE_ASSIST"
+            },
+            headers=headers,
+            params={"setting_binding_id": binding_id},
+            timeout=30.0
+        )
+
+        binding_status = binding_response.status_code
+
+        if binding_status == 200 or binding_status == 201:
+            await storage_adapter.update_credential_state(filename, {
+                "preview": True
+            }, mode=mode)
+
+            log.info(f"步骤 2/2: Setting Binding 创建成功 - Preview 通道配置完成: {filename}")
+
+            return JSONResponse(content={
+                "success": True,
+                "filename": filename,
+                "preview": True,
+                "message": "Preview 通道配置成功，已将 preview 属性设置为 true",
+                "setting_id": setting_id,
+                "binding_id": binding_id
+            })
+        elif binding_status == 409:
+            # Binding 已存在，说明已经配置过了
+            await storage_adapter.update_credential_state(filename, {
+                "preview": True
+            }, mode=mode)
+
+            log.info(f"步骤 2/2: Setting Binding 已存在 - Preview 通道已配置: {filename}")
+
+            return JSONResponse(content={
+                "success": True,
+                "filename": filename,
+                "preview": True,
+                "message": "Preview 通道配置已存在，已将 preview 属性设置为 true"
+            })
+        else:
+            # 步骤 2 失败
+            error_text = binding_response.text if hasattr(binding_response, 'text') else ""
+            log.error(f"步骤 2/2 失败: {filename} - Status: {binding_status}, Error: {error_text}")
+
+            return JSONResponse(
+                status_code=binding_status,
+                content={
+                    "success": False,
+                    "filename": filename,
+                    "preview": False,
+                    "message": f"创建 Setting Binding 失败: HTTP {binding_status}",
+                    "error": error_text,
+                    "step": "create_binding"
+                }
+            )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"配置 preview 通道失败 {filename}: {e}")
+        raise HTTPException(status_code=500, detail=f"配置失败: {str(e)}")
+
+
+@router.post("/test/{filename}")
+async def test_credential(
+    filename: str,
+    mode: str = "geminicli",
+    _token: str = Depends(verify_panel_token)
+):
+    """
+    测试指定凭证是否可用
+
+    Args:
+        filename: 凭证文件名
+        mode: 凭证模式（geminicli 或 antigravity）
+
+    Returns:
+        返回状态码：
+        - 200: 凭证可用
+        - 429: 凭证被限流但有效
+        - 其他: 凭证失败（返回实际错误码）
+    """
+    try:
+        mode = validate_mode(mode)
+
+        # 验证文件名
+        if not filename.endswith(".json"):
+            raise HTTPException(status_code=400, detail="无效的文件名")
+
+        storage_adapter = await get_storage_adapter()
+
+        # 获取凭证数据
+        credential_data = await storage_adapter.get_credential(filename, mode=mode)
+        if not credential_data:
+            raise HTTPException(status_code=404, detail="凭证不存在")
+
+        # 创建凭证对象并尝试刷新 token（如果需要）
+        credentials = Credentials.from_dict(credential_data)
+        token_refreshed = await credentials.refresh_if_needed()
+
+        # 如果 token 被刷新了，更新存储
+        if token_refreshed:
+            log.info(f"Token已自动刷新: {filename} (mode={mode})")
+            credential_data = credentials.to_dict()
+            await storage_adapter.store_credential(filename, credential_data, mode=mode)
+
+        # 获取访问令牌
+        access_token = credential_data.get("access_token") or credential_data.get("token")
+        if not access_token:
+            raise HTTPException(status_code=400, detail="凭证中没有访问令牌")
+
+        # 根据模式构造测试请求
+        from src.httpx_client import post_async
+
+        # 获取 project_id
+        project_id = credential_data.get("project_id", "")
+        if not project_id:
+            raise HTTPException(status_code=400, detail="凭证中没有项目ID")
+
+        # 根据模式选择 API 端点和请求头
+        # 对于 geminicli 模式，使用两次测试：gemini-2.5-flash 和 gemini-3-flash-preview
+        # 对于 antigravity 模式，只使用 gemini-2.5-flash
+        test_model = "gemini-2.5-flash"
+
+        if mode == "antigravity":
+            api_base_url = await get_antigravity_api_url()
+            from src.api.antigravity import build_antigravity_headers
+            headers = build_antigravity_headers(access_token, test_model)
+        else:
+            api_base_url = await get_code_assist_endpoint()
+            headers = {
+                "Authorization": f"Bearer {access_token}",
+                "Content-Type": "application/json",
+                "User-Agent": GEMINICLI_USER_AGENT,
+            }
+
+        # 第一次测试：使用 gemini-2.5-flash
+        response = await post_async(
+            url=f"{api_base_url}/v1internal:generateContent",
+            json={
+                "model": test_model,
+                "project": project_id,
+                "request": {
+                    "contents": [{"role": "user", "parts": [{"text": "hi"}]}],
+                    "generationConfig": {"maxOutputTokens": 1}
+                }
+            },
+            headers=headers,
+            timeout=30.0
+        )
+
+        # 返回实际的状态码和详细信息
+        status_code = response.status_code
+
+        if status_code == 200 or status_code == 429:
+            log.info(f"凭证测试成功: {filename} (mode={mode}, model={test_model}, status={status_code})")
+            # 测试成功时清除错误状态
+            if status_code == 200:
+                await storage_adapter.update_credential_state(filename, {
+                    "error_codes": [],
+                    "error_messages": {}
+                }, mode=mode)
+
+                # 如果是 geminicli 模式且第一次测试成功，继续测试 gemini-3-flash-preview
+                if mode == "geminicli":
+                    preview_model = "gemini-3-flash-preview"
+                    log.info(f"开始测试 preview 模型: {filename} (model={preview_model})")
+
+                    try:
+                        preview_response = await post_async(
+                            url=f"{api_base_url}/v1internal:generateContent",
+                            json={
+                                "model": preview_model,
+                                "project": project_id,
+                                "request": {
+                                    "contents": [{"role": "user", "parts": [{"text": "hi"}]}],
+                                    "generationConfig": {"maxOutputTokens": 1}
+                                }
+                            },
+                            headers=headers,
+                            timeout=30.0
+                        )
+
+                        preview_status = preview_response.status_code
+
+                        if preview_status == 200 or preview_status == 429:
+                            # preview 模型测试成功，设置 preview=True
+                            log.info(f"Preview 模型测试成功: {filename} (status={preview_status})")
+                            await storage_adapter.update_credential_state(filename, {
+                                "preview": True
+                            }, mode=mode)
+                        elif preview_status == 404:
+                            # preview 模型返回 404，说明不支持，设置 preview=False
+                            log.warning(f"Preview 模型不支持: {filename} (status=404)")
+                            await storage_adapter.update_credential_state(filename, {
+                                "preview": False
+                            }, mode=mode)
+                        else:
+                            # 其他错误，保持默认 preview 状态
+                            log.warning(f"Preview 模型测试失败: {filename} (status={preview_status})")
+                    except Exception as e:
+                        log.error(f"Preview 模型测试异常: {filename} - {e}")
+
+            # 返回成功响应
+            return JSONResponse(
+                status_code=status_code,
+                content={
+                    "success": True,
+                    "status_code": status_code,
+                    "message": "测试成功",
+                    "filename": filename
+                }
+            )
+        else:
+            log.warning(f"凭证测试失败: {filename} (mode={mode}, status={status_code})")
+            # 测试失败时保存错误码和错误消息（覆盖模式，只保存最新的一个错误）
+            try:
+                error_text = response.text if hasattr(response, 'text') else ""
+
+                # 打印详细错误内容到日志
+                log.error(f"凭证测试错误详情 - 文件: {filename}, 模式: {mode}, 状态码: {status_code}, 错误内容: {error_text}")
+
+                # 使用覆盖模式保存错误（与 credential_manager 保持一致）
+                error_codes = [status_code]
+                error_messages = {str(status_code): error_text if error_text else f"HTTP {status_code}"}
+
+                # 更新状态
+                await storage_adapter.update_credential_state(filename, {
+                    "error_codes": error_codes,
+                    "error_messages": error_messages
+                }, mode=mode)
+
+                log.info(f"已保存测试错误信息: {filename} - 错误码 {status_code}")
+            except Exception as e:
+                log.error(f"保存测试错误信息失败: {e}")
+
+        # 返回错误响应，包含完整的错误信息
+        error_text = response.text if hasattr(response, 'text') else ""
+
+        return JSONResponse(
+            status_code=status_code,
+            content={
+                "success": False,
+                "status_code": status_code,
+                "message": f"测试失败: HTTP {status_code}",
+                "error": error_text,
+                "filename": filename
+            }
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"测试凭证失败 {filename}: {e}")
+        raise HTTPException(status_code=500, detail=f"测试失败: {str(e)}")

src/panel/logs.py

@@ -0,0 +1,237 @@
+"""
+日志路由模块 - 处理 /logs/* 相关的HTTP请求和WebSocket连接
+"""
+
+import asyncio
+import datetime
+import os
+
+from fastapi import APIRouter, Depends, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.responses import FileResponse, JSONResponse
+from starlette.websockets import WebSocketState
+
+import config
+from log import log
+from src.utils import verify_panel_token
+from .utils import ConnectionManager
+
+
+# 创建路由器
+router = APIRouter(prefix="/logs", tags=["logs"])
+
+# WebSocket连接管理器
+manager = ConnectionManager()
+
+
+@router.post("/clear")
+async def clear_logs(token: str = Depends(verify_panel_token)):
+    """清空日志文件"""
+    try:
+        # 直接使用环境变量获取日志文件路径
+        log_file_path = os.getenv("LOG_FILE", "log.txt")
+
+        # 检查日志文件是否存在
+        if os.path.exists(log_file_path):
+            try:
+                # 清空文件内容（保留文件），确保以UTF-8编码写入
+                # 使用 with 确保文件正确关闭
+                with open(log_file_path, "w", encoding="utf-8") as f:
+                    f.write("")
+                    f.flush()  # 强制刷新到磁盘
+                    # with 退出时会自动关闭文件
+                log.info(f"日志文件已清空: {log_file_path}")
+
+                # 通知所有WebSocket连接日志已清空
+                await manager.broadcast("--- 日志文件已清空 ---")
+
+                return JSONResponse(
+                    content={"message": f"日志文件已清空: {os.path.basename(log_file_path)}"}
+                )
+            except Exception as e:
+                log.error(f"清空日志文件失败: {e}")
+                raise HTTPException(status_code=500, detail=f"清空日志文件失败: {str(e)}")
+        else:
+            return JSONResponse(content={"message": "日志文件不存在"})
+
+    except Exception as e:
+        log.error(f"清空日志文件失败: {e}")
+        raise HTTPException(status_code=500, detail=f"清空日志文件失败: {str(e)}")
+
+
+@router.get("/download")
+async def download_logs(token: str = Depends(verify_panel_token)):
+    """下载日志文件"""
+    try:
+        # 直接使用环境变量获取日志文件路径
+        log_file_path = os.getenv("LOG_FILE", "log.txt")
+
+        # 检查日志文件是否存在
+        if not os.path.exists(log_file_path):
+            raise HTTPException(status_code=404, detail="日志文件不存在")
+
+        # 检查文件是否为空
+        file_size = os.path.getsize(log_file_path)
+        if file_size == 0:
+            raise HTTPException(status_code=404, detail="日志文件为空")
+
+        # 生成文件名（包含时间戳）
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"gcli2api_logs_{timestamp}.txt"
+
+        log.info(f"下载日志文件: {log_file_path}")
+
+        return FileResponse(
+            path=log_file_path,
+            filename=filename,
+            media_type="text/plain",
+            headers={"Content-Disposition": f"attachment; filename={filename}"},
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"下载日志文件失败: {e}")
+        raise HTTPException(status_code=500, detail=f"下载日志文件失败: {str(e)}")
+
+
+@router.websocket("/stream")
+async def websocket_logs(websocket: WebSocket):
+    """WebSocket端点，用于实时日志流"""
+    # WebSocket 认证: 从查询参数获取 token
+    token = websocket.query_params.get("token")
+
+    if not token:
+        await websocket.close(code=403, reason="Missing authentication token")
+        log.warning("WebSocket连接被拒绝: 缺少认证token")
+        return
+
+    # 验证 token
+    try:
+        panel_password = await config.get_panel_password()
+        if token != panel_password:
+            await websocket.close(code=403, reason="Invalid authentication token")
+            log.warning("WebSocket连接被拒绝: token验证失败")
+            return
+    except Exception as e:
+        await websocket.close(code=1011, reason="Authentication error")
+        log.error(f"WebSocket认证过程出错: {e}")
+        return
+
+    # 检查连接数限制
+    if not await manager.connect(websocket):
+        return
+
+    try:
+        # 直接使用环境变量获取日志文件路径
+        log_file_path = os.getenv("LOG_FILE", "log.txt")
+
+        # 发送初始日志（限制为最后50行，减少内存占用）
+        if os.path.exists(log_file_path):
+            try:
+                # 使用 with 确保文件正确关闭
+                with open(log_file_path, "r", encoding="utf-8") as f:
+                    lines = f.readlines()
+                    # 只发送最后50行，减少初始内存消耗
+                    for line in lines[-50:]:
+                        if line.strip():
+                            await websocket.send_text(line.strip())
+            except Exception as e:
+                await websocket.send_text(f"Error reading log file: {e}")
+                log.error(f"WebSocket初始日志读取错误: {e}")
+
+        # 监控日志文件变化
+        last_size = os.path.getsize(log_file_path) if os.path.exists(log_file_path) else 0
+        max_read_size = 8192  # 限制单次读取大小为8KB，防止大量日志造成内存激增
+        check_interval = 2  # 增加检查间隔，减少CPU和I/O开销
+
+        # 创建后台任务监听客户端断开
+        # 即使没有日志更新，receive_text() 也能即时感知断开
+        async def listen_for_disconnect():
+            try:
+                while True:
+                    await websocket.receive_text()
+            except Exception:
+                pass
+
+        listener_task = asyncio.create_task(listen_for_disconnect())
+
+        try:
+            while websocket.client_state == WebSocketState.CONNECTED:
+                # 使用 asyncio.wait 同时等待定时器和断开信号
+                # timeout=check_interval 替代了 asyncio.sleep
+                done, pending = await asyncio.wait(
+                    [listener_task],
+                    timeout=check_interval,
+                    return_when=asyncio.FIRST_COMPLETED
+                )
+
+                # 如果监听任务结束（通常是因为连接断开），则退出循环
+                if listener_task in done:
+                    break
+
+                if os.path.exists(log_file_path):
+                    current_size = os.path.getsize(log_file_path)
+                    if current_size > last_size:
+                        # 限制读取大小，防止单次读取过多内容
+                        read_size = min(current_size - last_size, max_read_size)
+
+                        try:
+                            # 使用 with 确保文件正确关闭，即使发生异常
+                            with open(log_file_path, "r", encoding="utf-8", errors="replace") as f:
+                                f.seek(last_size)
+                                new_content = f.read(read_size)
+                                # with 退出时自动关闭文件句柄
+
+                                # 处理编码错误的情况
+                                if not new_content:
+                                    last_size = current_size
+                                    continue
+
+                                # 分行发送，避免发送不完整的行
+                                lines = new_content.splitlines(keepends=True)
+                                if lines:
+                                    # 如果最后一行没有换行符，保留到下次处理
+                                    if not lines[-1].endswith("\n") and len(lines) > 1:
+                                        # 除了最后一行，其他都发送
+                                        for line in lines[:-1]:
+                                            if line.strip():
+                                                await websocket.send_text(line.rstrip())
+                                        # 更新位置，但要退回最后一行的字节数
+                                        last_size += len(new_content.encode("utf-8")) - len(
+                                            lines[-1].encode("utf-8")
+                                        )
+                                    else:
+                                        # 所有行都发送
+                                        for line in lines:
+                                            if line.strip():
+                                                await websocket.send_text(line.rstrip())
+                                        last_size += len(new_content.encode("utf-8"))
+                        except UnicodeDecodeError as e:
+                            # 遇到编码错误时，跳过这部分内容
+                            log.warning(f"WebSocket日志读取编码错误: {e}, 跳过部分内容")
+                            last_size = current_size
+                        except Exception as e:
+                            await websocket.send_text(f"Error reading new content: {e}")
+                            # 发生其他错误时，重置文件位置
+                            last_size = current_size
+
+                    # 如果文件被截断（如清空日志），重置位置
+                    elif current_size < last_size:
+                        last_size = 0
+                        await websocket.send_text("--- 日志已清空 ---")
+
+        finally:
+            # 确保清理监听任务
+            if not listener_task.done():
+                listener_task.cancel()
+                try:
+                    await listener_task
+                except asyncio.CancelledError:
+                    pass
+
+    except WebSocketDisconnect:
+        pass
+    except Exception as e:
+        log.error(f"WebSocket logs error: {e}")
+    finally:
+        manager.disconnect(websocket)

src/panel/root.py

@@ -0,0 +1,34 @@
+"""
+根路由模块 - 处理控制面板主页
+"""
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import HTMLResponse
+
+from log import log
+from .utils import is_mobile_user_agent
+
+
+# 创建路由器
+router = APIRouter(tags=["root"])
+
+
+@router.get("/", response_class=HTMLResponse)
+async def serve_control_panel(request: Request):
+    """提供统一控制面板"""
+    try:
+        user_agent = request.headers.get("user-agent", "")
+        is_mobile = is_mobile_user_agent(user_agent)
+
+        if is_mobile:
+            html_file_path = "front/control_panel_mobile.html"
+        else:
+            html_file_path = "front/control_panel.html"
+
+        with open(html_file_path, "r", encoding="utf-8") as f:
+            html_content = f.read()
+        return HTMLResponse(content=html_content)
+
+    except Exception as e:
+        log.error(f"加载控制面板页面失败: {e}")
+        raise HTTPException(status_code=500, detail="服务器内部错误")

src/panel/utils.py

@@ -0,0 +1,166 @@
+"""
+共享工具模块 - 包含WebSocket连接管理、工具函数等
+"""
+
+import os
+import time
+from collections import deque
+from typing import Set
+
+from fastapi import HTTPException, WebSocket
+from starlette.websockets import WebSocketState
+
+import config
+from log import log
+
+
+# =============================================================================
+# WebSocket连接管理
+# =============================================================================
+
+
+class ConnectionManager:
+    def __init__(self, max_connections: int = 3):  # 进一步降低最大连接数
+        # 使用双端队列严格限制内存使用
+        self.active_connections: deque = deque(maxlen=max_connections)
+        self.max_connections = max_connections
+        self._last_cleanup = 0
+        self._cleanup_interval = 120  # 120秒清理一次死连接
+
+    async def connect(self, websocket: WebSocket):
+        # 自动清理死连接
+        self._auto_cleanup()
+
+        # 限制最大连接数，防止内存无限增长
+        if len(self.active_connections) >= self.max_connections:
+            await websocket.close(code=1008, reason="Too many connections")
+            return False
+
+        await websocket.accept()
+        self.active_connections.append(websocket)
+        log.debug(f"WebSocket连接建立，当前连接数: {len(self.active_connections)}")
+        return True
+
+    def disconnect(self, websocket: WebSocket):
+        # 使用更高效的方式移除连接
+        try:
+            self.active_connections.remove(websocket)
+        except ValueError:
+            pass  # 连接已不存在
+        log.debug(f"WebSocket连接断开，当前连接数: {len(self.active_connections)}")
+
+    async def send_personal_message(self, message: str, websocket: WebSocket):
+        try:
+            await websocket.send_text(message)
+        except Exception:
+            self.disconnect(websocket)
+
+    async def broadcast(self, message: str):
+        # 使用更高效的方式处理广播，避免索引操作
+        dead_connections = []
+        for conn in self.active_connections:
+            try:
+                await conn.send_text(message)
+            except Exception:
+                dead_connections.append(conn)
+
+        # 批量移除死连接
+        for dead_conn in dead_connections:
+            self.disconnect(dead_conn)
+
+    def _auto_cleanup(self):
+        """自动清理死连接"""
+        current_time = time.time()
+        if current_time - self._last_cleanup > self._cleanup_interval:
+            self.cleanup_dead_connections()
+            self._last_cleanup = current_time
+
+    def cleanup_dead_connections(self):
+        """清理已断开的连接"""
+        original_count = len(self.active_connections)
+        # 使用列表推导式过滤活跃连接，更高效
+        alive_connections = deque(
+            [
+                conn
+                for conn in self.active_connections
+                if hasattr(conn, "client_state")
+                and conn.client_state != WebSocketState.DISCONNECTED
+            ],
+            maxlen=self.max_connections,
+        )
+
+        self.active_connections = alive_connections
+        cleaned = original_count - len(self.active_connections)
+        if cleaned > 0:
+            log.debug(f"清理了 {cleaned} 个死连接，剩余连接数: {len(self.active_connections)}")
+
+
+# =============================================================================
+# 工具函数
+# =============================================================================
+
+
+def is_mobile_user_agent(user_agent: str) -> bool:
+    """检测是否为移动设备用户代理"""
+    if not user_agent:
+        return False
+
+    user_agent_lower = user_agent.lower()
+    mobile_keywords = [
+        "mobile",
+        "android",
+        "iphone",
+        "ipad",
+        "ipod",
+        "blackberry",
+        "windows phone",
+        "samsung",
+        "htc",
+        "motorola",
+        "nokia",
+        "palm",
+        "webos",
+        "opera mini",
+        "opera mobi",
+        "fennec",
+        "minimo",
+        "symbian",
+        "psp",
+        "nintendo",
+        "tablet",
+    ]
+
+    return any(keyword in user_agent_lower for keyword in mobile_keywords)
+
+
+def validate_mode(mode: str = "geminicli") -> str:
+    """
+    验证 mode 参数
+
+    Args:
+        mode: 模式字符串 ("geminicli" 或 "antigravity")
+
+    Returns:
+        str: 验证后的 mode 字符串
+
+    Raises:
+        HTTPException: 如果 mode 参数无效
+    """
+    if mode not in ["geminicli", "antigravity"]:
+        raise HTTPException(
+            status_code=400,
+            detail=f"无效的 mode 参数: {mode}，只支持 'geminicli' 或 'antigravity'"
+        )
+    return mode
+
+
+def get_env_locked_keys() -> Set:
+    """获取被环境变量锁定的配置键集合"""
+    env_locked_keys = set()
+
+    # 使用 config.py 中统一维护的映射表
+    for env_key, config_key in config.ENV_MAPPINGS.items():
+        if os.getenv(env_key):
+            env_locked_keys.add(config_key)
+
+    return env_locked_keys

src/panel/version.py

@@ -0,0 +1,107 @@
+"""
+版本信息路由模块 - 处理 /version/* 相关的HTTP请求
+"""
+
+import os
+
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+
+from log import log
+
+
+# 创建路由器
+router = APIRouter(prefix="/version", tags=["version"])
+
+
+@router.get("/info")
+async def get_version_info(check_update: bool = False):
+    """
+    获取当前版本信息 - 从version.txt读取
+    可选参数 check_update: 是否检查GitHub上的最新版本
+    """
+    try:
+        # 获取项目根目录
+        project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        version_file = os.path.join(project_root, "version.txt")
+
+        # 读取version.txt
+        if not os.path.exists(version_file):
+            return JSONResponse({
+                "success": False,
+                "error": "version.txt文件不存在"
+            })
+
+        version_data = {}
+        with open(version_file, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                if '=' in line:
+                    key, value = line.split('=', 1)
+                    version_data[key] = value
+
+        # 检查必要字段
+        if 'short_hash' not in version_data:
+            return JSONResponse({
+                "success": False,
+                "error": "version.txt格式错误"
+            })
+
+        response_data = {
+            "success": True,
+            "version": version_data.get('short_hash', 'unknown'),
+            "full_hash": version_data.get('full_hash', ''),
+            "message": version_data.get('message', ''),
+            "date": version_data.get('date', '')
+        }
+
+        # 如果需要检查更新
+        if check_update:
+            try:
+                from src.httpx_client import get_async
+
+                # 直接获取GitHub上的version.txt文件
+                github_version_url = "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/version.txt"
+
+                # 使用统一的httpx客户端
+                resp = await get_async(github_version_url, timeout=10.0)
+
+                if resp.status_code == 200:
+                    # 解析远程version.txt
+                    remote_version_data = {}
+                    for line in resp.text.strip().split('\n'):
+                        line = line.strip()
+                        if '=' in line:
+                            key, value = line.split('=', 1)
+                            remote_version_data[key] = value
+
+                    latest_hash = remote_version_data.get('full_hash', '')
+                    latest_short_hash = remote_version_data.get('short_hash', '')
+                    current_hash = version_data.get('full_hash', '')
+
+                    has_update = (current_hash != latest_hash) if current_hash and latest_hash else None
+
+                    response_data['check_update'] = True
+                    response_data['has_update'] = has_update
+                    response_data['latest_version'] = latest_short_hash
+                    response_data['latest_hash'] = latest_hash
+                    response_data['latest_message'] = remote_version_data.get('message', '')
+                    response_data['latest_date'] = remote_version_data.get('date', '')
+                else:
+                    # GitHub获取失败，但不影响基本版本信息
+                    response_data['check_update'] = False
+                    response_data['update_error'] = f"GitHub返回错误: {resp.status_code}"
+
+            except Exception as e:
+                log.debug(f"检查更新失败: {e}")
+                response_data['check_update'] = False
+                response_data['update_error'] = str(e)
+
+        return JSONResponse(response_data)
+
+    except Exception as e:
+        log.error(f"获取版本信息失败: {e}")
+        return JSONResponse({
+            "success": False,
+            "error": str(e)
+        })