chore: repo cleanup and maintenance

.dockerignore

@@ -0,0 +1,13 @@
+.git
+.gitignore
+__pycache__/
+*.pyc
+.pytest_cache/
+.hypothesis/
+.env
+dist/
+build/
+release/
+.venv/
+venv/
+kiro_requests/

KiroProxy/.gitignore → .gitignore

@@ -40,6 +40,7 @@ flows
 flows_*
 traffic.mitm
 *.mitm
+kiro_requests/
 analyze_har.py
 parse_*.py
 *_analysis.txt

.orchids/orchids.json

@@ -1,9 +0,0 @@
-{
-  "projectId": "c1b5887f-dbf9-4c85-bec3-696c4662d56c",
-  "createdAt": 1768697452308,
-  "version": "1.0",
-  "startupCommands": [
-    "bun install; bun dev"
-  ],
-  "templateId": "nextjs"
-}

CAPTURE_GUIDE.md

@@ -0,0 +1,37 @@
+# Kiro 请求抓包指南
+
+本项目提供 `scripts/capture_kiro.py`（mitmproxy addon）用于抓取 Kiro IDE 与 AWS 端点的请求/响应，便于调试协议与字段。
+
+## 安装依赖
+
+```bash
+pip install mitmproxy
+```
+
+## 运行 mitmproxy
+
+带 UI：
+
+```bash
+mitmproxy --mode regular@8888 -s scripts/capture_kiro.py
+```
+
+无 UI：
+
+```bash
+mitmdump --mode regular@8888 -s scripts/capture_kiro.py
+```
+
+## 配置代理与证书
+
+- 将系统或 Kiro IDE 的 HTTP/HTTPS 代理设置为 `127.0.0.1:8888`
+- 如需解密 HTTPS，安装 mitmproxy CA 证书：访问 `http://mitm.it`
+
+## 输出文件
+
+抓到的请求/响应会输出到 `kiro_requests/`：
+
+- `*_request.json`
+- `*_response.json`
+
+`kiro_requests/` 已在 `.gitignore` 中忽略。

Dockerfile

@@ -23,7 +23,7 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
 # 复制项目文件
-COPY KiroProxy/ ./KiroProxy/
+COPY . .
 
 # 创建数据目录
 RUN mkdir -p /app/data
@@ -36,4 +36,4 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
     CMD curl -f http://localhost:7860/api/status || exit 1
 
 # 启动命令
-CMD ["python", "KiroProxy/run.py", "7860"]
+CMD ["python", "run.py", "7860"]

KiroProxy/README.md

