Upload 115 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+warp_accounts.db filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7777 8019 8000
+
+CMD ["python", "main.py", "all"]

LICENSE

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

README.md

@@ -1,11 +1,216 @@
----
-title: Warp2api
-emoji: 🔥
-colorFrom: green
-colorTo: yellow
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Warp AI 代理服务与账号池系统
+
+这是一个功能完备的Warp AI API代理服务，它不仅提供了与OpenAI Chat Completions API的兼容性，还集成了一套全自动的账号注册、维护和分配系统。项目的设计目标是提供一个稳定、高效且易于管理的Warp AI接口。
+
+该项目的设计思路和部分实现得益于以下优秀项目：
+- **Protobuf协议逆向基础**: [libaxuan/Warp2Api](https://github.com/libaxuan/Warp2Api)
+- **账号池与注册机思路**: [dundunduan/warp2api](https://github.com/dundunduan/warp2api)
+
+---
+
+## 🚀 核心特性
+
+- **OpenAI API 兼容**: 完全兼容 OpenAI Chat Completions API 格式，可无缝对接现有生态。
+- **全自动账号池**:
+    - **自动注册**: 通过Outlook API自动购买邮箱并注册Warp账号。
+    - **自动维护**: 定期检查账号状态，自动刷新即将过期的Token。
+    - **智能分配**: 通过独立的API服务，安全、高效地分配和回收账号。
+- **统一启动与管理**: 使用`main.py`一键启动所有服务，也支持为调试目的单独启动某个服务。
+- **中心化配置**: 所有配置项（端口、API密钥、数据库路径等）均在`config.py`中统一管理，清晰明了。
+- **高性能架构**:
+    - **Protobuf 通信**: 底层与Warp服务通过高效的Protobuf协议进行通信。
+    - **多进程模型**: 每个核心服务（API、账号池、维护等）都运行在独立的进程中，互不干扰。
+- **流式响应 (Streaming)**: 完全支持OpenAI的SSE流式响应格式。
+- **WebSocket 监控**: 内置WebSocket端点，用于实时监控Protobuf通信数据包。
+
+## 📁 项目结构
+
+项目采用扁平化结构，核心服务均在主目录下，方便理解和修改。
+
+```
+/
+├── main.py                  # 🚀 统一服务启动器
+├── config.py                # ⚙️ 全局配置文件
+│
+├── server.py                # 🔌 Protobuf 核心服务 (端口: 8000)
+├── openai_compat.py         # 🤖 OpenAI 兼容API服务 (端口: 8010)
+│
+├── pool_service.py          # 💧 账号池API服务 (端口: 8019)
+├── pool_maintenance.py      # 🛠️ 账号池维护与Token刷新服务
+├── warp_register.py         # 📧 Warp 账号自动注册服务
+│
+├── warp_accounts.db         # 🗃️ 存储Warp账号的SQLite数据库
+├── requirements.txt         # 🐍 Python 依赖
+└── README.md                # 📄 项目文档
+```
+
+## 🛠️ 安装与配置
+
+### 1. 克隆仓库
+
+```bash
+git clone <your-repository-url>
+cd <repository-name>
+```
+
+### 2. 安装依赖
+
+推荐使用 `uv` 或 `pip` 安装 `requirements.txt` 中的依赖。
+
+```bash
+# 使用 uv (推荐)
+uv pip install -r requirements.txt
+
+# 或者使用 pip
+pip install -r requirements.txt
+```
+
+### 3. 配置 `config.py`
+
+这是最关键的一步。打开 [`config.py`](config.py) 文件并填写必要的配置信息。
+
+**必须配置的选项:**
+
+- `OUTLOOK_BASE_URL`: 你的Outlook邮箱API购买地址的基础URL。
+- `OUTLOOK_API_CONFIG`:
+    - `app_id`: 你的Outlook API App ID。
+    - `app_key`: 你的Outlook API App Key。
+
+**可选配置（通常保持默认即可）:**
+
+- 各个服务的端口号（`SERVER_PORT`, `OPENAI_COMPAT_PORT`, `POOL_SERVICE_PORT`）。
+- 代理地址 `PROXY_URL`。
+- 账号池大小 `MIN_POOL_SIZE`, `MAX_POOL_SIZE`。
+- 目标注册账号数 `TARGET_ACCOUNTS`。
+
+## 🎯 使用方法
+
+我们提供了统一的启动脚本 [`main.py`](main.py)，极大简化了服务的管理和调试。
+
+### 一键启动所有服务（推荐）
+
+在终端中运行以下命令，即可启动全部五个核心服务：
+
+```bash
+python main.py all
+```
+
+脚本会为每个服务创建一个独立的进程，并打印出每个服务的启动信息和进程ID。你可以通过 `Ctrl+C` 来优雅地关闭所有服务。
+
+### 单独启动服务（用于调试）
+
+如果你想单独调试某个服务，可以使用 `main.py` 启动它。这对于问题排查非常有用。
+
+```bash
+# 仅启动 Protobuf 主服务
+python main.py server
+
+# 仅启动 OpenAI 兼容API
+python main.py openai
+
+# 仅启动账号池API服务
+python main.py pool_service
+
+# 仅启动账号池维护脚本
+python main.py pool_maintenance
+
+# 仅启动账号注册服务
+python main.py register
+```
+
+## 📝 API 使用
+
+服务启动后，你可以通过两个主要的API端点与系统交互。
+
+### 1. OpenAI 兼容 API (`http://127.0.0.1:8010`)
+
+你可以使用任何支持OpenAI API的客户端来访问此接口。
+
+- **Base URL**: `http://127.0.0.1:8010/v1`
+- **API Key**: **无���提供**。你可以填写任意字符串（例如 "dummy"），服务器不会进行验证。
+
+#### Python 示例
+
+```python
+import openai
+
+client = openai.OpenAI(
+    base_url="http://127.0.0.1:8010/v1",
+    api_key="not-needed"
+)
+
+response = client.chat.completions.create(
+    model="gemini-2.5-pro", # 或者其他Warp支持的模型
+    messages=[
+        {"role": "user", "content": "你好，请介绍一下你自己"}
+    ],
+    stream=True
+)
+
+for chunk in response:
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="")
+```
+
+#### cURL 示例
+
+```bash
+curl -X POST http://127.0.0.1:8010/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "claude-4-sonnet",
+    "messages": [
+      {"role": "user", "content": "解释量子计算的基本原理"}
+    ],
+    "stream": true
+  }'
+```
+
+### 2. 账号池服务 API (`http://0.0.0.0:8019`)
+
+你可以直接与账号池服务交互来监控其状态。
+
+#### 查看账号池状态
+
+```bash
+curl http://localhost:8019/api/status | jq
+```
+
+这将返回一个JSON对象，包含总账号数、可用账号数、锁定账号数等信息。
+
+#### 健康检查
+
+```bash
+curl http://localhost:8019/api/health
+```
+
+## 🏗️ 架构说明
+
+系统由五个协同工作的独立服务进程组成：
+
+1.  **账号注册服务 (`warp_register.py`)**: 作为一个生产者，它不断地通过Outlook API获取新邮箱，并自动完成Warp账号的注册流程，然后将成功的账号存入`warp_accounts.db`数据库。
+
+2.  **账号池维护服务 (`pool_maintenance.py`)**: 这是一个后台守护进程，定期扫描数据库中的所有账号，检查其Token的有效性。当Token即将过期时，它会自动执行刷新操作，确保账号池中的账号始终保持可用状态。
+
+3.  **账号池API服务 (`pool_service.py`)**: 这是一个面向内部的API服务，负责管理对数据库中账号的访问。当其他服务需要一个Warp账号时，会向它请求。它会从池中分配一个当前未被使用的账号，并将其标记为“锁定”状态，以防止并发冲突。使用完毕后，账号会被释放回池中。
+
+4.  **Protobuf主服务 (`server.py`)**: 这是与Warp官方服务器直接通信的核心桥梁。它接收内部请求，使用Protobuf协议对数据进行编码，然后发送给Warp。同样，它也负责解码从Warp返回的Protobuf数据。
+
+5.  **OpenAI兼容API服务 (`openai_compat.py`)**: 这是暴露给最终用户的服务。它接收一个标准格式的OpenAI API请求，然后向**账号池API服务**申请一个可用的Warp账号。获取到账号凭证后，它将请求转发给**Protobuf主服务**进行处理，最终将Warp的响应转换成OpenAI格式返回给用户。
+
+这个多进程、微服务化的架构确保了各个模块职责单一、高内聚、低耦合，提高了系统的健壮性和可维护性。
+
+## 🐛 故障排查
+
+- **服务无法启动**:
+    - 检查`config.py`中的端口是否被其他程序占用。
+    - 查看终端日志，了解详细的错误信息。
+- **账号注册失败**:
+    - 确保`config.py`中的Outlook API信息 (`app_id`, `app_key`, `base_url`) 正确无误且账户有余额。
+    - 检查`PROXY_URL`是否可用，注册过程依赖代理。
+- **账号池为空**:
+    - 首次启动时，请耐心等待`warp_register.py`服务完成第一批账号的注册。
+    - 查看`warp_register.py`进程的日志，确认注册流程是否正常。
+- **API请求失败**:
+    - 确保`all`服务都已正常启动。
+    - 检查`openai_compat.py`和`server.py`的日志，定位请求失败的具体环节。

config.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+统一配置管理
+"""
+
+# ==================== 临时邮箱API配置 ====================
+# 临时邮箱服务的基础URL
+TEMP_MAIL_BASE_URL = "https://mail.chatgpt.org.uk/api"
+
+# ==================== 代理配置 ====================
+# HTTP代理，用于常规请求
+# PROXY_URL = "http://127.0.0.1:7890"
+PROXY_URL = ""
+
+# ==================== 账号池维护 (pool_maintenance.py) ====================
+MIN_POOL_SIZE = 5  # 最小账号池大小
+MAX_POOL_SIZE = 50  # 最大账号池大小
+TOKEN_REFRESH_HOURS = 1  # Token刷新间隔（小时）
+MAINTENANCE_CHECK_INTERVAL = 60  # 维护检查间隔（秒）
+
+# ==================== 数据库配置 ====================
+DATABASE_PATH = "warp_accounts.db"
+DB_TIMEOUT = 10.0  # 数据库操作超时时间（秒）
+
+# ==================== Firebase API 配置 ====================
+FIREBASE_API_KEY = "AIzaSyBdy3O3S9hrdayLJxJ7mriBR4qgUaUygAs"
+FIREBASE_API_KEYS = [
+    FIREBASE_API_KEY
+]
+
+# ==================== 账号池服务 (pool_service.py) ====================
+POOL_SERVICE_HOST = "0.0.0.0"
+POOL_SERVICE_PORT = 8019
+MAX_SESSION_DURATION = 30 * 60  # 会话最大持续时间（30分钟）
+
+# ==================== 账号注册 (warp_register.py) ====================
+TARGET_ACCOUNTS = 200  # 目标账号数
+MAX_CONCURRENT_REGISTER = 2  # 最大并发注册数
+MAX_PROXY_RETRIES = 5  # 代理重试次数
+
+# ==================== OpenAI兼容服务 (openai_compat.py) ====================
+OPENAI_COMPAT_HOST = "0.0.0.0"
+OPENAI_COMPAT_PORT = 7777
+
+# ==================== Protobuf主服务 (server.py) ====================
+SERVER_HOST = "0.0.0.0"
+SERVER_PORT = 8000
+
+# ==================== 日志配置 ====================
+LOG_LEVEL = "INFO"
+LOG_FORMAT = '%(asctime)s - %(levelname)s - [%(processName)s] - %(message)s'

docker-compose.yml

@@ -0,0 +1,15 @@
+services:
+  warp2api:
+    build: .
+    container_name: warp2api
+    restart: unless-stopped
+    environment:
+      - PYTHONUNBUFFERED=1
+    ports:
+      - "7777:7777"
+      - "8777:8019"
+      - "8778:8000"
+    volumes:
+      - ./config.py:/app/config.py
+      - ./warp_accounts.db:/app/warp_accounts.db
+    command: ["python", "main.py", "all"]

main.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Warp 服务统一启动器
+"""
+
+import multiprocessing
+import time
+import sys
+import os
+import importlib
+import logging
+import asyncio
+
+# 在导入项目模块之前，确保项目根目录在sys.path中
+# 这有助于解决在不同环境下模块导入失败的问题
+project_root = os.path.dirname(os.path.abspath(__file__))
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
+import config
+
+# 配置日志
+logging.basicConfig(
+    level=config.LOG_LEVEL,
+    format=config.LOG_FORMAT
+)
+logger = logging.getLogger(__name__)
+
+
+# ==================== 服务启动函数 ====================
+
+def run_server():
+    """启动 Protobuf 主服务 (server.py)"""
+    logger.info("正在启动 Protobuf 主服务...")
+    try:
+        # 动态导入并执行main函数
+        module = importlib.import_module("server")
+        module.main()
+    except Exception as e:
+        logger.error(f"Protobuf 主服务启动失败: {e}", exc_info=True)
+
+
+def run_openai_compat():
+    """启动 OpenAI 兼容服务 (openai_compat.py)"""
+    logger.info("正在启动 OpenAI 兼容服务...")
+    try:
+        # openai_compat.py 使用 uvicorn.run 并且没有main函数
+        # 我们需要模拟它的 __main__ 执行块
+        module = importlib.import_module("openai_compat")
+        uvicorn = importlib.import_module("uvicorn")
+        
+        # 刷新JWT
+        try:
+            from warp2protobuf.core.auth import refresh_jwt_if_needed as _refresh_jwt
+            asyncio.run(_refresh_jwt())
+        except Exception:
+            pass
+            
+        uvicorn.run(
+            module.app,
+            host=config.OPENAI_COMPAT_HOST,
+            port=config.OPENAI_COMPAT_PORT,
+            log_level=config.LOG_LEVEL.lower(),
+        )
+    except Exception as e:
+        logger.error(f"OpenAI 兼容服务启动失败: {e}", exc_info=True)
+
+
+def run_pool_service():
+    """启动账号池HTTP服务 (pool_service.py)"""
+    logger.info("正在启动账号池HTTP服务...")
+    try:
+        module = importlib.import_module("pool_service")
+        asyncio.run(module.main())
+    except Exception as e:
+        logger.error(f"账号池HTTP服务启动失败: {e}", exc_info=True)
+
+
+def run_pool_maintenance():
+    """启动账号池维护脚本 (pool_maintenance.py)"""
+    logger.info("正在启动账号池维护脚本...")
+    try:
+        module = importlib.import_module("pool_maintenance")
+        # 默认以 'auto' 模式运行
+        sys.argv = [sys.argv[0], 'auto']
+        asyncio.run(module.main())
+    except Exception as e:
+        logger.error(f"账号池维护脚本启动失败: {e}", exc_info=True)
+
+
+def run_warp_register():
+    """启动Warp账号注册脚本 (warp_register.py)"""
+    logger.info("正在启动Warp账号注册脚本...")
+    try:
+        module = importlib.import_module("warp_register")
+        asyncio.run(module.main())
+    except Exception as e:
+        logger.error(f"Warp账号注册脚本启动失败: {e}", exc_info=True)
+
+
+# ==================== 进程管理 ====================
+
+SERVICES = {
+    "server": run_server,
+    "openai": run_openai_compat,
+    "pool_service": run_pool_service,
+    "pool_maintenance": run_pool_maintenance,
+    "register": run_warp_register,
+}
+
+
+def start_all_services():
+    """启动所有服务"""
+    processes = []
+    for name, target_func in SERVICES.items():
+        process = multiprocessing.Process(target=target_func, name=f"Process-{name}")
+        processes.append(process)
+        process.start()
+        logger.info(f"服务 '{name}' 已在进程 {process.pid} 中启动。")
+
+    try:
+        while True:
+            time.sleep(1)
+            for process in processes:
+                if not process.is_alive():
+                    logger.warning(f"进程 '{process.name}' (PID: {process.pid}) 已退出。")
+                    # 可选择在这里添加重启逻辑
+                    processes.remove(process)
+
+            if not processes:
+                logger.info("所有服务进程都已退出。")
+                break
+
+    except KeyboardInterrupt:
+        logger.info("接收到停止信号，正在关闭所有服务...")
+        for process in processes:
+            process.terminate()
+            process.join()
+        logger.info("所有服务已停止。")
+
+
+def print_usage():
+    """打印使用说明"""
+    print("=" * 60)
+    print("Warp 服务统一启动器")
+    print("=" * 60)
+    print("用法:")
+    print("  python main.py [命令]")
+    print("\n可用命令:")
+    print("  all                - 启动所有服务")
+    for name in SERVICES:
+        print(f"  {name:<18} - 仅启动 {name} 服务 (用于调试)")
+    print("\n示例:")
+    print("  python main.py all")
+    print("  python main.py server")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    # 设置多进程启动方式，这对于Windows和macOS是推荐的
+    multiprocessing.set_start_method("spawn", force=True)
+
+    if len(sys.argv) < 2:
+        print_usage()
+        sys.exit(1)
+
+    command = sys.argv[1].lower()
+
+    if command == "all":
+        start_all_services()
+    elif command in SERVICES:
+        logger.info(f"以调试模式启动单个服务: '{command}'")
+        SERVICES[command]()
+    else:
+        print(f"错误: 未知命令 '{command}'\n")
+        print_usage()
+        sys.exit(1)

openai_compat.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+OpenAI Chat Completions compatible server (system-prompt flavored)
+
+Startup entrypoint that exposes the modular app implemented in protobuf2openai.
+"""
+
+from __future__ import annotations
+
+import os
+import asyncio
+
+from protobuf2openai.app import app  # FastAPI app
+
+
+if __name__ == "__main__":
+    import uvicorn
+    import config
+    # Refresh JWT on startup before running the server
+    try:
+        from warp2protobuf.core.auth import refresh_jwt_if_needed as _refresh_jwt
+        asyncio.run(_refresh_jwt())
+    except Exception:
+        pass
+    uvicorn.run(
+        app,
+        host=os.getenv("HOST", config.OPENAI_COMPAT_HOST),
+        port=int(os.getenv("PORT", config.OPENAI_COMPAT_PORT)),
+        log_level=config.LOG_LEVEL.lower(),
+    )

pool_maintenance.py

@@ -0,0 +1,516 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Warp账号池维护脚本
+管理已注册的账号，包括token刷新、状态检查等
+"""
+
+import asyncio
+import sqlite3
+import json
+import time
+import base64
+import traceback
+
+import requests
+import logging
+from typing import Dict, List, Optional, Tuple, Any
+from datetime import datetime, timedelta
+from dataclasses import dataclass
+
+# ==================== 配置部分 ====================
+import config
+
+# 日志配置
+logging.basicConfig(
+    level=config.LOG_LEVEL,
+    format=config.LOG_FORMAT
+)
+logger = logging.getLogger(__name__)
+
+
+# ==================== 数据模型 ====================
+@dataclass
+class Account:
+    """账号数据模型"""
+    id: Optional[int] = None
+    email: str = ""
+    email_password: Optional[str] = None
+    local_id: str = ""
+    id_token: str = ""
+    refresh_token: str = ""
+    status: str = "active"
+    created_at: Optional[datetime] = None
+    last_used: Optional[datetime] = None
+    last_refresh_time: Optional[datetime] = None
+    use_count: int = 0
+    proxy_info: Optional[str] = None
+    user_agent: Optional[str] = None
+
+
+# ==================== 数据库管理 ====================
+class DatabaseManager:
+    """数据库管理器"""
+
+    def __init__(self, db_path=config.DATABASE_PATH):
+        self.db_path = db_path
+
+    def get_all_accounts(self, status: str = None) -> List[Account]:
+        """获取所有账号"""
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+
+        if status:
+            cursor.execute('SELECT * FROM accounts WHERE status = ?', (status,))
+        else:
+            cursor.execute('SELECT * FROM accounts')
+
+        rows = cursor.fetchall()
+        accounts = []
+
+        for row in rows:
+            account = Account(
+                id=row['id'],
+                email=row['email'],
+                email_password=row['email_password'],
+                local_id=row['local_id'],
+                id_token=row['id_token'],
+                refresh_token=row['refresh_token'],
+                status=row['status'],
+                created_at=datetime.fromisoformat(row['created_at']) if row['created_at'] else None,
+                last_used=datetime.fromisoformat(row['last_used']) if row['last_used'] else None,
+                last_refresh_time=datetime.fromisoformat(row['last_refresh_time']) if row[
+                    'last_refresh_time'] else None,
+                use_count=row['use_count'] or 0,
+                proxy_info=row['proxy_info'],
+                user_agent=row['user_agent']
+            )
+            accounts.append(account)
+
+        conn.close()
+        return accounts
+
+    def update_account_token(self, email: str, id_token: str, refresh_token: str = None):
+        """更新账号token"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        if refresh_token:
+            cursor.execute('''
+                           UPDATE accounts
+                           SET id_token          = ?,
+                               refresh_token     = ?,
+                               last_refresh_time = ?
+                           WHERE email = ?
+                           ''', (id_token, refresh_token, datetime.now(), email))
+        else:
+            cursor.execute('''
+                           UPDATE accounts
+                           SET id_token          = ?,
+                               last_refresh_time = ?
+                           WHERE email = ?
+                           ''', (id_token, datetime.now(), email))
+
+        conn.commit()
+        conn.close()
+        logger.info(f"✅ 更新账号token: {email}")
+
+    def update_account_status(self, email: str, status: str):
+        """更新账号状态"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        cursor.execute('''
+                       UPDATE accounts
+                       SET status = ?
+                       WHERE email = ?
+                       ''', (status, email))
+
+        conn.commit()
+        conn.close()
+        logger.info(f"📝 更新账号状态: {email} -> {status}")
+
+    def get_statistics(self) -> Dict[str, int]:
+        """获取统计信息"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        stats = {}
+        cursor.execute('SELECT status, COUNT(*) FROM accounts GROUP BY status')
+        for row in cursor.fetchall():
+            stats[row[0]] = row[1]
+
+        cursor.execute('SELECT COUNT(*) FROM accounts')
+        stats['total'] = cursor.fetchone()[0]
+
+        conn.close()
+        return stats
+
+    def cleanup_expired_accounts(self, days: int = 30):
+        """清理过期账号"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        # 删除30天未使用的账号
+        cutoff_date = datetime.now() - timedelta(days=days)
+        cursor.execute('''
+                       DELETE
+                       FROM accounts
+                       WHERE status = 'expired'
+                          OR (last_used IS NOT NULL AND last_used < ?)
+                       ''', (cutoff_date,))
+
+        deleted_count = cursor.rowcount
+        conn.commit()
+        conn.close()
+
+        if deleted_count > 0:
+            logger.info(f"🗑️ 清理了 {deleted_count} 个过期账号")
+
+        return deleted_count
+
+
+# ==================== Token刷新服务 ====================
+class TokenRefreshService:
+    """Token刷新服务"""
+
+    def __init__(self, firebase_api_key: str = config.FIREBASE_API_KEY):
+        self.firebase_api_key = firebase_api_key
+        self.base_url = "https://securetoken.googleapis.com/v1/token"
+
+    def is_token_expired(self, id_token: str, buffer_minutes: int = 5) -> bool:
+        """检查JWT token是否过期"""
+        try:
+            if not id_token:
+                return True
+
+            # 解码JWT token
+            parts = id_token.split('.')
+            if len(parts) != 3:
+                return True
+
+            # 解码payload
+            payload_part = parts[1]
+            payload_part += '=' * (4 - len(payload_part) % 4)
+
+            payload_bytes = base64.urlsafe_b64decode(payload_part)
+            payload = json.loads(payload_bytes.decode('utf-8'))
+
+            # 检查过期时间
+            exp_timestamp = payload.get('exp')
+            if not exp_timestamp:
+                return True
+
+            # 添加缓冲时间
+            current_time = time.time()
+            buffer_seconds = buffer_minutes * 60
+
+            return (exp_timestamp - current_time) <= buffer_seconds
+
+        except Exception as e:
+            logger.error(f"检查Token过期状态失败: {e}")
+            return True
+
+    def can_refresh_token(self, account: Account) -> Tuple[bool, Optional[str]]:
+        """检查是否可以刷新token（遵守1小时限制）"""
+        if not account.last_refresh_time:
+            return True, None
+
+        # 检查时间间隔
+        time_elapsed = datetime.now() - account.last_refresh_time
+        min_interval = timedelta(hours=config.TOKEN_REFRESH_HOURS)
+
+        if time_elapsed >= min_interval:
+            return True, None
+        else:
+            remaining = min_interval - time_elapsed
+            minutes = int(remaining.total_seconds() // 60)
+            seconds = int(remaining.total_seconds() % 60)
+            return False, f"需要等待 {minutes}分{seconds}秒"
+
+    def refresh_firebase_token(self, refresh_token: str) -> Tuple[bool, Optional[str], Optional[str]]:
+        """刷新Firebase Token"""
+        try:
+            payload = {
+                "grant_type": "refresh_token",
+                "refresh_token": refresh_token
+            }
+
+            url = f"{self.base_url}?key={self.firebase_api_key}"
+
+            response = requests.post(
+                url,
+                json=payload,
+                headers={"Content-Type": "application/json"},
+                timeout=30,
+            )
+
+            if response.ok:
+                data = response.json()
+                new_id_token = data.get('id_token')
+                if new_id_token:
+                    logger.info("✅ Firebase Token刷新成功")
+                    return True, new_id_token, None
+
+            return False, None, f"HTTP {response.status_code}"
+
+        except Exception as e:
+            return False, None, str(e)
+
+    async def refresh_account_if_needed(self, account: Account, db_manager: DatabaseManager) -> bool:
+        """根据需要刷新账号token"""
+        # 检查是否过期
+        if not self.is_token_expired(account.id_token, buffer_minutes=10):
+            return True
+
+        # 检查是否可以刷新
+        can_refresh, error_msg = self.can_refresh_token(account)
+        if not can_refresh:
+            logger.warning(f"⏰ {account.email} - {error_msg}")
+            return False
+
+        # 执行刷新
+        success, new_token, error = self.refresh_firebase_token(account.refresh_token)
+        if success and new_token:
+            db_manager.update_account_token(account.email, new_token)
+            logger.info(f"✨ 刷新token成功: {account.email}")
+            return True
+        else:
+            logger.error(f"❌ 刷新token失败: {account.email} - {error}")
+            return False
+
+
+# ==================== 账号池维护器 ====================
+class PoolMaintainer:
+    """账号池维护器"""
+
+    def __init__(self):
+        self.db_manager = DatabaseManager()
+        self.token_refresh_service = TokenRefreshService()
+        self.running = False
+
+    async def check_pool_health(self):
+        """检查账号池健康状态"""
+        stats = self.db_manager.get_statistics()
+        total = stats.get('total', 0)
+        active = stats.get('active', 0)
+        expired = stats.get('expired', 0)
+
+        logger.info("=" * 50)
+        logger.info("📊 账号池状态")
+        logger.info(f"📦 总账号数: {total}")
+        logger.info(f"✅ 活跃账号: {active}")
+        logger.info(f"❌ 过期账号: {expired}")
+
+        # 健康评估
+        if active < config.MIN_POOL_SIZE:
+            logger.warning(f"⚠️ 活跃账号不足 (当前: {active}, 最小: {config.MIN_POOL_SIZE})")
+        elif active > config.MAX_POOL_SIZE:
+            logger.warning(f"⚠️ 活跃账号过多 (当前: {active}, 最大: {config.MAX_POOL_SIZE})")
+        else:
+            logger.info(f"💚 账号池健康")
+
+        logger.info("=" * 50)
+
+        return stats
+
+    async def refresh_tokens(self):
+        """批量刷新token"""
+        logger.info("🔄 开始刷新token...")
+
+        accounts = self.db_manager.get_all_accounts(status='active')
+        refreshed = 0
+        failed = 0
+        skipped = 0
+
+        for account in accounts:
+            try:
+                if await self.token_refresh_service.refresh_account_if_needed(account, self.db_manager):
+                    refreshed += 1
+                else:
+                    skipped += 1
+            except Exception as e:
+                logger.error(f"刷新账号 {account.email} 失败: {e}")
+                failed += 1
+
+        logger.info(f"🔄 Token刷新完成 - 成功: {refreshed}, 跳过: {skipped}, 失败: {failed}")
+
+    async def verify_accounts(self):
+        """验证账号可用性"""
+        logger.info("🔍 验证账号可用性...")
+
+        accounts = self.db_manager.get_all_accounts(status='active')
+        verified = 0
+        invalid = 0
+
+        for account in accounts:
+            try:
+                # 简单验证token格式
+                if account.id_token and len(account.id_token.split('.')) == 3:
+                    verified += 1
+                else:
+                    self.db_manager.update_account_status(account.email, 'expired')
+                    invalid += 1
+            except Exception as e:
+                logger.error(f"验证账号 {account.email} 失败: {e}")
+                invalid += 1
+
+        logger.info(f"🔍 账号验证完成 - 有效: {verified}, 无效: {invalid}")
+
+    async def cleanup(self):
+        """清理任务"""
+        logger.info("🗑️ 执行清理任务...")
+
+        # 清理过期账号
+        deleted = self.db_manager.cleanup_expired_accounts(days=30)
+        logger.info(f"🗑️ 清理完成，删除 {deleted} 个过期账号")
+
+    async def maintenance_loop(self):
+        """维护循环"""
+        logger.info("🔧 账号池维护服务启动")
+
+        cycle = 0
+        while self.running:
+            cycle += 1
+            logger.info(f"\n🔄 第 {cycle} 个维护周期开始")
+
+            try:
+                # 1. 检查池健康状态
+                await self.check_pool_health()
+
+                # 2. 刷新即将过期的token
+                await self.refresh_tokens()
+
+                # 3. 验证账号可用性
+                await self.verify_accounts()
+
+                # 4. 每10个周期执行一次清理
+                if cycle % 10 == 0:
+                    await self.cleanup()
+
+                logger.info(f"✅ 第 {cycle} 个维护周期完成")
+
+            except Exception as e:
+                logger.error(f"❌ 维护周期异常: {e}")
+                logging.error(f"详细错误: {traceback.format_exc()}")
+
+            # 等待下一个周期
+            logger.info(f"⏰ 等待 {config.MAINTENANCE_CHECK_INTERVAL} 秒后进行下一次检查...")
+            await asyncio.sleep(config.MAINTENANCE_CHECK_INTERVAL)
+
+    async def start(self):
+        """启动维护服务"""
+        self.running = True
+
+        try:
+            await self.maintenance_loop()
+        except KeyboardInterrupt:
+            logger.info("⌨️ 收到停止信号")
+        finally:
+            self.running = False
+            logger.info("🛑 维护服务已停止")
+
+    async def manual_refresh(self, email: str = None, force: bool = False):
+        """手动刷新指定账号或所有账号"""
+        if email:
+            accounts = [acc for acc in self.db_manager.get_all_accounts() if acc.email == email]
+            if not accounts:
+                logger.error(f"账号不存在: {email}")
+                return
+        else:
+            accounts = self.db_manager.get_all_accounts(status='active')
+
+        logger.info(f"📋 手动刷新 {len(accounts)} 个账号")
+
+        for account in accounts:
+            try:
+                if force:
+                    # 强制刷新
+                    success, new_token, error = self.token_refresh_service.refresh_firebase_token(account.refresh_token)
+                    if success and new_token:
+                        self.db_manager.update_account_token(account.email, new_token)
+                        logger.info(f"✅ 强制刷新成功: {account.email}")
+                    else:
+                        logger.error(f"❌ 强制刷新失败: {account.email} - {error}")
+                else:
+                    # 正常刷新
+                    await self.token_refresh_service.refresh_account_if_needed(account, self.db_manager)
+
+            except Exception as e:
+                logger.error(f"刷新账号 {account.email} 时出错: {e}")
+
+
+# ==================== 命令行接口 ====================
+async def interactive_mode():
+    """交互模式"""
+    maintainer = PoolMaintainer()
+
+    print("\n" + "=" * 60)
+    print("🎮 Warp账号池维护 - 交互模式")
+    print("=" * 60)
+    print("命令列表:")
+    print("  status  - 查看账号池状态")
+    print("  refresh - 刷新所有账号token")
+    print("  verify  - 验证账号可用性")
+    print("  clean   - 清理过期账号")
+    print("  auto    - 启动自动维护")
+    print("  exit    - 退出程序")
+    print("=" * 60)
+
+    while True:
+        try:
+            cmd = input("\n> ").strip().lower()
+
+            if cmd == "status":
+                await maintainer.check_pool_health()
+            elif cmd == "refresh":
+                await maintainer.refresh_tokens()
+            elif cmd == "verify":
+                await maintainer.verify_accounts()
+            elif cmd == "clean":
+                await maintainer.cleanup()
+            elif cmd == "auto":
+                print("🔧 启动自动维护模式...")
+                await maintainer.start()
+            elif cmd == "exit":
+                print("👋 再见!")
+                break
+            else:
+                print(f"❓ 未知命令: {cmd}")
+
+        except KeyboardInterrupt:
+            print("\n👋 再见!")
+            break
+        except Exception as e:
+            print(f"❌ 错误: {e}")
+
+
+# ==================== 主函数 ====================
+async def main():
+    """主函数"""
+    import sys
+
+    if len(sys.argv) > 1:
+        mode = sys.argv[1].lower()
+
+        if mode == "auto":
+            # 自动模式
+            logger.info("🔧 启动自动维护模式")
+            maintainer = PoolMaintainer()
+            await maintainer.start()
+        elif mode == "interactive":
+            # 交互模式
+            await interactive_mode()
+        else:
+            print(f"❓ 未知模式: {mode}")
+            print("用法: python pool_maintenance.py [auto|interactive]")
+    else:
+        # 默认自动模式
+        logger.info("🔧 启动自动维护模式（默认）")
+        maintainer = PoolMaintainer()
+        await maintainer.start()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

pool_service.py

@@ -0,0 +1,546 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+账号池HTTP服务
+提供账号分配、释放、状态查询等API
+"""
+
+import asyncio
+import logging
+import time
+import traceback
+import uuid
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+
+import aiosqlite
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+# ==================== 配置 ====================
+import config
+
+# 日志配置
+logging.basicConfig(
+    level=config.LOG_LEVEL,
+    format=config.LOG_FORMAT
+)
+logger = logging.getLogger(__name__)
+
+
+# ==================== 数据模型 ====================
+class AllocateRequest(BaseModel):
+    count: int = 1
+    session_duration: Optional[int] = 1800  # 默认30分钟
+
+
+class ReleaseRequest(BaseModel):
+    session_id: str
+
+
+class RefreshRequest(BaseModel):
+    session_id: str
+    account_email: str
+
+
+class BlockAccountRequest(BaseModel):
+    jwt_token: Optional[str] = None
+    email: Optional[str] = None
+
+# ==================== 数据库优化器 ====================
+class DatabaseOptimizer:
+    """数据库性能优化器"""
+
+    @staticmethod
+    async def optimize_database(db_path: str):
+        """优化数据库性能"""
+        try:
+            async with aiosqlite.connect(db_path) as db:
+                # 创建索引以提升查询速度
+                await db.execute("""
+                                 CREATE INDEX IF NOT EXISTS idx_accounts_status_email
+                                     ON accounts(status, email)
+                                 """)
+
+                await db.execute("""
+                                 CREATE INDEX IF NOT EXISTS idx_accounts_status_last_used
+                                     ON accounts(status, last_used)
+                                 """)
+
+                await db.execute("""
+                                 CREATE INDEX IF NOT EXISTS idx_accounts_email
+                                     ON accounts(email)
+                                 """)
+
+                # 优化数据库设置
+                await db.execute("PRAGMA journal_mode = WAL")  # 使用WAL模式，提升并发性能
+                await db.execute("PRAGMA synchronous = NORMAL")  # 平衡性能和安全性
+                await db.execute("PRAGMA cache_size = 10000")  # 增加缓存大小
+                await db.execute("PRAGMA temp_store = MEMORY")  # 使用内存存储临时数据
+
+                await db.commit()
+                logger.info("✅ 数据库优化完成")
+        except Exception as e:
+            logger.error(f"数据库优化失败: {e}")
+
+# ==================== 账号池管理器 ====================
+class AccountPoolManager:
+    """账号池管理器"""
+
+    def __init__(self, db_path: str = config.DATABASE_PATH):
+        self.db_path = db_path
+        self.sessions: Dict[str, Dict] = {}  # 会话管理
+        self.locked_accounts: Dict[str, str] = {}  # email -> session_id
+        self.lock = asyncio.Lock()
+        self.account_cache: List[Dict] = []  # 账号缓存
+        self.cache_updated_at = 0
+        self.cache_ttl = 30  # 缓存有效期30秒
+
+    async def init_async(self):
+        """异步初始化"""
+        # 优化数据库
+        await DatabaseOptimizer.optimize_database(self.db_path)
+        # 预加载账号缓存
+        await self.refresh_account_cache()
+
+    async def refresh_account_cache(self):
+        """刷新账号缓存"""
+        try:
+            async with aiosqlite.connect(self.db_path, timeout=config.DB_TIMEOUT) as db:
+                db.row_factory = aiosqlite.Row
+
+                # 只缓存活跃账号的基本信息
+                cursor = await db.execute("""
+                                          SELECT email,
+                                                 local_id,
+                                                 id_token,
+                                                 refresh_token,
+                                                 client_id,
+                                                 outlook_refresh_token,
+                                                 proxy_info,
+                                                 user_agent,
+                                                 email_password,
+                                                 last_used,
+                                                 created_at
+                                          FROM accounts
+                                          WHERE status = 'active'
+                                          ORDER BY COALESCE(last_used, created_at) ASC
+                                          """)
+
+                rows = await cursor.fetchall()
+                self.account_cache = [dict(row) for row in rows]
+                self.cache_updated_at = time.time()
+
+                logger.info(f"账号缓存已更新: {len(self.account_cache)} 个账号")
+        except Exception as e:
+            logger.error(f"刷新账号缓存失败: {e}")
+
+    async def get_available_accounts_fast(self, count: int = 1) -> List[Dict[str, Any]]:
+        """快速获取可用账号（使用缓存）"""
+        # 检查缓存是否需要更新
+        if time.time() - self.cache_updated_at > self.cache_ttl:
+            asyncio.create_task(self.refresh_account_cache())  # 异步更新，不阻塞当前请求
+
+        # 从缓存中找出未锁定的账号
+        available = []
+        for account in self.account_cache:
+            if account['email'] not in self.locked_accounts:
+                available.append(account)
+                if len(available) >= count:
+                    break
+
+        return available
+
+    async def allocate_accounts(self, count: int = 1, session_duration: int = config.MAX_SESSION_DURATION) -> Dict[str, Any]:
+        """分配账号（优化版）"""
+        start_time = time.time()
+
+        try:
+            # 使用超时锁，避免无限等待
+            async with asyncio.timeout(3):  # 3秒超时
+                async with self.lock:
+                    logger.info(f"开始分配 {count} 个账号...")
+
+                    # 快速获取可用账号
+                    accounts = await self.get_available_accounts_fast(count)
+
+                    if not accounts:
+                        logger.warning("没有可用账号")
+                        raise HTTPException(status_code=503, detail="No available accounts")
+
+                    # 创建会话
+                    session_id = str(uuid.uuid4())
+                    session_info = {
+                        'session_id': session_id,
+                        'accounts': accounts,
+                        'created_at': time.time(),
+                        'expires_at': time.time() + session_duration,
+                        'status': 'active'
+                    }
+
+                    # 锁定账号
+                    for account in accounts:
+                        self.locked_accounts[account['email']] = session_id
+
+                    self.sessions[session_id] = session_info
+
+                    # 异步更新数据库（不阻塞响应）
+                    asyncio.create_task(self.update_last_used_async(accounts))
+
+                    elapsed = time.time() - start_time
+                    logger.info(f"✅ 分配了 {len(accounts)} 个账号，会话ID: {session_id}，耗时: {elapsed:.2f}秒")
+
+                    return {
+                        'success': True,
+                        'session_id': session_id,
+                        'accounts': accounts,
+                        'expires_at': session_info['expires_at']
+                    }
+
+        except asyncio.TimeoutError:
+            logger.error("分配账号超时")
+            raise HTTPException(status_code=503, detail="Request timeout")
+        except Exception as e:
+            logger.error(f"分配账号失败: {e}")
+            raise
+
+    async def mark_account_blocked(self, jwt_token: Optional[str] = None, email: Optional[str] = None) -> Dict[str, Any]:
+        """标记账号为已封禁"""
+        try:
+            async with aiosqlite.connect(self.db_path, timeout=config.DB_TIMEOUT) as db:
+                found_email = None
+
+                if email:
+                    # 直接根据email标记
+                    found_email = email
+                elif jwt_token:
+                    # 根据token片段查找账号
+                    # 注意：这是简化实现，实际可能需要更复杂的匹配逻辑
+                    cursor = await db.execute(
+                        'SELECT email, id_token FROM accounts WHERE status = "active"'
+                    )
+                    rows = await cursor.fetchall()
+                    for row in rows:
+                        # 粗略匹配token前缀（因为我们只传了前50个字符）
+                        if row[1] and jwt_token in row[1][:50]:
+                            found_email = row[0]
+                            break
+
+                if found_email:
+                    # 更新数据库状态为blocked
+                    await db.execute(
+                        'UPDATE accounts SET status = "blocked", last_used = ? WHERE email = ?',
+                        (datetime.now().isoformat(), found_email)
+                    )
+                    await db.commit()
+
+                    # 从缓存中移除
+                    self.account_cache = [
+                        acc for acc in self.account_cache
+                        if acc.get('email') != found_email
+                    ]
+
+                    # 从锁定列表中移除
+                    if found_email in self.locked_accounts:
+                        session_id = self.locked_accounts[found_email]
+                        del self.locked_accounts[found_email]
+
+                        # 更新会话信息
+                        if session_id in self.sessions:
+                            self.sessions[session_id]['accounts'] = [
+                                acc for acc in self.sessions[session_id]['accounts']
+                                if acc.get('email') != found_email
+                            ]
+
+                    logger.warning(f"⛔ 账号已标记为封禁: {found_email}")
+
+                    return {
+                        'success': True,
+                        'message': f'Account {found_email} marked as blocked',
+                        'email': found_email
+                    }
+                else:
+                    return {
+                        'success': False,
+                        'message': 'Account not found'
+                    }
+
+        except Exception as e:
+            logger.error(f"标记账号失败: {e}")
+            return {
+                'success': False,
+                'message': str(e)
+            }
+
+    async def update_last_used_async(self, accounts: List[Dict]):
+        """异步更新账号最后使用时间（后台任务）"""
+        try:
+            async with aiosqlite.connect(self.db_path, timeout=config.DB_TIMEOUT) as db:
+                for account in accounts:
+                    await db.execute(
+                        'UPDATE accounts SET last_used = ?, use_count = use_count + 1 WHERE email = ?',
+                        (datetime.now().isoformat(), account['email'])
+                    )
+                await db.commit()
+                logger.info(f"已更新 {len(accounts)} 个账号的使用时间")
+        except Exception as e:
+            logger.error(f"更新账号使用时间失败: {e}")
+
+    async def release_session(self, session_id: str) -> Dict[str, Any]:
+        """释放会话"""
+        try:
+            async with asyncio.timeout(2):
+                async with self.lock:
+                    if session_id not in self.sessions:
+                        return {
+                            'success': False,
+                            'message': 'Session not found'
+                        }
+
+                    session_info = self.sessions[session_id]
+
+                    # 解锁账号
+                    for account in session_info['accounts']:
+                        if account['email'] in self.locked_accounts:
+                            del self.locked_accounts[account['email']]
+
+                    # 删除会话
+                    del self.sessions[session_id]
+
+                    logger.info(f"释放会话: {session_id}")
+
+                    return {
+                        'success': True,
+                        'message': 'Session released'
+                    }
+        except asyncio.TimeoutError:
+            return {
+                'success': False,
+                'message': 'Release timeout'
+            }
+
+    async def get_pool_status(self) -> Dict[str, Any]:
+        """获取池状态（优化版）"""
+        try:
+            # 使用缓存的账号数量
+            total_active = len(self.account_cache)
+            locked_count = len(self.locked_accounts)
+            available_count = total_active - locked_count
+
+            # 异步获取过期账号数（不阻塞主查询）
+            total_expired = 0
+            try:
+                async with aiosqlite.connect(self.db_path, timeout=2) as db:
+                    cursor = await db.execute('SELECT COUNT(*) FROM accounts WHERE status = "expired"')
+                    total_expired = (await cursor.fetchone())[0]
+            except:
+                pass
+
+            return {
+                'total_active': total_active,
+                'total_expired': total_expired,
+                'locked': locked_count,
+                'available': available_count,
+                'active_sessions': len(self.sessions),
+                'cache_age_seconds': int(time.time() - self.cache_updated_at),
+                'sessions': [
+                    {
+                        'session_id': sid,
+                        'account_count': len(info['accounts']),
+                        'created_at': info['created_at'],
+                        'expires_at': info['expires_at']
+                    }
+                    for sid, info in self.sessions.items()
+                ]
+            }
+        except Exception as e:
+            logger.error(f"获取状态失败: {e}")
+            raise
+
+    async def cleanup_expired_sessions(self):
+        """清理过期会话"""
+        current_time = time.time()
+        expired_sessions = []
+
+        try:
+            async with self.lock:
+                for session_id, session_info in self.sessions.items():
+                    if current_time > session_info['expires_at']:
+                        expired_sessions.append(session_id)
+
+            # 在锁外释放会话，避免长时间持锁
+            for session_id in expired_sessions:
+                await self.release_session(session_id)
+                logger.info(f"清理过期会话: {session_id}")
+        except Exception as e:
+            logger.error(f"清理会话失败: {e}")
+
+
+# ==================== FastAPI应用 ====================
+app = FastAPI(title="Warp账号池服务", version="2.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 全局管理器实例
+pool_manager = None
+
+
+@app.on_event("startup")
+async def startup_event():
+    """启动事件"""
+    global pool_manager
+
+    logger.info("账号池服务启动中...")
+
+    # 初始化管理器
+    pool_manager = AccountPoolManager()
+    await pool_manager.init_async()
+
+    logger.info("账号池服务已启动")
+
+    # 启动定期任务
+    async def periodic_tasks():
+        while True:
+            await asyncio.sleep(60)  # 每分钟执行一次
+            try:
+                # 清理过期会话
+                await pool_manager.cleanup_expired_sessions()
+                # 刷新缓存
+                await pool_manager.refresh_account_cache()
+            except Exception as e:
+                logger.error(f"定期任务执行失败: {e}")
+
+    asyncio.create_task(periodic_tasks())
+
+
+@app.get("/")
+async def root():
+    """根路径"""
+    return {
+        "service": "Warp Account Pool",
+        "version": "2.0.0",
+        "status": "running",
+        "optimized": True
+    }
+
+
+@app.post("/api/accounts/allocate")
+async def allocate_accounts(request: AllocateRequest):
+    """分配账号"""
+    try:
+        if not pool_manager:
+            raise HTTPException(status_code=503, detail="Service initializing")
+
+        result = await pool_manager.allocate_accounts(
+            count=request.count,
+            session_duration=request.session_duration
+        )
+        return result
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"分配账号失败: {e}\n{traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/accounts/release")
+async def release_accounts(request: ReleaseRequest):
+    """释放账号"""
+    try:
+        if not pool_manager:
+            raise HTTPException(status_code=503, detail="Service initializing")
+
+        result = await pool_manager.release_session(request.session_id)
+        return result
+    except Exception as e:
+        logger.error(f"释放账号失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/accounts/mark_blocked")
+async def mark_account_blocked(request: BlockAccountRequest):
+    """标记账号为已封禁"""
+    try:
+        if not pool_manager:
+            raise HTTPException(status_code=503, detail="Service initializing")
+
+        # 根据JWT token片段或email找到并标记账号
+        result = await pool_manager.mark_account_blocked(
+            jwt_token=request.jwt_token,
+            email=request.email
+        )
+
+        if not result['success']:
+            raise HTTPException(status_code=404, detail=result['message'])
+
+        return result
+    except HTTPException as e:
+        logger.error(f"标记账号失败: {e}")
+        raise
+    except Exception as e:
+        logger.error(f"标记账号失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/status")
+async def get_status():
+    """获取池状态"""
+    try:
+        if not pool_manager:
+            raise HTTPException(status_code=503, detail="Service initializing")
+
+        status = await pool_manager.get_pool_status()
+        return status
+    except Exception as e:
+        logger.error(f"获取状态失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/health")
+async def health_check():
+    """健康检查"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "cache_enabled": True,
+        "optimized": True
+    }
+
+
+# ==================== 主函数 ====================
+async def main():
+    """主函数"""
+    logger.info("=" * 60)
+    logger.info("Warp账号池HTTP服务 v2.0 (优化版)")
+    logger.info(f"端口: {config.POOL_SERVICE_PORT}")
+    logger.info(f"数据库: {config.DATABASE_PATH}")
+    logger.info("=" * 60)
+
+    # 检查数据库
+    import os
+    if not os.path.exists(config.DATABASE_PATH):
+        logger.error(f"数据库文件不存在: {config.DATABASE_PATH}")
+        logger.error("请先运行注册脚本创建账号")
+        return
+
+    # 启动服务
+    uvicorn_config = uvicorn.Config(
+        app=app,
+        host=config.POOL_SERVICE_HOST,
+        port=config.POOL_SERVICE_PORT,
+        log_level=config.LOG_LEVEL.lower()
+    )
+    server = uvicorn.Server(uvicorn_config)
+    await server.serve()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

proto/attachment.proto

@@ -0,0 +1,57 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+import "options.proto";
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+message Attachment {
+    oneof value {
+        string plain_text = 1;
+        ExecutedShellCommand executed_shell_command = 2;
+        RunningShellCommand running_shell_command = 3;
+        DriveObject drive_object = 4;
+    }
+}
+
+message ExecutedShellCommand {
+    string command = 1;
+    string output = 2;
+    int32 exit_code = 3;
+}
+
+message RunningShellCommand {
+    string command = 1;
+    LongRunningShellCommandSnapshot snapshot = 2;
+}
+
+message LongRunningShellCommandSnapshot {
+    string output = 1;
+}
+
+message DriveObject {
+    string uid = 1;
+    
+    oneof object_payload {
+        Workflow workflow = 2;
+        Notebook notebook = 3;
+        GenericStringObject generic_string_object = 4;
+    }
+}
+
+message Workflow {
+    string name = 1;
+    string description = 2;
+    string command = 3;
+}
+
+message Notebook {
+    string title = 1;
+    string content = 2;
+}
+
+message GenericStringObject {
+    string payload = 1;
+    string object_type = 2;
+}

proto/citations.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+message Citation {
+    string document_id = 1;
+    DocumentType document_type = 2;
+}
+
+enum DocumentType {
+    WARP_DRIVE_WORKFLOW = 0;
+    WARP_DRIVE_NOTEBOOK = 1;
+    WARP_DRIVE_ENV_VAR = 2;
+    RULE = 3;
+    WARP_DOCUMENTATION = 4;
+    WEB_PAGE = 5;
+    UNKNOWN = 6;
+}

proto/debug.proto

@@ -0,0 +1,12 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+import "task.proto";
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+message TaskList {
+    repeated Task tasks = 1;
+    repeated string ordered_message_ids = 2;
+}

proto/file_content.proto

@@ -0,0 +1,18 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+import "options.proto";
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+message FileContentLineRange {
+    uint32 start = 1;
+    uint32 end = 2;
+}
+
+message FileContent {
+    string file_path = 1;
+    string content = 2;
+    FileContentLineRange line_range = 3;
+}

proto/input_context.proto

@@ -0,0 +1,64 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+import "google/protobuf/timestamp.proto";
+import "file_content.proto";
+import "attachment.proto";
+import "options.proto";
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+message InputContext {
+    Directory directory = 1;
+    message Directory {
+        string pwd = 1;
+        string home = 2;
+        bool pwd_file_symbols_indexed = 3;
+    }
+    
+    OperatingSystem operating_system = 2;
+    message OperatingSystem {
+        string platform = 1;
+        string distribution = 2;
+    }
+    
+    Shell shell = 3;
+    message Shell {
+        string name = 1;
+        string version = 2;
+    }
+    
+    google.protobuf.Timestamp current_time = 4;
+    
+    repeated Codebase codebases = 8;
+    message Codebase {
+        string name = 1;
+        string path = 2;
+    }
+    
+    repeated ProjectRules project_rules = 10;
+    message ProjectRules {
+        string root_path = 1;
+        repeated FileContent active_rule_files = 2;
+        repeated string additional_rule_file_paths = 3;
+    }
+    
+    repeated ExecutedShellCommand executed_shell_commands = 5 [deprecated = true];
+    
+    repeated SelectedText selected_text = 6;
+    message SelectedText {
+        string text = 1;
+    }
+    
+    repeated Image images = 7;
+    message Image {
+        bytes data = 1;
+        string mime_type = 2;
+    }
+    
+    repeated File files = 9;
+    message File {
+        FileContent content = 1;
+    }
+}

proto/options.proto

@@ -0,0 +1,12 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+extend google.protobuf.FieldOptions {
+    bool sensitive = 50000;
+    bool internal = 50001;
+}

proto/request.proto

@@ -0,0 +1,173 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+import "google/protobuf/struct.proto";
+import "input_context.proto";
+import "attachment.proto";
+import "options.proto";
+import "suggestions.proto";
+import "task.proto";
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+message Request {
+    TaskContext task_context = 1;
+    message TaskContext {
+        repeated Task tasks = 1;
+        string active_task_id = 2;
+    }
+    
+    Input input = 2;
+    message Input {
+        InputContext context = 1;
+        
+        oneof type {
+            UserInputs user_inputs = 6;
+            QueryWithCannedResponse query_with_canned_response = 4;
+            AutoCodeDiffQuery auto_code_diff_query = 5;
+            ResumeConversation resume_conversation = 7;
+            InitProjectRules init_project_rules = 8;
+            UserQuery user_query = 2 [deprecated = true];
+            ToolCallResult tool_call_result = 3 [deprecated = true];
+        }
+        
+        message UserQuery {
+            string query = 1;
+            map<string, Attachment> referenced_attachments = 2;
+        }
+        
+        message UserInputs {
+            repeated UserInput inputs = 1;
+            message UserInput {
+                oneof input {
+                    UserQuery user_query = 1;
+                    ToolCallResult tool_call_result = 2;
+                }
+            }
+        }
+        
+        message ToolCallResult {
+            string tool_call_id = 1;
+            
+            oneof result {
+                RunShellCommandResult run_shell_command = 2;
+                ReadFilesResult read_files = 3;
+                SearchCodebaseResult search_codebase = 4;
+                ApplyFileDiffsResult apply_file_diffs = 5;
+                SuggestPlanResult suggest_plan = 6;
+                SuggestCreatePlanResult suggest_create_plan = 7;
+                GrepResult grep = 8;
+                FileGlobResult file_glob = 9;
+                RefineResult refine = 10;
+                ReadMCPResourceResult read_mcp_resource = 11;
+                CallMCPToolResult call_mcp_tool = 12;
+                WriteToLongRunningShellCommandResult write_to_long_running_shell_command = 13;
+                SuggestNewConversationResult suggest_new_conversation = 14;
+                FileGlobV2Result file_glob_v2 = 15;
+            }
+            
+            message RefineResult {
+                UserQuery user_query = 1;
+            }
+        }
+        
+        message QueryWithCannedResponse {
+            string query = 1;
+            
+            oneof type {
+                Install install = 2;
+                Code code = 3;
+                Deploy deploy = 4;
+                SomethingElse something_else = 5;
+                CustomOnboardingRequest custom_onboarding_request = 6;
+                AgenticOnboardingKickoff agentic_onboarding_kickoff = 7;
+            }
+            
+            message Install {
+                
+            }
+            
+            message Code {
+                
+            }
+            
+            message Deploy {
+                
+            }
+            
+            message SomethingElse {
+                
+            }
+            
+            message CustomOnboardingRequest {
+                
+            }
+            
+            message AgenticOnboardingKickoff {
+                
+            }
+        }
+        
+        message AutoCodeDiffQuery {
+            string query = 1;
+        }
+        
+        message ResumeConversation {
+            
+        }
+        
+        message InitProjectRules {
+            
+        }
+    }
+    
+    Settings settings = 3;
+    message Settings {
+        ModelConfig model_config = 1;
+        message ModelConfig {
+            string base = 1;
+            string planning = 2;
+            string coding = 3;
+        }
+        
+        bool rules_enabled = 2;
+        bool web_context_retrieval_enabled = 3;
+        bool supports_parallel_tool_calls = 4;
+        bool use_anthropic_text_editor_tools = 5;
+        bool planning_enabled = 6;
+        bool warp_drive_context_enabled = 7;
+        bool supports_create_files = 8;
+        repeated ToolType supported_tools = 9;
+        bool supports_long_running_commands = 10;
+        bool should_preserve_file_content_in_history = 11;
+        bool supports_todos_ui = 12;
+        bool supports_linked_code_blocks = 13;
+    }
+    
+    Metadata metadata = 4;
+    message Metadata {
+        string conversation_id = 1;
+        map<string, google.protobuf.Value> logging = 2;
+    }
+    
+    Suggestions existing_suggestions = 5;
+    
+    MCPContext mcp_context = 6;
+    message MCPContext {
+        repeated MCPResource resources = 1;
+        message MCPResource {
+            string uri = 1;
+            string name = 2;
+            string description = 3;
+            string mime_type = 4;
+        }
+        
+        repeated MCPTool tools = 2;
+        message MCPTool {
+            string name = 1;
+            string description = 2;
+            google.protobuf.Struct input_schema = 3;
+        }
+    }
+}

proto/response.proto

@@ -0,0 +1,159 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+import "google/protobuf/field_mask.proto";
+import "options.proto";
+import "suggestions.proto";
+import "task.proto";
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+message ResponseEvent {
+    oneof type {
+        StreamInit init = 1;
+        ClientActions client_actions = 2;
+        StreamFinished finished = 3;
+    }
+    
+    message StreamInit {
+        string conversation_id = 1;
+        string request_id = 2;
+    }
+    
+    message ClientActions {
+        repeated ClientAction actions = 1;
+    }
+    
+    message StreamFinished {
+        repeated TokenUsage token_usage = 8;
+        message TokenUsage {
+            string model_id = 1;
+            uint32 total_input = 2;
+            uint32 output = 3;
+            uint32 input_cache_read = 4;
+            uint32 input_cache_write = 5;
+            float cost_in_cents = 6;
+        }
+        
+        bool should_refresh_model_config = 9;
+        
+        RequestCost request_cost = 10;
+        message RequestCost {
+            float exact = 1;
+        }
+        
+        ContextWindowInfo context_window_info = 11;
+        message ContextWindowInfo {
+            float context_window_usage = 1;
+            bool summarized = 2;
+        }
+        
+        oneof reason {
+            Other other = 1;
+            Done done = 2;
+            ReachedMaxTokenLimit max_token_limit = 3;
+            QuotaLimit quota_limit = 4;
+            ContextWindowExceeded context_window_exceeded = 5;
+            LLMUnavailable llm_unavailable = 6;
+            InternalError internal_error = 7;
+        }
+        
+        message Other {
+            
+        }
+        
+        message Done {
+            
+        }
+        
+        message ReachedMaxTokenLimit {
+            
+        }
+        
+        message QuotaLimit {
+            
+        }
+        
+        message ContextWindowExceeded {
+            
+        }
+        
+        message LLMUnavailable {
+            
+        }
+        
+        message InternalError {
+            string message = 1;
+        }
+    }
+}
+
+message ClientAction {
+    oneof action {
+        CreateTask create_task = 1;
+        UpdateTaskStatus update_task_status = 2;
+        AddMessagesToTask add_messages_to_task = 3;
+        UpdateTaskMessage update_task_message = 4;
+        AppendToMessageContent append_to_message_content = 5;
+        Suggestions show_suggestions = 6;
+        UpdateTaskSummary update_task_summary = 7;
+        UpdateTaskDescription update_task_description = 8;
+        BeginTransaction begin_transaction = 9;
+        CommitTransaction commit_transaction = 10;
+        RollbackTransaction rollback_transaction = 11;
+        StartNewConversation start_new_conversation = 12;
+    }
+    
+    message CreateTask {
+        Task task = 1;
+    }
+    
+    message UpdateTaskStatus {
+        string task_id = 1;
+        TaskStatus task_status = 2;
+    }
+    
+    message UpdateTaskDescription {
+        string task_id = 1;
+        string description = 2;
+    }
+    
+    message AddMessagesToTask {
+        string task_id = 1;
+        repeated Message messages = 2;
+    }
+    
+    message UpdateTaskMessage {
+        string task_id = 3;
+        Message message = 1;
+        google.protobuf.FieldMask mask = 2;
+    }
+    
+    message AppendToMessageContent {
+        string task_id = 3;
+        Message message = 1;
+        google.protobuf.FieldMask mask = 2;
+    }
+    
+    message UpdateTaskSummary {
+        string task_id = 1;
+        string summary = 2;
+    }
+    
+    message BeginTransaction {
+        
+    }
+    
+    message CommitTransaction {
+        
+    }
+    
+    message RollbackTransaction {
+        
+    }
+    
+    message StartNewConversation {
+        string start_from_message_id = 1;
+    }
+}

proto/suggestions.proto

@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+message Suggestions {
+    repeated SuggestedRule rules = 1;
+    repeated SuggestedAgentModeWorkflow workflows = 2;
+}
+
+message SuggestedRule {
+    string name = 1;
+    string content = 2;
+    string logging_id = 3;
+}
+
+message SuggestedAgentModeWorkflow {
+    string name = 1;
+    string prompt = 2;
+    string logging_id = 3;
+}

proto/task.proto

@@ -0,0 +1,503 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+import "google/protobuf/empty.proto";
+import "google/protobuf/descriptor.proto";
+import "google/protobuf/struct.proto";
+import "citations.proto";
+import "input_context.proto";
+import "attachment.proto";
+import "file_content.proto";
+import "options.proto";
+import "todo.proto";
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+message Task {
+    string id = 1;
+    string description = 2;
+    
+    Dependencies dependencies = 3;
+    message Dependencies {
+        string parent_task_id = 1;
+        repeated string sibling_dependencies = 2;
+    }
+    
+    TaskStatus status = 4;
+    repeated Message messages = 5;
+    string summary = 6;
+}
+
+message TaskStatus {
+    oneof status {
+        Pending pending = 1;
+        InProgress in_progress = 2;
+        Blocked blocked = 3;
+        Succeeded succeeded = 4;
+        Failed failed = 5;
+        Aborted aborted = 6;
+    }
+    
+    message Pending {
+        
+    }
+    
+    message InProgress {
+        
+    }
+    
+    message Blocked {
+        
+    }
+    
+    message Succeeded {
+        
+    }
+    
+    message Failed {
+        
+    }
+    
+    message Aborted {
+        
+    }
+}
+
+message Message {
+    string id = 1;
+    string task_id = 11;
+    string server_message_data = 7;
+    repeated Citation citations = 8;
+    
+    oneof message {
+        UserQuery user_query = 2;
+        AgentOutput agent_output = 3;
+        ToolCall tool_call = 4;
+        ToolCallResult tool_call_result = 5;
+        ServerEvent server_event = 6;
+        SystemQuery system_query = 9;
+        UpdateTodos update_todos = 10;
+    }
+    
+    message UserQuery {
+        string query = 1;
+        InputContext context = 2;
+        map<string, Attachment> referenced_attachments = 3;
+    }
+    
+    message SystemQuery {
+        InputContext context = 2;
+        
+        oneof type {
+            AutoCodeDiff auto_code_diff = 1;
+            ResumeConversation resume_conversation = 3;
+        }
+    }
+    
+    message AutoCodeDiff {
+        string query = 1;
+    }
+    
+    message ResumeConversation {
+        
+    }
+    
+    message AgentOutput {
+        string text = 1;
+        string reasoning = 2;
+    }
+    
+    message ToolCall {
+        string tool_call_id = 1;
+        
+        oneof tool {
+            RunShellCommand run_shell_command = 2;
+            SearchCodebase search_codebase = 3;
+            Server server = 4;
+            ReadFiles read_files = 5;
+            ApplyFileDiffs apply_file_diffs = 6;
+            SuggestPlan suggest_plan = 7;
+            SuggestCreatePlan suggest_create_plan = 8;
+            Grep grep = 9;
+            FileGlob file_glob = 10 [deprecated = true];
+            ReadMCPResource read_mcp_resource = 11;
+            CallMCPTool call_mcp_tool = 12;
+            WriteToLongRunningShellCommand write_to_long_running_shell_command = 13;
+            SuggestNewConversation suggest_new_conversation = 14;
+            FileGlobV2 file_glob_v2 = 15;
+        }
+        
+        message Server {
+            string payload = 1;
+        }
+        
+        message RunShellCommand {
+            string command = 1;
+            bool is_read_only = 2;
+            bool uses_pager = 3;
+            repeated Citation citations = 4;
+            bool is_risky = 5;
+        }
+        
+        message WriteToLongRunningShellCommand {
+            bytes input = 1;
+        }
+        
+        message SuggestNewConversation {
+            string message_id = 1;
+        }
+        
+        message ReadFiles {
+            repeated File files = 1;
+            message File {
+                string name = 1;
+                repeated FileContentLineRange line_ranges = 2;
+            }
+        }
+        
+        message SearchCodebase {
+            string query = 1;
+            repeated string path_filters = 2;
+            string codebase_path = 3;
+        }
+        
+        message ApplyFileDiffs {
+            string summary = 1;
+            
+            repeated FileDiff diffs = 2;
+            message FileDiff {
+                string file_path = 1;
+                string search = 2;
+                string replace = 3;
+            }
+            
+            repeated NewFile new_files = 3;
+            message NewFile {
+                string file_path = 1;
+                string content = 2;
+            }
+        }
+        
+        message SuggestPlan {
+            string summary = 1;
+            repeated Task proposed_tasks = 2;
+        }
+        
+        message SuggestCreatePlan {
+            
+        }
+        
+        message Grep {
+            repeated string queries = 1;
+            string path = 2;
+        }
+        
+        message FileGlob {
+            repeated string patterns = 1;
+            string path = 2;
+        }
+        
+        message FileGlobV2 {
+            repeated string patterns = 1;
+            string search_dir = 2;
+            int32 max_matches = 3;
+            int32 max_depth = 4;
+            int32 min_depth = 5;
+        }
+        
+        message ReadMCPResource {
+            string uri = 1;
+        }
+        
+        message CallMCPTool {
+            string name = 1;
+            google.protobuf.Struct args = 2;
+        }
+    }
+    
+    message ToolCallResult {
+        string tool_call_id = 1;
+        InputContext context = 11;
+        
+        oneof result {
+            RunShellCommandResult run_shell_command = 2;
+            SearchCodebaseResult search_codebase = 3;
+            ServerResult server = 4;
+            ReadFilesResult read_files = 5;
+            ApplyFileDiffsResult apply_file_diffs = 6;
+            SuggestPlanResult suggest_plan = 7;
+            SuggestCreatePlanResult suggest_create_plan = 8;
+            GrepResult grep = 9;
+            FileGlobResult file_glob = 10 [deprecated = true];
+            RefineResult refine = 13;
+            google.protobuf.Empty cancel = 14;
+            ReadMCPResourceResult read_mcp_resource = 15;
+            CallMCPToolResult call_mcp_tool = 16;
+            WriteToLongRunningShellCommandResult write_to_long_running_shell_command = 17;
+            SuggestNewConversationResult suggest_new_conversation = 18;
+            FileGlobV2Result file_glob_v2 = 19;
+        }
+        
+        message ServerResult {
+            string serialized_result = 1;
+        }
+        
+        message RefineResult {
+            UserQuery user_query = 1;
+        }
+    }
+    
+    message ServerEvent {
+        string payload = 1;
+    }
+    
+    message UpdateTodos {
+        oneof operation {
+            CreateTodoList create_todo_list = 1;
+            UpdatePendingTodos update_pending_todos = 2;
+            MarkTodosCompleted mark_todos_completed = 3;
+        }
+    }
+}
+
+message RunShellCommandResult {
+    string command = 3;
+    string output = 1 [deprecated = true];
+    int32 exit_code = 2 [deprecated = true];
+    
+    oneof result {
+        LongRunningShellCommandSnapshot long_running_command_snapshot = 4;
+        ShellCommandFinished command_finished = 5;
+    }
+}
+
+message ReadFilesResult {
+    oneof result {
+        Success success = 1;
+        Error error = 2;
+    }
+    
+    message Success {
+        repeated FileContent files = 1;
+    }
+    
+    message Error {
+        string message = 1;
+    }
+}
+
+message SearchCodebaseResult {
+    oneof result {
+        Success success = 1;
+        Error error = 2;
+    }
+    
+    message Success {
+        repeated FileContent files = 1;
+    }
+    
+    message Error {
+        string message = 1;
+    }
+}
+
+message ApplyFileDiffsResult {
+    oneof result {
+        Success success = 1;
+        Error error = 2;
+    }
+    
+    message Success {
+        repeated FileContent updated_files = 1 [deprecated = true];
+        
+        repeated UpdatedFileContent updated_files_v2 = 2;
+        message UpdatedFileContent {
+            FileContent file = 1;
+            bool was_edited_by_user = 2;
+        }
+    }
+    
+    message Error {
+        string message = 1;
+    }
+}
+
+message SuggestCreatePlanResult {
+    bool accepted = 1;
+}
+
+message SuggestPlanResult {
+    oneof result {
+        google.protobuf.Empty accepted = 1;
+        UserEditedPlan user_edited_plan = 2;
+    }
+    
+    message UserEditedPlan {
+        string plan_text = 1;
+    }
+}
+
+message GrepResult {
+    oneof result {
+        Success success = 1;
+        Error error = 2;
+    }
+    
+    message Success {
+        repeated GrepFileMatch matched_files = 1;
+        message GrepFileMatch {
+            string file_path = 1;
+            
+            repeated GrepLineMatch matched_lines = 2;
+            message GrepLineMatch {
+                uint32 line_number = 1;
+            }
+        }
+    }
+    
+    message Error {
+        string message = 1;
+    }
+}
+
+message FileGlobResult {
+    oneof result {
+        Success success = 1;
+        Error error = 2;
+    }
+    
+    message Success {
+        string matched_files = 1;
+    }
+    
+    message Error {
+        string message = 1;
+    }
+}
+
+message FileGlobV2Result {
+    oneof result {
+        Success success = 1;
+        Error error = 2;
+    }
+    
+    message Success {
+        repeated FileGlobMatch matched_files = 1;
+        message FileGlobMatch {
+            string file_path = 1;
+        }
+    }
+    
+    message Error {
+        string message = 1;
+    }
+}
+
+message MCPResourceContent {
+    string uri = 1;
+    
+    oneof content_type {
+        Text text = 2;
+        Binary binary = 3;
+    }
+    
+    message Text {
+        string content = 1;
+        string mime_type = 2;
+    }
+    
+    message Binary {
+        bytes data = 1;
+        string mime_type = 2;
+    }
+}
+
+message ReadMCPResourceResult {
+    oneof result {
+        Success success = 1;
+        Error error = 2;
+    }
+    
+    message Success {
+        repeated MCPResourceContent contents = 1;
+    }
+    
+    message Error {
+        string message = 1;
+    }
+}
+
+message WriteToLongRunningShellCommandResult {
+    oneof result {
+        LongRunningShellCommandSnapshot long_running_command_snapshot = 1;
+        ShellCommandFinished command_finished = 2;
+    }
+}
+
+message SuggestNewConversationResult {
+    oneof result {
+        Accepted accepted = 1;
+        Rejected rejected = 2;
+    }
+    
+    message Accepted {
+        string message_id = 1;
+    }
+    
+    message Rejected {
+        
+    }
+}
+
+message ShellCommandFinished {
+    string output = 1;
+    int32 exit_code = 2;
+}
+
+message CallMCPToolResult {
+    oneof result {
+        Success success = 1;
+        Error error = 2;
+    }
+    
+    message Success {
+        repeated Result results = 1;
+        message Result {
+            oneof result {
+                Text text = 1;
+                Image image = 2;
+                MCPResourceContent resource = 3;
+            }
+            
+            message Text {
+                string text = 1;
+            }
+            
+            message Image {
+                bytes data = 1;
+                string mime_type = 2;
+            }
+        }
+    }
+    
+    message Error {
+        string message = 1;
+    }
+}
+
+enum ToolType {
+    RUN_SHELL_COMMAND = 0;
+    SEARCH_CODEBASE = 1;
+    READ_FILES = 2;
+    APPLY_FILE_DIFFS = 3;
+    SUGGEST_PLAN = 4;
+    SUGGEST_CREATE_PLAN = 5;
+    GREP = 6;
+    FILE_GLOB = 7;
+    READ_MCP_RESOURCE = 8;
+    CALL_MCP_TOOL = 9;
+    WRITE_TO_LONG_RUNNING_SHELL_COMMAND = 10;
+    SUGGEST_NEW_CONVERSATION = 11;
+    FILE_GLOB_V2 = 12;
+}

proto/todo.proto

@@ -0,0 +1,23 @@
+syntax = "proto3";
+
+package warp.multi_agent.v1;
+
+option go_package = "github.com/warp/warp-proto-apis/multi_agent/v1";
+
+message TodoItem {
+    string id = 1;
+    string title = 2;
+    string description = 3;
+}
+
+message CreateTodoList {
+    repeated TodoItem initial_todos = 1;
+}
+
+message UpdatePendingTodos {
+    repeated TodoItem updated_pending_todos = 1;
+}
+
+message MarkTodosCompleted {
+    repeated string todo_ids = 1;
+}

protobuf2openai/__init__.py

@@ -0,0 +1,3 @@
+# Package for converting between Warp protobuf JSON and OpenAI Chat Completions API
+
+__all__ = [] 

protobuf2openai/app.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import asyncio
+
+import httpx
+from fastapi import FastAPI
+
+from .bridge import initialize_once
+from .config import BRIDGE_BASE_URL, WARMUP_INIT_RETRIES, WARMUP_INIT_DELAY_S
+from .logging import logger
+from .router import router
+
+app = FastAPI(title="OpenAI Chat Completions - Streaming")
+app.include_router(router)
+
+
+@app.on_event("startup")
+async def _on_startup():
+    try:
+        logger.info("[OpenAI Compat] Server starting. BRIDGE_BASE_URL=%s", BRIDGE_BASE_URL)
+        logger.info("[OpenAI Compat] Endpoints: GET /healthz, GET /v1/models, POST /v1/chat/completions")
+    except Exception:
+        pass
+
+    url = f"{BRIDGE_BASE_URL}/healthz"
+    retries = WARMUP_INIT_RETRIES
+    delay_s = WARMUP_INIT_DELAY_S
+    for attempt in range(1, retries + 1):
+        try:
+            async with httpx.AsyncClient(timeout=5.0, trust_env=True) as client:
+                resp = await client.get(url)
+            if resp.status_code == 200:
+                logger.info("[OpenAI Compat] Bridge server is ready at %s", url)
+                break
+            else:
+                logger.warning("[OpenAI Compat] Bridge health at %s -> HTTP %s", url, resp.status_code)
+        except Exception as e:
+            logger.warning("[OpenAI Compat] Bridge health attempt %s/%s failed: %s", attempt, retries, e)
+        await asyncio.sleep(delay_s)
+    else:
+        logger.error("[OpenAI Compat] Bridge server not ready at %s", url)
+
+    try:
+        await initialize_once()
+    except Exception as e:
+        logger.warning(f"[OpenAI Compat] Warmup initialize_once on startup failed: {e}")
+
+
+@app.on_event("shutdown")
+async def _on_shutdown():
+    """清理全局资源"""
+    try:
+        # 关闭全局 HTTP 客户端
+        from .bridge import _http_client
+        if _http_client is not None:
+            await _http_client.aclose()
+            logger.info("[OpenAI Compat] Global HTTP client closed")
+    except Exception as e:
+        logger.warning(f"[OpenAI Compat] Error during shutdown: {e}")

protobuf2openai/bridge.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import json
+import time
+import uuid
+import asyncio
+from typing import Any, Dict, Optional
+
+import httpx
+from .logging import logger
+
+from .config import (
+    BRIDGE_BASE_URL,
+    FALLBACK_BRIDGE_URLS,
+    WARMUP_INIT_RETRIES,
+    WARMUP_INIT_DELAY_S,
+    WARMUP_REQUEST_RETRIES,
+    WARMUP_REQUEST_DELAY_S,
+)
+from .packets import packet_template
+from .state import GLOBAL_BASELINE, ensure_tool_ids, STATE
+
+# 创建一个全局的、可复用的 httpx.AsyncClient 实例以提高性能
+_http_client: Optional[httpx.AsyncClient] = None
+_initialization_lock = asyncio.Lock()
+_initialized = False
+
+
+def get_http_client() -> httpx.AsyncClient:
+    """获取或创建全局 HTTP 客户端"""
+    global _http_client
+    if _http_client is None:
+        _http_client = httpx.AsyncClient(
+            timeout=httpx.Timeout(connect=5.0, read=180.0, write=10.0, pool=10.0),
+            limits=httpx.Limits(max_keepalive_connections=200, max_connections=400),
+            trust_env=True
+        )
+    return _http_client
+
+
+async def bridge_send_stream(packet: Dict[str, Any]) -> Dict[str, Any]:
+    """异步发送数据流到 bridge 服务"""
+    last_exc: Optional[Exception] = None
+    client = get_http_client()
+
+    for base in FALLBACK_BRIDGE_URLS:
+        url = f"{base}/api/warp/send_stream"
+        try:
+            wrapped_packet = {"json_data": packet, "message_type": "warp.multi_agent.v1.Request"}
+
+            # try:
+            #     logger.info("[OpenAI Compat] Bridge request URL: %s", url)
+            #     logger.info("[OpenAI Compat] Bridge request payload: %s",
+            #                 json.dumps(wrapped_packet, ensure_ascii=False))
+            # except Exception:
+            #     logger.info("[OpenAI Compat] Bridge request payload serialization failed for URL %s", url)
+
+            # 使用全局的 httpx.AsyncClient 实例发送异步请求
+            r = await client.post(url, json=wrapped_packet)
+
+            if r.status_code == 200:
+                try:
+                    logger.info("[OpenAI Compat] Bridge response (raw text): %s", r.text)
+                except Exception:
+                    pass
+                return r.json()
+            else:
+                txt = r.text
+                last_exc = Exception(f"bridge_error: HTTP {r.status_code} {txt}")
+
+        except httpx.ReadTimeout:
+            # logger.warning(f"[OpenAI Compat] Request timeout for {url}, trying next fallback")
+            last_exc = Exception("Request timeout")
+            continue
+
+        except Exception as e:
+            last_exc = e
+            continue
+
+    if last_exc:
+        raise last_exc
+    raise Exception("bridge_unreachable")
+#
+#
+# async def initialize_once() -> None:
+#     """异步地、线程安全地执行一次性初始化"""
+#     global _initialized
+#
+#     # 快速检查，避免不必要的加锁开销
+#     if _initialized:
+#         return
+#
+#     async with _initialization_lock:
+#         # 在锁内再次检查，防止并发进入
+#         if _initialized:
+#             return
+#
+#         logger.info("[OpenAI Compat] Starting one-time initialization...")
+#
+#         ensure_tool_ids()
+#
+#         first_task_id = STATE.baseline_task_id or str(uuid.uuid4())
+#         STATE.baseline_task_id = first_task_id
+#
+#         client = get_http_client()
+#         health_urls = [f"{base}/healthz" for base in FALLBACK_BRIDGE_URLS]
+#         last_err: Optional[str] = None
+#
+#         for _ in range(WARMUP_INIT_RETRIES):
+#             try:
+#                 ok = False
+#                 last_err = None
+#                 for h in health_urls:
+#                     try:
+#                         resp = await client.get(h, timeout=5.0)
+#                         if resp.status_code == 200:
+#                             ok = True
+#                             break
+#                         else:
+#                             last_err = f"HTTP {resp.status_code} at {h}"
+#                     except Exception as he:
+#                         last_err = f"{type(he).__name__}: {he} at {h}"
+#                 if ok:
+#                     break
+#             except Exception as e:
+#                 last_err = str(e)
+#             await asyncio.sleep(WARMUP_INIT_DELAY_S)
+#         else:
+#             # 注意：我们不再抛出异常，只是记录警告
+#             logger.warning(f"Bridge server not ready during init: {last_err}")
+#
+#         pkt = packet_template()
+#         pkt["task_context"]["active_task_id"] = first_task_id
+#         pkt["input"]["user_inputs"]["inputs"].append({"user_query": {"query": "warmup"}})
+#
+#         last_exc: Optional[Exception] = None
+#         for attempt in range(1, WARMUP_REQUEST_RETRIES + 1):
+#             try:
+#                 resp = await bridge_send_stream(pkt)
+#                 # ================ 关键修改 ================
+#                 # 将结果存入真正的全局对象，而不是临时的上下文状态
+#                 GLOBAL_BASELINE.conversation_id = resp.get("conversation_id") or GLOBAL_BASELINE.conversation_id
+#                 ret_task_id = resp.get("task_id")
+#                 if isinstance(ret_task_id, str) and ret_task_id:
+#                     GLOBAL_BASELINE.baseline_task_id = ret_task_id
+#                 # ==========================================
+#                 break
+#             except Exception as e:
+#                 last_exc = e
+#                 logger.warning(f"[OpenAI Compat] Warmup attempt {attempt}/{WARMUP_REQUEST_RETRIES} failed: {e}")
+#                 if attempt < WARMUP_REQUEST_RETRIES:
+#                     await asyncio.sleep(WARMUP_REQUEST_DELAY_S)
+#
+#         # 即使预热失败，我们也标记为已初始化，避免重复尝试
+#         _initialized = True
+#
+#         if last_exc:
+#             logger.warning(f"[OpenAI Compat] Initialization completed with warnings: {last_exc}")
+#         else:
+#             logger.info("[OpenAI Compat] One-time initialization completed successfully.")
+#             logger.info(f"[OpenAI Compat] Global baseline set: conversation_id='{GLOBAL_BASELINE.conversation_id}', baseline_task_id='{GLOBAL_BASELINE.baseline_task_id}'")
+
+
+async def initialize_once() -> None:
+    """异步地、线程安全地执行一次性初始化"""
+    global _initialized
+
+    # 快速检查，避免不必要的加锁开销
+    if _initialized:
+        return
+
+    async with _initialization_lock:
+        # 在锁内再次检查，防止并发进入
+        if _initialized:
+            return
+
+        ensure_tool_ids()
+
+        first_task_id = STATE.baseline_task_id or str(uuid.uuid4())
+        STATE.baseline_task_id = first_task_id
+
+        client = get_http_client()
+        health_urls = [f"{base}/healthz" for base in FALLBACK_BRIDGE_URLS]
+        last_err: Optional[str] = None
+
+        for _ in range(WARMUP_INIT_RETRIES):
+            try:
+                ok = False
+                last_err = None
+                for h in health_urls:
+                    try:
+                        resp = await client.get(h, timeout=5.0)
+                        if resp.status_code == 200:
+                            ok = True
+                            break
+                        else:
+                            last_err = f"HTTP {resp.status_code} at {h}"
+                    except Exception as he:
+                        last_err = f"{type(he).__name__}: {he} at {h}"
+                if ok:
+                    break
+            except Exception as e:
+                last_err = str(e)
+            await asyncio.sleep(WARMUP_INIT_DELAY_S)
+        else:
+            # 注意：我们不再抛出异常，只是记录警告
+            logger.warning(f"Bridge server not ready during init: {last_err}")
+
+        # 即使预热失败，我们也标记为已初始化，避免重复尝试
+        _initialized = True

protobuf2openai/config.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import os
+
+BRIDGE_BASE_URL = os.getenv("WARP_BRIDGE_URL", "http://127.0.0.1:8000")
+FALLBACK_BRIDGE_URLS = [
+    BRIDGE_BASE_URL,
+    "http://127.0.0.1:8000",
+]
+
+WARMUP_INIT_RETRIES = int(os.getenv("WARP_COMPAT_INIT_RETRIES", "10"))
+WARMUP_INIT_DELAY_S = float(os.getenv("WARP_COMPAT_INIT_DELAY", "0.5"))
+WARMUP_REQUEST_RETRIES = int(os.getenv("WARP_COMPAT_WARMUP_RETRIES", "3"))
+WARMUP_REQUEST_DELAY_S = float(os.getenv("WARP_COMPAT_WARMUP_DELAY", "1.5"))