@@ -1,425 +0,0 @@
-<p align="center">
-  <img src="assets/icon.svg" width="80" height="96" alt="Kiro Proxy">
-</p>
-
-<h1 align="center">Kiro API Proxy</h1>
-
-<p align="center">
-  Kiro IDE API 反向代理服务器，支持多账号轮询、Token 自动刷新、配额管理
-</p>
-
-<p align="center">
-  <a href="#功能特性">功能</a> •
-  <a href="#快速开始">快速开始</a> •
-  <a href="#cli-配置">CLI 配置</a> •
-  <a href="#api-端点">API</a> •
-  <a href="#许可证">许可证</a>
-</p>
-
----
-
-> **⚠️ 测试说明**
-> 
-> 本项目支持 **Claude Code**、**Codex CLI**、**Gemini CLI** 三种客户端，工具调用功能已全面支持。
-
-## 功能特性
-
-### 核心功能
-- **多协议支持** - OpenAI / Anthropic / Gemini 三种协议兼容
-- **完整工具调用** - 三种协议的工具调用功能全面支持
-- **图片理解** - 支持 Claude Code / Codex CLI 图片输入
-- **网络搜索** - 支持 Claude Code / Codex CLI 网络搜索工具
-- **思考功能** - 支持 Claude 的扩展思考功能（Extended Thinking）
-- **多账号轮询（默认随机）** - 每次请求随机切换账号，分散压力，避免单账号 RPM 过高
-- **会话粘性（可选）** - 非 `random` 策略下，同一会话 60 秒内使用同一账号，保持上下文
-- **Web UI** - 简洁的管理界面，支持监控、日志、设置
-
-### v1.7.1 新功能
-- **Windows 支持补强** - 注册表浏览器检测 + PATH 回退，兼容便携版
-- **打包资源修复** - PyInstaller 打包后可正常加载图标与内置文档
-- **Token 扫描稳定性** - Windows 路径编码处理修复
-
-### v1.6.3 新功能
-- **命令行工具 (CLI)** - 无 GUI 服务器也能轻松管理
-  - `python run.py accounts list` - 列出账号
-  - `python run.py accounts export/import` - 导出/导入账号
-  - `python run.py accounts add` - 交互式添加 Token
-  - `python run.py accounts scan` - 扫描本地 Token
-  - `python run.py login google/github` - 命令行登录
-  - `python run.py login remote` - 生成远程登录链接
-- **远程登录链接** - 在有浏览器的机器上完成授权，Token 自动同步
-- **账号导入导出** - 跨机器迁移账号配置
-- **手动添加 Token** - 直接粘贴 accessToken/refreshToken
-
-### v1.6.2 新功能
-- **Codex CLI 完整支持** - 使用 OpenAI Responses API (`/v1/responses`)
-  - 完整工具调用支持（shell、file 等所有工具）
-  - 图片输入支持（`input_image` 类型）
-  - 网络搜索支持（`web_search` 工具）
-  - 错误代码映射（rate_limit、context_length 等）
-- **Claude Code 增强** - 图片理解和网络搜索完整支持
-  - 支持 Anthropic 和 OpenAI 两种图片格式
-  - 支持 `web_search` / `web_search_20250305` 工具
-
-### v1.6.1 新功能
-- **请求限速** - 通过限制请求频率降低账号封禁风险
-  - 每账号最小请求间隔
-  - 每账号每分钟最大请求数
-  - 全局每分钟最大请求数
-  - WebUI 设置页面可配置
-- **账号封禁检测** - 自动检测 TEMPORARILY_SUSPENDED 错误
-  - 友好的错误日志输出
-  - 自动禁用被封禁账号
-  - 自动切换到其他可用账号
-- **统一错误处理** - 三种协议使用统一的错误分类和处理
-
-### v1.6.0 功能
-- **历史消息管理** - 4 种策略处理对话长度限制，可自由组合
-  - 自动截断：发送前优先保留最新上下文并摘要前文，必要时按数量/字符数截断
-  - 智能摘要：用 AI 生成早期对话摘要，保留关键信息
-  - 摘要缓存：历史变化不大时复用最近摘要，减少重复 LLM 调用（默认启用）
-  - 错误重试：遇到长度错误时自动截断重试（默认启用）
-  - 预估检测：预估 token 数量，超限预先截断
-- **Gemini 工具调用** - 完整支持 functionDeclarations/functionCall/functionResponse
-- **设置页面** - WebUI 新增设置标签页，可配置历史消息管理策略
-
-### v1.5.0 功能
-- **用量查询** - 查询账号配额使用情况，显示已用/余额/使用率
-- **多登录方式** - 支持 Google / GitHub / AWS Builder ID 三种登录方式
-- **流量监控** - 完整的 LLM 请求监控，支持搜索、过滤、导出
-- **浏览器选择** - 自动检测已安装浏览器，支持无痕模式
-- **文档中心** - 内置帮助文档，左侧目录 + 右侧 Markdown 渲染
-
-### v1.4.0 功能
-- **Token 预刷新** - 后台每 5 分钟检查，提前 15 分钟自动刷新
-- **健康检查** - 每 10 分钟检测账号可用性，自动标记状态
-- **请求统计增强** - 按账号/模型统计，24 小时趋势
-- **请求重试机制** - 网络错误/5xx 自动重试，指数退避
-
-## 工具调用支持
-
-| 功能 | Anthropic (Claude Code) | OpenAI (Codex CLI) | Gemini |
-|------|------------------------|-------------------|--------|
-| 工具定义 | ✅ `tools` | ✅ `tools.function` | ✅ `functionDeclarations` |
-| 工具调用响应 | ✅ `tool_use` | ✅ `tool_calls` | ✅ `functionCall` |
-| 工具结果 | ✅ `tool_result` | �� `tool` 角色消息 | ✅ `functionResponse` |
-| 强制工具调用 | ✅ `tool_choice` | ✅ `tool_choice` | ✅ `toolConfig.mode` |
-| 工具数量限制 | ✅ 50 个 | ✅ 50 个 | ✅ 50 个 |
-| 历史消息修复 | ✅ | ✅ | ✅ |
-| 图片理解 | ✅ | ✅ | ❌ |
-| 网络搜索 | ✅ | ✅ | ❌ |
-
-## 已知限制
-
-### 对话长度限制
-
-Kiro API 有输入长度限制。当对话历史过长时，会返回错误：
-
-```
-Input is too long. (CONTENT_LENGTH_EXCEEDS_THRESHOLD)
-```
-
-#### 自动处理（v1.6.0+）
-
-代理内置了历史消息管理功能，可在「设置」页面配置：
-
-- **错误重试**（默认）：遇到长度错误时自动截断并重试
-- **智能摘要**：用 AI 生成早期对话摘要，保留关键信息
-- **摘要缓存**（默认）：历史变化不大时复用最近摘要，减少重复 LLM 调用
-- **自动截断**：每次请求前优先保留最新上下文并摘要前文，必要时按数量/字符数截断
-- **预估检测**：预估 token 数量，超限预先截断
-
-如需 **关闭自动压缩/重试**（超限时直接报错），可设置环境变量 `KIROPROXY_HISTORY_ERROR_RETRY=0`，或将历史配置的 `strategies` 中移除 `error_retry`。
-
-摘要缓存可通过以下配置项调整（默认值）：
-- `summary_cache_enabled`: `true`
-- `summary_cache_min_delta_messages`: `3`
-- `summary_cache_min_delta_chars`: `4000`
-- `summary_cache_max_age_seconds`: `180`
-
-#### 手动处理
-
-1. 在 Claude Code 中输入 `/clear` 清空对话历史
-2. 告诉 AI 你之前在做什么，它会读取代码文件恢复上下文
-
-## 快速开始
-
-### 方式一：下载预编译版本
-
-从 [Releases](../../releases) 下载对应平台的安装包，解压后直接运行。
-
-### 方式二：从源码运行
-
-```bash
-# 克隆项目
-git clone https://github.com/yourname/kiro-proxy.git
-cd kiro-proxy
-
-# 创建虚拟环境
-python -m venv venv
-source venv/bin/activate  # Windows: venv\Scripts\activate
-
-# 安装依赖
-pip install -r requirements.txt
-
-# 运行
-python run.py
-
-# 或指定端口
-python run.py 8081
-```
-
-启动后访问 http://localhost:8080
-
-### 命令行工具 (CLI)
-
-无 GUI 服务器可使用 CLI 管理账号：
-
-```bash
-# 账号管理
-python run.py accounts list              # 列出账号
-python run.py accounts export -o acc.json  # 导出账号
-python run.py accounts import acc.json   # 导入账号
-python run.py accounts add               # 交互式添加 Token
-python run.py accounts scan --auto       # 扫描并自动添加本地 Token
-
-# 登录
-python run.py login google               # Google 登录
-python run.py login github               # GitHub 登录
-python run.py login remote --host myserver.com:8080  # 生成远程登录链接
-
-# 服务
-python run.py serve                      # 启动服务 (默认 8080)
-python run.py serve -p 8081              # 指定端口
-python run.py status                     # 查看状态
-```
-
-### 登录获取 Token
-
-**方式一：在线登录（推荐）**
-1. 打开 Web UI，点击「在线登录」
-2. 选择登录方式：Google / GitHub / AWS Builder ID
-3. 在浏览器中完成授权
-4. 账号自动添加
-
-**方式二：扫描 Token**
-1. 打开 Kiro IDE，使用 Google/GitHub 账号登录
-2. 登录成功后 token 自动保存到 `~/.aws/sso/cache/`
-3. 在 Web UI 点击「扫描 Token」添加账号
-
-## CLI 配置
-
-### 模型对照表
-
-| Kiro 模型 | 能力 | Claude Code | Codex |
-|-----------|------|-------------|-------|
-| `claude-sonnet-4` | ⭐⭐⭐ 推荐 | `claude-sonnet-4` | `gpt-4o` |
-| `claude-sonnet-4.5` | ⭐⭐⭐⭐ 更强 | `claude-sonnet-4.5` | `gpt-4o` |
-| `claude-haiku-4.5` | ⚡ 快速 | `claude-haiku-4.5` | `gpt-4o-mini` |
-
-### Claude Code 配置
-
-```
-名称: Kiro Proxy
-API Key: any
-Base URL: http://localhost:8080
-模型: claude-sonnet-4
-```
-
-### Codex 配置
-
-Codex CLI 使用 OpenAI Responses API，配置如下：
-
-```bash
-# 设置环境变量
-export OPENAI_API_KEY=any
-export OPENAI_BASE_URL=http://localhost:8080/v1
-
-# 运行 Codex
-codex
-```
-
-或在 `~/.codex/config.toml` 中配置：
-
-```toml
-[providers.openai]
-api_key = "any"
-base_url = "http://localhost:8080/v1"
-```
-
-## 思考功能支持
-
-### 什么是思考功能
-
-思考功能（Extended Thinking）允许 Claude 在生成回答前展示其思考过程，帮助用户理解 AI 的推理步骤。
-
-### 如何使用
-
-在请求中添加 `thinking`（或对应协议的 thinking 配置）即可启用：
-
-```json
-{
-  "model": "claude-sonnet-4.5",
-  "messages": [
-    {
-      "role": "user",
-      "content": "解释一下量子计算的原理"
-    }
-  ],
-  "thinking": {
-    "thinking_type": "enabled",
-    "budget_tokens": 20000
-  },
-  "stream": true
-}
-```
-
-OpenAI Chat Completions (`POST /v1/chat/completions`) 也支持：
-
-```json
-{
-  "model": "gpt-4o",
-  "messages": [{"role": "user", "content": "解释一下量子计算的原理"}],
-  "thinking": { "type": "enabled" },
-  "stream": true
-}
-```
-
-OpenAI Responses (`POST /v1/responses`) 也支持：
-
-```json
-{
-  "model": "gpt-4o",
-  "input": "解释一下量子计算的原理",
-  "thinking": { "type": "enabled" }
-}
-```
-
-Gemini generateContent (`POST /v1/models/{model}:generateContent`) 也支持：
-
-```json
-{
-  "contents": [{"role": "user", "parts": [{"text": "解释一下量子计算的原理"}]}],
-  "generationConfig": {
-    "thinkingConfig": { "includeThoughts": true }
-  }
-}
-```
-
-### 参数说明
-
-- `thinking_type`: 思考类型，设为 `"enabled"` 启用思考功能
-- `budget_tokens`: 思考过程的 token 预算（不传则视为无限制）
-
-### 响应格式
-
-启用思考功能后，流式响应会包含两种内容块：
-
-1. **思考块**（type: "thinking"）：展示 AI 的思考过程
-2. **文本块**（type: "text"）：最终的回答内容
-
-示例响应：
-```
-data: {"type":"content_block_start","index":1,"content_block":{"type":"thinking","thinking":""}}
-data: {"type":"content_block_delta","index":1,"delta":{"type":"thinking_delta","thinking":"让我思考一下量子计算的原理..."}}
-data: {"type":"content_block_stop","index":1}
-data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}
-data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"量子计算是一种..."}}
-data: {"type":"content_block_stop","index":0}
-```
-
-## API 端点
-
-| 协议 | 端点 | 用途 |
-|------|------|------|
-| OpenAI | `POST /v1/chat/completions` | Chat Completions API |
-| OpenAI | `POST /v1/responses` | Responses API (Codex CLI) |
-| OpenAI | `GET /v1/models` | 模型列表 |
-| Anthropic | `POST /v1/messages` | Claude Code |
-| Anthropic | `POST /v1/messages/count_tokens` | Token 计数 |
-| Gemini | `POST /v1/models/{model}:generateContent` | Gemini CLI |
-
-### 管理 API
-
-| 端点 | 方法 | 说明 |
-|------|------|------|
-| `/api/accounts` | GET | 获取所有账号状态 |
-| `/api/accounts/{id}` | GET | 获取账号详情 |
-| `/api/accounts/{id}/usage` | GET | 获取账号用量信息 |
-| `/api/accounts/{id}/refresh` | POST | 刷新账号 Token |
-| `/api/accounts/{id}/restore` | POST | 恢复账号（从冷却状态） |
-| `/api/accounts/refresh-all` | POST | 刷新所有即将过期的 Token |
-| `/api/flows` | GET | 获取流量记录 |
-| `/api/flows/stats` | GET | 获取流量统计 |
-| `/api/flows/{id}` | GET | 获取流量详情 |
-| `/api/quota` | GET | 获取配额状态 |
-| `/api/stats` | GET | 获取统计信息 |
-| `/api/health-check` | POST | 手动触发健康检查 |
-| `/api/browsers` | GET | 获取可用浏览器列表 |
-| `/api/docs` | GET | 获取文档列表 |
-| `/api/docs/{id}` | GET | 获取文档内容 |
-
-## 项目结构
-
-```
-kiro_proxy/
-├── main.py                    # FastAPI 应用入口
-├── config.py                  # 全局配置
-├── converters.py              # 协议转换
-│
-├── core/                      # 核心模块
-│   ├── account.py            # 账号管理
-│   ├── state.py              # 全局状态
-│   ├── persistence.py        # 配置持久化
-│   ├── scheduler.py          # 后台任务调度
-│   ├── stats.py              # 请求统计
-│   ├── retry.py              # 重试机制
-│   ├── browser.py            # 浏览器检测
-│   ├── flow_monitor.py       # 流量监控
-│   └── usage.py              # 用量查询
-│
-├── credential/                # 凭证管理
-│   ├── types.py              # KiroCredentials
-│   ├── fingerprint.py        # Machine ID 生成
-│   ├── quota.py              # 配额管理器
-│   └── refresher.py          # Token 刷新
-│
-├── auth/                      # 认证模块
-│   └── device_flow.py        # Device Code Flow / Social Auth
-│
-├── handlers/                  # API 处理器
-│   ├── anthropic.py          # /v1/messages
-│   ├── openai.py             # /v1/chat/completions
-│   ├── responses.py          # /v1/responses (Codex CLI)
-│   ├── gemini.py             # /v1/models/{model}:generateContent
-│   └── admin.py              # 管理 API
-│
-├── cli.py                     # 命令行工具
-│
-├── docs/                      # 内置文档
-│   ├── 01-quickstart.md      # 快速开始
-│   ├── 02-features.md        # 功能特性
-│   ├── 03-faq.md             # 常见问题
-│   └── 04-api.md             # API 参考
-│
-└── web/
-    └── html.py               # Web UI (组件化单文件)
-```
-
-## 构建
-
-```bash
-# 安装构建依赖
-pip install pyinstaller
-
-# 构建
-python build.py
-```
-
-输出文件在 `dist/` 目录。
-
-## 免责声明
-
-本项目仅供学习研究，禁止商用。使用本项目产生的任何后果由使用者自行承担，与作者无关。
-
-本项目与 Kiro / AWS / Anthropic 官方无关。

KiroProxy/kiro_proxy/main_legacy.py

@@ -1,694 +0,0 @@
-"""Kiro API Proxy - 主应用"""
-import json
-import uuid
-import httpx
-import sys
-import time
-from pathlib import Path
-from contextlib import asynccontextmanager
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import HTMLResponse, StreamingResponse, JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-
-from . import __version__
-from .config import MODELS_URL
-from .core import state, scheduler, stats_manager, get_quota_scheduler, get_refresh_manager
-from .handlers import anthropic, openai, gemini, admin
-from .handlers import responses as responses_handler
-from .web.html import HTML_PAGE
-from .credential import generate_machine_id, get_kiro_version
-
-
-def get_resource_path(relative_path: str) -> Path:
-    """获取资源文件路径，支持从打包资源读取"""
-    base_path = Path(sys._MEIPASS) if hasattr(sys, '_MEIPASS') else Path(__file__).parent.parent
-    return base_path / relative_path
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """应用生命周期管理"""
-    # 启动时
-    await scheduler.start()
-    
-    # 初始化刷新管理器
-    refresh_manager = get_refresh_manager()
-    refresh_manager.set_accounts_getter(lambda: state.accounts)
-    
-    # 启动时先刷新所有需要刷新的 Token，避免首次请求使用过期 Token
-    accounts = state.accounts
-    if accounts:
-        print(f"[Startup] 检查 {len(accounts)} 个账号的 Token 状态...")
-        for account in accounts:
-            if account.enabled and refresh_manager.should_refresh_token(account):
-                try:
-                    success, msg = await refresh_manager.refresh_token_if_needed(account)
-                    if success:
-                        print(f"[Startup] 账号 {account.name} Token 刷新成功")
-                    else:
-                        print(f"[Startup] 账号 {account.name} Token 刷新失败: {msg}")
-                except Exception as e:
-                    print(f"[Startup] 账号 {account.name} Token 刷新异常: {e}")
-    
-    # 启动额度调度器（在 Token 刷新之后，避免首次额度获取使用过期 Token）
-    quota_scheduler = get_quota_scheduler()
-    quota_scheduler.set_accounts_getter(lambda: state.accounts)
-    await quota_scheduler.start()
-    
-    await refresh_manager.start_auto_refresh()
-    
-    yield
-    
-    # 关闭时
-    await refresh_manager.stop_auto_refresh()
-    await quota_scheduler.stop()
-    await scheduler.stop()
-
-
-app = FastAPI(title="Kiro API Proxy", docs_url="/docs", redoc_url=None, lifespan=lifespan)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-@app.middleware("http")
-async def log_requests(request: Request, call_next):
-    start_time = time.time()
-    path = request.url.path
-    method = request.method
-    
-    body_str = "<skipped>"
-            
-    print(f"[Request] {method} {path} | Body: {body_str}")
-    
-    response = await call_next(request)
-    
-    duration = (time.time() - start_time) * 1000
-    print(f"[Response] {method} {path} - {response.status_code} ({duration:.2f}ms)")
-    return response
-
-
-# ==================== Web UI ====================
-
-@app.get("/", response_class=HTMLResponse)
-async def index():
-    return HTML_PAGE
-
-
-@app.get("/assets/{path:path}")
-async def serve_assets(path: str):
-    """提供静态资源"""
-    file_path = get_resource_path("assets") / path
-    if file_path.exists():
-        content_type = "image/svg+xml" if path.endswith(".svg") else "application/octet-stream"
-        return StreamingResponse(open(file_path, "rb"), media_type=content_type)
-    raise HTTPException(status_code=404)
-
-
-# ==================== API 端点 ====================
-
-@app.get("/v1/models")
-async def models():
-    """获取可用模型列表"""
-    try:
-        account = state.get_available_account()
-        if not account:
-            raise Exception("No available account")
-        
-        token = account.get_token()
-        machine_id = account.get_machine_id()
-        kiro_version = get_kiro_version()
-        
-        headers = {
-            "content-type": "application/json",
-            "x-amz-user-agent": f"aws-sdk-js/1.0.0 KiroIDE-{kiro_version}-{machine_id}",
-            "amz-sdk-invocation-id": str(uuid.uuid4()),
-            "Authorization": f"Bearer {token}",
-        }
-        async with httpx.AsyncClient(verify=False, timeout=30) as client:
-            resp = await client.get(MODELS_URL, headers=headers, params={"origin": "AI_EDITOR"})
-            if resp.status_code == 200:
-                data = resp.json()
-                return {
-                    "object": "list",
-                    "data": [
-                        {
-                            "id": m["modelId"],
-                            "object": "model",
-                            "owned_by": "kiro",
-                            "name": m["modelName"],
-                        }
-                        for m in data.get("models", [])
-                    ]
-                }
-    except Exception:
-        pass
-    
-    # 降级返回静态列表
-    return {"object": "list", "data": [
-        {"id": "auto", "object": "model", "owned_by": "kiro", "name": "Auto"},
-        {"id": "claude-sonnet-4.5", "object": "model", "owned_by": "kiro", "name": "Claude Sonnet 4.5"},
-        {"id": "claude-sonnet-4", "object": "model", "owned_by": "kiro", "name": "Claude Sonnet 4"},
-        {"id": "claude-haiku-4.5", "object": "model", "owned_by": "kiro", "name": "Claude Haiku 4.5"},
-    ]}
-
-
-# Anthropic 协议
-@app.post("/v1/messages")
-async def anthropic_messages(request: Request):
-    print(f"[Main] Received /v1/messages request from {request.client.host}")
-    return await anthropic.handle_messages(request)
-
-@app.post("/v1/messages/count_tokens")
-async def anthropic_count_tokens(request: Request):
-    return await anthropic.handle_count_tokens(request)
-
-
-
-@app.post("/v1/complete")
-async def anthropic_complete(request: Request):
-    print(f"[Main] Received /v1/complete request from {request.client.host}")
-    # 暂时重定向或提示，或者如果需要可以实现 handle_complete
-    return JSONResponse(
-        status_code=400,
-        content={"error": {"type": "invalid_request_error", "message": "KiroProxy currently only supports /v1/messages. Please check if your client can be configured to use Messages API."}}
-    )
-
-
-# OpenAI 协议
-@app.post("/v1/chat/completions")
-async def openai_chat(request: Request):
-    return await openai.handle_chat_completions(request)
-
-
-# OpenAI Responses API (Codex CLI 新版本)
-@app.post("/v1/responses")
-async def openai_responses(request: Request):
-    return await responses_handler.handle_responses(request)
-
-
-# Gemini 协议
-@app.post("/v1beta/models/{model_name}:generateContent")
-@app.post("/v1/models/{model_name}:generateContent")
-async def gemini_generate(model_name: str, request: Request):
-    return await gemini.handle_generate_content(model_name, request)
-
-
-# ==================== 管理 API ====================
-
-@app.get("/api/status")
-async def api_status():
-    return await admin.get_status()
-
-@app.post("/api/event_logging/batch")
-async def api_event_logging_batch(request: Request):
-    return await admin.event_logging_batch(request)
-
-
-@app.get("/api/stats")
-async def api_stats():
-    return await admin.get_stats()
-
-
-@app.get("/api/logs")
-async def api_logs(limit: int = 100):
-    return await admin.get_logs(limit)
-
-
-# ==================== 账号导入导出 API ====================
-
-@app.get("/api/accounts/export")
-async def api_export_accounts():
-    """导出所有账号配置"""
-    return await admin.export_accounts()
-
-
-@app.post("/api/accounts/import")
-async def api_import_accounts(request: Request):
-    """导入账号配置"""
-    return await admin.import_accounts(request)
-
-
-@app.post("/api/accounts/manual")
-async def api_add_manual_token(request: Request):
-    """手动添加 Token"""
-    return await admin.add_manual_token(request)
-
-
-@app.post("/api/accounts/batch")
-async def api_batch_import_accounts(request: Request):
-    """批量导入账号"""
-    return await admin.batch_import_accounts(request)
-
-
-@app.post("/api/accounts/refresh-all")
-async def api_refresh_all():
-    """刷新所有即将过期的 token"""
-    return await admin.refresh_all_tokens()
-
-
-# ==================== 额度管理 API (必须在 {account_id} 路由之前) ====================
-
-@app.get("/api/accounts/status")
-async def api_accounts_status_enhanced():
-    """获取完整账号状态（增强版）"""
-    return await admin.get_accounts_status_enhanced()
-
-
-@app.get("/api/accounts/summary")
-async def api_accounts_summary():
-    """获取账号汇总统计"""
-    return await admin.get_accounts_summary()
-
-
-@app.post("/api/accounts/refresh-all-quotas")
-async def api_refresh_all_quotas():
-    """刷新所有账号额度"""
-    return await admin.refresh_all_quotas()
-
-
-# ==================== 刷新进度 API ====================
-
-@app.get("/api/refresh/progress")
-async def api_refresh_progress():
-    """获取刷新进度"""
-    return await admin.get_refresh_progress()
-
-
-@app.post("/api/refresh/all")
-async def api_refresh_all_with_progress():
-    """批量刷新（带进度和锁检查）"""
-    return await admin.refresh_all_with_progress()
-
-
-@app.get("/api/refresh/config")
-async def api_get_refresh_config():
-    """获取刷新配置"""
-    return await admin.get_refresh_config()
-
-
-@app.put("/api/refresh/config")
-async def api_update_refresh_config(request: Request):
-    """更新刷新配置"""
-    return await admin.update_refresh_config(request)
-
-
-@app.get("/api/refresh/status")
-async def api_refresh_status():
-    """获取刷新管理器状态"""
-    return await admin.get_refresh_manager_status()
-
-
-@app.get("/api/accounts")
-async def api_accounts():
-    return await admin.get_accounts()
-
-
-@app.post("/api/accounts")
-async def api_add_account(request: Request):
-    return await admin.add_account(request)
-
-
-@app.delete("/api/accounts/{account_id}")
-async def api_delete_account(account_id: str):
-    return await admin.delete_account(account_id)
-
-
-@app.put("/api/accounts/{account_id}")
-async def api_update_account(account_id: str, request: Request):
-    return await admin.update_account(account_id, request)
-
-
-@app.post("/api/accounts/{account_id}/toggle")
-async def api_toggle_account(account_id: str):
-    return await admin.toggle_account(account_id)
-
-
-@app.post("/api/speedtest")
-async def api_speedtest():
-    return await admin.speedtest()
-
-
-@app.get("/api/accounts/{account_id}/test")
-async def api_test_account_token(account_id: str):
-    """测试指定账号的 Token 是否有效"""
-    return await admin.test_account_token(account_id)
-
-
-@app.get("/api/token/scan")
-async def api_scan_tokens():
-    return await admin.scan_tokens()
-
-
-@app.post("/api/token/add-from-scan")
-async def api_add_from_scan(request: Request):
-    return await admin.add_from_scan(request)
-
-
-@app.get("/api/config/export")
-async def api_export_config():
-    return await admin.export_config()
-
-
-@app.post("/api/config/import")
-async def api_import_config(request: Request):
-    return await admin.import_config(request)
-
-
-@app.post("/api/token/refresh-check")
-async def api_refresh_check():
-    return await admin.refresh_token_check()
-
-
-@app.post("/api/accounts/{account_id}/refresh")
-async def api_refresh_account(account_id: str):
-    """刷新指定账号的 token（集成 RefreshManager）"""
-    return await admin.refresh_account_token_with_manager(account_id)
-
-
-@app.post("/api/accounts/{account_id}/restore")
-async def api_restore_account(account_id: str):
-    """恢复账号（从冷却状态）"""
-    return await admin.restore_account(account_id)
-
-
-@app.get("/api/accounts/{account_id}/usage")
-async def api_account_usage(account_id: str):
-    """获取账号用量信息"""
-    return await admin.get_account_usage_info(account_id)
-
-
-@app.get("/api/accounts/{account_id}")
-async def api_account_detail(account_id: str):
-    """获取账号详细信息"""
-    return await admin.get_account_detail(account_id)
-
-
-@app.post("/api/accounts/{account_id}/refresh-quota")
-async def api_refresh_account_quota(account_id: str):
-    """刷新单个账号额度（先刷新 Token）"""
-    return await admin.refresh_account_quota_with_token(account_id)
-
-
-# ==================== 优先账号 API ====================
-
-@app.get("/api/priority")
-async def api_get_priority_accounts():
-    """获取优先账号列表"""
-    return await admin.get_priority_accounts()
-
-
-@app.post("/api/priority/{account_id}")
-async def api_set_priority_account(account_id: str, request: Request):
-    """设置优先账号"""
-    return await admin.set_priority_account(account_id, request)
-
-
-@app.delete("/api/priority/{account_id}")
-async def api_remove_priority_account(account_id: str):
-    """取消优先账号"""
-    return await admin.remove_priority_account(account_id)
-
-
-@app.put("/api/priority/reorder")
-async def api_reorder_priority_accounts(request: Request):
-    """调整优先账号顺序"""
-    return await admin.reorder_priority_accounts(request)
-
-
-@app.get("/api/quota")
-async def api_quota_status():
-    """获取配额状态"""
-    return await admin.get_quota_status()
-
-
-@app.get("/api/kiro/login-url")
-async def api_login_url():
-    return await admin.get_kiro_login_url()
-
-
-@app.get("/api/stats/detailed")
-async def api_detailed_stats():
-    """获取详细统计信息"""
-    return await admin.get_detailed_stats()
-
-
-@app.post("/api/health-check")
-async def api_health_check():
-    """手动触发健康检查"""
-    return await admin.run_health_check()
-
-
-@app.get("/api/browsers")
-async def api_browsers():
-    """获取可用浏览器列表"""
-    return await admin.get_browsers()
-
-
-# ==================== Kiro 登录 API ====================
-
-@app.post("/api/kiro/login/start")
-async def api_kiro_login_start(request: Request):
-    """启动 Kiro 设备授权登录"""
-    return await admin.start_kiro_login(request)
-
-
-@app.get("/api/kiro/login/poll")
-async def api_kiro_login_poll():
-    """轮询登录状态"""
-    return await admin.poll_kiro_login()
-
-
-@app.post("/api/kiro/login/cancel")
-async def api_kiro_login_cancel():
-    """取消登录"""
-    return await admin.cancel_kiro_login()
-
-
-@app.get("/api/kiro/login/status")
-async def api_kiro_login_status():
-    """获取登录状态"""
-    return await admin.get_kiro_login_status()
-
-
-# ==================== Social Auth API (Google/GitHub) ====================
-
-@app.post("/api/kiro/social/start")
-async def api_social_login_start(request: Request):
-    """启动 Social Auth 登录"""
-    return await admin.start_social_login(request)
-
-
-@app.post("/api/kiro/social/exchange")
-async def api_social_token_exchange(request: Request):
-    """交换 Social Auth Token"""
-    return await admin.exchange_social_token(request)
-
-
-@app.post("/api/kiro/social/cancel")
-async def api_social_login_cancel():
-    """取消 Social Auth 登录"""
-    return await admin.cancel_social_login()
-
-
-@app.get("/api/kiro/social/status")
-async def api_social_login_status():
-    """获取 Social Auth 状态"""
-    return await admin.get_social_login_status()
-
-
-# ==================== 协议注册 API ====================
-
-@app.post("/api/protocol/register")
-async def api_register_protocol():
-    """注册 kiro:// 协议"""
-    return await admin.register_kiro_protocol()
-
-
-@app.post("/api/protocol/unregister")
-async def api_unregister_protocol():
-    """取消注册 kiro:// 协议"""
-    return await admin.unregister_kiro_protocol()
-
-
-@app.get("/api/protocol/status")
-async def api_protocol_status():
-    """获取协议注册状态"""
-    return await admin.get_protocol_status()
-
-
-@app.get("/api/protocol/callback")
-async def api_protocol_callback():
-    """获取回调结果"""
-    return await admin.get_callback_result()
-
-
-# ==================== Flow Monitor API ====================
-
-@app.get("/api/flows")
-async def api_flows(
-    protocol: str = None,
-    model: str = None,
-    account_id: str = None,
-    state: str = None,
-    has_error: bool = None,
-    bookmarked: bool = None,
-    search: str = None,
-    limit: int = 50,
-    offset: int = 0,
-):
-    """查询 Flows"""
-    return await admin.get_flows(
-        protocol=protocol,
-        model=model,
-        account_id=account_id,
-        state_filter=state,
-        has_error=has_error,
-        bookmarked=bookmarked,
-        search=search,
-        limit=limit,
-        offset=offset,
-    )
-
-
-@app.get("/api/flows/stats")
-async def api_flow_stats():
-    """获取 Flow 统计"""
-    return await admin.get_flow_stats()
-
-
-@app.get("/api/flows/{flow_id}")
-async def api_flow_detail(flow_id: str):
-    """获取 Flow 详情"""
-    return await admin.get_flow_detail(flow_id)
-
-
-@app.post("/api/flows/{flow_id}/bookmark")
-async def api_bookmark_flow(flow_id: str, request: Request):
-    """书签 Flow"""
-    return await admin.bookmark_flow(flow_id, request)
-
-
-@app.post("/api/flows/{flow_id}/note")
-async def api_add_flow_note(flow_id: str, request: Request):
-    """添加 Flow 备注"""
-    return await admin.add_flow_note(flow_id, request)
-
-
-@app.post("/api/flows/{flow_id}/tag")
-async def api_add_flow_tag(flow_id: str, request: Request):
-    """添加 Flow 标签"""
-    return await admin.add_flow_tag(flow_id, request)
-
-
-@app.post("/api/flows/export")
-async def api_export_flows(request: Request):
-    """导出 Flows"""
-    return await admin.export_flows(request)
-
-
-# ==================== 历史消息管理 API ====================
-
-from .core import get_history_config, update_history_config, TruncateStrategy
-from .core.rate_limiter import get_rate_limiter
-
-@app.get("/api/settings/history")
-async def api_get_history_config():
-    """获取历史消息管理配置"""
-    config = get_history_config()
-    return config.to_dict()
-
-
-@app.post("/api/settings/history")
-async def api_update_history_config(request: Request):
-    """更新历史消息管理配置"""
-    data = await request.json()
-    update_history_config(data)
-    return {"ok": True, "config": get_history_config().to_dict()}
-
-
-# ==================== 限速配置 API ====================
-
-@app.get("/api/settings/rate-limit")
-async def api_get_rate_limit_config():
-    """获取限速配置"""
-    limiter = get_rate_limiter()
-    return {
-        "enabled": limiter.config.enabled,
-        "min_request_interval": limiter.config.min_request_interval,
-        "max_requests_per_minute": limiter.config.max_requests_per_minute,
-        "global_max_requests_per_minute": limiter.config.global_max_requests_per_minute,
-        "stats": limiter.get_stats()
-    }
-
-
-@app.post("/api/settings/rate-limit")
-async def api_update_rate_limit_config(request: Request):
-    """更新限速配置"""
-    data = await request.json()
-    limiter = get_rate_limiter()
-    limiter.update_config(**data)
-    return {"ok": True, "config": {
-        "enabled": limiter.config.enabled,
-        "min_request_interval": limiter.config.min_request_interval,
-        "max_requests_per_minute": limiter.config.max_requests_per_minute,
-        "global_max_requests_per_minute": limiter.config.global_max_requests_per_minute,
-    }}
-
-
-# ==================== 文档 API ====================
-
-# 文档标题映射
-DOC_TITLES = {
-    "01-quickstart": "快速开始",
-    "02-features": "功能特性",
-    "03-faq": "常见问题",
-    "04-api": "API 参考",
-    "05-server-deploy": "服务器部署",
-}
-
-@app.get("/api/docs")
-async def api_docs_list():
-    """获取文档列表"""
-    docs_dir = get_resource_path("kiro_proxy/docs")
-    docs = []
-    if docs_dir.exists():
-        for doc_file in sorted(docs_dir.glob("*.md")):
-            doc_id = doc_file.stem
-            title = DOC_TITLES.get(doc_id, doc_id)
-            docs.append({"id": doc_id, "title": title})
-    return {"docs": docs}
-
-
-@app.get("/api/docs/{doc_id}")
-async def api_docs_content(doc_id: str):
-    """获取文档内容"""
-    docs_dir = get_resource_path("kiro_proxy/docs")
-    doc_file = docs_dir / f"{doc_id}.md"
-    if not doc_file.exists():
-        raise HTTPException(status_code=404, detail="文档不存在")
-    content = doc_file.read_text(encoding="utf-8")
-    title = DOC_TITLES.get(doc_id, doc_id)
-    return {"id": doc_id, "title": title, "content": content}
-
-
-# ==================== 启动 ====================
-
-def run(port: int = 8080):
-    import uvicorn
-    print(f"\n{'='*50}")
-    print(f"  Kiro API Proxy v{__version__}")
-    print(f"  http://localhost:{port}")
-    print(f"{'='*50}\n")
-    uvicorn.run(app, host="0.0.0.0", port=port)
-
-
-if __name__ == "__main__":
-    import sys
-    port = int(sys.argv[1]) if len(sys.argv) > 1 else 8080
-    run(port)

KiroProxy/legacy/kiro_proxy.py

@@ -1,313 +0,0 @@
-#!/usr/bin/env python3
-"""
-Kiro API 反向代理服务器
-对外暴露 OpenAI 兼容接口，内部调用 Kiro/AWS Q API
-"""
-
-import json
-import uuid
-import os
-import httpx
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import StreamingResponse, JSONResponse
-import uvicorn
-from datetime import datetime
-from pathlib import Path
-import logging
-
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-app = FastAPI(title="Kiro API Proxy")
-
-# Kiro API 配置
-KIRO_API_URL = "https://q.us-east-1.amazonaws.com/generateAssistantResponse"
-TOKEN_PATH = Path.home() / ".aws/sso/cache/kiro-auth-token.json"
-MACHINE_ID = "fa41d5def91e29225c73f6ea8ee0941a87bd812aae5239e3dde72c3ba7603a26"
-
-def get_kiro_token() -> str:
-    """从本地文件读取 Kiro token"""
-    try:
-        with open(TOKEN_PATH) as f:
-            data = json.load(f)
-            return data.get("accessToken", "")
-    except Exception as e:
-        logger.error(f"读取 token 失败: {e}")
-        raise HTTPException(status_code=500, detail="无法读取 Kiro token")
-
-def build_kiro_headers(token: str) -> dict:
-    """构建 Kiro API 请求头"""
-    return {
-        "content-type": "application/json",
-        "x-amzn-codewhisperer-optout": "true",
-        "x-amzn-kiro-agent-mode": "vibe",
-        "x-amz-user-agent": f"aws-sdk-js/1.0.27 KiroIDE-0.8.0-{MACHINE_ID}",
-        "user-agent": f"aws-sdk-js/1.0.27 ua/2.1 os/linux lang/js md/nodejs api/codewhispererstreaming KiroIDE-0.8.0-{MACHINE_ID}",
-        "amz-sdk-invocation-id": str(uuid.uuid4()),
-        "amz-sdk-request": "attempt=1; max=3",
-        "Authorization": f"Bearer {token}",
-    }
-
-def build_kiro_request(messages: list, model: str, conversation_id: str = None) -> dict:
-    """将 OpenAI 格式转换为 Kiro 格式"""
-    if not conversation_id:
-        conversation_id = str(uuid.uuid4())
-    
-    # 提取最后一条用户消息
-    user_content = ""
-    for msg in reversed(messages):
-        if msg.get("role") == "user":
-            user_content = msg.get("content", "")
-            break
-    
-    return {
-        "conversationState": {
-            "conversationId": conversation_id,
-            "currentMessage": {
-                "userInputMessage": {
-                    "content": user_content,
-                    "modelId": model.replace("kiro-", ""),  # 移除前缀
-                    "origin": "AI_EDITOR",
-                    "userInputMessageContext": {}
-                }
-            },
-            "chatTriggerType": "MANUAL"
-        }
-    }
-
-def parse_kiro_response(response_data: dict) -> str:
-    """解析 Kiro 响应，提取 AI 回复内容"""
-    try:
-        # Kiro 响应格式可能是流式的，需要解析
-        if isinstance(response_data, dict):
-            # 尝试多种可能的响应路径
-            if "generateAssistantResponseResponse" in response_data:
-                resp = response_data["generateAssistantResponseResponse"]
-                if "assistantResponseEvent" in resp:
-                    event = resp["assistantResponseEvent"]
-                    if "content" in event:
-                        return event["content"]
-            
-            # 直接返回文本内容
-            if "content" in response_data:
-                return response_data["content"]
-            
-            if "message" in response_data:
-                return response_data["message"]
-        
-        return json.dumps(response_data)
-    except Exception as e:
-        logger.error(f"解析响应失败: {e}")
-        return str(response_data)
-
-def parse_event_stream(raw_content: bytes) -> str:
-    """解析 AWS event-stream 格式的响应"""
-    try:
-        # 尝试直接解码为 UTF-8
-        try:
-            text = raw_content.decode('utf-8')
-            # 如果是纯 JSON
-            if text.startswith('{'):
-                data = json.loads(text)
-                return parse_kiro_response(data)
-        except:
-            pass
-        
-        # AWS event-stream 格式解析
-        # 格式: [prelude (8 bytes)][headers][payload][message CRC (4 bytes)]
-        content_parts = []
-        pos = 0
-        
-        while pos < len(raw_content):
-            if pos + 12 > len(raw_content):
-                break
-            
-            # 读取 prelude: total_length (4 bytes) + headers_length (4 bytes) + prelude_crc (4 bytes)
-            total_length = int.from_bytes(raw_content[pos:pos+4], 'big')
-            headers_length = int.from_bytes(raw_content[pos+4:pos+8], 'big')
-            
-            if total_length == 0 or total_length > len(raw_content) - pos:
-                break
-            
-            # 跳过 prelude (12 bytes) 和 headers
-            payload_start = pos + 12 + headers_length
-            payload_end = pos + total_length - 4  # 减去 message CRC
-            
-            if payload_start < payload_end:
-                payload = raw_content[payload_start:payload_end]
-                try:
-                    # 尝试解析 payload 为 JSON
-                    payload_text = payload.decode('utf-8')
-                    if payload_text.strip():
-                        payload_json = json.loads(payload_text)
-                        
-                        # 提取文本内容
-                        if "assistantResponseEvent" in payload_json:
-                            event = payload_json["assistantResponseEvent"]
-                            if "content" in event:
-                                content_parts.append(event["content"])
-                        elif "content" in payload_json:
-                            content_parts.append(payload_json["content"])
-                        elif "text" in payload_json:
-                            content_parts.append(payload_json["text"])
-                        else:
-                            logger.info(f"   Event: {payload_text[:200]}")
-                except Exception as e:
-                    logger.debug(f"解析 payload 失败: {e}")
-            
-            pos += total_length
-        
-        if content_parts:
-            return "".join(content_parts)
-        
-        # 如果解析失败，返回原始内容的十六进制表示用于调试
-        return f"[无法解析响应，原始数据: {raw_content[:500].hex()}]"
-        
-    except Exception as e:
-        logger.error(f"解析 event-stream 失败: {e}")
-        return f"[解析错误: {e}]"
-
-@app.get("/")
-async def root():
-    """健康检查"""
-    token_exists = TOKEN_PATH.exists()
-    return {
-        "status": "ok",
-        "service": "Kiro API Proxy",
-        "token_available": token_exists,
-        "endpoints": {
-            "chat": "/v1/chat/completions",
-            "models": "/v1/models"
-        }
-    }
-
-@app.get("/v1/models")
-async def list_models():
-    """列出可用模型 (OpenAI 兼容)"""
-    return {
-        "object": "list",
-        "data": [
-            {"id": "kiro-claude-sonnet-4", "object": "model", "owned_by": "kiro"},
-            {"id": "kiro-claude-opus-4.5", "object": "model", "owned_by": "kiro"},
-            {"id": "claude-sonnet-4", "object": "model", "owned_by": "kiro"},
-            {"id": "claude-opus-4.5", "object": "model", "owned_by": "kiro"},
-        ]
-    }
-
-@app.post("/v1/chat/completions")
-async def chat_completions(request: Request):
-    """OpenAI 兼容的聊天接口"""
-    try:
-        body = await request.json()
-    except:
-        raise HTTPException(status_code=400, detail="Invalid JSON")
-    
-    messages = body.get("messages", [])
-    model = body.get("model", "claude-sonnet-4")
-    stream = body.get("stream", False)
-    
-    if not messages:
-        raise HTTPException(status_code=400, detail="messages is required")
-    
-    # 获取 token
-    token = get_kiro_token()
-    
-    # 构建请求
-    headers = build_kiro_headers(token)
-    kiro_body = build_kiro_request(messages, model)
-    
-    logger.info(f"📤 发送请求到 Kiro API, model={model}")
-    logger.info(f"   消息: {messages[-1].get('content', '')[:100]}...")
-    
-    try:
-        async with httpx.AsyncClient(timeout=60.0, verify=False) as client:
-            response = await client.post(
-                KIRO_API_URL,
-                headers=headers,
-                json=kiro_body
-            )
-            
-            logger.info(f"📥 Kiro 响应状态: {response.status_code}")
-            logger.info(f"   Content-Type: {response.headers.get('content-type')}")
-            
-            if response.status_code != 200:
-                logger.error(f"Kiro API 错误: {response.text}")
-                raise HTTPException(
-                    status_code=response.status_code,
-                    detail=f"Kiro API error: {response.text}"
-                )
-            
-            # 处理响应 - 可能是 event-stream 或 JSON
-            raw_content = response.content
-            logger.info(f"   响应大小: {len(raw_content)} bytes")
-            logger.info(f"   原始响应前200字节: {raw_content[:200]}")
-            
-            content = parse_event_stream(raw_content)
-            
-            logger.info(f"   回复: {content[:100]}...")
-            
-            # 返回 OpenAI 兼容格式
-            return JSONResponse({
-                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
-                "object": "chat.completion",
-                "created": int(datetime.now().timestamp()),
-                "model": model,
-                "choices": [{
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": content
-                    },
-                    "finish_reason": "stop"
-                }],
-                "usage": {
-                    "prompt_tokens": 0,
-                    "completion_tokens": 0,
-                    "total_tokens": 0
-                }
-            })
-            
-    except httpx.RequestError as e:
-        logger.error(f"请求失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-    except Exception as e:
-        logger.error(f"未知错误: {e}")
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/token/status")
-async def token_status():
-    """检查 token 状态"""
-    try:
-        with open(TOKEN_PATH) as f:
-            data = json.load(f)
-            expires_at = data.get("expiresAt", "unknown")
-            return {
-                "valid": True,
-                "expires_at": expires_at,
-                "path": str(TOKEN_PATH)
-            }
-    except Exception as e:
-        return {
-            "valid": False,
-            "error": str(e),
-            "path": str(TOKEN_PATH)
-        }
-
-if __name__ == "__main__":
-    print("""
-╔══════════════════════════════════════════════════════════════╗
-║              Kiro API 反向代理服务器                           ║
-╠══════════════════════════════════════════════════════════════╣
-║  端口: 8000                                                   ║
-║  OpenAI 兼容接口: http://127.0.0.1:8000/v1/chat/completions   ║
-╠══════════════════════════════════════════════════════════════╣
-║  使用方法:                                                    ║
-║  curl http://127.0.0.1:8000/v1/chat/completions \\            ║
-║    -H "Content-Type: application/json" \\                     ║
-║    -d '{"model":"claude-sonnet-4","messages":[{"role":"user",║
-║         "content":"Hello"}]}'                                 ║
-╚══════════════════════════════════════════════════════════════╝
-    """)
-    uvicorn.run(app, host="0.0.0.0", port=8000)

KiroProxy/requirements.txt

@@ -1,13 +0,0 @@
-fastapi>=0.100.0
-uvicorn>=0.23.0
-httpx>=0.24.0
-requests>=2.31.0
-pytest>=7.0.0
-hypothesis>=6.0.0
-tiktoken>=0.5.0
-cbor2>=5.4.0
-
-# 数据库驱动（可选，根据DATABASE_URL自动选择）
-asyncpg>=0.28.0  # PostgreSQL
-aiomysql>=0.2.0  # MySQL
-aiosqlite>=0.19.0  # SQLite

KiroProxy/run.py

@@ -1,14 +0,0 @@
-#!/usr/bin/env python3
-"""Kiro API Proxy 启动脚本"""
-import sys
-
-if __name__ == "__main__":
-    # 如果有子命令参数，使用 CLI 模式
-    if len(sys.argv) > 1 and sys.argv[1] in ("accounts", "login", "status", "serve"):
-        from kiro_proxy.cli import main
-        main()
-    else:
-        # 兼容旧的启动方式: python run.py [port]
-        port = int(sys.argv[1]) if len(sys.argv) > 1 else 8080
-        from kiro_proxy.main import run
-        run(port)

KiroProxy/scripts/capture_kiro.py

@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-"""
-Kiro IDE 请求抓取工具
-
-使用 mitmproxy 抓取 Kiro IDE 发送到 AWS 的请求。
-
-安装:
-    pip install mitmproxy
-
-使用方法:
-    1. 运行此脚本: python capture_kiro.py
-    2. 设置系统代理为 127.0.0.1:8888
-    3. 安装 mitmproxy 的 CA 证书 (访问 http://mitm.it)
-    4. 启动 Kiro IDE 并使用
-    5. 查看 kiro_requests/ 目录下的抓取结果
-
-或者使用 mitmproxy 命令行:
-    mitmproxy --mode regular@8888 -s capture_kiro.py
-    
-    或者使用 mitmdump (无 UI):
-    mitmdump --mode regular@8888 -s capture_kiro.py
-"""
-
-import json
-import os
-from datetime import datetime
-from mitmproxy import http, ctx
-
-# 创建输出目录
-OUTPUT_DIR = "kiro_requests"
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-# 计数器
-request_count = 0
-
-def request(flow: http.HTTPFlow) -> None:
-    """处理请求"""
-    global request_count
-    
-    # 只抓取 Kiro/AWS 相关请求
-    if "q.us-east-1.amazonaws.com" not in flow.request.host:
-        return
-    
-    request_count += 1
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    
-    # 保存请求
-    request_data = {
-        "timestamp": timestamp,
-        "method": flow.request.method,
-        "url": flow.request.url,
-        "headers": dict(flow.request.headers),
-        "body": None
-    }
-    
-    # 解析请求体
-    if flow.request.content:
-        try:
-            request_data["body"] = json.loads(flow.request.content.decode('utf-8'))
-        except:
-            request_data["body_raw"] = flow.request.content.decode('utf-8', errors='replace')
-    
-    # 保存到文件
-    filename = f"{OUTPUT_DIR}/{timestamp}_{request_count:04d}_request.json"
-    with open(filename, 'w', encoding='utf-8') as f:
-        json.dump(request_data, f, indent=2, ensure_ascii=False)
-    
-    ctx.log.info(f"[Kiro] Captured request #{request_count}: {flow.request.method} {flow.request.path}")
-
-
-def response(flow: http.HTTPFlow) -> None:
-    """处理响应"""
-    # 只处理 Kiro/AWS 相关响应
-    if "q.us-east-1.amazonaws.com" not in flow.request.host:
-        return
-    
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    
-    # 保存响应
-    response_data = {
-        "timestamp": timestamp,
-        "status_code": flow.response.status_code,
-        "headers": dict(flow.response.headers),
-        "body": None
-    }
-    
-    # 响应体可能是 event-stream 格式
-    if flow.response.content:
-        try:
-            # 尝试解析为 JSON
-            response_data["body"] = json.loads(flow.response.content.decode('utf-8'))
-        except:
-            # 保存原始内容（可能是 event-stream）
-            response_data["body_raw_length"] = len(flow.response.content)
-            # 保存前 2000 字节用于调试
-            response_data["body_preview"] = flow.response.content[:2000].decode('utf-8', errors='replace')
-    
-    # 保存到文件
-    filename = f"{OUTPUT_DIR}/{timestamp}_{request_count:04d}_response.json"
-    with open(filename, 'w', encoding='utf-8') as f:
-        json.dump(response_data, f, indent=2, ensure_ascii=False)
-    
-    ctx.log.info(f"[Kiro] Captured response: {flow.response.status_code}")
-
-
-# 如果直接运行此脚本
-if __name__ == "__main__":
-    print("""
-╔══════════════════════════════════════════════════════════════════╗
-║           Kiro IDE 请求抓取工具                                    ║
-╠══════════════════════════════════════════════════════════════════╣
-║                                                                  ║
-║  方法 1: 使用 mitmproxy (推荐)                                    ║
-║  ─────────────────────────────────────────────────────────────── ║
-║  1. 安装: pip install mitmproxy                                  ║
-║  2. 运行: mitmproxy -s capture_kiro.py                           ║
-║     或:   mitmdump -s capture_kiro.py                            ║
-║  3. 设置 Kiro IDE 的代理为 127.0.0.1:8080                         ║
-║  4. 安装 CA 证书: 访问 http://mitm.it                             ║
-║                                                                  ║
-║  方法 2: 使用 Burp Suite                                          ║
-║  ─────────────────────────────────────────────────────────────── ║
-║  1. 启动 Burp Suite                                              ║
-║  2. 设置代理监听 127.0.0.1:8080                                   ║
-║  3. 导出 CA 证书并安装到系统                                       ║
-║  4. 设置 Kiro IDE 的代理                                          ║
-║                                                                  ║
-║  方法 3: 直接修改 Kiro IDE (最简单)                                ║
-║  ─────────────────────────────────────────────────────────────── ║
-║  在 Kiro IDE 的设置中添加:                                        ║
-║    "http.proxy": "http://127.0.0.1:8080"                         ║
-║                                                                  ║
-║  或者设置环境变量:                                                 ║
-║    export HTTPS_PROXY=http://127.0.0.1:8080                      ║
-║    export HTTP_PROXY=http://127.0.0.1:8080                       ║
-║    export NODE_TLS_REJECT_UNAUTHORIZED=0                         ║
-║                                                                  ║
-╚══════════════════════════════════════════════════════════════════╝
-""")

KiroProxy/scripts/proxy_server.py

@@ -1,135 +0,0 @@
-#!/usr/bin/env python3
-"""
-Kiro IDE 反向代理测试服务器
-用于测试是否能成功拦截和转发 Kiro 的 API 请求
-"""
-
-from fastapi import FastAPI, Request, Response
-from fastapi.responses import JSONResponse, StreamingResponse
-import httpx
-import uvicorn
-import json
-import logging
-from datetime import datetime
-
-# 配置日志
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-app = FastAPI(title="Kiro Reverse Proxy Test")
-
-# 原始 Kiro API 地址（如果需要转发到真实服务器）
-KIRO_API_BASE = "https://api.kiro.dev"
-
-# 记录所有请求
-request_log = []
-
-@app.middleware("http")
-async def log_requests(request: Request, call_next):
-    """记录所有进入的请求"""
-    body = await request.body()
-    
-    log_entry = {
-        "timestamp": datetime.now().isoformat(),
-        "method": request.method,
-        "url": str(request.url),
-        "path": request.url.path,
-        "headers": dict(request.headers),
-        "body": body.decode('utf-8', errors='ignore')[:2000] if body else None
-    }
-    
-    request_log.append(log_entry)
-    logger.info(f"📥 {request.method} {request.url.path}")
-    logger.info(f"   Headers: {dict(request.headers)}")
-    if body:
-        logger.info(f"   Body: {body.decode('utf-8', errors='ignore')[:500]}...")
-    
-    response = await call_next(request)
-    return response
-
-@app.get("/")
-async def root():
-    """健康检查"""
-    return {"status": "ok", "message": "Kiro Proxy Server Running", "requests_logged": len(request_log)}
-
-@app.get("/logs")
-async def get_logs():
-    """查看所有记录的请求"""
-    return {"total": len(request_log), "requests": request_log[-50:]}
-
-@app.get("/clear")
-async def clear_logs():
-    """清空日志"""
-    request_log.clear()
-    return {"message": "Logs cleared"}
-
-# 模拟认证成功响应
-@app.api_route("/auth/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"])
-async def mock_auth(request: Request, path: str):
-    """模拟认证端点"""
-    logger.info(f"🔐 Auth request: {path}")
-    return JSONResponse({
-        "success": True,
-        "token": "mock-token-for-testing",
-        "expires_in": 3600
-    })
-
-# 模拟 AI 对话端点
-@app.post("/v1/chat/completions")
-async def mock_chat_completions(request: Request):
-    """模拟 OpenAI 兼容的聊天接口"""
-    body = await request.json()
-    logger.info(f"💬 Chat request: {json.dumps(body, ensure_ascii=False)[:500]}")
-    
-    # 返回模拟响应
-    return JSONResponse({
-        "id": "chatcmpl-test",
-        "object": "chat.completion",
-        "created": int(datetime.now().timestamp()),
-        "model": "kiro-proxy-test",
-        "choices": [{
-            "index": 0,
-            "message": {
-                "role": "assistant",
-                "content": "🎉 反向代理测试成功！你的请求已被成功拦截。"
-            },
-            "finish_reason": "stop"
-        }],
-        "usage": {"prompt_tokens": 10, "completion_tokens": 20, "total_tokens": 30}
-    })
-
-# 捕获所有其他请求
-@app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"])
-async def catch_all(request: Request, path: str):
-    """捕获所有其他请求并记录"""
-    body = await request.body()
-    
-    logger.info(f"🎯 Caught: {request.method} /{path}")
-    
-    return JSONResponse({
-        "proxy_status": "intercepted",
-        "method": request.method,
-        "path": f"/{path}",
-        "message": "请求已被反向代理捕获",
-        "headers_received": dict(request.headers)
-    })
-
-if __name__ == "__main__":
-    print("""
-╔══════════════════════════════════════════════════════════════╗
-║           Kiro IDE 反向代理测试服务器                          ║
-╠══════════════════════════════════════════════════════════════╣
-║  端口: 8000                                                   ║
-║  查看日志: http://127.0.0.1:8000/logs                         ║
-║  清空日志: http://127.0.0.1:8000/clear                        ║
-╠══════════════════════════════════════════════════════════════╣
-║  使用方法:                                                    ║
-║  1. 修改 Kiro 的 JS 源码，将 api.kiro.dev 替换为 127.0.0.1:8000 ║
-║  2. 或者修改 /etc/hosts 添加: 127.0.0.1 api.kiro.dev          ║
-║  3. 启动 Kiro，观察此终端的日志输出                             ║
-╚════════════════════════════���═════════════════════════════════╝
-    """)
-    uvicorn.run(app, host="0.0.0.0", port=8000)

README.md

@@ -1,6 +1,6 @@
 ---
 title: KiroProxy
-emoji: 🚀
+emoji: ??
 colorFrom: blue
 colorTo: purple
 sdk: docker
@@ -10,107 +10,412 @@ short_description: Kiro IDE API 反向代理服务器 - 支持多账号管理和
 app_port: 7860
 ---
 
-# KiroProxy
+<p align="center">
+  <img src="assets/icon.svg" width="80" height="96" alt="Kiro Proxy">
+</p>
 
-🚀 **Kiro IDE API 反向代理服务器** - 支持多账号管理和多协议转换
+<h1 align="center">Kiro API Proxy</h1>
+
+<p align="center">
+  Kiro IDE API 反向代理服务器，支持多账号轮询、Token 自动刷新、配额管理
+</p>
+
+<p align="center">
+  <a href="#功能特性">功能</a> ?
+  <a href="#快速开始">快速开始</a> ?
+  <a href="#cli-配置">CLI 配置</a> ?
+  <a href="#api-端点">API</a> ?
+  <a href="#许可证">许可证</a>
+</p>
+
+---
+
+> **?? 测试说明**
+> 
+> 本项目支持 **Claude Code**、**Codex CLI**、**Gemini CLI** 三种客户端，工具调用功能已全面支持。
 
 ## 功能特性
 
-- **多协议支持** - 兼容 OpenAI、Anthropic、Gemini 三种 API 协议
-- **多账号轮询** - 支持随机、轮询、会话粘性等选择策略
-- **自动 Token 管理** - 后台自动刷新即将过期的 Token
-- **配额管理** - 智能配额调度和超限冷却
-- **Web UI** - 内置管理界面，支持账号管理、监控、日志
-- **数据库支持** - 支持文件系统和远程SQL数据库存储
-- **管理员认证** - 安全的密码认证和会话管理系统
+### 核心功能
+- **多协议支持** - OpenAI / Anthropic / Gemini 三种协议兼容
+- **完整工具调用** - 三种协议的工具调用功能全面支持
+- **图片理解** - 支持 Claude Code / Codex CLI 图片输入
+- **网络搜索** - 支持 Claude Code / Codex CLI 网络搜索工具
+- **思考功能** - 支持 Claude 的扩展思考功能（Extended Thinking）
+- **多账号轮询（默认随机）** - 每次请求随机切换账号，分散压力，避免单账号 RPM 过高
+- **会话粘性（可选）** - 非 `random` 策略下，同一会话 60 秒内使用同一账号，保持上下文
+- **Web UI** - 简洁的管理界面，支持监控、日志、设置
+
+### v1.7.1 新功能
+- **Windows 支持补强** - 注册表浏览器检测 + PATH 回退，兼容便携版
+- **打包资源修复** - PyInstaller 打包后可正常加载图标与内置文档
+- **Token 扫描稳定性** - Windows 路径编码处理修复
+
+### v1.6.3 新功能
+- **命令行工具 (CLI)** - 无 GUI 服务器也能轻松管理
+  - `python run.py accounts list` - 列出账号
+  - `python run.py accounts export/import` - 导出/导入账号
+  - `python run.py accounts add` - 交互式添加 Token
+  - `python run.py accounts scan` - 扫描本地 Token
+  - `python run.py login google/github` - 命令行登录
+  - `python run.py login remote` - 生成远程登录链接
+- **远程登录链接** - 在有浏览器的机器上完成授权，Token 自动同步
+- **账号导入导出** - 跨机器迁移账号配置
+- **手动添加 Token** - 直接粘贴 accessToken/refreshToken
+
+### v1.6.2 新功能
+- **Codex CLI 完整支持** - 使用 OpenAI Responses API (`/v1/responses`)
+  - 完整工具调用支持（shell、file 等所有工具）
+  - 图片输入支持（`input_image` 类型）
+  - 网络搜索支持（`web_search` 工具）
+  - 错误代码映射（rate_limit、context_length 等）
+- **Claude Code 增强** - 图片理解和网络搜索完整支持
+  - 支持 Anthropic 和 OpenAI 两种图片格式
+  - 支持 `web_search` / `web_search_20250305` 工具
+
+### v1.6.1 新功能
+- **请求限速** - 通过限制请求频率降低账号封禁风险
+  - 每账号最小请求间隔
+  - 每账号每分钟最大请求数
+  - 全局每分钟最大请求数
+  - WebUI 设置页面可配置
+- **账号封禁检测** - 自动检测 TEMPORARILY_SUSPENDED 错误
+  - 友好的错误日志输出
+  - 自动禁用被封禁账号
+  - 自动切换到其他可用账号
+- **统一错误处理** - 三种协议使用统一的错误分类和处理
+
+### v1.6.0 功能
+- **历史消息管理** - 4 种策略处理对话长度限制，可自由组合
+  - 自动截断：发送前优先保留最新上下文并摘要前文，必要时按数量/字符数截断
+  - 智能摘要：用 AI 生成早期对话摘要，保留关键信息
+  - 摘要缓存：历史变化不大时复用最近摘要，减少重复 LLM 调用（默认启用）
+  - 错误重试：遇到长度错误时自动截断重试（默认启用）
+  - 预估检测：预估 token 数量，超限预先截断
+- **Gemini 工具调用** - 完整支持 functionDeclarations/functionCall/functionResponse
+- **设置页面** - WebUI 新增设置标签页，可配置历史消息管理策略
+
+### v1.5.0 功能
+- **用量查询** - 查询账号配额使用情况，显示已用/余额/使用率
+- **多登录方式** - 支持 Google / GitHub / AWS Builder ID 三种登录方式
+- **流量监控** - 完整的 LLM 请求监控，支持搜索、过滤、导出
+- **浏览器选择** - 自动检测已安��浏览器，支持无痕模式
+- **文档中心** - 内置帮助文档，左侧目录 + 右侧 Markdown 渲染
+
+### v1.4.0 功能
+- **Token 预刷新** - 后台每 5 分钟检查，提前 15 分钟自动刷新
+- **健康检查** - 每 10 分钟检测账号可用性，自动标记状态
+- **请求统计增强** - 按账号/模型统计，24 小时趋势
+- **请求重试机制** - 网络错误/5xx 自动重试，指数退避
+
+## 工具调用支持
+
+| 功能 | Anthropic (Claude Code) | OpenAI (Codex CLI) | Gemini |
+|------|------------------------|-------------------|--------|
+| 工具定义 | ? `tools` | ? `tools.function` | ? `functionDeclarations` |
+| 工具调用响应 | ? `tool_use` | ? `tool_calls` | ? `functionCall` |
+| 工具结果 | ? `tool_result` | ? `tool` 角色消息 | ? `functionResponse` |
+| 强制工具调用 | ? `tool_choice` | ? `tool_choice` | ? `toolConfig.mode` |
+| 工具数量限制 | ? 50 个 | ? 50 个 | ? 50 个 |
+| 历史消息修复 | ? | ? | ? |
+| 图片理解 | ? | ? | ? |
+| 网络搜索 | ? | ? | ? |
+
+## 已知限制
+
+### 对话长度限制
+
+Kiro API 有输入长度限制。当对话历史过长时，会返回错误：
+
+```
+Input is too long. (CONTENT_LENGTH_EXCEEDS_THRESHOLD)
+```
+
+#### 自动处理（v1.6.0+）
+
+代理内置了历史消息管理功能，可在「设置」页面配置：
+
+- **错误重试**（默认）：遇到长度错误时自动截断并重试
+- **智能摘要**：用 AI 生成早期对话摘要，保留关键信息
+- **摘要缓存**（默认）：历史变化不大时复用最近摘要，减少重复 LLM 调用
+- **自动截断**：每次请求前优先保留最新上下文并摘要前文，必要时按数量/字符数截断
+- **预估检测**：预估 token 数量，超限预先截断
+
+如需 **关闭自动压缩/重试**（超限时直接报错），可设置环境变量 `KIROPROXY_HISTORY_ERROR_RETRY=0`，或将历史配置的 `strategies` 中移除 `error_retry`。
+
+摘要缓存可通过以下配置项调整（默认值）：
+- `summary_cache_enabled`: `true`
+- `summary_cache_min_delta_messages`: `3`
+- `summary_cache_min_delta_chars`: `4000`
+- `summary_cache_max_age_seconds`: `180`
+
+#### 手动处理
+
+1. 在 Claude Code 中输入 `/clear` 清空对话历史
+2. 告诉 AI 你之前在做什么，它会读取代码文件恢复上下文
 
 ## 快速开始
 
-### 本地运行
+### 方式一：下载预编译版本
+
+从 [Releases](../../releases) 下载对应平台的安装包，解压后直接运行。
+
+### 方式二：从源码运行
 
 ```bash
 # 克隆项目
-git clone <repository-url>
-cd KiroProxy
+git clone https://github.com/yourname/kiro-proxy.git
+cd kiro-proxy
+
+# 创建虚拟环境
+python -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
 
 # 安装依赖
 pip install -r requirements.txt
 
-# 启动服务
-python run.py 8080
+# 运行
+python run.py
+
+# 或指定端口
+python run.py 8081
 ```
 
-### Docker 部署
+启动后访问 http://localhost:8080
+
+### 命令行工具 (CLI)
+
+无 GUI 服务器可使用 CLI 管理账号：
 
 ```bash
-# 构建镜像
-docker build -t kiroproxy .
+# 账号管理
+python run.py accounts list              # 列出账号
+python run.py accounts export -o acc.json  # 导出账号
+python run.py accounts import acc.json   # 导入账号
+python run.py accounts add               # 交互式添加 Token
+python run.py accounts scan --auto       # 扫描并自动添加本地 Token
+
+# 登录
+python run.py login google               # Google 登录
+python run.py login github               # GitHub 登录
+python run.py login remote --host myserver.com:8080  # 生成远程登录链接
+
+# 服务
+python run.py serve                      # 启动服务 (默认 8080)
+python run.py serve -p 8081              # 指定端口
+python run.py status                     # 查看状态
+```
+
+### 登录获取 Token
+
+**方式一：在线登录（推荐）**
+1. 打开 Web UI，点击「在线登录」
+2. 选择登录方式：Google / GitHub / AWS Builder ID
+3. 在浏览器中完成授权
+4. 账号自动添加
+
+**方式二：扫描 Token**
+1. 打开 Kiro IDE，使用 Google/GitHub 账号登录
+2. 登录成功后 token 自动保存到 `~/.aws/sso/cache/`
+3. 在 Web UI 点击「扫描 Token」添加账号
+
+## CLI 配置
+
+### 模型对照表
+
+| Kiro 模型 | 能力 | Claude Code | Codex |
+|-----------|------|-------------|-------|
+| `claude-sonnet-4` | ??? 推荐 | `claude-sonnet-4` | `gpt-4o` |
+| `claude-sonnet-4.5` | ???? 更强 | `claude-sonnet-4.5` | `gpt-4o` |
+| `claude-haiku-4.5` | ? 快速 | `claude-haiku-4.5` | `gpt-4o-mini` |
+
+### Claude Code 配置
 
-# 运行容器
-docker run -p 7860:7860 \
-  -e ADMIN_PASSWORD=your_password \
-  -e DATABASE_URL=postgresql://user:pass@host:5432/db \
-  kiroproxy
+```
+名称: Kiro Proxy
+API Key: any
+Base URL: http://localhost:8080
+模型: claude-sonnet-4
 ```
 
-### Hugging Face Space 部署
+### Codex 配置
 
-1. Fork 此项目到你的 Hugging Face Space
-2. 在 Space 设置中配置环境��量：
-   - `ADMIN_PASSWORD`: 管理员密码
-   - `DATABASE_URL`: 远程数据库连接（可选）
-3. Space 将自动构建和部署
+Codex CLI 使用 OpenAI Responses API，配置如下：
 
-## 环境变量配置
+```bash
+# 设置环境变量
+export OPENAI_API_KEY=any
+export OPENAI_BASE_URL=http://localhost:8080/v1
 
-参考 `.env.example` 文件了解所有可用的环境变量配置选项。
+# 运行 Codex
+codex
+```
 
-### 核心配置
+或在 `~/.codex/config.toml` 中配置：
 
-- `ADMIN_PASSWORD`: 管理员面板密码（强烈推荐设置）
-- `DATABASE_URL`: 数据库连接URL（可选，支持PostgreSQL/MySQL/SQLite）
-- `PORT`: 服务器端口（默认：8080，Hugging Face Space使用7860）
+```toml
+[providers.openai]
+api_key = "any"
+base_url = "http://localhost:8080/v1"
+```
 
-## 管理员面板
+## 思考功能支持
 
-访问 `http://localhost:8080` 进入管理界面。
+### 什么是思考功能
 
-首次启动时：
-- 如果设置了 `ADMIN_PASSWORD` 环境变量，使用该密码登录
-- 如果未设置，系统会自动生成随机密码并在启动日志中显示
+思考功能（Extended Thinking）允许 Claude 在生成回答前展示其思考过程，帮助用户理解 AI 的推理步骤。
 
-## 数据存储
+### 如何使用
 
-### 文件系统存储（默认）
-- 配置存储在 `~/.kiro-proxy/` 目录
-- 适合本地开发和小规模部署
+在请求中添加 `thinking`（或对应协议的 thinking 配置）即可启用：
 
-### 远程数据库存储
-- 支持 PostgreSQL、MySQL、SQLite
-- 适合生产环境和多实例部署
-- 通过 `DATABASE_URL` 环境变量配置
+```json
+{
+  "model": "claude-sonnet-4.5",
+  "messages": [
+    {
+      "role": "user",
+      "content": "解释一下量子计算的原理"
+    }
+  ],
+  "thinking": {
+    "thinking_type": "enabled",
+    "budget_tokens": 20000
+  },
+  "stream": true
+}
+```
 
-## API 协议支持
+OpenAI Chat Completions (`POST /v1/chat/completions`) 也支持：
 
-### OpenAI 兼容
+```json
+{
+  "model": "gpt-4o",
+  "messages": [{"role": "user", "content": "解释一下量子计算的原理"}],
+  "thinking": { "type": "enabled" },
+  "stream": true
+}
 ```
-POST /v1/chat/completions
+
+OpenAI Responses (`POST /v1/responses`) 也支持：
+
+```json
+{
+  "model": "gpt-4o",
+  "input": "解释一下量子计算的原理",
+  "thinking": { "type": "enabled" }
+}
 ```
 
-### Anthropic 兼容
+Gemini generateContent (`POST /v1/models/{model}:generateContent`) 也支持：
+
+```json
+{
+  "contents": [{"role": "user", "parts": [{"text": "解释一下量子计算的原理"}]}],
+  "generationConfig": {
+    "thinkingConfig": { "includeThoughts": true }
+  }
+}
 ```
-POST /v1/messages
+
+### 参数说明
+
+- `thinking_type`: 思考类型，设为 `"enabled"` 启用思考功能
+- `budget_tokens`: 思考过程的 token 预算（不传则视为无限制）
+
+### 响应格式
+
+启用思考功能后，流式响应会包含两种内容块：
+
+1. **思考块**（type: "thinking"）：展示 AI 的思考过程
+2. **文本块**（type: "text"）：最终的回答内容
+
+示例响应：
+```
+data: {"type":"content_block_start","index":1,"content_block":{"type":"thinking","thinking":""}}
+data: {"type":"content_block_delta","index":1,"delta":{"type":"thinking_delta","thinking":"让我思考一下量子计算的原理..."}}
+data: {"type":"content_block_stop","index":1}
+data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}
+data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"量子计算是一种..."}}
+data: {"type":"content_block_stop","index":0}
 ```
 
-### Gemini 兼容
+## API 端点
+
+| 协议 | 端点 | 用途 |
+|------|------|------|
+| OpenAI | `POST /v1/chat/completions` | Chat Completions API |
+| OpenAI | `POST /v1/responses` | Responses API (Codex CLI) |
+| OpenAI | `GET /v1/models` | 模型列表 |
+| Anthropic | `POST /v1/messages` | Claude Code |
+| Anthropic | `POST /v1/messages/count_tokens` | Token 计数 |
+| Gemini | `POST /v1/models/{model}:generateContent` | Gemini CLI |
+
+### 管理 API
+
+| 端点 | 方法 | 说明 |
+|------|------|------|
+| `/api/accounts` | GET | 获取所有账号状态 |
+| `/api/accounts/{id}` | GET | 获取账号详情 |
+| `/api/accounts/{id}/usage` | GET | 获取账号用量信息 |
+| `/api/accounts/{id}/refresh` | POST | 刷新账号 Token |
+| `/api/accounts/{id}/restore` | POST | 恢复账号（从冷却状态） |
+| `/api/accounts/refresh-all` | POST | 刷新所有即将过期的 Token |
+| `/api/flows` | GET | 获取流量记录 |
+| `/api/flows/stats` | GET | 获取流量统计 |
+| `/api/flows/{id}` | GET | 获取流量详情 |
+| `/api/quota` | GET | 获取配额状态 |
+| `/api/stats` | GET | 获取统计信息 |
+| `/api/health-check` | POST | 手动触发健康检查 |
+| `/api/browsers` | GET | 获取可用浏览器列表 |
+| `/api/docs` | GET | 获取文档列表 |
+| `/api/docs/{id}` | GET | 获取文档内容 |
+
+## 项目结构
+
+```
+.
+├── run.py
+├── build.py
+├── pyproject.toml
+├── requirements.txt
+├── kiro_proxy/
+│   ├── main.py                    # FastAPI 应用入口
+│   ├── config.py                  # 全局配置
+│   ├── converters/                # 协议转换
+│   ├── core/                      # 核心模块
+│   ├── credential/                # 凭证管理
+│   ├── auth/                      # 认证模块
+│   ├── handlers/                  # API 处理器
+│   │   ├── anthropic/             # /v1/messages
+│   │   ├── admin/                 # 管理 API
+│   │   ├── openai.py              # /v1/chat/completions
+│   │   ├── responses.py           # /v1/responses (Codex CLI)
+│   │   └── gemini.py              # /v1/models/{model}:generateContent
+│   ├── routers/                   # 路由层
+│   ├── web/                       # Web UI
+│   └── docs/                      # 内置文档
+├── assets/                        # 资源文件
+├── legacy/                        # 兼容旧入口
+├── scripts/                       # 辅助脚本
+├── examples/                      # 示例
+└── tests/                         # 测试
 ```
-POST /v1beta/models/{model}:generateContent
+
+## 构建
+
+```bash
+# 安装构建依赖
+pip install pyinstaller
+
+# 构建
+python build.py
 ```
 
-## 许可证
+输出文件在 `dist/` 目录。
 
-MIT License
+## 免责声明
 
-## 贡献
+本项目仅供学习研究，禁止商用。使用本项目产生的任何后果由使用者自行承担，与作者无关。
 
-欢迎提交 Issue 和 Pull Request！
+本项目与 Kiro / AWS / Anthropic 官方无关。

README_HF.md

@@ -1,9 +0,0 @@
-title: KiroProxy
-emoji: 🚀
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
-license: mit
-short_description: Kiro IDE API 反向代理服务器 - 支持多账号管理和多协议转换
-app_port: 7860