Initial deployment

.gitattributes

@@ -0,0 +1,38 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+*.png filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.ico filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,50 @@
+# Hugging Face Spaces Docker 部署文件
+# 使用官方Node.js运行时作为基础镜像
+FROM node:20-alpine
+
+# 设置标签
+LABEL maintainer="AIClient2API Team"
+LABEL description="Docker image for AIClient2API server on Hugging Face Spaces"
+
+# 安装必要的系统工具
+RUN apk add --no-cache tar git
+
+# 创建非 root 用户 (HF Spaces 要求)
+RUN adduser -D -u 1000 appuser
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制package.json和package-lock.json
+COPY package*.json ./
+
+# 安装依赖
+RUN npm install --omit=dev
+
+# 复制源代码
+COPY . .
+
+# 创建配置和日志目录，并设置权限
+RUN mkdir -p /app/configs /app/logs && \
+    chown -R appuser:appuser /app
+
+# 复制示例配置文件
+RUN cp -n configs/config.json.example configs/config.json 2>/dev/null || true
+
+# 切换到非 root 用户
+USER appuser
+
+# HF Spaces 默认端口是 7860，但我们的应用使用 3000
+# 通过环境变量设置端口
+ENV SERVER_PORT=7860
+ENV HOST=0.0.0.0
+
+# 暴露端口
+EXPOSE 7860
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
+  CMD node healthcheck.js || exit 1
+
+# 启动命令
+CMD ["node", "src/core/master.js"]

README.md

@@ -0,0 +1,29 @@
+---
+title: AIClient-2-API
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: gpl-3.0
+app_port: 7860
+---
+
+# AIClient-2-API
+
+一个能将多种仅客户端内使用的大模型 API（Gemini CLI, Antigravity, Qwen Code, Kiro ...），模拟请求，统一封装为本地 OpenAI 兼容接口的强大代理。
+
+## 使用说明
+
+1. 访问 Web UI 管理界面添加账号配置
+2. 使用 OpenAI 兼容的 API 格式调用
+
+## API 端点
+
+- `POST /v1/chat/completions` - 聊天补全
+- `GET /v1/models` - 获取可用模型列表
+- `GET /health` - 健康检查
+
+## 更多信息
+
+请访问 [GitHub 仓库](https://github.com/justlovemaki/AIClient-2-API) 了解详情。

configs/antigravity/1769225597642_oauth_creds.json

@@ -0,0 +1,7 @@
+{
+  "access_token": "ya29.a0AUMWg_JeH7Sv6jyaowhfmL3G840d-BfpsSzcO9d0kQTqOZdqKs8yDWOXaOMD6XuinSd3wzqFyMGWRtC2r1NlbvgwsDQ9sJ2xeKx-35-L8b6EhCx5NNJELmb4MFhGutyzQPFRdH8Icu7cvuxe52n21wKnXyHjWFn2EAYC7wHe1vA6LVY_GVGYA6vK8O4_UuZC1KOwPgs8eHzFaCgYKAQESARISFQHGX2MiUZVn11HuBiwd-y9Dmt85lQ0211",
+  "refresh_token": "1//0gj4nApJu9H2rCgYIARAAGBASNwF-L9IrGmrKt0QPaeJhTTnQwB11ay7Rj_IAyxPhqaGnLTI11NUw6UslAjLIBKT5W6BqqeR0a3Y",
+  "scope": "https://www.googleapis.com/auth/cloud-platform",
+  "token_type": "Bearer",
+  "expiry_date": 1769229196641
+}

configs/antigravity/1769225702945_oauth_creds.json

@@ -0,0 +1,7 @@
+{
+  "access_token": "ya29.a0AUMWg_LXsfEby-mp2js055q9ETPYyIQGsppOEbUBRRZnQWppHGiCbNDedtkBzyS95N82H-gwxD90kpJ5bIdC7VBCKlEGGDIjIFtKFdgIpmu1MnJoNr5RcpVdGHrSmPqYl5L4pAYYYw00nPvdqsTIJaQK0CKXjygwYcFf7O1AlN4cesr9Ak3WJKwu3ATnXzvPXJJ38vBMOmC5aCgYKAbsSARESFQHGX2MiML_vy6uw9_otVEWp2pr-Ow0211",
+  "refresh_token": "1//0ghNIZ9aGEjWwCgYIARAAGBASNwF-L9Irxv1fzCbtzjydvELuh_QDHVueFa6oY4MPucSC7xTtF4LACk1uxCdPe8jwnb7nieyKfe0",
+  "scope": "https://www.googleapis.com/auth/cloud-platform",
+  "token_type": "Bearer",
+  "expiry_date": 1769229301944
+}

configs/antigravity/1769225782003_oauth_creds.json

@@ -0,0 +1,7 @@
+{
+  "access_token": "ya29.a0AUMWg_JTJ4UYXpcfxExjKbQiz7bdJ5aMYSfCxA2kl6O6sRr4w0f6xBoJXLLqTTpgP3vexEGHx1T1l_pv4ScXK6le4YWCROPLDm8MFUywrU_jyCesCyOme_zHzDxKEmnM2wisJ7RZshkCB4spBmyXMVSQ1XKQfYa1vRAyeQJeJF8waMmeeWM0q5kUVPR51YQxPXyCZfniNUDyaCgYKAQ4SARISFQHGX2Mi4qcpxyBXBYIt-iKhPzULlQ0211",
+  "refresh_token": "1//0g73AXXq_01hqCgYIARAAGBASNwF-L9IrWfZjVzvqMx9Rm9ypo5sgoJo5gLBcMvtNXe5osvrPr7MGwoFxVMxpvWacLgGnxnCb5t8",
+  "scope": "https://www.googleapis.com/auth/cloud-platform",
+  "token_type": "Bearer",
+  "expiry_date": 1769229381002
+}

configs/antigravity/1769225856991_oauth_creds.json

@@ -0,0 +1,7 @@
+{
+  "access_token": "ya29.a0AUMWg_J7HQtBbdg7GIbJwmcjmjPe1Z8Y5i_0IrDNCapapEYy077JrTKv86VbkoIyllhvYAKnt1ZeOX0J0xWxNZhhLZjHLd0Cj_rvOFCZS1SX7jsy3NqGIfIVBqcM_j1bjAD0wTDDy5Q9qFWb7Pm4bRW2kuaB7-WdzVfu3BDbkHpHTpi7KSOMP559W51T9n49U2eUMi0AxO30aCgYKAUUSARISFQHGX2MiBiD7jtM3Anr43U6tdOXDxw0211",
+  "refresh_token": "1//0g2AXkvBZIr3-CgYIARAAGBASNwF-L9IrJPSLuDBTntjzQr9w86JXInpqbZ9uobXGamOmeZ5sb0IaCpftz3cN03Gn6ZxYLj2hVls",
+  "scope": "https://www.googleapis.com/auth/cloud-platform",
+  "token_type": "Bearer",
+  "expiry_date": 1769229455991
+}

configs/api-potluck-data.json

@@ -0,0 +1,4 @@
+{
+  "config": {},
+  "users": {}
+}

configs/api-potluck-data.json.example

@@ -0,0 +1,29 @@
+{
+  "config": {
+    "defaultDailyLimit": 500,
+    "bonusPerCredential": 300,
+    "bonusValidityDays": 30,
+    "persistInterval": 5000
+  },
+  "users": {
+    "maki_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx": {
+      "credentials": [
+        {
+          "id": "cred_0000000000000_xxxxxx",
+          "path": "configs/kiro/example_kiro-auth-token/example_kiro-auth-token.json",
+          "provider": "claude-kiro-oauth",
+          "authMethod": "refresh-token",
+          "addedAt": "2026-01-01T00:00:00.000Z"
+        }
+      ],
+      "credentialBonuses": [
+        {
+          "credentialId": "cred_0000000000000_xxxxxx",
+          "grantedAt": "2026-01-01T00:00:00.000Z",
+          "usedCount": 0
+        }
+      ],
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    }
+  }
+}

configs/api-potluck-keys.json.example

@@ -0,0 +1,16 @@
+{
+  "keys": {
+    "maki_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx": {
+      "id": "maki_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+      "name": "示例用户",
+      "createdAt": "2026-01-01T00:00:00.000Z",
+      "dailyLimit": 500,
+      "todayUsage": 0,
+      "totalUsage": 0,
+      "lastResetDate": "2026-01-01",
+      "lastUsedAt": null,
+      "enabled": true,
+      "bonusRemaining": 0
+    }
+  }
+}

configs/config.json

@@ -0,0 +1,25 @@
+{
+  "REQUIRED_API_KEY": "123456",
+  "SERVER_PORT": 3000,
+  "HOST": "0.0.0.0",
+  "MODEL_PROVIDER": "gemini-antigravity",
+  "SYSTEM_PROMPT_FILE_PATH": "configs/input_system_prompt.txt",
+  "SYSTEM_PROMPT_MODE": "append",
+  "PROMPT_LOG_BASE_NAME": "prompt_log",
+  "PROMPT_LOG_MODE": "none",
+  "REQUEST_MAX_RETRIES": 3,
+  "REQUEST_BASE_DELAY": 1000,
+  "CREDENTIAL_SWITCH_MAX_RETRIES": 5,
+  "CRON_NEAR_MINUTES": 15,
+  "CRON_REFRESH_TOKEN": false,
+  "PROVIDER_POOLS_FILE_PATH": "configs/provider_pools.json",
+  "MAX_ERROR_COUNT": 10,
+  "WARMUP_TARGET": 0,
+  "REFRESH_CONCURRENCY_PER_PROVIDER": 1,
+  "providerFallbackChain": {},
+  "modelFallbackMapping": {},
+  "PROXY_URL": null,
+  "PROXY_ENABLED_PROVIDERS": [
+    "gemini-antigravity"
+  ]
+}

configs/config.json.example

@@ -0,0 +1,49 @@
+{
+    "REQUIRED_API_KEY": "123456",
+    "SERVER_PORT": 3000,
+    "HOST": "0.0.0.0",
+    "MODEL_PROVIDER": "gemini-cli-oauth",
+    "SYSTEM_PROMPT_FILE_PATH": "configs/input_system_prompt.txt",
+    "SYSTEM_PROMPT_MODE": "overwrite",
+    "PROMPT_LOG_BASE_NAME": "prompt_log",
+    "PROMPT_LOG_MODE": "none",
+    "REQUEST_MAX_RETRIES": 3,
+    "REQUEST_BASE_DELAY": 1000,
+    "CRON_NEAR_MINUTES": 1,
+    "CRON_REFRESH_TOKEN": false,
+    "PROVIDER_POOLS_FILE_PATH": "configs/provider_pools.json",
+    "MAX_ERROR_COUNT": 3,
+    "providerFallbackChain": {
+      "gemini-cli-oauth": ["gemini-antigravity"],
+      "gemini-antigravity": ["gemini-cli-oauth"],
+      "claude-kiro-oauth": ["claude-custom"],
+      "claude-custom": ["claude-kiro-oauth"]
+    },
+    "modelFallbackMapping": {
+      "gemini-claude-opus-4-5-thinking": {
+        "targetProviderType": "claude-kiro-oauth",
+        "targetModel": "claude-opus-4-5"
+      },
+      "gemini-claude-sonnet-4-5-thinking": {
+        "targetProviderType": "claude-kiro-oauth", 
+        "targetModel": "claude-sonnet-4-5"
+      },
+      "gemini-claude-sonnet-4-5": {
+        "targetProviderType": "claude-kiro-oauth",
+        "targetModel": "claude-sonnet-4-5"
+      },
+      "claude-opus-4-5": {
+        "targetProviderType": "gemini-antigravity",
+        "targetModel": "gemini-claude-opus-4-5-thinking"
+      },
+      "claude-sonnet-4-5": {
+        "targetProviderType": "gemini-antigravity",
+        "targetModel": "gemini-claude-sonnet-4-5"
+      }
+    },
+    "PROXY_URL": "http://127.0.0.1:1089",
+    "PROXY_ENABLED_PROVIDERS": [
+      "gemini-cli-oauth",
+      "gemini-antigravity"
+    ]
+  }

configs/gemini/1769225674911_oauth_creds.json

@@ -0,0 +1,7 @@
+{
+  "access_token": "ya29.a0AUMWg_KAYGG-Hw_Py9KPKou7c2DOpA8nMONO0A4qnL4L8N9RsPLgAcTbZmzdWuU0Y-WvnSvqeKsn7Sd1n4Fj22-lhGXL87HVCBcheb0nbe8J_dnxIEHAshlh5bg6SJvRC83h6t2RxiPbQrkWMPT98gDTjxs_BjJHTdnU5evV6AbWXjraOWUZeW5k-dhiJOz0UxXfx7UGzeE8aCgYKAYQSARESFQHGX2Mi2hHBN1sDCU3BCQNUUnr47w0211",
+  "refresh_token": "1//0gULsM_b1IjcqCgYIARAAGBASNwF-L9IrR_jh9j1sxZ3JJqAq097QqO6ny5EJZ3NxUUh32uznBcaGYIu0Azpm-4vCxWs--fSOtEE",
+  "scope": "https://www.googleapis.com/auth/cloud-platform",
+  "token_type": "Bearer",
+  "expiry_date": 1769229273910
+}

configs/plugins.json

@@ -0,0 +1,12 @@
+{
+  "plugins": {
+    "api-potluck": {
+      "enabled": true,
+      "description": "API 大锅饭 - Key 管理和用量统计插件<br>管理端：<a href=\"potluck.html\" target=\"_blank\">potluck.html</a><br>用户端：<a href=\"potluck-user.html\" target=\"_blank\">potluck-user.html</a>"
+    },
+    "default-auth": {
+      "enabled": true,
+      "description": "默认 API Key 认证插件"
+    }
+  }
+}

configs/plugins.json.example

@@ -0,0 +1,12 @@
+{
+  "plugins": {
+    "api-potluck": {
+      "enabled": true,
+      "description": "API 大锅饭 - Key 管理和用量统计插件"
+    },
+    "default-auth": {
+      "enabled": true,
+      "description": "默认 API Key 认证插件（内置）"
+    }
+  }
+}

configs/provider_pools.json

@@ -0,0 +1,90 @@
+{
+  "claude-kiro-oauth": [],
+  "openai-qwen-oauth": [],
+  "openai-iflow": [],
+  "openai-codex-oauth": [],
+  "gemini-cli-oauth": [
+    {
+      "GEMINI_OAUTH_CREDS_FILE_PATH": "configs/gemini/1769225674911_oauth_creds.json",
+      "uuid": "8cb833b9-8533-4ea8-930f-46a272129bcc",
+      "checkModelName": "gemini-2.5-flash",
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null,
+      "lastHealthCheckTime": null,
+      "lastHealthCheckModel": null,
+      "lastErrorMessage": null,
+      "PROJECT_ID": ""
+    }
+  ],
+  "gemini-antigravity": [
+    {
+      "ANTIGRAVITY_OAUTH_CREDS_FILE_PATH": "configs/antigravity/1769225597642_oauth_creds.json",
+      "uuid": "7caa7971-7fb4-4466-bc64-b1bbaa3dc5d0",
+      "checkModelName": "gemini-2.5-computer-use-preview-10-2025",
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null,
+      "lastHealthCheckTime": null,
+      "lastHealthCheckModel": null,
+      "lastErrorMessage": null,
+      "PROJECT_ID": ""
+    },
+    {
+      "ANTIGRAVITY_OAUTH_CREDS_FILE_PATH": "configs/antigravity/1769225702945_oauth_creds.json",
+      "uuid": "74a34d43-2e2d-47a1-ae04-f7956f4eac32",
+      "checkModelName": "gemini-2.5-computer-use-preview-10-2025",
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null,
+      "lastHealthCheckTime": null,
+      "lastHealthCheckModel": null,
+      "lastErrorMessage": null,
+      "PROJECT_ID": ""
+    },
+    {
+      "ANTIGRAVITY_OAUTH_CREDS_FILE_PATH": "configs/antigravity/1769225782003_oauth_creds.json",
+      "uuid": "2dc29208-0047-442a-a810-fd9af1290875",
+      "checkModelName": "gemini-2.5-computer-use-preview-10-2025",
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null,
+      "lastHealthCheckTime": null,
+      "lastHealthCheckModel": null,
+      "lastErrorMessage": null,
+      "PROJECT_ID": ""
+    },
+    {
+      "ANTIGRAVITY_OAUTH_CREDS_FILE_PATH": "configs/antigravity/1769225856991_oauth_creds.json",
+      "uuid": "6d7301c2-da5c-491c-8fb9-e822ec781bb8",
+      "checkModelName": "gemini-2.5-computer-use-preview-10-2025",
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null,
+      "lastHealthCheckTime": null,
+      "lastHealthCheckModel": null,
+      "lastErrorMessage": null,
+      "PROJECT_ID": ""
+    }
+  ]
+}

configs/provider_pools.json.example

@@ -0,0 +1,213 @@
+{
+  "openai-custom": [
+    {
+      "customName": "OpenAI节点1",
+      "OPENAI_API_KEY": "sk-openai-key1",
+      "OPENAI_BASE_URL": "https://api.openai.com/v1",
+      "checkModelName": null,
+      "checkHealth": false,
+      "notSupportedModels": ["gpt-4-turbo"],
+      "uuid": "2f579c65-d3c5-41b1-9985-9f6e3d7bf39c",
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    },
+    {
+      "customName": "OpenAI节点2",
+      "OPENAI_API_KEY": "sk-openai-key2",
+      "OPENAI_BASE_URL": "https://api.openai.com/v1",
+      "checkModelName": null,
+      "checkHealth": false,
+      "notSupportedModels": ["gpt-4-turbo", "gpt-4"],
+      "uuid": "e284628d-302f-456d-91f3-6095386fb3b8",
+      "isHealthy": true,
+      "isDisabled": true,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    }
+  ],
+  "openaiResponses-custom": [
+    {
+      "customName": "OpenAI Responses节点",
+      "OPENAI_API_KEY": "sk-openai-key",
+      "OPENAI_BASE_URL": "https://api.openai.com/v1",
+      "checkModelName": null,
+      "checkHealth": false,
+      "uuid": "e284628d-302f-456d-91f3-609538678968",
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    }
+  ],
+  "gemini-cli-oauth": [
+    {
+      "customName": "Gemini OAuth节点1",
+      "GEMINI_OAUTH_CREDS_FILE_PATH": "./credentials1.json",
+      "PROJECT_ID": "your-project-id-1",
+      "checkModelName": null,
+      "checkHealth": false,
+      "uuid": "ac200154-26b8-4f5f-8650-e8cc738b06e3",
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    },
+    {
+      "customName": "Gemini OAuth节点2",
+      "GEMINI_OAUTH_CREDS_FILE_PATH": "./credentials2.json",
+      "PROJECT_ID": "your-project-id-2",
+      "checkModelName": null,
+      "checkHealth": false,
+      "uuid": "4f8afcc2-a9bb-4b96-bb50-3b9667a71f54",
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    }
+  ],
+  "claude-custom": [
+    {
+      "customName": "Claude节点1",
+      "CLAUDE_API_KEY": "sk-claude-key1",
+      "CLAUDE_BASE_URL": "https://api.anthropic.com",
+      "checkModelName": null,
+      "checkHealth": false,
+      "uuid": "bb87047a-3b1d-4249-adbb-1087ecd58128",
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    },
+    {
+      "customName": "Claude节点2",
+      "CLAUDE_API_KEY": "sk-claude-key2",
+      "CLAUDE_BASE_URL": "https://api.anthropic.com",
+      "checkModelName": null,
+      "checkHealth": false,
+      "uuid": "7c2002c6-122a-4db0-af06-8a0ff433801a",
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    }
+  ],
+  "claude-kiro-oauth": [
+    {
+      "customName": "Kiro OAuth节点1",
+      "KIRO_OAUTH_CREDS_FILE_PATH": "./kiro_creds1.json",
+      "uuid": "2c69d0ac-b86f-43d8-9d17-0d300afc5cfd",
+      "checkModelName": null,
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    },
+    {
+      "customName": "Kiro OAuth节点2",
+      "KIRO_OAUTH_CREDS_FILE_PATH": "./kiro_creds2.json",
+      "uuid": "7482abe6-8083-4288-bb7d-d8ecb7c461e2",
+      "checkModelName": null,
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    }
+  ],
+  "openai-qwen-oauth": [
+    {
+      "customName": "Qwen OAuth节点",
+      "QWEN_OAUTH_CREDS_FILE_PATH": "./qwen_creds.json",
+      "uuid": "658a2114-c4c9-d713-b8d4-ceabf0e0bf18",
+      "checkModelName": null,
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    }
+  ],
+  "gemini-antigravity": [
+    {
+      "customName": "Antigravity节点1",
+      "ANTIGRAVITY_OAUTH_CREDS_FILE_PATH": "./antigravity_creds1.json",
+      "PROJECT_ID": "antigravity-project-1",
+      "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+      "checkModelName": null,
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    },
+    {
+      "customName": "Antigravity节点2",
+      "ANTIGRAVITY_OAUTH_CREDS_FILE_PATH": "./antigravity_creds2.json",
+      "PROJECT_ID": "antigravity-project-2",
+      "uuid": "f0e9d8c7-b6a5-4321-fedc-ba9876543210",
+      "checkModelName": null,
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    }
+  ],
+  "openai-iflow": [
+    {
+      "customName": "iFlow Token节点1",
+      "IFLOW_TOKEN_FILE_PATH": "./configs/iflow/iflow_token.json",
+      "IFLOW_BASE_URL": "https://apis.iflow.cn/v1",
+      "uuid": "11223344-5566-7788-99aa-bbccddeeff00",
+      "checkModelName": "gpt-4o",
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    },
+    {
+      "customName": "iFlow Token节点2",
+      "IFLOW_TOKEN_FILE_PATH": "./configs/iflow/iflow_token2.json",
+      "IFLOW_BASE_URL": "https://apis.iflow.cn/v1",
+      "uuid": "aabbccdd-eeff-0011-2233-445566778899",
+      "checkModelName": "gpt-4o",
+      "checkHealth": false,
+      "isHealthy": true,
+      "isDisabled": false,
+      "lastUsed": null,
+      "usageCount": 0,
+      "errorCount": 0,
+      "lastErrorTime": null
+    }
+  ]
+}

configs/pwd

@@ -0,0 +1 @@
+admin123

configs/token-store.json

@@ -0,0 +1,9 @@
+{
+  "tokens": {
+    "59fe6fdb91e45d1710d8cd190246064ed3a8c87e6a4b7fe8b29e8c20b251a29d": {
+      "username": "admin",
+      "loginTime": 1769225324808,
+      "expiryTime": 1769228924808
+    }
+  }
+}

configs/usage-cache.json

@@ -0,0 +1,907 @@
+{
+  "timestamp": "2026-01-24T03:38:30.804Z",
+  "providers": {
+    "claude-kiro-oauth": {
+      "providerType": "claude-kiro-oauth",
+      "instances": [],
+      "totalCount": 0,
+      "successCount": 0,
+      "errorCount": 0
+    },
+    "gemini-cli-oauth": {
+      "providerType": "gemini-cli-oauth",
+      "instances": [
+        {
+          "uuid": "8cb833b9-8533-4ea8-930f-46a272129bcc",
+          "name": "8cb833b9-8533-4ea8-930f-46a272129bcc",
+          "isHealthy": true,
+          "isDisabled": false,
+          "success": true,
+          "usage": {
+            "daysUntilReset": null,
+            "nextDateReset": null,
+            "subscription": {
+              "title": "Gemini CLI OAuth",
+              "type": "gemini-cli-oauth",
+              "upgradeCapability": null,
+              "overageCapability": null
+            },
+            "user": {
+              "email": null,
+              "userId": null
+            },
+            "usageBreakdown": [
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-2.5-flash",
+                "displayNamePlural": "gemini-2.5-flash",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-25T03:38:34.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-2.5-flash",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 19:38",
+                "resetTimeRaw": "2026-01-25T03:38:34Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-2.5-flash-lite",
+                "displayNamePlural": "gemini-2.5-flash-lite",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-25T03:38:34.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-2.5-flash-lite",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 19:38",
+                "resetTimeRaw": "2026-01-25T03:38:34Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-2.5-pro",
+                "displayNamePlural": "gemini-2.5-pro",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-25T03:38:34.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-2.5-pro",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 19:38",
+                "resetTimeRaw": "2026-01-25T03:38:34Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-flash-preview",
+                "displayNamePlural": "gemini-3-flash-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-25T03:38:34.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-flash-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 19:38",
+                "resetTimeRaw": "2026-01-25T03:38:34Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-pro-preview",
+                "displayNamePlural": "gemini-3-pro-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-25T03:38:34.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-pro-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 19:38",
+                "resetTimeRaw": "2026-01-25T03:38:34Z"
+              }
+            ]
+          },
+          "error": null
+        }
+      ],
+      "totalCount": 1,
+      "successCount": 1,
+      "errorCount": 0
+    },
+    "gemini-antigravity": {
+      "providerType": "gemini-antigravity",
+      "instances": [
+        {
+          "uuid": "7caa7971-7fb4-4466-bc64-b1bbaa3dc5d0",
+          "name": "7caa7971-7fb4-4466-bc64-b1bbaa3dc5d0",
+          "isHealthy": true,
+          "isDisabled": false,
+          "success": true,
+          "usage": {
+            "daysUntilReset": null,
+            "nextDateReset": null,
+            "subscription": {
+              "title": "Gemini Antigravity",
+              "type": "gemini-antigravity",
+              "upgradeCapability": null,
+              "overageCapability": null
+            },
+            "user": {
+              "email": null,
+              "userId": null
+            },
+            "usageBreakdown": [
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-2.5-flash-preview",
+                "displayNamePlural": "gemini-2.5-flash-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:42.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-2.5-flash-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:42Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-flash-preview",
+                "displayNamePlural": "gemini-3-flash-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:42.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-flash-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:42Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-pro-image-preview",
+                "displayNamePlural": "gemini-3-pro-image-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:42.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-pro-image-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:42Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-pro-preview",
+                "displayNamePlural": "gemini-3-pro-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:42.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-pro-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:42Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-opus-4-5-thinking",
+                "displayNamePlural": "gemini-claude-opus-4-5-thinking",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:42.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-opus-4-5-thinking",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:42Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-sonnet-4-5",
+                "displayNamePlural": "gemini-claude-sonnet-4-5",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:42.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-sonnet-4-5",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:42Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-sonnet-4-5-thinking",
+                "displayNamePlural": "gemini-claude-sonnet-4-5-thinking",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:42.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-sonnet-4-5-thinking",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:42Z"
+              }
+            ]
+          },
+          "error": null
+        },
+        {
+          "uuid": "74a34d43-2e2d-47a1-ae04-f7956f4eac32",
+          "name": "74a34d43-2e2d-47a1-ae04-f7956f4eac32",
+          "isHealthy": true,
+          "isDisabled": false,
+          "success": true,
+          "usage": {
+            "daysUntilReset": null,
+            "nextDateReset": null,
+            "subscription": {
+              "title": "Gemini Antigravity",
+              "type": "gemini-antigravity",
+              "upgradeCapability": null,
+              "overageCapability": null
+            },
+            "user": {
+              "email": null,
+              "userId": null
+            },
+            "usageBreakdown": [
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-2.5-flash-preview",
+                "displayNamePlural": "gemini-2.5-flash-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:45.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-2.5-flash-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:45Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-flash-preview",
+                "displayNamePlural": "gemini-3-flash-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:45.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-flash-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:45Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-pro-image-preview",
+                "displayNamePlural": "gemini-3-pro-image-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:45.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-pro-image-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:45Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-pro-preview",
+                "displayNamePlural": "gemini-3-pro-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:45.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-pro-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:45Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-opus-4-5-thinking",
+                "displayNamePlural": "gemini-claude-opus-4-5-thinking",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:27:27.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-opus-4-5-thinking",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:27",
+                "resetTimeRaw": "2026-01-24T08:27:27Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-sonnet-4-5",
+                "displayNamePlural": "gemini-claude-sonnet-4-5",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:27:27.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-sonnet-4-5",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:27",
+                "resetTimeRaw": "2026-01-24T08:27:27Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-sonnet-4-5-thinking",
+                "displayNamePlural": "gemini-claude-sonnet-4-5-thinking",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:27:27.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-sonnet-4-5-thinking",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:27",
+                "resetTimeRaw": "2026-01-24T08:27:27Z"
+              }
+            ]
+          },
+          "error": null
+        },
+        {
+          "uuid": "2dc29208-0047-442a-a810-fd9af1290875",
+          "name": "2dc29208-0047-442a-a810-fd9af1290875",
+          "isHealthy": true,
+          "isDisabled": false,
+          "success": true,
+          "usage": {
+            "daysUntilReset": null,
+            "nextDateReset": null,
+            "subscription": {
+              "title": "Gemini Antigravity",
+              "type": "gemini-antigravity",
+              "upgradeCapability": null,
+              "overageCapability": null
+            },
+            "user": {
+              "email": null,
+              "userId": null
+            },
+            "usageBreakdown": [
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-2.5-flash-preview",
+                "displayNamePlural": "gemini-2.5-flash-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:46.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-2.5-flash-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:46Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-flash-preview",
+                "displayNamePlural": "gemini-3-flash-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:46.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-flash-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:46Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-pro-image-preview",
+                "displayNamePlural": "gemini-3-pro-image-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:46.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-pro-image-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:46Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-pro-preview",
+                "displayNamePlural": "gemini-3-pro-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:46.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-pro-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:46Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-opus-4-5-thinking",
+                "displayNamePlural": "gemini-claude-opus-4-5-thinking",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:46.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-opus-4-5-thinking",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:46Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-sonnet-4-5",
+                "displayNamePlural": "gemini-claude-sonnet-4-5",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:46.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-sonnet-4-5",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:46Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-sonnet-4-5-thinking",
+                "displayNamePlural": "gemini-claude-sonnet-4-5-thinking",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:46.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-sonnet-4-5-thinking",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:46Z"
+              }
+            ]
+          },
+          "error": null
+        },
+        {
+          "uuid": "6d7301c2-da5c-491c-8fb9-e822ec781bb8",
+          "name": "6d7301c2-da5c-491c-8fb9-e822ec781bb8",
+          "isHealthy": true,
+          "isDisabled": false,
+          "success": true,
+          "usage": {
+            "daysUntilReset": null,
+            "nextDateReset": null,
+            "subscription": {
+              "title": "Gemini Antigravity",
+              "type": "gemini-antigravity",
+              "upgradeCapability": null,
+              "overageCapability": null
+            },
+            "user": {
+              "email": null,
+              "userId": null
+            },
+            "usageBreakdown": [
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-2.5-flash-preview",
+                "displayNamePlural": "gemini-2.5-flash-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:49.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-2.5-flash-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:49Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-flash-preview",
+                "displayNamePlural": "gemini-3-flash-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:49.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-flash-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:49Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-pro-image-preview",
+                "displayNamePlural": "gemini-3-pro-image-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:49.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-pro-image-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:49Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-3-pro-preview",
+                "displayNamePlural": "gemini-3-pro-preview",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T08:38:49.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-3-pro-preview",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-25 00:38",
+                "resetTimeRaw": "2026-01-24T08:38:49Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-opus-4-5-thinking",
+                "displayNamePlural": "gemini-claude-opus-4-5-thinking",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T07:24:04.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-opus-4-5-thinking",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-24 23:24",
+                "resetTimeRaw": "2026-01-24T07:24:04Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-sonnet-4-5",
+                "displayNamePlural": "gemini-claude-sonnet-4-5",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T07:24:04.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-sonnet-4-5",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-24 23:24",
+                "resetTimeRaw": "2026-01-24T07:24:04Z"
+              },
+              {
+                "resourceType": "MODEL_USAGE",
+                "displayName": "gemini-claude-sonnet-4-5-thinking",
+                "displayNamePlural": "gemini-claude-sonnet-4-5-thinking",
+                "unit": "quota",
+                "currency": null,
+                "currentUsage": 0,
+                "usageLimit": 100,
+                "currentOverages": 0,
+                "overageCap": 0,
+                "overageRate": null,
+                "overageCharges": 0,
+                "nextDateReset": "2026-01-24T07:24:04.000Z",
+                "freeTrial": null,
+                "bonuses": [],
+                "modelName": "gemini-claude-sonnet-4-5-thinking",
+                "inputTokenLimit": 0,
+                "outputTokenLimit": 0,
+                "remaining": 1,
+                "remainingPercent": 100,
+                "resetTime": "01-24 23:24",
+                "resetTimeRaw": "2026-01-24T07:24:04Z"
+              }
+            ]
+          },
+          "error": null
+        }
+      ],
+      "totalCount": 4,
+      "successCount": 4,
+      "errorCount": 0
+    }
+  }
+}

healthcheck.js

@@ -0,0 +1,46 @@
+/**
+ * Docker健康检查脚本
+ * 用于检查API服务器是否正常运行
+ */
+
+import http from 'http';
+
+// 从环境变量获取主机和端口，如果没有设置则使用默认值
+const HOST = process.env.HOST || 'localhost';
+const PORT = process.env.SERVER_PORT || 3000;
+
+// 发送HTTP请求到健康检查端点
+const options = {
+  hostname: HOST,
+  port: PORT,
+  path: '/health',
+  method: 'GET',
+  timeout: 2000 // 2秒超时
+};
+
+const req = http.request(options, (res) => {
+  // 如果状态码是200，表示服务健康
+  if (res.statusCode === 200) {
+    console.log('Health check passed');
+    process.exit(0);
+  } else {
+    console.log(`Health check failed with status code: ${res.statusCode}`);
+    process.exit(1);
+  }
+});
+
+// 处理请求错误
+req.on('error', (e) => {
+  console.error(`Health check failed: ${e.message}`);
+  process.exit(1);
+});
+
+// 设置超时处理
+req.on('timeout', () => {
+  console.error('Health check timed out');
+  req.destroy();
+  process.exit(1);
+});
+
+// 结束请求
+req.end();

package.json

@@ -0,0 +1,42 @@
+{
+  "type": "module",
+  "dependencies": {
+    "@anthropic-ai/tokenizer": "^0.0.4",
+    "adm-zip": "^0.5.16",
+    "axios": "^1.10.0",
+    "deepmerge": "^4.3.1",
+    "dotenv": "^16.4.5",
+    "google-auth-library": "^10.1.0",
+    "http-proxy-agent": "^7.0.2",
+    "https-proxy-agent": "^7.0.6",
+    "lodash": "^4.17.21",
+    "multer": "^2.0.2",
+    "open": "^10.2.0",
+    "socks-proxy-agent": "^8.0.5",
+    "undici": "^7.12.0",
+    "uuid": "^11.1.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.28.0",
+    "@jest/globals": "^29.7.0",
+    "babel-jest": "^30.0.5",
+    "babel-plugin-transform-import-meta": "^2.3.3",
+    "jest": "^29.7.0",
+    "jest-environment-node": "^29.7.0",
+    "supertest": "^6.3.3"
+  },
+  "scripts": {
+    "start": "node src/core/master.js",
+    "start:standalone": "node src/services/api-server.js",
+    "start:dev": "node src/core/master.js --dev",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:verbose": "jest --verbose",
+    "test:silent": "jest --silent",
+    "test:unit": "node run-tests.js --unit",
+    "test:integration": "node run-tests.js --integration",
+    "test:summary": "node test-summary.js"
+  }
+}

src/auth/codex-oauth.js

@@ -0,0 +1,851 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import open from 'open';
+import axios from 'axios';
+import { broadcastEvent } from '../services/ui-manager.js';
+import { autoLinkProviderConfigs } from '../services/service-manager.js';
+import { CONFIG } from '../core/config-manager.js';
+import { getProxyConfigForProvider } from '../utils/proxy-utils.js';
+
+/**
+ * Codex OAuth 配置
+ */
+const CODEX_OAUTH_CONFIG = {
+    clientId: 'app_EMoamEEZ73f0CkXaXp7hrann',
+    authUrl: 'https://auth.openai.com/oauth/authorize',
+    tokenUrl: 'https://auth.openai.com/oauth/token',
+    redirectUri: 'http://localhost:1455/auth/callback',
+    port: 1455,
+    scopes: 'openid email profile offline_access',
+    logPrefix: '[Codex Auth]'
+};
+
+/**
+ * Codex OAuth 认证类
+ * 实现 OAuth2 + PKCE 流程
+ */
+class CodexAuth {
+    constructor(config) {
+        this.config = config;
+        
+        // 配置代理支持
+        const axiosConfig = { timeout: 30000 };
+        const proxyConfig = getProxyConfigForProvider(config, 'openai-codex-oauth');
+        if (proxyConfig) {
+            axiosConfig.httpAgent = proxyConfig.httpAgent;
+            axiosConfig.httpsAgent = proxyConfig.httpsAgent;
+            console.log('[Codex Auth] Proxy enabled for OAuth requests');
+        }
+        
+        this.httpClient = axios.create(axiosConfig);
+        this.server = null; // 存储服务器实例
+    }
+
+    /**
+     * 生成 PKCE 代码
+     * @returns {{verifier: string, challenge: string}}
+     */
+    generatePKCECodes() {
+        // 生成 code verifier (96 随机字节 → 128 base64url 字符)
+        const verifier = crypto.randomBytes(96)
+            .toString('base64url');
+
+        // 生成 code challenge (SHA256 of verifier)
+        const challenge = crypto.createHash('sha256')
+            .update(verifier)
+            .digest('base64url');
+
+        return { verifier, challenge };
+    }
+
+    /**
+     * 生成授权 URL（不启动完整流程）
+     * @returns {{authUrl: string, state: string, pkce: Object, server: Object}}
+     */
+    async generateAuthUrl() {
+        const pkce = this.generatePKCECodes();
+        const state = crypto.randomBytes(16).toString('hex');
+
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Generating auth URL...`);
+
+        // 如果已有服务器在运行，先关闭
+        if (this.server) {
+            console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Closing existing callback server...`);
+            try {
+                this.server.close();
+                this.server = null;
+            } catch (error) {
+                console.warn(`${CODEX_OAUTH_CONFIG.logPrefix} Failed to close existing server:`, error.message);
+            }
+        }
+
+        // 启动本地回调服务器
+        const server = await this.startCallbackServer();
+        this.server = server;
+
+        // 构建授权 URL
+        const authUrl = new URL(CODEX_OAUTH_CONFIG.authUrl);
+        authUrl.searchParams.set('client_id', CODEX_OAUTH_CONFIG.clientId);
+        authUrl.searchParams.set('response_type', 'code');
+        authUrl.searchParams.set('redirect_uri', CODEX_OAUTH_CONFIG.redirectUri);
+        authUrl.searchParams.set('scope', CODEX_OAUTH_CONFIG.scopes);
+        authUrl.searchParams.set('state', state);
+        authUrl.searchParams.set('code_challenge', pkce.challenge);
+        authUrl.searchParams.set('code_challenge_method', 'S256');
+        authUrl.searchParams.set('prompt', 'login');
+        authUrl.searchParams.set('id_token_add_organizations', 'true');
+        authUrl.searchParams.set('codex_cli_simplified_flow', 'true');
+
+        return {
+            authUrl: authUrl.toString(),
+            state,
+            pkce,
+            server
+        };
+    }
+
+    /**
+     * 完成 OAuth 流程（在收到回调后调用）
+     * @param {string} code - 授权码
+     * @param {string} state - 状态参数
+     * @param {string} expectedState - 期望的状态参数
+     * @param {Object} pkce - PKCE 代码
+     * @returns {Promise<Object>} tokens 和凭据路径
+     */
+    async completeOAuthFlow(code, state, expectedState, pkce) {
+        // 验证 state
+        if (state !== expectedState) {
+            throw new Error('State mismatch - possible CSRF attack');
+        }
+
+        // 用 code 换取 tokens
+        const tokens = await this.exchangeCodeForTokens(code, pkce.verifier);
+
+        // 解析 JWT 提取账户信息
+        const claims = this.parseJWT(tokens.id_token);
+
+        // 保存凭据（遵循 CLIProxyAPI 格式）
+        const credentials = {
+            id_token: tokens.id_token,
+            access_token: tokens.access_token,
+            refresh_token: tokens.refresh_token,
+            account_id: claims['https://api.openai.com/auth']?.chatgpt_account_id || claims.sub,
+            last_refresh: new Date().toISOString(),
+            email: claims.email,
+            type: 'codex',
+            expired: new Date(Date.now() + (tokens.expires_in || 3600) * 1000).toISOString()
+        };
+
+        // 保存凭据并获取路径
+        const saveResult = await this.saveCredentials(credentials);
+        const credPath = saveResult.credsPath;
+        const relativePath = saveResult.relativePath;
+
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Authentication successful!`);
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Email: ${credentials.email}`);
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Account ID: ${credentials.account_id}`);
+
+        // 关闭服务器
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+
+        return {
+            ...credentials,
+            credPath,
+            relativePath
+        };
+    }
+
+    /**
+     * 启动 OAuth 流程
+     * @returns {Promise<Object>} 返回 tokens
+     */
+    async startOAuthFlow() {
+        const pkce = this.generatePKCECodes();
+        const state = crypto.randomBytes(16).toString('hex');
+
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Starting OAuth flow...`);
+
+        // 启动本地回调服务器
+        const server = await this.startCallbackServer();
+
+        // 构建授权 URL
+        const authUrl = new URL(CODEX_OAUTH_CONFIG.authUrl);
+        authUrl.searchParams.set('client_id', CODEX_OAUTH_CONFIG.clientId);
+        authUrl.searchParams.set('response_type', 'code');
+        authUrl.searchParams.set('redirect_uri', CODEX_OAUTH_CONFIG.redirectUri);
+        authUrl.searchParams.set('scope', CODEX_OAUTH_CONFIG.scopes);
+        authUrl.searchParams.set('state', state);
+        authUrl.searchParams.set('code_challenge', pkce.challenge);
+        authUrl.searchParams.set('code_challenge_method', 'S256');
+        authUrl.searchParams.set('prompt', 'login');
+        authUrl.searchParams.set('id_token_add_organizations', 'true');
+        authUrl.searchParams.set('codex_cli_simplified_flow', 'true');
+
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Opening browser for authentication...`);
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} If browser doesn't open, visit: ${authUrl.toString()}`);
+
+        try {
+            await open(authUrl.toString());
+        } catch (error) {
+            console.warn(`${CODEX_OAUTH_CONFIG.logPrefix} Failed to open browser automatically:`, error.message);
+        }
+
+        // 等待回调
+        const result = await this.waitForCallback(server, state);
+
+        // 用 code 换取 tokens
+        const tokens = await this.exchangeCodeForTokens(result.code, pkce.verifier);
+
+        // 解析 JWT 提取账户信息
+        const claims = this.parseJWT(tokens.id_token);
+
+        // 保存凭据（遵循 CLIProxyAPI 格式）
+        const credentials = {
+            id_token: tokens.id_token,
+            access_token: tokens.access_token,
+            refresh_token: tokens.refresh_token,
+            account_id: claims['https://api.openai.com/auth']?.chatgpt_account_id || claims.sub,
+            last_refresh: new Date().toISOString(),
+            email: claims.email,
+            type: 'codex',
+            expired: new Date(Date.now() + (tokens.expires_in || 3600) * 1000).toISOString()
+        };
+
+        await this.saveCredentials(credentials);
+
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Authentication successful!`);
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Email: ${credentials.email}`);
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Account ID: ${credentials.account_id}`);
+
+        return credentials;
+    }
+
+    /**
+     * 启动回调服务器
+     * @returns {Promise<http.Server>}
+     */
+    async startCallbackServer() {
+        return new Promise((resolve, reject) => {
+            const server = http.createServer();
+
+            server.on('request', (req, res) => {
+                if (req.url.startsWith('/auth/callback')) {
+                    const url = new URL(req.url, `http://localhost:${CODEX_OAUTH_CONFIG.port}`);
+                    const code = url.searchParams.get('code');
+                    const state = url.searchParams.get('state');
+                    const error = url.searchParams.get('error');
+                    const errorDescription = url.searchParams.get('error_description');
+
+                    if (error) {
+                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(`
+                            <!DOCTYPE html>
+                            <html>
+                            <head>
+                                <title>Authentication Failed</title>
+                                <style>
+                                    body { font-family: Arial, sans-serif; text-align: center; padding: 50px; }
+                                    h1 { color: #d32f2f; }
+                                    p { color: #666; }
+                                </style>
+                            </head>
+                            <body>
+                                <h1>❌ Authentication Failed</h1>
+                                <p>${errorDescription || error}</p>
+                                <p>You can close this window and try again.</p>
+                            </body>
+                            </html>
+                        `);
+                        server.emit('auth-error', new Error(errorDescription || error));
+                    } else if (code && state) {
+                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(`
+                            <!DOCTYPE html>
+                            <html>
+                            <head>
+                                <title>Authentication Successful</title>
+                                <style>
+                                    body { font-family: Arial, sans-serif; text-align: center; padding: 50px; }
+                                    h1 { color: #4caf50; }
+                                    p { color: #666; }
+                                    .countdown { font-size: 24px; font-weight: bold; color: #2196f3; }
+                                </style>
+                                <script>
+                                    let countdown = 10;
+                                    setInterval(() => {
+                                        countdown--;
+                                        document.getElementById('countdown').textContent = countdown;
+                                        if (countdown <= 0) {
+                                            window.close();
+                                        }
+                                    }, 1000);
+                                </script>
+                            </head>
+                            <body>
+                                <h1>✅ Authentication Successful!</h1>
+                                <p>You can now close this window and return to the application.</p>
+                                <p>This window will close automatically in <span id="countdown" class="countdown">10</span> seconds.</p>
+                            </body>
+                            </html>
+                        `);
+                        server.emit('auth-success', { code, state });
+                    }
+                } else if (req.url === '/success') {
+                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end('<h1>Success!</h1>');
+                }
+            });
+
+            server.listen(CODEX_OAUTH_CONFIG.port, () => {
+                console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Callback server listening on port ${CODEX_OAUTH_CONFIG.port}`);
+                resolve(server);
+            });
+
+            server.on('error', (error) => {
+                if (error.code === 'EADDRINUSE') {
+                    reject(new Error(`Port ${CODEX_OAUTH_CONFIG.port} is already in use. Please close other applications using this port.`));
+                } else {
+                    reject(error);
+                }
+            });
+        });
+    }
+
+    /**
+     * 等待 OAuth 回调
+     * @param {http.Server} server
+     * @param {string} expectedState
+     * @returns {Promise<{code: string, state: string}>}
+     */
+    async waitForCallback(server, expectedState) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                server.close();
+                reject(new Error('Authentication timeout (10 minutes)'));
+            }, 10 * 60 * 1000); // 10 分钟
+
+            server.once('auth-success', (result) => {
+                clearTimeout(timeout);
+                server.close();
+
+                if (result.state !== expectedState) {
+                    reject(new Error('State mismatch - possible CSRF attack'));
+                } else {
+                    resolve(result);
+                }
+            });
+
+            server.once('auth-error', (error) => {
+                clearTimeout(timeout);
+                server.close();
+                reject(error);
+            });
+        });
+    }
+
+    /**
+     * 用授权码换取 tokens
+     * @param {string} code
+     * @param {string} codeVerifier
+     * @returns {Promise<Object>}
+     */
+    async exchangeCodeForTokens(code, codeVerifier) {
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Exchanging authorization code for tokens...`);
+
+        try {
+            const response = await this.httpClient.post(
+                CODEX_OAUTH_CONFIG.tokenUrl,
+                new URLSearchParams({
+                    grant_type: 'authorization_code',
+                    client_id: CODEX_OAUTH_CONFIG.clientId,
+                    code: code,
+                    redirect_uri: CODEX_OAUTH_CONFIG.redirectUri,
+                    code_verifier: codeVerifier
+                }).toString(),
+                {
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                        'Accept': 'application/json'
+                    }
+                }
+            );
+
+            return response.data;
+        } catch (error) {
+            console.error(`${CODEX_OAUTH_CONFIG.logPrefix} Token exchange failed:`, error.response?.data || error.message);
+            throw new Error(`Failed to exchange code for tokens: ${error.response?.data?.error_description || error.message}`);
+        }
+    }
+
+    /**
+     * 刷新 tokens
+     * @param {string} refreshToken
+     * @returns {Promise<Object>}
+     */
+    async refreshTokens(refreshToken) {
+        console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Refreshing access token...`);
+
+        try {
+            const response = await this.httpClient.post(
+                CODEX_OAUTH_CONFIG.tokenUrl,
+                new URLSearchParams({
+                    grant_type: 'refresh_token',
+                    client_id: CODEX_OAUTH_CONFIG.clientId,
+                    refresh_token: refreshToken
+                }).toString(),
+                {
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                        'Accept': 'application/json'
+                    }
+                }
+            );
+
+            const tokens = response.data;
+            const claims = this.parseJWT(tokens.id_token);
+
+            return {
+                id_token: tokens.id_token,
+                access_token: tokens.access_token,
+                refresh_token: tokens.refresh_token || refreshToken,
+                account_id: claims['https://api.openai.com/auth']?.chatgpt_account_id || claims.sub,
+                last_refresh: new Date().toISOString(),
+                email: claims.email,
+                type: 'codex',
+                expired: new Date(Date.now() + (tokens.expires_in || 3600) * 1000).toISOString()
+            };
+        } catch (error) {
+            console.error(`${CODEX_OAUTH_CONFIG.logPrefix} Token refresh failed:`, error.response?.data || error.message);
+            throw new Error(`Failed to refresh tokens: ${error.response?.data?.error_description || error.message}`);
+        }
+    }
+
+    /**
+     * 解析 JWT token
+     * @param {string} token
+     * @returns {Object}
+     */
+    parseJWT(token) {
+        try {
+            const parts = token.split('.');
+            if (parts.length !== 3) {
+                throw new Error('Invalid JWT token format');
+            }
+
+            // 解码 payload (base64url)
+            const payload = Buffer.from(parts[1], 'base64url').toString('utf8');
+            return JSON.parse(payload);
+        } catch (error) {
+            console.error(`${CODEX_OAUTH_CONFIG.logPrefix} Failed to parse JWT:`, error.message);
+            throw new Error(`Failed to parse JWT token: ${error.message}`);
+        }
+    }
+
+    /**
+     * 保存凭据到文件
+     * @param {Object} creds
+     * @returns {Promise<Object>}
+     */
+    async saveCredentials(creds) {
+        const email = creds.email || this.config.CODEX_EMAIL || 'default';
+
+        // 优先使用配置中指定的路径，否则保存到 configs/codex 目录
+        let credsPath;
+        if (this.config.CODEX_OAUTH_CREDS_FILE_PATH) {
+            credsPath = this.config.CODEX_OAUTH_CREDS_FILE_PATH;
+        } else {
+            // 保存到 configs/codex 目录（与其他供应商一致）
+            const projectDir = process.cwd();
+            const targetDir = path.join(projectDir, 'configs', 'codex');
+            await fs.promises.mkdir(targetDir, { recursive: true });
+            const timestamp = Date.now();
+            const filename = `${timestamp}_codex-${email}.json`;
+            credsPath = path.join(targetDir, filename);
+        }
+
+        try {
+            const credsDir = path.dirname(credsPath);
+            await fs.promises.mkdir(credsDir, { recursive: true });
+            await fs.promises.writeFile(credsPath, JSON.stringify(creds, null, 2), { mode: 0o600 });
+
+            const relativePath = path.relative(process.cwd(), credsPath);
+            console.log(`${CODEX_OAUTH_CONFIG.logPrefix} Credentials saved to ${relativePath}`);
+
+            // 返回保存路径供后续使用
+            return { credsPath, relativePath };
+        } catch (error) {
+            console.error(`${CODEX_OAUTH_CONFIG.logPrefix} Failed to save credentials:`, error.message);
+            throw new Error(`Failed to save credentials: ${error.message}`);
+        }
+    }
+
+    /**
+     * 加载凭据
+     * @param {string} email
+     * @returns {Promise<Object|null>}
+     */
+    async loadCredentials(email) {
+        // 优先使用配置中指定的路径，否则从 configs/codex 目录加载
+        let credsPath;
+        if (this.config.CODEX_OAUTH_CREDS_FILE_PATH) {
+            credsPath = this.config.CODEX_OAUTH_CREDS_FILE_PATH;
+        } else {
+            // 从 configs/codex 目录加载（与其他供应商一致）
+            const projectDir = process.cwd();
+            const targetDir = path.join(projectDir, 'configs', 'codex');
+
+            // 扫描目录找到匹配的凭据文件
+            try {
+                const files = await fs.promises.readdir(targetDir);
+                const emailPattern = email || 'default';
+                const matchingFile = files
+                    .filter(f => f.includes(`codex-${emailPattern}`) && f.endsWith('.json'))
+                    .sort()
+                    .pop(); // 获取最新的文件
+
+                if (matchingFile) {
+                    credsPath = path.join(targetDir, matchingFile);
+                } else {
+                    return null;
+                }
+            } catch (error) {
+                if (error.code === 'ENOENT') {
+                    return null;
+                }
+                throw error;
+            }
+        }
+
+        try {
+            const data = await fs.promises.readFile(credsPath, 'utf8');
+            return JSON.parse(data);
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                return null; // 文件不存在
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * 检查凭据文件是否存在
+     * @param {string} email
+     * @returns {Promise<boolean>}
+     */
+    async credentialsExist(email) {
+        // 优先使用配置中指定的路径，否则从 configs/codex 目录检查
+        let credsPath;
+        if (this.config.CODEX_OAUTH_CREDS_FILE_PATH) {
+            credsPath = this.config.CODEX_OAUTH_CREDS_FILE_PATH;
+        } else {
+            const projectDir = process.cwd();
+            const targetDir = path.join(projectDir, 'configs', 'codex');
+
+            try {
+                const files = await fs.promises.readdir(targetDir);
+                const emailPattern = email || 'default';
+                const hasMatch = files.some(f =>
+                    f.includes(`codex-${emailPattern}`) && f.endsWith('.json')
+                );
+                return hasMatch;
+            } catch (error) {
+                return false;
+            }
+        }
+
+        try {
+            await fs.promises.access(credsPath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+}
+
+/**
+ * 带重试的 Codex token 刷新
+ * @param {string} refreshToken
+ * @param {Object} config
+ * @param {number} maxRetries
+ * @returns {Promise<Object>}
+ */
+export async function refreshCodexTokensWithRetry(refreshToken, config = {}, maxRetries = 3) {
+    const auth = new CodexAuth(config);
+    let lastError;
+
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            return await auth.refreshTokens(refreshToken);
+        } catch (error) {
+            lastError = error;
+            console.warn(`${CODEX_OAUTH_CONFIG.logPrefix} Retry ${i + 1}/${maxRetries} failed:`, error.message);
+
+            if (i < maxRetries - 1) {
+                // 指数退避
+                const delay = Math.min(1000 * Math.pow(2, i), 10000);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    }
+
+    throw lastError;
+}
+
+/**
+ * 处理 Codex OAuth 认证
+ * @param {Object} currentConfig - 当前配置
+ * @param {Object} options - 选项
+ * @returns {Promise<Object>} 返回认证结果
+ */
+export async function handleCodexOAuth(currentConfig, options = {}) {
+    const auth = new CodexAuth(currentConfig);
+
+    try {
+        console.log('[Codex Auth] Generating OAuth URL...');
+
+        // 清理所有旧的会话和服务器
+        if (global.codexOAuthSessions && global.codexOAuthSessions.size > 0) {
+            console.log('[Codex Auth] Cleaning up old OAuth sessions...');
+            for (const [sessionId, session] of global.codexOAuthSessions.entries()) {
+                try {
+                    // 清理定时器
+                    if (session.pollTimer) {
+                        clearInterval(session.pollTimer);
+                    }
+                    // 关闭服务器
+                    if (session.server) {
+                        session.server.close();
+                    }
+                    global.codexOAuthSessions.delete(sessionId);
+                } catch (error) {
+                    console.warn(`[Codex Auth] Failed to clean up session ${sessionId}:`, error.message);
+                }
+            }
+        }
+
+        // 生成授权 URL 和启动回调服务器
+        const { authUrl, state, pkce, server } = await auth.generateAuthUrl();
+
+        console.log('[Codex Auth] OAuth URL generated successfully');
+
+        // 存储 OAuth 会话信息，供后续回调使用
+        if (!global.codexOAuthSessions) {
+            global.codexOAuthSessions = new Map();
+        }
+
+        const sessionId = state; // 使用 state 作为 session ID
+        
+        // 轮询计数器
+        let pollCount = 0;
+        const maxPollCount = 30; // 最多轮询次数（可随意更改）
+        const pollInterval = 3000; // 轮询间隔（毫秒）
+        let pollTimer = null;
+        let isCompleted = false;
+        
+        // 创建会话对象
+        const session = {
+            auth,
+            state,
+            pkce,
+            server,
+            pollTimer: null,
+            createdAt: Date.now()
+        };
+        
+        global.codexOAuthSessions.set(sessionId, session);
+
+        // 启动轮询日志
+        pollTimer = setInterval(() => {
+            pollCount++;
+            if (pollCount <= maxPollCount && !isCompleted) {
+                console.log(`[Codex Auth] Waiting for callback... (${pollCount}/${maxPollCount})`);
+            }
+            
+            if (pollCount >= maxPollCount && !isCompleted) {
+                clearInterval(pollTimer);
+                const totalSeconds = (maxPollCount * pollInterval) / 1000;
+                console.log(`[Codex Auth] Polling timeout (${totalSeconds}s), releasing session for next authorization`);
+                
+                // 清理会话和服务器
+                if (global.codexOAuthSessions.has(sessionId)) {
+                    const session = global.codexOAuthSessions.get(sessionId);
+                    if (session.server) {
+                        session.server.close();
+                    }
+                    global.codexOAuthSessions.delete(sessionId);
+                }
+            }
+        }, pollInterval);
+        
+        // 将 pollTimer 存储到会话中
+        session.pollTimer = pollTimer;
+
+        // 监听回调服务器的 auth-success 事件，自动完成 OAuth 流程
+        server.once('auth-success', async (result) => {
+            isCompleted = true;
+            if (pollTimer) {
+                clearInterval(pollTimer);
+            }
+            
+            try {
+                console.log('[Codex Auth] Received auth callback, completing OAuth flow...');
+                
+                const session = global.codexOAuthSessions.get(sessionId);
+                if (!session) {
+                    console.error('[Codex Auth] Session not found');
+                    return;
+                }
+
+                // 完成 OAuth 流程
+                const credentials = await auth.completeOAuthFlow(result.code, result.state, session.state, session.pkce);
+
+                // 清理会话
+                global.codexOAuthSessions.delete(sessionId);
+
+                // 广播认证成功事件
+                broadcastEvent('oauth_success', {
+                    provider: 'openai-codex-oauth',
+                    credPath: credentials.credPath,
+                    relativePath: credentials.relativePath,
+                    timestamp: new Date().toISOString(),
+                    email: credentials.email,
+                    accountId: credentials.account_id
+                });
+
+                // 自动关联新生成的凭据到 Pools
+                await autoLinkProviderConfigs(CONFIG);
+
+                console.log('[Codex Auth] OAuth flow completed successfully');
+            } catch (error) {
+                console.error('[Codex Auth] Failed to complete OAuth flow:', error.message);
+                
+                // 广播认证失败事件
+                broadcastEvent('oauth_error', {
+                    provider: 'openai-codex-oauth',
+                    error: error.message
+                });
+            }
+        });
+
+        // 监听 auth-error 事件
+        server.once('auth-error', (error) => {
+            isCompleted = true;
+            if (pollTimer) {
+                clearInterval(pollTimer);
+            }
+            
+            console.error('[Codex Auth] Auth error:', error.message);
+            global.codexOAuthSessions.delete(sessionId);
+            
+            broadcastEvent('oauth_error', {
+                provider: 'openai-codex-oauth',
+                error: error.message
+            });
+        });
+
+        return {
+            success: true,
+            authUrl: authUrl,
+            authInfo: {
+                provider: 'openai-codex-oauth',
+                method: 'oauth2-pkce',
+                sessionId: sessionId,
+                redirectUri: CODEX_OAUTH_CONFIG.redirectUri,
+                port: CODEX_OAUTH_CONFIG.port,
+                instructions: [
+                    '1. 点击下方按钮在浏览器中打开授权链接',
+                    '2. 使用您的 OpenAI 账户登录',
+                    '3. 授权应用访问您的 Codex API',
+                    '4. 授权成功后会自动保存凭据',
+                    '5. 如果浏览器未自动跳转，请手动复制回调 URL'
+                ]
+            }
+        };
+    } catch (error) {
+        console.error('[Codex Auth] Failed to generate OAuth URL:', error.message);
+
+        return {
+            success: false,
+            error: error.message,
+            authInfo: {
+                provider: 'openai-codex-oauth',
+                method: 'oauth2-pkce',
+                instructions: [
+                    `1. 确保端口 ${CODEX_OAUTH_CONFIG.port} 未被占用`,
+                    '2. 确保可以访问 auth.openai.com',
+                    '3. 确保浏览器可以正常打开',
+                    '4. 如果问题持续，请检查网络连接'
+                ]
+            }
+        };
+    }
+}
+
+/**
+ * 处理 Codex OAuth 回调
+ * @param {string} code - 授权码
+ * @param {string} state - 状态参数
+ * @returns {Promise<Object>} 返回认证结果
+ */
+export async function handleCodexOAuthCallback(code, state) {
+    try {
+        if (!global.codexOAuthSessions || !global.codexOAuthSessions.has(state)) {
+            throw new Error('Invalid or expired OAuth session');
+        }
+
+        const session = global.codexOAuthSessions.get(state);
+        const { auth, state: expectedState, pkce } = session;
+
+        console.log('[Codex Auth] Processing OAuth callback...');
+
+        // 完成 OAuth 流程
+        const result = await auth.completeOAuthFlow(code, state, expectedState, pkce);
+
+        // 清理会话
+        global.codexOAuthSessions.delete(state);
+
+        // 广播认证成功事件（与 gemini 格式一致）
+        broadcastEvent('oauth_success', {
+            provider: 'openai-codex-oauth',
+            credPath: result.credPath,
+            relativePath: result.relativePath,
+            timestamp: new Date().toISOString(),
+            email: result.email,
+            accountId: result.account_id
+        });
+
+        // 自动关联新生成的凭据到 Pools
+        await autoLinkProviderConfigs(CONFIG);
+
+        console.log('[Codex Auth] OAuth callback processed successfully');
+
+        return {
+            success: true,
+            message: 'Codex authentication successful',
+            credentials: result,
+            email: result.email,
+            accountId: result.account_id,
+            credPath: result.credPath,
+            relativePath: result.relativePath
+        };
+    } catch (error) {
+        console.error('[Codex Auth] OAuth callback failed:', error.message);
+
+        // 广播认证失败事件
+        broadcastEvent({
+            type: 'oauth-error',
+            provider: 'openai-codex-oauth',
+            error: error.message
+        });
+
+        return {
+            success: false,
+            error: error.message
+        };
+    }
+}

src/auth/gemini-oauth.js

@@ -0,0 +1,289 @@
+import { OAuth2Client } from 'google-auth-library';
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { broadcastEvent } from '../services/ui-manager.js';
+import { autoLinkProviderConfigs } from '../services/service-manager.js';
+import { CONFIG } from '../core/config-manager.js';
+import { getGoogleAuthProxyConfig } from '../utils/proxy-utils.js';
+
+/**
+ * OAuth 提供商配置
+ */
+const OAUTH_PROVIDERS = {
+    'gemini-cli-oauth': {
+        clientId: '681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com',
+        clientSecret: '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',
+        port: 8085,
+        credentialsDir: '.gemini',
+        credentialsFile: 'oauth_creds.json',
+        scope: ['https://www.googleapis.com/auth/cloud-platform'],
+        logPrefix: '[Gemini Auth]'
+    },
+    'gemini-antigravity': {
+        clientId: '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com',
+        clientSecret: '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',
+        port: 8086,
+        credentialsDir: '.antigravity',
+        credentialsFile: 'oauth_creds.json',
+        scope: ['https://www.googleapis.com/auth/cloud-platform'],
+        logPrefix: '[Antigravity Auth]'
+    }
+};
+
+/**
+ * 活动的服务器实例管理
+ */
+const activeServers = new Map();
+
+/**
+ * 生成 HTML 响应页面
+ * @param {boolean} isSuccess - 是否成功
+ * @param {string} message - 显示消息
+ * @returns {string} HTML 内容
+ */
+function generateResponsePage(isSuccess, message) {
+    const title = isSuccess ? '授权成功！' : '授权失败';
+    
+    return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+</head>
+<body>
+    <div class="container">
+        <h1>${title}</h1>
+        <p>${message}</p>
+    </div>
+</body>
+</html>`;
+}
+
+/**
+ * 关闭指定端口的活动服务器
+ * @param {number} port - 端口号
+ * @returns {Promise<void>}
+ */
+async function closeActiveServer(provider, port = null) {
+    // 1. 关闭该提供商之前的所有服务器
+    const existing = activeServers.get(provider);
+    if (existing) {
+        await new Promise((resolve) => {
+            existing.server.close(() => {
+                activeServers.delete(provider);
+                console.log(`[OAuth] 已关闭提供商 ${provider} 在端口 ${existing.port} 上的旧服务器`);
+                resolve();
+            });
+        });
+    }
+
+    // 2. 如果指定了端口，检查是否有其他提供商占用了该端口
+    if (port) {
+        for (const [p, info] of activeServers.entries()) {
+            if (info.port === port) {
+                await new Promise((resolve) => {
+                    info.server.close(() => {
+                        activeServers.delete(p);
+                        console.log(`[OAuth] 已关闭端口 ${port} 上被占用（提供商: ${p}）的旧服务器`);
+                        resolve();
+                    });
+                });
+            }
+        }
+    }
+}
+
+/**
+ * 创建 OAuth 回调服务器
+ * @param {Object} config - OAuth 提供商配置
+ * @param {string} redirectUri - 重定向 URI
+ * @param {OAuth2Client} authClient - OAuth2 客户端
+ * @param {string} credPath - 凭据保存路径
+ * @param {string} provider - 提供商标识
+ * @returns {Promise<http.Server>} HTTP 服务器实例
+ */
+async function createOAuthCallbackServer(config, redirectUri, authClient, credPath, provider, options = {}) {
+    const port = parseInt(options.port) || config.port;
+    // 先关闭该提供商之前可能运行的所有服务器，或该端口上的旧服务器
+    await closeActiveServer(provider, port);
+    
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(async (req, res) => {
+            try {
+                const url = new URL(req.url, redirectUri);
+                const code = url.searchParams.get('code');
+                const errorParam = url.searchParams.get('error');
+                
+                if (code) {
+                    console.log(`${config.logPrefix} 收到来自 Google 的成功回调: ${req.url}`);
+                    
+                    try {
+                        const { tokens } = await authClient.getToken(code);
+                        let finalCredPath = credPath;
+                        
+                        // 如果指定了保存到 configs 目录
+                        if (options.saveToConfigs) {
+                            const providerDir = options.providerDir;
+                            const targetDir = path.join(process.cwd(), 'configs', providerDir);
+                            await fs.promises.mkdir(targetDir, { recursive: true });
+                            const timestamp = Date.now();
+                            const filename = `${timestamp}_oauth_creds.json`;
+                            finalCredPath = path.join(targetDir, filename);
+                        }
+
+                        await fs.promises.mkdir(path.dirname(finalCredPath), { recursive: true });
+                        await fs.promises.writeFile(finalCredPath, JSON.stringify(tokens, null, 2));
+                        console.log(`${config.logPrefix} 新令牌已接收并保存到文件: ${finalCredPath}`);
+                        
+                        const relativePath = path.relative(process.cwd(), finalCredPath);
+
+                        // 广播授权成功事件
+                        broadcastEvent('oauth_success', {
+                            provider: provider,
+                            credPath: finalCredPath,
+                            relativePath: relativePath,
+                            timestamp: new Date().toISOString()
+                        });
+                        
+                        // 自动关联新生成的凭据到 Pools
+                        await autoLinkProviderConfigs(CONFIG);
+                        
+                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(generateResponsePage(true, '您可以关闭此页面'));
+                    } catch (tokenError) {
+                        console.error(`${config.logPrefix} 获取令牌失败:`, tokenError);
+                        res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(generateResponsePage(false, `获取令牌失败: ${tokenError.message}`));
+                    } finally {
+                        server.close(() => {
+                            activeServers.delete(provider);
+                        });
+                    }
+                } else if (errorParam) {
+                    const errorMessage = `授权失败。Google 返回错误: ${errorParam}`;
+                    console.error(`${config.logPrefix}`, errorMessage);
+                    
+                    res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end(generateResponsePage(false, errorMessage));
+                    server.close(() => {
+                        activeServers.delete(provider);
+                    });
+                } else {
+                    console.log(`${config.logPrefix} 忽略无关请求: ${req.url}`);
+                    res.writeHead(204);
+                    res.end();
+                }
+            } catch (error) {
+                console.error(`${config.logPrefix} 处理回调时出错:`, error);
+                res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(generateResponsePage(false, `服务器错误: ${error.message}`));
+                
+                if (server.listening) {
+                    server.close(() => {
+                        activeServers.delete(provider);
+                    });
+                }
+            }
+        });
+        
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                console.error(`${config.logPrefix} 端口 ${port} 已被占用`);
+                reject(new Error(`端口 ${port} 已被占用`));
+            } else {
+                console.error(`${config.logPrefix} 服务器错误:`, err);
+                reject(err);
+            }
+        });
+        
+        const host = '0.0.0.0';
+        server.listen(port, host, () => {
+            console.log(`${config.logPrefix} OAuth 回调服务器已启动于 ${host}:${port}`);
+            activeServers.set(provider, { server, port });
+            resolve(server);
+        });
+    });
+}
+
+/**
+ * 处理 Google OAuth 授权（通用函数）
+ * @param {string} providerKey - 提供商键名
+ * @param {Object} currentConfig - 当前配置对象
+ * @param {Object} options - 额外选项
+ * @returns {Promise<Object>} 返回授权URL和相关信息
+ */
+async function handleGoogleOAuth(providerKey, currentConfig, options = {}) {
+    const config = OAUTH_PROVIDERS[providerKey];
+    if (!config) {
+        throw new Error(`未知的提供商: ${providerKey}`);
+    }
+    
+    const port = parseInt(options.port) || config.port;
+    const host = 'localhost';
+    const redirectUri = `http://${host}:${port}`;
+
+    // 获取代理配置
+    const proxyConfig = getGoogleAuthProxyConfig(currentConfig, providerKey);
+
+    // 构建 OAuth2Client 选项
+    const oauth2Options = {
+        clientId: config.clientId,
+        clientSecret: config.clientSecret,
+    };
+
+    if (proxyConfig) {
+        oauth2Options.transporterOptions = proxyConfig;
+        console.log(`${config.logPrefix} Using proxy for OAuth token exchange`);
+    }
+
+    const authClient = new OAuth2Client(oauth2Options);
+    authClient.redirectUri = redirectUri;
+    
+    const authUrl = authClient.generateAuthUrl({
+        access_type: 'offline',
+        prompt: 'select_account',
+        scope: config.scope
+    });
+    
+    // 启动回调服务器
+    const credPath = path.join(os.homedir(), config.credentialsDir, config.credentialsFile);
+    
+    try {
+        await createOAuthCallbackServer(config, redirectUri, authClient, credPath, providerKey, options);
+    } catch (error) {
+        throw new Error(`启动回调服务器失败: ${error.message}`);
+    }
+    
+    return {
+        authUrl,
+        authInfo: {
+            provider: providerKey,
+            redirectUri: redirectUri,
+            port: port,
+            ...options
+        }
+    };
+}
+
+/**
+ * 处理 Gemini CLI OAuth 授权
+ * @param {Object} currentConfig - 当前配置对象
+ * @param {Object} options - 额外选项
+ * @returns {Promise<Object>} 返回授权URL和相关信息
+ */
+export async function handleGeminiCliOAuth(currentConfig, options = {}) {
+    return handleGoogleOAuth('gemini-cli-oauth', currentConfig, options);
+}
+
+/**
+ * 处理 Gemini Antigravity OAuth 授权
+ * @param {Object} currentConfig - 当前配置对象
+ * @param {Object} options - 额外选项
+ * @returns {Promise<Object>} 返回授权URL和相关信息
+ */
+export async function handleGeminiAntigravityOAuth(currentConfig, options = {}) {
+    return handleGoogleOAuth('gemini-antigravity', currentConfig, options);
+}

src/auth/iflow-oauth.js

@@ -0,0 +1,529 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { broadcastEvent } from '../services/ui-manager.js';
+import { autoLinkProviderConfigs } from '../services/service-manager.js';
+import { CONFIG } from '../core/config-manager.js';
+import { getProxyConfigForProvider } from '../utils/proxy-utils.js';
+
+/**
+ * iFlow OAuth 配置
+ */
+const IFLOW_OAUTH_CONFIG = {
+    // OAuth 端点
+    tokenEndpoint: 'https://iflow.cn/oauth/token',
+    authorizeEndpoint: 'https://iflow.cn/oauth',
+    userInfoEndpoint: 'https://iflow.cn/api/oauth/getUserInfo',
+    successRedirectURL: 'https://iflow.cn/oauth/success',
+    
+    // 客户端凭据
+    clientId: '10009311001',
+    clientSecret: '4Z3YjXycVsQvyGF1etiNlIBB4RsqSDtW',
+    
+    // 本地回调端口
+    callbackPort: 8087,
+    
+    // 凭据存储
+    credentialsDir: '.iflow',
+    credentialsFile: 'oauth_creds.json',
+    
+    // 日志前缀
+    logPrefix: '[iFlow Auth]'
+};
+
+/**
+ * 活动的 iFlow 回调服务器管理
+ */
+const activeIFlowServers = new Map();
+
+/**
+ * 创建带代理支持的 fetch 请求
+ * 使用 axios 替代原生 fetch，以正确支持代理配置
+ * @param {string} url - 请求 URL
+ * @param {Object} options - fetch 选项（兼容 fetch API 格式）
+ * @param {string} providerType - 提供商类型，用于获取代理配置
+ * @returns {Promise<Object>} 返回类似 fetch Response 的对象
+ */
+async function fetchWithProxy(url, options = {}, providerType) {
+    const proxyConfig = getProxyConfigForProvider(CONFIG, providerType);
+
+    // 构建 axios 配置
+    const axiosConfig = {
+        url,
+        method: options.method || 'GET',
+        headers: options.headers || {},
+        timeout: 30000, // 30 秒超时
+    };
+
+    // 处理请求体
+    if (options.body) {
+        axiosConfig.data = options.body;
+    }
+
+    // 配置代理
+    if (proxyConfig) {
+        axiosConfig.httpAgent = proxyConfig.httpAgent;
+        axiosConfig.httpsAgent = proxyConfig.httpsAgent;
+        axiosConfig.proxy = false; // 禁用 axios 内置代理，使用我们的 agent
+        console.log(`[OAuth] Using proxy for ${providerType}: ${CONFIG.PROXY_URL}`);
+    }
+
+    try {
+        const axios = (await import('axios')).default;
+        const response = await axios(axiosConfig);
+        
+        // 返回类似 fetch Response 的对象
+        return {
+            ok: response.status >= 200 && response.status < 300,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            json: async () => response.data,
+            text: async () => typeof response.data === 'string' ? response.data : JSON.stringify(response.data),
+        };
+    } catch (error) {
+        // 处理 axios 错误，转换为类似 fetch 的响应格式
+        if (error.response) {
+            // 服务器返回了错误状态码
+            return {
+                ok: false,
+                status: error.response.status,
+                statusText: error.response.statusText,
+                headers: error.response.headers,
+                json: async () => error.response.data,
+                text: async () => typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data),
+            };
+        }
+        // 网络错误或其他错误
+        throw error;
+    }
+}
+
+/**
+ * 生成 HTML 响应页面
+ * @param {boolean} isSuccess - 是否成功
+ * @param {string} message - 显示消息
+ * @returns {string} HTML 内容
+ */
+function generateResponsePage(isSuccess, message) {
+    const title = isSuccess ? '授权成功！' : '授权失败';
+    
+    return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+</head>
+<body>
+    <div class="container">
+        <h1>${title}</h1>
+        <p>${message}</p>
+    </div>
+</body>
+</html>`;
+}
+
+/**
+ * 生成 iFlow 授权链接
+ * @param {string} state - 状态参数
+ * @param {number} port - 回调端口
+ * @returns {Object} 包含 authUrl 和 redirectUri
+ */
+function generateIFlowAuthorizationURL(state, port) {
+    const redirectUri = `http://localhost:${port}/oauth2callback`;
+    const params = new URLSearchParams({
+        loginMethod: 'phone',
+        type: 'phone',
+        redirect: redirectUri,
+        state: state,
+        client_id: IFLOW_OAUTH_CONFIG.clientId
+    });
+    const authUrl = `${IFLOW_OAUTH_CONFIG.authorizeEndpoint}?${params.toString()}`;
+    return { authUrl, redirectUri };
+}
+
+/**
+ * 交换授权码获取 iFlow 令牌
+ * @param {string} code - 授权码
+ * @param {string} redirectUri - 重定向 URI
+ * @returns {Promise<Object>} 令牌数据
+ */
+async function exchangeIFlowCodeForTokens(code, redirectUri) {
+    const form = new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: code,
+        redirect_uri: redirectUri,
+        client_id: IFLOW_OAUTH_CONFIG.clientId,
+        client_secret: IFLOW_OAUTH_CONFIG.clientSecret
+    });
+    
+    // 生成 Basic Auth 头
+    const basicAuth = Buffer.from(`${IFLOW_OAUTH_CONFIG.clientId}:${IFLOW_OAUTH_CONFIG.clientSecret}`).toString('base64');
+
+    const response = await fetchWithProxy(IFLOW_OAUTH_CONFIG.tokenEndpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Accept': 'application/json',
+            'Authorization': `Basic ${basicAuth}`
+        },
+        body: form.toString()
+    }, 'openai-iflow');
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`iFlow token exchange failed: ${response.status} ${errorText}`);
+    }
+    
+    const tokenData = await response.json();
+    
+    if (!tokenData.access_token) {
+        throw new Error('iFlow token: missing access token in response');
+    }
+    
+    return {
+        accessToken: tokenData.access_token,
+        refreshToken: tokenData.refresh_token,
+        tokenType: tokenData.token_type,
+        scope: tokenData.scope,
+        expiresIn: tokenData.expires_in,
+        expiresAt: new Date(Date.now() + tokenData.expires_in * 1000).toISOString()
+    };
+}
+
+/**
+ * 获取 iFlow 用户信息（包含 API Key）
+ * @param {string} accessToken - 访问令牌
+ * @returns {Promise<Object>} 用户信息
+ */
+async function fetchIFlowUserInfo(accessToken) {
+    if (!accessToken || accessToken.trim() === '') {
+        throw new Error('iFlow api key: access token is empty');
+    }
+    
+    const endpoint = `${IFLOW_OAUTH_CONFIG.userInfoEndpoint}?accessToken=${encodeURIComponent(accessToken)}`;
+
+    const response = await fetchWithProxy(endpoint, {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json'
+        }
+    }, 'openai-iflow');
+    
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`iFlow user info failed: ${response.status} ${errorText}`);
+    }
+    
+    const result = await response.json();
+    
+    if (!result.success) {
+        throw new Error('iFlow api key: request not successful');
+    }
+    
+    if (!result.data || !result.data.apiKey) {
+        throw new Error('iFlow api key: missing api key in response');
+    }
+    
+    // 获取邮箱或手机号作为账户标识
+    let email = (result.data.email || '').trim();
+    if (!email) {
+        email = (result.data.phone || '').trim();
+    }
+    if (!email) {
+        throw new Error('iFlow token: missing account email/phone in user info');
+    }
+    
+    return {
+        apiKey: result.data.apiKey,
+        email: email,
+        phone: result.data.phone || ''
+    };
+}
+
+/**
+ * 关闭 iFlow 服务器
+ * @param {string} provider - 提供商标识
+ * @param {number} port - 端口号（可选）
+ */
+async function closeIFlowServer(provider, port = null) {
+    const existing = activeIFlowServers.get(provider);
+    if (existing) {
+        await new Promise((resolve) => {
+            existing.server.close(() => {
+                activeIFlowServers.delete(provider);
+                console.log(`${IFLOW_OAUTH_CONFIG.logPrefix} 已关闭提供商 ${provider} 在端口 ${existing.port} 上的旧服务器`);
+                resolve();
+            });
+        });
+    }
+
+    if (port) {
+        for (const [p, info] of activeIFlowServers.entries()) {
+            if (info.port === port) {
+                await new Promise((resolve) => {
+                    info.server.close(() => {
+                        activeIFlowServers.delete(p);
+                        console.log(`${IFLOW_OAUTH_CONFIG.logPrefix} 已关闭端口 ${port} 上的旧服务器`);
+                        resolve();
+                    });
+                });
+            }
+        }
+    }
+}
+
+/**
+ * 创建 iFlow OAuth 回调服务器
+ * @param {number} port - 端口号
+ * @param {string} redirectUri - 重定向 URI
+ * @param {string} expectedState - 预期的 state 参数
+ * @param {Object} options - 额外选项
+ * @returns {Promise<http.Server>} HTTP 服务器实例
+ */
+function createIFlowCallbackServer(port, redirectUri, expectedState, options = {}) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(async (req, res) => {
+            try {
+                const url = new URL(req.url, `http://localhost:${port}`);
+                
+                if (url.pathname === '/oauth2callback') {
+                    const code = url.searchParams.get('code');
+                    const state = url.searchParams.get('state');
+                    const errorParam = url.searchParams.get('error');
+                    
+                    if (errorParam) {
+                        console.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 授权失败: ${errorParam}`);
+                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(generateResponsePage(false, `授权失败: ${errorParam}`));
+                        server.close(() => {
+                            activeIFlowServers.delete('openai-iflow');
+                        });
+                        return;
+                    }
+                    
+                    if (state !== expectedState) {
+                        console.error(`${IFLOW_OAUTH_CONFIG.logPrefix} State 验证失败`);
+                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(generateResponsePage(false, 'State 验证失败'));
+                        server.close(() => {
+                            activeIFlowServers.delete('openai-iflow');
+                        });
+                        return;
+                    }
+                    
+                    if (!code) {
+                        console.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 缺少授权码`);
+                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(generateResponsePage(false, '缺少授权码'));
+                        server.close(() => {
+                            activeIFlowServers.delete('openai-iflow');
+                        });
+                        return;
+                    }
+                    
+                    console.log(`${IFLOW_OAUTH_CONFIG.logPrefix} 收到授权回调，正在交换令牌...`);
+                    
+                    try {
+                        // 1. 交换授权码获取令牌
+                        const tokenData = await exchangeIFlowCodeForTokens(code, redirectUri);
+                        console.log(`${IFLOW_OAUTH_CONFIG.logPrefix} 令牌交换成功`);
+                        
+                        // 2. 获取用户信息（包含 API Key）
+                        const userInfo = await fetchIFlowUserInfo(tokenData.accessToken);
+                        console.log(`${IFLOW_OAUTH_CONFIG.logPrefix} 用户信息获取成功: ${userInfo.email}`);
+                        
+                        // 3. 组合完整的凭据数据
+                        const credentialsData = {
+                            access_token: tokenData.accessToken,
+                            refresh_token: tokenData.refreshToken,
+                            expiry_date: new Date(tokenData.expiresAt).getTime(),
+                            token_type: tokenData.tokenType,
+                            scope: tokenData.scope,
+                            apiKey: userInfo.apiKey
+                        };
+                        
+                        // 4. 保存凭据
+                        let credPath = path.join(os.homedir(), IFLOW_OAUTH_CONFIG.credentialsDir, IFLOW_OAUTH_CONFIG.credentialsFile);
+                        
+                        if (options.saveToConfigs) {
+                            const providerDir = options.providerDir || 'iflow';
+                            const targetDir = path.join(process.cwd(), 'configs', providerDir);
+                            await fs.promises.mkdir(targetDir, { recursive: true });
+                            const timestamp = Date.now();
+                            const filename = `${timestamp}_oauth_creds.json`;
+                            credPath = path.join(targetDir, filename);
+                        }
+                        
+                        await fs.promises.mkdir(path.dirname(credPath), { recursive: true });
+                        await fs.promises.writeFile(credPath, JSON.stringify(credentialsData, null, 2));
+                        console.log(`${IFLOW_OAUTH_CONFIG.logPrefix} 凭据已保存: ${credPath}`);
+                        
+                        const relativePath = path.relative(process.cwd(), credPath);
+                        
+                        // 5. 广播授权成功事件
+                        broadcastEvent('oauth_success', {
+                            provider: 'openai-iflow',
+                            credPath: credPath,
+                            relativePath: relativePath,
+                            email: userInfo.email,
+                            timestamp: new Date().toISOString()
+                        });
+                        
+                        // 6. 自动关联新生成的凭据到 Pools
+                        await autoLinkProviderConfigs(CONFIG);
+                        
+                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(generateResponsePage(true, `授权成功！账户: ${userInfo.email}，您可以关闭此页面`));
+                        
+                    } catch (tokenError) {
+                        console.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 令牌处理失败:`, tokenError);
+                        res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(generateResponsePage(false, `令牌处理失败: ${tokenError.message}`));
+                    } finally {
+                        server.close(() => {
+                            activeIFlowServers.delete('openai-iflow');
+                        });
+                    }
+                } else {
+                    // 忽略其他请求
+                    res.writeHead(204);
+                    res.end();
+                }
+            } catch (error) {
+                console.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 处理回调出错:`, error);
+                res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(generateResponsePage(false, `服务器错误: ${error.message}`));
+                
+                if (server.listening) {
+                    server.close(() => {
+                        activeIFlowServers.delete('openai-iflow');
+                    });
+                }
+            }
+        });
+        
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                console.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 端口 ${port} 已被占用`);
+                reject(new Error(`端口 ${port} 已被占用`));
+            } else {
+                console.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 服务器错误:`, err);
+                reject(err);
+            }
+        });
+        
+        const host = '0.0.0.0';
+        server.listen(port, host, () => {
+            console.log(`${IFLOW_OAUTH_CONFIG.logPrefix} OAuth 回调服务器已启动于 ${host}:${port}`);
+            resolve(server);
+        });
+        
+        // 10 分钟超时自动关闭
+        setTimeout(() => {
+            if (server.listening) {
+                console.log(`${IFLOW_OAUTH_CONFIG.logPrefix} 回调服务器超时，自动关闭`);
+                server.close(() => {
+                    activeIFlowServers.delete('openai-iflow');
+                });
+            }
+        }, 10 * 60 * 1000);
+    });
+}
+
+/**
+ * 处理 iFlow OAuth 授权
+ * @param {Object} currentConfig - 当前配置对象
+ * @param {Object} options - 额外选项
+ *   - port: 自定义端口号
+ *   - saveToConfigs: 是否保存到 configs 目录
+ *   - providerDir: 提供商目录名
+ * @returns {Promise<Object>} 返回授权URL和相关信息
+ */
+export async function handleIFlowOAuth(currentConfig, options = {}) {
+    const port = parseInt(options.port) || IFLOW_OAUTH_CONFIG.callbackPort;
+    const providerKey = 'openai-iflow';
+    
+    // 生成 state 参数
+    const state = crypto.randomBytes(16).toString('base64url');
+    
+    // 生成授权链接
+    const { authUrl, redirectUri } = generateIFlowAuthorizationURL(state, port);
+    
+    console.log(`${IFLOW_OAUTH_CONFIG.logPrefix} 生成授权链接: ${authUrl}`);
+    
+    // 关闭之前可能存在的服务器
+    await closeIFlowServer(providerKey, port);
+    
+    // 启动回调服务器
+    try {
+        const server = await createIFlowCallbackServer(port, redirectUri, state, options);
+        activeIFlowServers.set(providerKey, { server, port });
+    } catch (error) {
+        throw new Error(`启动 iFlow 回调服务器失败: ${error.message}`);
+    }
+    
+    return {
+        authUrl,
+        authInfo: {
+            provider: 'openai-iflow',
+            redirectUri: redirectUri,
+            callbackPort: port,
+            state: state,
+            ...options
+        }
+    };
+}
+
+/**
+ * 使用 refresh_token 刷新 iFlow 令牌
+ * @param {string} refreshToken - 刷新令牌
+ * @returns {Promise<Object>} 新的令牌数据
+ */
+export async function refreshIFlowTokens(refreshToken) {
+    const form = new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+        client_id: IFLOW_OAUTH_CONFIG.clientId,
+        client_secret: IFLOW_OAUTH_CONFIG.clientSecret
+    });
+    
+    // 生成 Basic Auth 头
+    const basicAuth = Buffer.from(`${IFLOW_OAUTH_CONFIG.clientId}:${IFLOW_OAUTH_CONFIG.clientSecret}`).toString('base64');
+
+    const response = await fetchWithProxy(IFLOW_OAUTH_CONFIG.tokenEndpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Accept': 'application/json',
+            'Authorization': `Basic ${basicAuth}`
+        },
+        body: form.toString()
+    }, 'openai-iflow');
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`iFlow token refresh failed: ${response.status} ${errorText}`);
+    }
+    
+    const tokenData = await response.json();
+    
+    if (!tokenData.access_token) {
+        throw new Error('iFlow token refresh: missing access token in response');
+    }
+    
+    // 获取用户信息以更新 API Key
+    const userInfo = await fetchIFlowUserInfo(tokenData.access_token);
+    
+    return {
+        access_token: tokenData.access_token,
+        refresh_token: tokenData.refresh_token,
+        expiry_date: Date.now() + tokenData.expires_in * 1000,
+        token_type: tokenData.token_type,
+        scope: tokenData.scope,
+        apiKey: userInfo.apiKey
+    };
+}

src/auth/index.js

@@ -0,0 +1,32 @@
+// Codex OAuth
+export {
+    refreshCodexTokensWithRetry,
+    handleCodexOAuth,
+    handleCodexOAuthCallback
+} from './codex-oauth.js';
+
+// Gemini OAuth
+export {
+    handleGeminiCliOAuth,
+    handleGeminiAntigravityOAuth
+} from './gemini-oauth.js';
+
+// Qwen OAuth
+export {
+    handleQwenOAuth
+} from './qwen-oauth.js';
+
+// Kiro OAuth
+export {
+    handleKiroOAuth,
+    checkKiroCredentialsDuplicate,
+    batchImportKiroRefreshTokens,
+    batchImportKiroRefreshTokensStream,
+    importAwsCredentials
+} from './kiro-oauth.js';
+
+// iFlow OAuth
+export {
+    handleIFlowOAuth,
+    refreshIFlowTokens
+} from './iflow-oauth.js';

src/auth/kiro-oauth.js

@@ -0,0 +1,1117 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import os from 'os';
+import { broadcastEvent } from '../services/ui-manager.js';
+import { autoLinkProviderConfigs } from '../services/service-manager.js';
+import { CONFIG } from '../core/config-manager.js';
+import { getProxyConfigForProvider } from '../utils/proxy-utils.js';
+
+/**
+ * Kiro OAuth 配置（支持多种认证方式）
+ */
+const KIRO_OAUTH_CONFIG = {
+    // Kiro Auth Service 端点 (用于 Social Auth)
+    authServiceEndpoint: 'https://prod.us-east-1.auth.desktop.kiro.dev',
+    
+    // AWS SSO OIDC 端点 (用于 Builder ID)
+    ssoOIDCEndpoint: 'https://oidc.{{region}}.amazonaws.com',
+    
+    // AWS Builder ID 起始 URL
+    builderIDStartURL: 'https://view.awsapps.com/start',
+    
+    // 本地回调端口范围（用于 Social Auth HTTP 回调）
+    callbackPortStart: 19876,
+    callbackPortEnd: 19880,
+    
+    // 超时配置
+    authTimeout: 10 * 60 * 1000,  // 10 分钟
+    pollInterval: 5000,           // 5 秒
+    
+    // CodeWhisperer Scopes
+    scopes: [
+        'codewhisperer:completions',
+        'codewhisperer:analysis',
+        'codewhisperer:conversations',
+        // 'codewhisperer:transformations',
+        // 'codewhisperer:taskassist'
+    ],
+    
+    // 凭据存储（符合现有规范）
+    credentialsDir: '.kiro',
+    credentialsFile: 'oauth_creds.json',
+    
+    // 日志前缀
+    logPrefix: '[Kiro Auth]'
+};
+
+/**
+ * 活动的 Kiro 回调服务器管理
+ */
+const activeKiroServers = new Map();
+
+/**
+ * 活动的 Kiro 轮询任务管理（用于 Builder ID Device Code）
+ */
+const activeKiroPollingTasks = new Map();
+
+/**
+ * 创建带代理支持的 fetch 请求
+ * 使用 axios 替代原生 fetch，以正确支持代理配置
+ * @param {string} url - 请求 URL
+ * @param {Object} options - fetch 选项（兼容 fetch API 格式）
+ * @param {string} providerType - 提供商类型，用于获取代理配置
+ * @returns {Promise<Object>} 返回类似 fetch Response 的对象
+ */
+async function fetchWithProxy(url, options = {}, providerType) {
+    const proxyConfig = getProxyConfigForProvider(CONFIG, providerType);
+
+    // 构建 axios 配置
+    const axiosConfig = {
+        url,
+        method: options.method || 'GET',
+        headers: options.headers || {},
+        timeout: 30000, // 30 秒超时
+    };
+
+    // 处理请求体
+    if (options.body) {
+        axiosConfig.data = options.body;
+    }
+
+    // 配置代理
+    if (proxyConfig) {
+        axiosConfig.httpAgent = proxyConfig.httpAgent;
+        axiosConfig.httpsAgent = proxyConfig.httpsAgent;
+        axiosConfig.proxy = false; // 禁用 axios 内置代理，使用我们的 agent
+        console.log(`[OAuth] Using proxy for ${providerType}: ${CONFIG.PROXY_URL}`);
+    }
+
+    try {
+        const axios = (await import('axios')).default;
+        const response = await axios(axiosConfig);
+        
+        // 返回类似 fetch Response 的对象
+        return {
+            ok: response.status >= 200 && response.status < 300,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            json: async () => response.data,
+            text: async () => typeof response.data === 'string' ? response.data : JSON.stringify(response.data),
+        };
+    } catch (error) {
+        // 处理 axios 错误，转换为类似 fetch 的响应格式
+        if (error.response) {
+            // 服务器返回了错误状态码
+            return {
+                ok: false,
+                status: error.response.status,
+                statusText: error.response.statusText,
+                headers: error.response.headers,
+                json: async () => error.response.data,
+                text: async () => typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data),
+            };
+        }
+        // 网络错误或其他错误
+        throw error;
+    }
+}
+
+/**
+ * 生成 HTML 响应页面
+ * @param {boolean} isSuccess - 是否成功
+ * @param {string} message - 显示消息
+ * @returns {string} HTML 内容
+ */
+function generateResponsePage(isSuccess, message) {
+    const title = isSuccess ? '授权成功！' : '授权失败';
+    
+    return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+</head>
+<body>
+    <div class="container">
+        <h1>${title}</h1>
+        <p>${message}</p>
+    </div>
+</body>
+</html>`;
+}
+
+/**
+ * 生成 PKCE 代码验证器
+ * @returns {string} Base64URL 编码的随机字符串
+ */
+function generateCodeVerifier() {
+    return crypto.randomBytes(32).toString('base64url');
+}
+
+/**
+ * 生成 PKCE 代码挑战
+ * @param {string} codeVerifier - 代码验证器
+ * @returns {string} Base64URL 编码的 SHA256 哈希
+ */
+function generateCodeChallenge(codeVerifier) {
+    const hash = crypto.createHash('sha256');
+    hash.update(codeVerifier);
+    return hash.digest('base64url');
+}
+
+/**
+ * 处理 Kiro OAuth 授权（统一入口）
+ * @param {Object} currentConfig - 当前配置对象
+ * @param {Object} options - 额外选项
+ *   - method: 'google' | 'github' | 'builder-id'
+ *   - saveToConfigs: boolean
+ * @returns {Promise<Object>} 返回授权URL和相关信息
+ */
+export async function handleKiroOAuth(currentConfig, options = {}) {
+    const method = options.method || options.authMethod || 'google';  // 默认使用 Google，同时支持 authMethod 参数
+    
+    console.log(`${KIRO_OAUTH_CONFIG.logPrefix} Starting OAuth with method: ${method}`);
+    
+    switch (method) {
+        case 'google':
+            return handleKiroSocialAuth('Google', currentConfig, options);
+        case 'github':
+            return handleKiroSocialAuth('Github', currentConfig, options);
+        case 'builder-id':
+            return handleKiroBuilderIDDeviceCode(currentConfig, options);
+        default:
+            throw new Error(`不支持的认证方式: ${method}`);
+    }
+}
+
+/**
+ * Kiro Social Auth (Google/GitHub) - 使用 HTTP localhost 回调
+ */
+async function handleKiroSocialAuth(provider, currentConfig, options = {}) {
+    // 生成 PKCE 参数
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    const state = crypto.randomBytes(16).toString('base64url');
+    
+    // 启动本地回调服务器并获取端口
+    let handlerPort;
+    const providerKey = 'claude-kiro-oauth';
+    if (options.port) {
+        const port = parseInt(options.port);
+        await closeKiroServer(providerKey, port);
+        const server = await createKiroHttpCallbackServer(port, codeVerifier, state, options);
+        activeKiroServers.set(providerKey, { server, port });
+        handlerPort = port;
+    } else {
+        handlerPort = await startKiroCallbackServer(codeVerifier, state, options);
+    }
+    
+    // 使用 HTTP localhost 作为 redirect_uri
+    const redirectUri = `http://127.0.0.1:${handlerPort}/oauth/callback`;
+    
+    // 构建授权 URL
+    const authUrl = `${KIRO_OAUTH_CONFIG.authServiceEndpoint}/login?` +
+        `idp=${provider}&` +
+        `redirect_uri=${encodeURIComponent(redirectUri)}&` +
+        `code_challenge=${codeChallenge}&` +
+        `code_challenge_method=S256&` +
+        `state=${state}&` +
+        `prompt=select_account`;
+    
+    return {
+        authUrl,
+        authInfo: {
+            provider: 'claude-kiro-oauth',
+            authMethod: 'social',
+            socialProvider: provider,
+            port: handlerPort,
+            redirectUri: redirectUri,
+            state: state,
+            ...options
+        }
+    };
+}
+
+/**
+ * Kiro Builder ID - Device Code Flow（类似 Qwen OAuth 模式）
+ */
+async function handleKiroBuilderIDDeviceCode(currentConfig, options = {}) {
+    // 停止之前的轮询任务
+    for (const [existingTaskId] of activeKiroPollingTasks.entries()) {
+        if (existingTaskId.startsWith('kiro-')) {
+            stopKiroPollingTask(existingTaskId);
+        }
+    }
+
+    // 获取 Builder ID Start URL（优先使用前端传入的值，否则使用默认值）
+    const builderIDStartURL = options.builderIDStartURL || KIRO_OAUTH_CONFIG.builderIDStartURL;
+    console.log(`${KIRO_OAUTH_CONFIG.logPrefix} Using Builder ID Start URL: ${builderIDStartURL}`);
+
+    // 1. 注册 OIDC 客户端
+    const region = options.region || 'us-east-1';
+    const ssoOIDCEndpoint = KIRO_OAUTH_CONFIG.ssoOIDCEndpoint.replace('{{region}}', region);
+    
+    const regResponse = await fetchWithProxy(`${ssoOIDCEndpoint}/client/register`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'User-Agent': 'KiroIDE'
+        },
+        body: JSON.stringify({
+            clientName: 'Kiro IDE',
+            clientType: 'public',
+            scopes: KIRO_OAUTH_CONFIG.scopes,
+            // grantTypes: ['urn:ietf:params:oauth:grant-type:device_code', 'refresh_token']
+        })
+    }, 'claude-kiro-oauth');
+    
+    if (!regResponse.ok) {
+        throw new Error(`Kiro OAuth 客户端注册失败: ${regResponse.status}`);
+    }
+    
+    const regData = await regResponse.json();
+    
+    // 2. 启动设备授权
+    const authResponse = await fetchWithProxy(`${ssoOIDCEndpoint}/device_authorization`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            clientId: regData.clientId,
+            clientSecret: regData.clientSecret,
+            startUrl: builderIDStartURL
+        })
+    }, 'claude-kiro-oauth');
+    
+    if (!authResponse.ok) {
+        throw new Error(`Kiro OAuth 设备授权失败: ${authResponse.status}`);
+    }
+    
+    const deviceAuth = await authResponse.json();
+    
+    // 3. 启动后台轮询（类似 Qwen OAuth ��模式）
+    const taskId = `kiro-${deviceAuth.deviceCode.substring(0, 8)}-${Date.now()}`;
+
+    
+    // 异步轮询
+    pollKiroBuilderIDToken(
+        regData.clientId,
+        regData.clientSecret,
+        deviceAuth.deviceCode,
+        5, 
+        300, 
+        taskId,
+        { ...options, region }
+    ).catch(error => {
+        console.error(`${KIRO_OAUTH_CONFIG.logPrefix} 轮询失败 [${taskId}]:`, error);
+        broadcastEvent('oauth_error', {
+            provider: 'claude-kiro-oauth',
+            error: error.message,
+            timestamp: new Date().toISOString()
+        });
+    });
+    
+    return {
+        authUrl: deviceAuth.verificationUriComplete,
+        authInfo: {
+            provider: 'claude-kiro-oauth',
+            authMethod: 'builder-id',
+            deviceCode: deviceAuth.deviceCode,
+            userCode: deviceAuth.userCode,
+            verificationUri: deviceAuth.verificationUri,
+            verificationUriComplete: deviceAuth.verificationUriComplete,
+            expiresIn: deviceAuth.expiresIn,
+            interval: deviceAuth.interval,
+            ...options
+        }
+    };
+}
+
+/**
+ * 轮询获取 Kiro Builder ID Token
+ */
+async function pollKiroBuilderIDToken(clientId, clientSecret, deviceCode, interval, expiresIn, taskId, options = {}) {
+    let credPath = path.join(os.homedir(), KIRO_OAUTH_CONFIG.credentialsDir, KIRO_OAUTH_CONFIG.credentialsFile);
+    const maxAttempts = Math.floor(expiresIn / interval);
+    let attempts = 0;
+    
+    const taskControl = { shouldStop: false };
+    activeKiroPollingTasks.set(taskId, taskControl);
+    
+    console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 开始轮询令牌 [${taskId}]`);
+    
+    const poll = async () => {
+        if (taskControl.shouldStop) {
+            throw new Error('轮询任务已被取消');
+        }
+        
+        if (attempts >= maxAttempts) {
+            activeKiroPollingTasks.delete(taskId);
+            throw new Error('授权超时');
+        }
+        
+        attempts++;
+        
+        try {
+            const region = options.region || 'us-east-1';
+            const ssoOIDCEndpoint = KIRO_OAUTH_CONFIG.ssoOIDCEndpoint.replace('{{region}}', region);
+            const response = await fetchWithProxy(`${ssoOIDCEndpoint}/token`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'KiroIDE'
+                },
+                body: JSON.stringify({
+                    clientId,
+                    clientSecret,
+                    deviceCode,
+                    grantType: 'urn:ietf:params:oauth:grant-type:device_code'
+                })
+            }, 'claude-kiro-oauth');
+            
+            const data = await response.json();
+            
+            if (response.ok && data.accessToken) {
+                console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 成功获取令牌 [${taskId}]`);
+                
+                // 保存令牌（符合现有规范）
+                if (options.saveToConfigs) {
+                    const timestamp = Date.now();
+                    const folderName = `${timestamp}_kiro-auth-token`;
+                    const targetDir = path.join(process.cwd(), 'configs', 'kiro', folderName);
+                    await fs.promises.mkdir(targetDir, { recursive: true });
+                    credPath = path.join(targetDir, `${folderName}.json`);
+                }
+                
+                const tokenData = {
+                    accessToken: data.accessToken,
+                    refreshToken: data.refreshToken,
+                    expiresAt: new Date(Date.now() + data.expiresIn * 1000).toISOString(),
+                    authMethod: 'builder-id',
+                    clientId,
+                    clientSecret,
+                    idcRegion: options.region || 'us-east-1'
+                };
+                
+                await fs.promises.mkdir(path.dirname(credPath), { recursive: true });
+                await fs.promises.writeFile(credPath, JSON.stringify(tokenData, null, 2));
+                
+                activeKiroPollingTasks.delete(taskId);
+                
+                // 广播成功事件（符合现有规范）
+                broadcastEvent('oauth_success', {
+                    provider: 'claude-kiro-oauth',
+                    credPath,
+                    relativePath: path.relative(process.cwd(), credPath),
+                    timestamp: new Date().toISOString()
+                });
+                
+                // 自动关联新生成的凭据到 Pools
+                await autoLinkProviderConfigs(CONFIG);
+                
+                return tokenData;
+            }
+            
+            // 检查错误类型
+            if (data.error === 'authorization_pending') {
+                console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 等待用户授权 [${taskId}]... (${attempts}/${maxAttempts})`);
+                await new Promise(resolve => setTimeout(resolve, interval * 1000));
+                return poll();
+            } else if (data.error === 'slow_down') {
+                await new Promise(resolve => setTimeout(resolve, (interval + 5) * 1000));
+                return poll();
+            } else {
+                activeKiroPollingTasks.delete(taskId);
+                throw new Error(`授权失败: ${data.error || '未知错误'}`);
+            }
+        } catch (error) {
+            if (error.message.includes('授权') || error.message.includes('取消')) {
+                throw error;
+            }
+            await new Promise(resolve => setTimeout(resolve, interval * 1000));
+            return poll();
+        }
+    };
+    
+    return poll();
+}
+
+/**
+ * 停止 Kiro 轮询任务
+ */
+function stopKiroPollingTask(taskId) {
+    const task = activeKiroPollingTasks.get(taskId);
+    if (task) {
+        task.shouldStop = true;
+        activeKiroPollingTasks.delete(taskId);
+        console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 已停止轮询任务: ${taskId}`);
+    }
+}
+
+/**
+ * 启动 Kiro 回调服务器（用于 Social Auth HTTP 回调）
+ */
+async function startKiroCallbackServer(codeVerifier, expectedState, options = {}) {
+    const portStart = KIRO_OAUTH_CONFIG.callbackPortStart;
+    const portEnd = KIRO_OAUTH_CONFIG.callbackPortEnd;
+    
+    for (let port = portStart; port <= portEnd; port++) {
+    // 关闭已存在的服务器
+    await closeKiroServer(port);
+    
+    try {
+        const server = await createKiroHttpCallbackServer(port, codeVerifier, expectedState, options);
+        activeKiroServers.set('claude-kiro-oauth', { server, port });
+        console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 回调服务器已启动于端口 ${port}`);
+        return port;
+    } catch (err) {
+            console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 端口 ${port} 被占用，尝试下一个...`);
+    }
+    }
+    
+    throw new Error('所有端口都被占用');
+}
+
+/**
+ * 关闭 Kiro 服务器
+ */
+async function closeKiroServer(provider, port = null) {
+    const existing = activeKiroServers.get(provider);
+    if (existing) {
+        await new Promise((resolve) => {
+            existing.server.close(() => {
+                activeKiroServers.delete(provider);
+                console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 已关闭提供商 ${provider} 在端口 ${existing.port} 上的旧服务器`);
+                resolve();
+            });
+        });
+    }
+
+    if (port) {
+        for (const [p, info] of activeKiroServers.entries()) {
+            if (info.port === port) {
+                await new Promise((resolve) => {
+                    info.server.close(() => {
+                        activeKiroServers.delete(p);
+                        console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 已关闭端口 ${port} 上的旧服务器`);
+                        resolve();
+                    });
+                });
+            }
+        }
+    }
+}
+
+/**
+ * 创建 Kiro HTTP 回调服务器
+ */
+function createKiroHttpCallbackServer(port, codeVerifier, expectedState, options = {}) {
+    const redirectUri = `http://127.0.0.1:${port}/oauth/callback`;
+    
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(async (req, res) => {
+            try {
+                const url = new URL(req.url, `http://127.0.0.1:${port}`);
+                
+                if (url.pathname === '/oauth/callback') {
+                    const code = url.searchParams.get('code');
+                    const state = url.searchParams.get('state');
+                    const errorParam = url.searchParams.get('error');
+                    
+                    if (errorParam) {
+                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(generateResponsePage(false, `授权失败: ${errorParam}`));
+                        return;
+                    }
+                    
+                    if (state !== expectedState) {
+                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(generateResponsePage(false, 'State 验证失败'));
+                        return;
+                    }
+                    
+                    // 交换 Code 获取 Token（使用动态的 redirect_uri）
+                    const tokenResponse = await fetchWithProxy(`${KIRO_OAUTH_CONFIG.authServiceEndpoint}/oauth/token`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'User-Agent': 'AIClient-2-API/1.0.0'
+                        },
+                        body: JSON.stringify({
+                            code,
+                            code_verifier: codeVerifier,
+                            redirect_uri: redirectUri
+                        })
+                    }, 'claude-kiro-oauth');
+                    
+                    if (!tokenResponse.ok) {
+                        const errorText = await tokenResponse.text();
+                        console.error(`${KIRO_OAUTH_CONFIG.logPrefix} Token exchange failed:`, errorText);
+                        res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.end(generateResponsePage(false, `获取令牌失败: ${tokenResponse.status}`));
+                        return;
+                    }
+                    
+                    const tokenData = await tokenResponse.json();
+                    
+                    // 保存令牌
+                    let credPath = path.join(os.homedir(), KIRO_OAUTH_CONFIG.credentialsDir, KIRO_OAUTH_CONFIG.credentialsFile);
+                    
+                    if (options.saveToConfigs) {
+                        const timestamp = Date.now();
+                        const folderName = `${timestamp}_kiro-auth-token`;
+                        const targetDir = path.join(process.cwd(), 'configs', 'kiro', folderName);
+                        await fs.promises.mkdir(targetDir, { recursive: true });
+                        credPath = path.join(targetDir, `${folderName}.json`);
+                    }
+                    
+                    const saveData = {
+                        accessToken: tokenData.accessToken,
+                        refreshToken: tokenData.refreshToken,
+                        profileArn: tokenData.profileArn,
+                        expiresAt: new Date(Date.now() + (tokenData.expiresIn || 3600) * 1000).toISOString(),
+                        authMethod: 'social',
+                        region: 'us-east-1'
+                    };
+                    
+                    await fs.promises.mkdir(path.dirname(credPath), { recursive: true });
+                    await fs.promises.writeFile(credPath, JSON.stringify(saveData, null, 2));
+                    
+                    console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 令牌已保存: ${credPath}`);
+                    
+                    // 广播成功事件
+                    broadcastEvent('oauth_success', {
+                        provider: 'claude-kiro-oauth',
+                        credPath,
+                        relativePath: path.relative(process.cwd(), credPath),
+                        timestamp: new Date().toISOString()
+                    });
+                    
+                    // 自动关联新生成的凭据到 Pools
+                    await autoLinkProviderConfigs(CONFIG);
+                    
+                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end(generateResponsePage(true, '授权成功！您可以关闭此页面'));
+                    
+                    // 关闭服务器
+                    server.close(() => {
+                        activeKiroServers.delete('claude-kiro-oauth');
+                    });
+                    
+                } else {
+                    res.writeHead(204);
+                    res.end();
+                }
+            } catch (error) {
+                console.error(`${KIRO_OAUTH_CONFIG.logPrefix} 处理回调出错:`, error);
+                res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(generateResponsePage(false, `服务器错误: ${error.message}`));
+            }
+        });
+        
+        server.on('error', reject);
+        server.listen(port, '127.0.0.1', () => resolve(server));
+        
+        // 超时自动关闭
+        setTimeout(() => {
+            if (server.listening) {
+                server.close(() => {
+                    activeKiroServers.delete('claude-kiro-oauth');
+                });
+            }
+        }, KIRO_OAUTH_CONFIG.authTimeout);
+    });
+}
+
+/**
+ * Kiro Token 刷新常量
+ */
+const KIRO_REFRESH_CONSTANTS = {
+    REFRESH_URL: 'https://prod.{{region}}.auth.desktop.kiro.dev/refreshToken',
+    REFRESH_IDC_URL: 'https://oidc.{{region}}.amazonaws.com/token',
+    CONTENT_TYPE_JSON: 'application/json',
+    AUTH_METHOD_SOCIAL: 'social',
+    DEFAULT_PROVIDER: 'Google',
+    REQUEST_TIMEOUT: 30000,
+    DEFAULT_REGION: 'us-east-1',
+    IDC_REGION: 'us-east-1'  // 用于 REFRESH_IDC_URL 的区域配置
+};
+
+/**
+ * 通过 refreshToken 获取 accessToken
+ * @param {string} refreshToken - Kiro 的 refresh token
+ * @param {string} region - AWS 区域 (默认: us-east-1)
+ * @returns {Promise<Object>} 包含 accessToken 等信息的对象
+ */
+async function refreshKiroToken(refreshToken, region = KIRO_REFRESH_CONSTANTS.DEFAULT_REGION) {
+    const refreshUrl = KIRO_REFRESH_CONSTANTS.REFRESH_URL.replace('{{region}}', region);
+    
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), KIRO_REFRESH_CONSTANTS.REQUEST_TIMEOUT);
+    
+    try {
+        const response = await fetchWithProxy(refreshUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': KIRO_REFRESH_CONSTANTS.CONTENT_TYPE_JSON
+            },
+            body: JSON.stringify({ refreshToken }),
+            signal: controller.signal
+        }, 'claude-kiro-oauth');
+        
+        clearTimeout(timeoutId);
+        
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP ${response.status}: ${errorText}`);
+        }
+        
+        const data = await response.json();
+        
+        if (!data.accessToken) {
+            throw new Error('Invalid refresh response: Missing accessToken');
+        }
+        
+        const expiresIn = data.expiresIn || 3600;
+        const expiresAt = new Date(Date.now() + expiresIn * 1000).toISOString();
+        
+        return {
+            accessToken: data.accessToken,
+            refreshToken: data.refreshToken || refreshToken,
+            profileArn: data.profileArn || '',
+            expiresAt: expiresAt,
+            authMethod: KIRO_REFRESH_CONSTANTS.AUTH_METHOD_SOCIAL,
+            provider: KIRO_REFRESH_CONSTANTS.DEFAULT_PROVIDER,
+            region: region
+        };
+    } catch (error) {
+        clearTimeout(timeoutId);
+        if (error.name === 'AbortError') {
+            throw new Error('Request timeout');
+        }
+        throw error;
+    }
+}
+
+/**
+ * 检查 Kiro 凭据是否已存在（基于 refreshToken + provider 组合）
+ * @param {string} refreshToken - 要检查的 refreshToken
+ * @param {string} provider - 提供商名称 (默认: 'claude-kiro-oauth')
+ * @returns {Promise<{isDuplicate: boolean, existingPath?: string}>} 检查结果
+ */
+export async function checkKiroCredentialsDuplicate(refreshToken, provider = 'claude-kiro-oauth') {
+    const kiroDir = path.join(process.cwd(), 'configs', 'kiro');
+    
+    try {
+        // 检查 configs/kiro 目录是否存在
+        if (!fs.existsSync(kiroDir)) {
+            return { isDuplicate: false };
+        }
+        
+        // 递归扫描所有 JSON 文件
+        const scanDirectory = async (dirPath) => {
+            const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+            
+            for (const entry of entries) {
+                const fullPath = path.join(dirPath, entry.name);
+                
+                if (entry.isDirectory()) {
+                    const result = await scanDirectory(fullPath);
+                    if (result.isDuplicate) {
+                        return result;
+                    }
+                } else if (entry.isFile() && entry.name.endsWith('.json')) {
+                    try {
+                        const content = await fs.promises.readFile(fullPath, 'utf8');
+                        const credentials = JSON.parse(content);
+                        
+                        // 检查 refreshToken 是否匹配
+                        if (credentials.refreshToken && credentials.refreshToken === refreshToken) {
+                            const relativePath = path.relative(process.cwd(), fullPath);
+                            console.log(`${KIRO_OAUTH_CONFIG.logPrefix} Found duplicate refreshToken in: ${relativePath}`);
+                            return {
+                                isDuplicate: true,
+                                existingPath: relativePath
+                            };
+                        }
+                    } catch (parseError) {
+                        // 忽略解析错误的文件
+                    }
+                }
+            }
+            
+            return { isDuplicate: false };
+        };
+        
+        return await scanDirectory(kiroDir);
+        
+    } catch (error) {
+        console.warn(`${KIRO_OAUTH_CONFIG.logPrefix} Error checking duplicates:`, error.message);
+        return { isDuplicate: false };
+    }
+}
+
+/**
+ * 批量导入 Kiro refreshToken 并生成凭据文件
+ * @param {string[]} refreshTokens - refreshToken 数组
+ * @param {string} region - AWS 区域 (默认: us-east-1)
+ * @param {boolean} skipDuplicateCheck - 是否跳过重复检查 (默认: false)
+ * @returns {Promise<Object>} 批量处理结果
+ */
+export async function batchImportKiroRefreshTokens(refreshTokens, region = KIRO_REFRESH_CONSTANTS.DEFAULT_REGION, skipDuplicateCheck = false) {
+    const results = {
+        total: refreshTokens.length,
+        success: 0,
+        failed: 0,
+        details: []
+    };
+    
+    for (let i = 0; i < refreshTokens.length; i++) {
+        const refreshToken = refreshTokens[i].trim();
+        
+        if (!refreshToken) {
+            results.details.push({
+                index: i + 1,
+                success: false,
+                error: 'Empty token'
+            });
+            results.failed++;
+            continue;
+        }
+        
+        // 检查重复
+        if (!skipDuplicateCheck) {
+            const duplicateCheck = await checkKiroCredentialsDuplicate(refreshToken);
+            if (duplicateCheck.isDuplicate) {
+                results.details.push({
+                    index: i + 1,
+                    success: false,
+                    error: 'duplicate',
+                    existingPath: duplicateCheck.existingPath
+                });
+                results.failed++;
+                continue;
+            }
+        }
+        
+        try {
+            console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 正在刷新第 ${i + 1}/${refreshTokens.length} 个 token...`);
+            
+            const tokenData = await refreshKiroToken(refreshToken, region);
+            
+            // 生成文件路径: configs/kiro/{timestamp}_kiro-auth-token/{timestamp}_kiro-auth-token.json
+            const timestamp = Date.now();
+            const folderName = `${timestamp}_kiro-auth-token`;
+            const targetDir = path.join(process.cwd(), 'configs', 'kiro', folderName);
+            await fs.promises.mkdir(targetDir, { recursive: true });
+            
+            const credPath = path.join(targetDir, `${folderName}.json`);
+            await fs.promises.writeFile(credPath, JSON.stringify(tokenData, null, 2));
+            
+            const relativePath = path.relative(process.cwd(), credPath);
+            
+            console.log(`${KIRO_OAUTH_CONFIG.logPrefix} Token ${i + 1} 已保存: ${relativePath}`);
+            
+            results.details.push({
+                index: i + 1,
+                success: true,
+                path: relativePath,
+                expiresAt: tokenData.expiresAt
+            });
+            results.success++;
+            
+        } catch (error) {
+            console.error(`${KIRO_OAUTH_CONFIG.logPrefix} Token ${i + 1} 刷新失败:`, error.message);
+            
+            results.details.push({
+                index: i + 1,
+                success: false,
+                error: error.message
+            });
+            results.failed++;
+        }
+    }
+    
+    // 如果有成功的，广播事件并自动关联
+    if (results.success > 0) {
+        broadcastEvent('oauth_batch_success', {
+            provider: 'claude-kiro-oauth',
+            count: results.success,
+            timestamp: new Date().toISOString()
+        });
+        
+        // 自动关联新生成的凭据到 Pools
+        await autoLinkProviderConfigs(CONFIG);
+    }
+    
+    return results;
+}
+
+/**
+ * 批量导入 Kiro refreshToken 并生成凭据文件（流式版本，支持实时进度回调）
+ * @param {string[]} refreshTokens - refreshToken 数组
+ * @param {string} region - AWS 区域 (默认: us-east-1)
+ * @param {Function} onProgress - 进度回调函数，每处理完一个 token 调用
+ * @param {boolean} skipDuplicateCheck - 是否跳过重复检查 (默认: false)
+ * @returns {Promise<Object>} 批量处理结果
+ */
+export async function batchImportKiroRefreshTokensStream(refreshTokens, region = KIRO_REFRESH_CONSTANTS.DEFAULT_REGION, onProgress = null, skipDuplicateCheck = false) {
+    const results = {
+        total: refreshTokens.length,
+        success: 0,
+        failed: 0,
+        details: []
+    };
+    
+    for (let i = 0; i < refreshTokens.length; i++) {
+        const refreshToken = refreshTokens[i].trim();
+        const progressData = {
+            index: i + 1,
+            total: refreshTokens.length,
+            current: null
+        };
+        
+        if (!refreshToken) {
+            progressData.current = {
+                index: i + 1,
+                success: false,
+                error: 'Empty token'
+            };
+            results.details.push(progressData.current);
+            results.failed++;
+            
+            // 发送进度更新
+            if (onProgress) {
+                onProgress({
+                    ...progressData,
+                    successCount: results.success,
+                    failedCount: results.failed
+                });
+            }
+            continue;
+        }
+        
+        // 检查重复
+        if (!skipDuplicateCheck) {
+            const duplicateCheck = await checkKiroCredentialsDuplicate(refreshToken);
+            if (duplicateCheck.isDuplicate) {
+                progressData.current = {
+                    index: i + 1,
+                    success: false,
+                    error: 'duplicate',
+                    existingPath: duplicateCheck.existingPath
+                };
+                results.details.push(progressData.current);
+                results.failed++;
+                
+                // 发送进度更新
+                if (onProgress) {
+                    onProgress({
+                        ...progressData,
+                        successCount: results.success,
+                        failedCount: results.failed
+                    });
+                }
+                continue;
+            }
+        }
+        
+        try {
+            console.log(`${KIRO_OAUTH_CONFIG.logPrefix} 正在刷新第 ${i + 1}/${refreshTokens.length} 个 token...`);
+            
+            const tokenData = await refreshKiroToken(refreshToken, region);
+            
+            // 生成文件路径: configs/kiro/{timestamp}_kiro-auth-token/{timestamp}_kiro-auth-token.json
+            const timestamp = Date.now();
+            const folderName = `${timestamp}_kiro-auth-token`;
+            const targetDir = path.join(process.cwd(), 'configs', 'kiro', folderName);
+            await fs.promises.mkdir(targetDir, { recursive: true });
+            
+            const credPath = path.join(targetDir, `${folderName}.json`);
+            await fs.promises.writeFile(credPath, JSON.stringify(tokenData, null, 2));
+            
+            const relativePath = path.relative(process.cwd(), credPath);
+            
+            console.log(`${KIRO_OAUTH_CONFIG.logPrefix} Token ${i + 1} 已保存: ${relativePath}`);
+            
+            progressData.current = {
+                index: i + 1,
+                success: true,
+                path: relativePath,
+                expiresAt: tokenData.expiresAt
+            };
+            results.details.push(progressData.current);
+            results.success++;
+            
+        } catch (error) {
+            console.error(`${KIRO_OAUTH_CONFIG.logPrefix} Token ${i + 1} 刷新失败:`, error.message);
+            
+            progressData.current = {
+                index: i + 1,
+                success: false,
+                error: error.message
+            };
+            results.details.push(progressData.current);
+            results.failed++;
+        }
+        
+        // 发送进度更新
+        if (onProgress) {
+            onProgress({
+                ...progressData,
+                successCount: results.success,
+                failedCount: results.failed
+            });
+        }
+    }
+    
+    // 如果有成功的，广播事件并自动关联
+    if (results.success > 0) {
+        broadcastEvent('oauth_batch_success', {
+            provider: 'claude-kiro-oauth',
+            count: results.success,
+            timestamp: new Date().toISOString()
+        });
+        
+        // 自动关联新生成的凭据到 Pools
+        await autoLinkProviderConfigs(CONFIG);
+    }
+    
+    return results;
+}
+
+/**
+ * 导入 AWS SSO 凭据用于 Kiro (Builder ID 模式)
+ * 从用户上传的 AWS SSO cache 文件中导入凭据
+ * @param {Object} credentials - 合并后的凭据对象，需包含 clientId 和 clientSecret
+ * @param {boolean} skipDuplicateCheck - 是否跳过重复检查 (默认: false)
+ * @returns {Promise<Object>} 导入结果
+ */
+export async function importAwsCredentials(credentials, skipDuplicateCheck = false) {
+    try {
+        // 验证必需字段 - 需要四个字段都存在
+        const missingFields = [];
+        if (!credentials.clientId) missingFields.push('clientId');
+        if (!credentials.clientSecret) missingFields.push('clientSecret');
+        if (!credentials.accessToken) missingFields.push('accessToken');
+        if (!credentials.refreshToken) missingFields.push('refreshToken');
+        
+        if (missingFields.length > 0) {
+            return {
+                success: false,
+                error: `Missing required fields: ${missingFields.join(', ')}`
+            };
+        }
+        
+        // 检查重复凭据
+        if (!skipDuplicateCheck) {
+            const duplicateCheck = await checkKiroCredentialsDuplicate(credentials.refreshToken);
+            if (duplicateCheck.isDuplicate) {
+                return {
+                    success: false,
+                    error: 'duplicate',
+                    existingPath: duplicateCheck.existingPath
+                };
+            }
+        }
+        
+        console.log(`${KIRO_OAUTH_CONFIG.logPrefix} Importing AWS credentials...`);
+        
+        // 准备凭据数据 - 四个字段都是必需的
+        const credentialsData = {
+            clientId: credentials.clientId,
+            clientSecret: credentials.clientSecret,
+            accessToken: credentials.accessToken,
+            refreshToken: credentials.refreshToken,
+            authMethod: credentials.authMethod || 'builder-id',
+            // region: credentials.region || KIRO_REFRESH_CONSTANTS.DEFAULT_REGION,
+            idcRegion: credentials.idcRegion || KIRO_REFRESH_CONSTANTS.IDC_REGION
+        };
+        
+        // 可选字段
+        if (credentials.expiresAt) {
+            credentialsData.expiresAt = credentials.expiresAt;
+        }
+        if (credentials.startUrl) {
+            credentialsData.startUrl = credentials.startUrl;
+        }
+        if (credentials.registrationExpiresAt) {
+            credentialsData.registrationExpiresAt = credentials.registrationExpiresAt;
+        }
+        
+        // 尝试刷新获取最新的 accessToken
+        try {
+            console.log(`${KIRO_OAUTH_CONFIG.logPrefix} Attempting to refresh token with provided credentials...`);
+            
+            const refreshRegion = credentials.idcRegion || KIRO_REFRESH_CONSTANTS.IDC_REGION;
+            const refreshUrl = KIRO_REFRESH_CONSTANTS.REFRESH_IDC_URL.replace('{{region}}', refreshRegion);
+            
+            const refreshResponse = await fetchWithProxy(refreshUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    refreshToken: credentials.refreshToken,
+                    clientId: credentials.clientId,
+                    clientSecret: credentials.clientSecret,
+                    grantType: 'refresh_token'
+                })
+            }, 'claude-kiro-oauth');
+            
+            if (refreshResponse.ok) {
+                const tokenData = await refreshResponse.json();
+                credentialsData.accessToken = tokenData.accessToken;
+                credentialsData.refreshToken = tokenData.refreshToken;
+                const expiresIn = tokenData.expiresIn || 3600;
+                credentialsData.expiresAt = new Date(Date.now() + expiresIn * 1000).toISOString();
+                console.log(`${KIRO_OAUTH_CONFIG.logPrefix} Token refreshed successfully`);
+            } else {
+                console.warn(`${KIRO_OAUTH_CONFIG.logPrefix} Token refresh failed, saving original credentials`);
+            }
+        } catch (refreshError) {
+            console.warn(`${KIRO_OAUTH_CONFIG.logPrefix} Token refresh error:`, refreshError.message);
+            // 继续保存原始凭据
+        }
+        
+        // 生成文件路径: configs/kiro/{timestamp}_kiro-auth-token/{timestamp}_kiro-auth-token.json
+        const timestamp = Date.now();
+        const folderName = `${timestamp}_kiro-auth-token`;
+        const targetDir = path.join(process.cwd(), 'configs', 'kiro', folderName);
+        await fs.promises.mkdir(targetDir, { recursive: true });
+        
+        const credPath = path.join(targetDir, `${folderName}.json`);
+        await fs.promises.writeFile(credPath, JSON.stringify(credentialsData, null, 2));
+        
+        const relativePath = path.relative(process.cwd(), credPath);
+        
+        console.log(`${KIRO_OAUTH_CONFIG.logPrefix} AWS credentials saved to: ${relativePath}`);
+        
+        // 广播事件
+        broadcastEvent('oauth_success', {
+            provider: 'claude-kiro-oauth',
+            relativePath: relativePath,
+            timestamp: new Date().toISOString()
+        });
+        
+        // 自动关联新生成的凭据到 Pools
+        await autoLinkProviderConfigs(CONFIG);
+        
+        return {
+            success: true,
+            path: relativePath
+        };
+        
+    } catch (error) {
+        console.error(`${KIRO_OAUTH_CONFIG.logPrefix} AWS credentials import failed:`, error);
+        return {
+            success: false,
+            error: error.message
+        };
+    }
+}

src/auth/oauth-handlers.js

@@ -0,0 +1,24 @@
+// OAuth 处理器统一导出文件
+// 此文件已按提供商拆分为多个独立文件，请从 index.js 导入
+
+// 重新导出所有 OAuth 处理函数以保持向后兼容
+export {
+    // Codex OAuth
+    refreshCodexTokensWithRetry,
+    handleCodexOAuth,
+    handleCodexOAuthCallback,
+    // Gemini OAuth
+    handleGeminiCliOAuth,
+    handleGeminiAntigravityOAuth,
+    // Qwen OAuth
+    handleQwenOAuth,
+    // Kiro OAuth
+    handleKiroOAuth,
+    checkKiroCredentialsDuplicate,
+    batchImportKiroRefreshTokens,
+    batchImportKiroRefreshTokensStream,
+    importAwsCredentials,
+    // iFlow OAuth
+    handleIFlowOAuth,
+    refreshIFlowTokens,
+} from './index.js';

src/auth/qwen-oauth.js

@@ -0,0 +1,339 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { broadcastEvent } from '../services/ui-manager.js';
+import { autoLinkProviderConfigs } from '../services/service-manager.js';
+import { CONFIG } from '../core/config-manager.js';
+import { getProxyConfigForProvider } from '../utils/proxy-utils.js';
+
+/**
+ * Qwen OAuth 配置
+ */
+const QWEN_OAUTH_CONFIG = {
+    clientId: 'f0304373b74a44d2b584a3fb70ca9e56',
+    scope: 'openid profile email model.completion',
+    deviceCodeEndpoint: 'https://chat.qwen.ai/api/v1/oauth2/device/code',
+    tokenEndpoint: 'https://chat.qwen.ai/api/v1/oauth2/token',
+    grantType: 'urn:ietf:params:oauth:grant-type:device_code',
+    credentialsDir: '.qwen',
+    credentialsFile: 'oauth_creds.json',
+    logPrefix: '[Qwen Auth]'
+};
+
+/**
+ * 活动的轮询任务管理
+ */
+const activePollingTasks = new Map();
+
+/**
+ * 创建带代理支持的 fetch 请求
+ * 使用 axios 替代原生 fetch，以正确支持代理配置
+ * @param {string} url - 请求 URL
+ * @param {Object} options - fetch 选项（兼容 fetch API 格式）
+ * @param {string} providerType - 提供商类型，用于获取代理配置
+ * @returns {Promise<Object>} 返回类似 fetch Response 的对象
+ */
+async function fetchWithProxy(url, options = {}, providerType) {
+    const proxyConfig = getProxyConfigForProvider(CONFIG, providerType);
+
+    // 构建 axios 配置
+    const axiosConfig = {
+        url,
+        method: options.method || 'GET',
+        headers: options.headers || {},
+        timeout: 30000, // 30 秒超时
+    };
+
+    // 处理请求体
+    if (options.body) {
+        axiosConfig.data = options.body;
+    }
+
+    // 配置代理
+    if (proxyConfig) {
+        axiosConfig.httpAgent = proxyConfig.httpAgent;
+        axiosConfig.httpsAgent = proxyConfig.httpsAgent;
+        axiosConfig.proxy = false; // 禁用 axios 内置代理，使用我们的 agent
+        console.log(`[OAuth] Using proxy for ${providerType}: ${CONFIG.PROXY_URL}`);
+    }
+
+    try {
+        const axios = (await import('axios')).default;
+        const response = await axios(axiosConfig);
+        
+        // 返回类似 fetch Response 的对象
+        return {
+            ok: response.status >= 200 && response.status < 300,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            json: async () => response.data,
+            text: async () => typeof response.data === 'string' ? response.data : JSON.stringify(response.data),
+        };
+    } catch (error) {
+        // 处理 axios 错误，转换为类似 fetch 的响应格式
+        if (error.response) {
+            // 服务器返回了错误状态码
+            return {
+                ok: false,
+                status: error.response.status,
+                statusText: error.response.statusText,
+                headers: error.response.headers,
+                json: async () => error.response.data,
+                text: async () => typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data),
+            };
+        }
+        // 网络错误或其他错误
+        throw error;
+    }
+}
+
+/**
+ * 生成 PKCE 代码验证器
+ * @returns {string} Base64URL 编码的随机字符串
+ */
+function generateCodeVerifier() {
+    return crypto.randomBytes(32).toString('base64url');
+}
+
+/**
+ * 生成 PKCE 代码挑战
+ * @param {string} codeVerifier - 代码验证器
+ * @returns {string} Base64URL 编码的 SHA256 哈希
+ */
+function generateCodeChallenge(codeVerifier) {
+    const hash = crypto.createHash('sha256');
+    hash.update(codeVerifier);
+    return hash.digest('base64url');
+}
+
+/**
+ * 停止活动的轮询任务
+ * @param {string} taskId - 任务标识符
+ */
+function stopPollingTask(taskId) {
+    const task = activePollingTasks.get(taskId);
+    if (task) {
+        task.shouldStop = true;
+        activePollingTasks.delete(taskId);
+        console.log(`${QWEN_OAUTH_CONFIG.logPrefix} 已停止轮询任务: ${taskId}`);
+    }
+}
+
+/**
+ * 轮询获取 Qwen OAuth 令牌
+ * @param {string} deviceCode - 设备代码
+ * @param {string} codeVerifier - PKCE 代码验证器
+ * @param {number} interval - 轮询间隔（秒）
+ * @param {number} expiresIn - 过期时间（秒）
+ * @param {string} taskId - 任务标识符
+ * @param {Object} options - 额外选项
+ * @returns {Promise<Object>} 返回令牌信息
+ */
+async function pollQwenToken(deviceCode, codeVerifier, interval = 5, expiresIn = 300, taskId = 'default', options = {}) {
+    let credPath = path.join(os.homedir(), QWEN_OAUTH_CONFIG.credentialsDir, QWEN_OAUTH_CONFIG.credentialsFile);
+    const maxAttempts = Math.floor(expiresIn / interval);
+    let attempts = 0;
+    
+    // 创建任务控制对象
+    const taskControl = { shouldStop: false };
+    activePollingTasks.set(taskId, taskControl);
+    
+    console.log(`${QWEN_OAUTH_CONFIG.logPrefix} 开���轮询令牌 [${taskId}]，间隔 ${interval} 秒，最多尝试 ${maxAttempts} 次`);
+    
+    const poll = async () => {
+        // 检查是否需要停止
+        if (taskControl.shouldStop) {
+            console.log(`${QWEN_OAUTH_CONFIG.logPrefix} 轮询任务 [${taskId}] 已被停止`);
+            throw new Error('轮询任务已被取消');
+        }
+        
+        if (attempts >= maxAttempts) {
+            activePollingTasks.delete(taskId);
+            throw new Error('授权超时，请重新开始授权流程');
+        }
+        
+        attempts++;
+        
+        const bodyData = {
+            client_id: QWEN_OAUTH_CONFIG.clientId,
+            device_code: deviceCode,
+            grant_type: QWEN_OAUTH_CONFIG.grantType,
+            code_verifier: codeVerifier
+        };
+        
+        const formBody = Object.entries(bodyData)
+            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+            .join('&');
+        
+        try {
+            const response = await fetchWithProxy(QWEN_OAUTH_CONFIG.tokenEndpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'Accept': 'application/json'
+                },
+                body: formBody
+            }, 'openai-qwen-oauth');
+            
+            const data = await response.json();
+            
+            if (response.ok && data.access_token) {
+                // 成功获取令牌
+                console.log(`${QWEN_OAUTH_CONFIG.logPrefix} 成功获取令牌 [${taskId}]`);
+                
+                // 如果指定了保存到 configs 目录
+                if (options.saveToConfigs) {
+                    const targetDir = path.join(process.cwd(), 'configs', options.providerDir);
+                    await fs.promises.mkdir(targetDir, { recursive: true });
+                    const timestamp = Date.now();
+                    const filename = `${timestamp}_oauth_creds.json`;
+                    credPath = path.join(targetDir, filename);
+                }
+
+                // 保存令牌到文件
+                await fs.promises.mkdir(path.dirname(credPath), { recursive: true });
+                await fs.promises.writeFile(credPath, JSON.stringify(data, null, 2));
+                console.log(`${QWEN_OAUTH_CONFIG.logPrefix} 令牌已保存到 ${credPath}`);
+                
+                const relativePath = path.relative(process.cwd(), credPath);
+
+                // 清理任务
+                activePollingTasks.delete(taskId);
+                
+                // 广播授权成功事件
+                broadcastEvent('oauth_success', {
+                    provider: 'openai-qwen-oauth',
+                    credPath: credPath,
+                    relativePath: relativePath,
+                    timestamp: new Date().toISOString()
+                });
+                
+                // 自动关联新生成的凭据到 Pools
+                await autoLinkProviderConfigs(CONFIG);
+                
+                return data;
+            }
+            
+            // 检查错误类型
+            if (data.error === 'authorization_pending') {
+                // 用户尚未完成授权，继续轮询
+                console.log(`${QWEN_OAUTH_CONFIG.logPrefix} 等待用户授权 [${taskId}]... (第 ${attempts}/${maxAttempts} 次尝试)`);
+                await new Promise(resolve => setTimeout(resolve, interval * 1000));
+                return poll();
+            } else if (data.error === 'slow_down') {
+                // 需要降低轮询频率
+                console.log(`${QWEN_OAUTH_CONFIG.logPrefix} 降低轮询频率`);
+                await new Promise(resolve => setTimeout(resolve, (interval + 5) * 1000));
+                return poll();
+            } else if (data.error === 'expired_token') {
+                activePollingTasks.delete(taskId);
+                throw new Error('设备代码已过期，请重新开始授权流程');
+            } else if (data.error === 'access_denied') {
+                activePollingTasks.delete(taskId);
+                throw new Error('用户拒绝了授权请求');
+            } else {
+                activePollingTasks.delete(taskId);
+                throw new Error(`授权失败: ${data.error || '未知错误'}`);
+            }
+        } catch (error) {
+            if (error.message.includes('授权') || error.message.includes('过期') || error.message.includes('拒绝')) {
+                throw error;
+            }
+            console.error(`${QWEN_OAUTH_CONFIG.logPrefix} 轮询出错:`, error);
+            // 网络错误，继续重试
+            await new Promise(resolve => setTimeout(resolve, interval * 1000));
+            return poll();
+        }
+    };
+    
+    return poll();
+}
+
+/**
+ * 处理 Qwen OAuth 授权（设备授权流程）
+ * @param {Object} currentConfig - 当前配置对象
+ * @param {Object} options - 额外选项
+ * @returns {Promise<Object>} 返回授权URL和相关信息
+ */
+export async function handleQwenOAuth(currentConfig, options = {}) {
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    
+    const bodyData = {
+        client_id: QWEN_OAUTH_CONFIG.clientId,
+        scope: QWEN_OAUTH_CONFIG.scope,
+        code_challenge: codeChallenge,
+        code_challenge_method: 'S256'
+    };
+    
+    const formBody = Object.entries(bodyData)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+        .join('&');
+    
+    try {
+        const response = await fetchWithProxy(QWEN_OAUTH_CONFIG.deviceCodeEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json'
+            },
+            body: formBody
+        }, 'openai-qwen-oauth');
+        
+        if (!response.ok) {
+            throw new Error(`Qwen OAuth请求失败: ${response.status} ${response.statusText}`);
+        }
+        
+        const deviceAuth = await response.json();
+        
+        if (!deviceAuth.device_code || !deviceAuth.verification_uri_complete) {
+            throw new Error('Qwen OAuth响应格式错误，缺少必要字段');
+        }
+        
+        // 启动后台轮询获取令牌
+        const interval = 5;
+        // const expiresIn = deviceAuth.expires_in || 1800;
+        const expiresIn = 300;
+        
+        // 生成唯一的任务ID
+        const taskId = `qwen-${deviceAuth.device_code.substring(0, 8)}-${Date.now()}`;
+        
+        // 先停止之前可能存在的所有 Qwen 轮询任务
+        for (const [existingTaskId] of activePollingTasks.entries()) {
+            if (existingTaskId.startsWith('qwen-')) {
+                stopPollingTask(existingTaskId);
+            }
+        }
+        
+        // 不等待轮询完成，立即返回授权信息
+        pollQwenToken(deviceAuth.device_code, codeVerifier, interval, expiresIn, taskId, options)
+            .catch(error => {
+                console.error(`${QWEN_OAUTH_CONFIG.logPrefix} 轮询失败 [${taskId}]:`, error);
+                // 广播授权失败事件
+                broadcastEvent('oauth_error', {
+                    provider: 'openai-qwen-oauth',
+                    error: error.message,
+                    timestamp: new Date().toISOString()
+                });
+            });
+        
+        return {
+            authUrl: deviceAuth.verification_uri_complete,
+            authInfo: {
+                provider: 'openai-qwen-oauth',
+                deviceCode: deviceAuth.device_code,
+                userCode: deviceAuth.user_code,
+                verificationUri: deviceAuth.verification_uri,
+                verificationUriComplete: deviceAuth.verification_uri_complete,
+                expiresIn: expiresIn,
+                interval: interval,
+                codeVerifier: codeVerifier
+            }
+        };
+    } catch (error) {
+        console.error(`${QWEN_OAUTH_CONFIG.logPrefix} 请求失败:`, error);
+        throw new Error(`Qwen OAuth 授权失败: ${error.message}`);
+    }
+}

src/convert/convert.js

@@ -0,0 +1,389 @@
+/**
+ * 协议转换模块 - 新架构版本
+ * 使用重构后的转换器架构
+ *
+ * 这个文件展示了如何使用新的转换器架构
+ * 可以逐步替换原有的 convert.js
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { MODEL_PROTOCOL_PREFIX, getProtocolPrefix } from '../utils/common.js';
+import { ConverterFactory } from '../converters/ConverterFactory.js';
+import {
+    generateResponseCreated,
+    generateResponseInProgress,
+    generateOutputItemAdded,
+    generateContentPartAdded,
+    generateOutputTextDone,
+    generateContentPartDone,
+    generateOutputItemDone,
+    generateResponseCompleted
+} from '../providers/openai/openai-responses-core.mjs';
+
+// =============================================================================
+// 初始化：注册所有转换器
+// =============================================================================
+
+// =============================================================================
+// 主转换函数
+// =============================================================================
+
+/**
+ * 通用数据转换函数（新架构版本）
+ * @param {object} data - 要转换的数据（请求体或响应）
+ * @param {string} type - 转换类型：'request', 'response', 'streamChunk', 'modelList'
+ * @param {string} fromProvider - 源模型提供商
+ * @param {string} toProvider - 目标模型提供商
+ * @param {string} [model] - 可选的模型名称（用于响应转换）
+ * @returns {object} 转换后的数据
+ * @throws {Error} 如果找不到合适的转换函数
+ */
+export function convertData(data, type, fromProvider, toProvider, model) {
+    try {
+        // 获取协议前缀
+        const fromProtocol = getProtocolPrefix(fromProvider);
+        const toProtocol = getProtocolPrefix(toProvider);
+
+        // 如果目标协议为 forward，直接返回原始数据，无需转换
+        if (toProtocol === MODEL_PROTOCOL_PREFIX.FORWARD || fromProtocol === MODEL_PROTOCOL_PREFIX.FORWARD) {
+            console.log(`[Convert] Target protocol is forward, skipping conversion`);
+            return data;
+        }
+
+        // 从工厂获取转换器
+        const converter = ConverterFactory.getConverter(fromProtocol);
+
+        if (!converter) {
+            throw new Error(`No converter found for protocol: ${fromProtocol}`);
+        }
+
+        // 根据类型调用相应的转换方法
+        switch (type) {
+            case 'request':
+                return converter.convertRequest(data, toProtocol);
+                
+            case 'response':
+                return converter.convertResponse(data, toProtocol, model);
+                
+            case 'streamChunk':
+                return converter.convertStreamChunk(data, toProtocol, model);
+                
+            case 'modelList':
+                return converter.convertModelList(data, toProtocol);
+                
+            default:
+                throw new Error(`Unsupported conversion type: ${type}`);
+        }
+    } catch (error) {
+        console.error(`Conversion error: ${error.message}`);
+        throw error;
+    }
+}
+
+// =============================================================================
+// 向后兼容的导出函数
+// =============================================================================
+
+/**
+ * 以下函数保持与原有API的兼容性
+ * 内部使用新的转换器架构
+ */
+
+// OpenAI 相关转换
+export function toOpenAIRequestFromGemini(geminiRequest) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
+    return converter.toOpenAIRequest(geminiRequest);
+}
+
+export function toOpenAIRequestFromClaude(claudeRequest) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
+    return converter.toOpenAIRequest(claudeRequest);
+}
+
+export function toOpenAIChatCompletionFromGemini(geminiResponse, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
+    return converter.toOpenAIResponse(geminiResponse, model);
+}
+
+export function toOpenAIChatCompletionFromClaude(claudeResponse, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
+    return converter.toOpenAIResponse(claudeResponse, model);
+}
+
+export function toOpenAIStreamChunkFromGemini(geminiChunk, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
+    return converter.toOpenAIStreamChunk(geminiChunk, model);
+}
+
+export function toOpenAIStreamChunkFromClaude(claudeChunk, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
+    return converter.toOpenAIStreamChunk(claudeChunk, model);
+}
+
+export function toOpenAIModelListFromGemini(geminiModels) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
+    return converter.toOpenAIModelList(geminiModels);
+}
+
+export function toOpenAIModelListFromClaude(claudeModels) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
+    return converter.toOpenAIModelList(claudeModels);
+}
+
+// Claude 相关转换
+export function toClaudeRequestFromOpenAI(openaiRequest) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
+    return converter.toClaudeRequest(openaiRequest);
+}
+
+export function toClaudeRequestFromOpenAIResponses(responsesRequest) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
+    return converter.toClaudeRequest(responsesRequest);
+}
+
+export function toClaudeChatCompletionFromOpenAI(openaiResponse, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
+    return converter.toClaudeResponse(openaiResponse, model);
+}
+
+export function toClaudeChatCompletionFromGemini(geminiResponse, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
+    return converter.toClaudeResponse(geminiResponse, model);
+}
+
+export function toClaudeStreamChunkFromOpenAI(openaiChunk, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
+    return converter.toClaudeStreamChunk(openaiChunk, model);
+}
+
+export function toClaudeStreamChunkFromGemini(geminiChunk, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
+    return converter.toClaudeStreamChunk(geminiChunk, model);
+}
+
+export function toClaudeModelListFromOpenAI(openaiModels) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
+    return converter.toClaudeModelList(openaiModels);
+}
+
+export function toClaudeModelListFromGemini(geminiModels) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
+    return converter.toClaudeModelList(geminiModels);
+}
+
+// Gemini 相关转换
+export function toGeminiRequestFromOpenAI(openaiRequest) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
+    return converter.toGeminiRequest(openaiRequest);
+}
+
+export function toGeminiRequestFromClaude(claudeRequest) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
+    return converter.toGeminiRequest(claudeRequest);
+}
+
+export function toGeminiRequestFromOpenAIResponses(responsesRequest) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
+    return converter.toGeminiRequest(responsesRequest);
+}
+
+// OpenAI Responses 相关转换
+export function toOpenAIResponsesFromOpenAI(openaiResponse, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
+    return converter.toOpenAIResponsesResponse(openaiResponse, model);
+}
+
+export function toOpenAIResponsesFromClaude(claudeResponse, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
+    return converter.toOpenAIResponsesResponse(claudeResponse, model);
+}
+
+export function toOpenAIResponsesFromGemini(geminiResponse, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
+    return converter.toOpenAIResponsesResponse(geminiResponse, model);
+}
+
+export function toOpenAIResponsesStreamChunkFromOpenAI(openaiChunk, model, requestId) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
+    return converter.toOpenAIResponsesStreamChunk(openaiChunk, model, requestId);
+}
+
+export function toOpenAIResponsesStreamChunkFromClaude(claudeChunk, model, requestId) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
+    return converter.toOpenAIResponsesStreamChunk(claudeChunk, model, requestId);
+}
+
+export function toOpenAIResponsesStreamChunkFromGemini(geminiChunk, model, requestId) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
+    return converter.toOpenAIResponsesStreamChunk(geminiChunk, model, requestId);
+}
+
+// 从 OpenAI Responses 转换到其他格式
+export function toOpenAIRequestFromOpenAIResponses(responsesRequest) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
+    return converter.toOpenAIRequest(responsesRequest);
+}
+
+export function toOpenAIChatCompletionFromOpenAIResponses(responsesResponse, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
+    return converter.toOpenAIResponse(responsesResponse, model);
+}
+
+export function toOpenAIStreamChunkFromOpenAIResponses(responsesChunk, model) {
+    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
+    return converter.toOpenAIStreamChunk(responsesChunk, model);
+}
+
+// 辅助函数导出
+export async function extractAndProcessSystemMessages(messages) {
+    const { Utils } = await import('../converters/utils.js');
+    return Utils.extractSystemMessages(messages);
+}
+
+export async function extractTextFromMessageContent(content) {
+    const { Utils } = await import('../converters/utils.js');
+    return Utils.extractText(content);
+}
+
+// =============================================================================
+// 工具函数
+// =============================================================================
+
+/**
+ * 获取所有已注册的协议
+ * @returns {Array<string>} 协议前缀数组
+ */
+export function getRegisteredProtocols() {
+    return ConverterFactory.getRegisteredProtocols();
+}
+
+/**
+ * 检查协议是否已注册
+ * @param {string} protocol - 协议前缀
+ * @returns {boolean} 是否已注册
+ */
+export function isProtocolRegistered(protocol) {
+    return ConverterFactory.isProtocolRegistered(protocol);
+}
+
+/**
+ * 清除所有转换器缓存
+ */
+export function clearConverterCache() {
+    ConverterFactory.clearCache();
+}
+
+/**
+ * 获取转换器实例（用于高级用法）
+ * @param {string} protocol - 协议前缀
+ * @returns {BaseConverter} 转换器实例
+ */
+export function getConverter(protocol) {
+    return ConverterFactory.getConverter(protocol);
+}
+
+// =============================================================================
+// 辅助函数 - 从原 convert.js 迁移
+// =============================================================================
+
+/**
+ * 生成 OpenAI 流式响应的停止块
+ * @param {string} model - 模型名称
+ * @returns {Object} OpenAI 流式停止块
+ */
+export function getOpenAIStreamChunkStop(model) {
+    return {
+        id: `chatcmpl-${uuidv4()}`,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: model,
+        system_fingerprint: "",
+        choices: [{
+            index: 0,
+            delta: {
+                content: "",
+                reasoning_content: ""
+            },
+            finish_reason: 'stop',
+            message: {
+                content: "",
+                reasoning_content: ""
+            }
+        }],
+        usage:{
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            total_tokens: 0,
+        },
+    };
+}
+
+/**
+ * 生成 OpenAI Responses 流式响应的开始事件
+ * @param {string} id - 响应 ID
+ * @param {string} model - 模型名称
+ * @returns {Array} 开始事件数组
+ */
+export function getOpenAIResponsesStreamChunkBegin(id, model) {
+    return [
+        generateResponseCreated(id, model),
+        generateResponseInProgress(id),
+        generateOutputItemAdded(id),
+        generateContentPartAdded(id)
+    ];
+}
+
+/**
+ * 生成 OpenAI Responses 流式响应的结束事件
+ * @param {string} id - 响应 ID
+ * @returns {Array} 结束事件数组
+ */
+export function getOpenAIResponsesStreamChunkEnd(id) {
+    return [
+        generateOutputTextDone(id),
+        generateContentPartDone(id),
+        generateOutputItemDone(id),
+        generateResponseCompleted(id)
+    ];
+}
+
+// =============================================================================
+// 默认导出
+// =============================================================================
+
+export default {
+    convertData,
+    getRegisteredProtocols,
+    isProtocolRegistered,
+    clearConverterCache,
+    getConverter,
+    // 向后兼容的函数
+    toOpenAIRequestFromGemini,
+    toOpenAIRequestFromClaude,
+    toOpenAIChatCompletionFromGemini,
+    toOpenAIChatCompletionFromClaude,
+    toOpenAIStreamChunkFromGemini,
+    toOpenAIStreamChunkFromClaude,
+    toOpenAIModelListFromGemini,
+    toOpenAIModelListFromClaude,
+    toClaudeRequestFromOpenAI,
+    toClaudeChatCompletionFromOpenAI,
+    toClaudeChatCompletionFromGemini,
+    toClaudeStreamChunkFromOpenAI,
+    toClaudeStreamChunkFromGemini,
+    toClaudeModelListFromOpenAI,
+    toClaudeModelListFromGemini,
+    toGeminiRequestFromOpenAI,
+    toGeminiRequestFromClaude,
+    toOpenAIResponsesFromOpenAI,
+    toOpenAIResponsesFromClaude,
+    toOpenAIResponsesFromGemini,
+    toOpenAIResponsesStreamChunkFromOpenAI,
+    toOpenAIResponsesStreamChunkFromClaude,
+    toOpenAIResponsesStreamChunkFromGemini,
+    toOpenAIRequestFromOpenAIResponses,
+    toOpenAIChatCompletionFromOpenAIResponses,
+    toOpenAIStreamChunkFromOpenAIResponses,
+    toClaudeRequestFromOpenAIResponses,
+    toGeminiRequestFromOpenAIResponses,
+};

src/converters/BaseConverter.js

@@ -0,0 +1,115 @@
+/**
+ * 转换器基类
+ * 使用策略模式定义转换器的通用接口
+ */
+
+/**
+ * 抽象转换器基类
+ * 所有具体的协议转换器都应继承此类
+ */
+export class BaseConverter {
+    constructor(protocolName) {
+        if (new.target === BaseConverter) {
+            throw new Error('BaseConverter是抽象类，不能直接实例化');
+        }
+        this.protocolName = protocolName;
+    }
+
+    /**
+     * 转换请求
+     * @param {Object} data - 请求数据
+     * @param {string} targetProtocol - 目标协议
+     * @returns {Object} 转换后的请求
+     */
+    convertRequest(data, targetProtocol) {
+        throw new Error('convertRequest方法必须被子类实现');
+    }
+
+    /**
+     * 转换响应
+     * @param {Object} data - 响应数据
+     * @param {string} targetProtocol - 目标协议
+     * @param {string} model - 模型名称
+     * @returns {Object} 转换后的响应
+     */
+    convertResponse(data, targetProtocol, model) {
+        throw new Error('convertResponse方法必须被子类实现');
+    }
+
+    /**
+     * 转换流式响应块
+     * @param {Object} chunk - 流式响应块
+     * @param {string} targetProtocol - 目标协议
+     * @param {string} model - 模型名称
+     * @returns {Object} 转换后的流式响应块
+     */
+    convertStreamChunk(chunk, targetProtocol, model) {
+        throw new Error('convertStreamChunk方法必须被子类实现');
+    }
+
+    /**
+     * 转换模型列表
+     * @param {Object} data - 模型列表数据
+     * @param {string} targetProtocol - 目标协议
+     * @returns {Object} 转换后的模型列表
+     */
+    convertModelList(data, targetProtocol) {
+        throw new Error('convertModelList方法必须被子类实现');
+    }
+
+    /**
+     * 获取协议名称
+     * @returns {string} 协议名称
+     */
+    getProtocolName() {
+        return this.protocolName;
+    }
+}
+
+/**
+ * 内容处理器接口
+ * 用于处理不同类型的内容（文本、图片、音频等）
+ */
+export class ContentProcessor {
+    /**
+     * 处理内容
+     * @param {*} content - 内容数据
+     * @returns {*} 处理后的内容
+     */
+    process(content) {
+        throw new Error('process方法必须被子类实现');
+    }
+}
+
+/**
+ * 工具处理器接口
+ * 用于处理工具调用相关的转换
+ */
+export class ToolProcessor {
+    /**
+     * 处理工具定义
+     * @param {Array} tools - 工具定义数组
+     * @returns {Array} 处理后的工具定义
+     */
+    processToolDefinitions(tools) {
+        throw new Error('processToolDefinitions方法必须被子类实现');
+    }
+
+    /**
+     * 处理工具调用
+     * @param {Object} toolCall - 工具调用数据
+     * @returns {Object} 处理后的工具调用
+     */
+    processToolCall(toolCall) {
+        throw new Error('processToolCall方法必须被子类实现');
+    }
+
+    /**
+     * 处理工具结果
+     * @param {Object} toolResult - 工具结果数据
+     * @returns {Object} 处理后的工具结果
+     */
+    processToolResult(toolResult) {
+        throw new Error('processToolResult方法必须被子类实现');
+    }
+}

src/converters/ConverterFactory.js

@@ -0,0 +1,182 @@
+/**
+ * 转换器工厂类
+ * 使用工厂模式管理转换器实例的创建和缓存
+ */
+
+import { MODEL_PROTOCOL_PREFIX } from '../utils/common.js';
+
+/**
+ * 转换器工厂（单例模式 + 工厂模式）
+ */
+export class ConverterFactory {
+    // 私有静态属性：存储转换器实例
+    static #converters = new Map();
+    
+    // 私有静态属性：存储转换器类
+    static #converterClasses = new Map();
+
+    /**
+     * 注册转换器类
+     * @param {string} protocolPrefix - 协议前缀
+     * @param {Class} ConverterClass - 转换器类
+     */
+    static registerConverter(protocolPrefix, ConverterClass) {
+        this.#converterClasses.set(protocolPrefix, ConverterClass);
+    }
+
+    /**
+     * 获取转换器实例（带缓存）
+     * @param {string} protocolPrefix - 协议前缀
+     * @returns {BaseConverter} 转换器实例
+     */
+    static getConverter(protocolPrefix) {
+        // 检查缓存
+        if (this.#converters.has(protocolPrefix)) {
+            return this.#converters.get(protocolPrefix);
+        }
+
+        // 创建新实例
+        const converter = this.createConverter(protocolPrefix);
+        
+        // 缓存实例
+        if (converter) {
+            this.#converters.set(protocolPrefix, converter);
+        }
+
+        return converter;
+    }
+
+    /**
+     * 创建转换器实例
+     * @param {string} protocolPrefix - 协议前缀
+     * @returns {BaseConverter} 转换器实例
+     */
+    static createConverter(protocolPrefix) {
+        const ConverterClass = this.#converterClasses.get(protocolPrefix);
+        
+        if (!ConverterClass) {
+            throw new Error(`No converter registered for protocol: ${protocolPrefix}`);
+        }
+
+        return new ConverterClass();
+    }
+
+    /**
+     * 清除所有缓存的转换器
+     */
+    static clearCache() {
+        this.#converters.clear();
+    }
+
+    /**
+     * 清除特定协议的转换器缓存
+     * @param {string} protocolPrefix - 协议前缀
+     */
+    static clearConverterCache(protocolPrefix) {
+        this.#converters.delete(protocolPrefix);
+    }
+
+    /**
+     * 获取所有已注册的协议
+     * @returns {Array<string>} 协议前缀数组
+     */
+    static getRegisteredProtocols() {
+        return Array.from(this.#converterClasses.keys());
+    }
+
+    /**
+     * 检查协议是否已注册
+     * @param {string} protocolPrefix - 协议前缀
+     * @returns {boolean} 是否已注册
+     */
+    static isProtocolRegistered(protocolPrefix) {
+        return this.#converterClasses.has(protocolPrefix);
+    }
+}
+
+/**
+ * 内容处理器工厂
+ */
+export class ContentProcessorFactory {
+    static #processors = new Map();
+
+    /**
+     * 获取内容处理器
+     * @param {string} sourceFormat - 源格式
+     * @param {string} targetFormat - 目标格式
+     * @returns {ContentProcessor} 内容处理器实例
+     */
+    static getProcessor(sourceFormat, targetFormat) {
+        const key = `${sourceFormat}_to_${targetFormat}`;
+        
+        if (!this.#processors.has(key)) {
+            this.#processors.set(key, this.createProcessor(sourceFormat, targetFormat));
+        }
+        
+        return this.#processors.get(key);
+    }
+
+    /**
+     * 创建内容处理器
+     * @param {string} sourceFormat - 源格式
+     * @param {string} targetFormat - 目标格式
+     * @returns {ContentProcessor} 内容处理器实例
+     */
+    static createProcessor(sourceFormat, targetFormat) {
+        // 这里返回null，实际使用时需要导入具体的处理器类
+        // 为了避免循环依赖，处理器类应该在使用时动态导入
+        console.warn(`Content processor for ${sourceFormat} to ${targetFormat} not yet implemented`);
+        return null;
+    }
+
+    /**
+     * 清除所有缓存的处理器
+     */
+    static clearCache() {
+        this.#processors.clear();
+    }
+}
+
+/**
+ * 工具处理器工厂
+ */
+export class ToolProcessorFactory {
+    static #processors = new Map();
+
+    /**
+     * 获取工具处理器
+     * @param {string} sourceFormat - 源格式
+     * @param {string} targetFormat - 目标格式
+     * @returns {ToolProcessor} 工具处理器实例
+     */
+    static getProcessor(sourceFormat, targetFormat) {
+        const key = `${sourceFormat}_to_${targetFormat}`;
+        
+        if (!this.#processors.has(key)) {
+            this.#processors.set(key, this.createProcessor(sourceFormat, targetFormat));
+        }
+        
+        return this.#processors.get(key);
+    }
+
+    /**
+     * 创建工具处理器
+     * @param {string} sourceFormat - 源格式
+     * @param {string} targetFormat - 目标格式
+     * @returns {ToolProcessor} 工具处理器实例
+     */
+    static createProcessor(sourceFormat, targetFormat) {
+        console.warn(`Tool processor for ${sourceFormat} to ${targetFormat} not yet implemented`);
+        return null;
+    }
+
+    /**
+     * 清除所有缓存的处理器
+     */
+    static clearCache() {
+        this.#processors.clear();
+    }
+}
+
+// 导出工厂类
+export default ConverterFactory;

src/converters/register-converters.js

@@ -0,0 +1,29 @@
+/**
+ * 转换器注册模块
+ * 用于注册所有转换器到工厂，避免循环依赖问题
+ */
+
+import { MODEL_PROTOCOL_PREFIX } from '../utils/common.js';
+import { ConverterFactory } from './ConverterFactory.js';
+import { OpenAIConverter } from './strategies/OpenAIConverter.js';
+import { OpenAIResponsesConverter } from './strategies/OpenAIResponsesConverter.js';
+import { ClaudeConverter } from './strategies/ClaudeConverter.js';
+import { GeminiConverter } from './strategies/GeminiConverter.js';
+import { OllamaConverter } from './strategies/OllamaConverter.js';
+import { CodexConverter } from './strategies/CodexConverter.js';
+
+/**
+ * 注册所有转换器到工厂
+ * 此函数应在应用启动时调用一次
+ */
+export function registerAllConverters() {
+    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.OPENAI, OpenAIConverter);
+    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES, OpenAIResponsesConverter);
+    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.CLAUDE, ClaudeConverter);
+    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.GEMINI, GeminiConverter);
+    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.OLLAMA, OllamaConverter);
+    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.CODEX, CodexConverter);
+}
+
+// 自动注册所有转换器
+registerAllConverters();

src/converters/strategies/ClaudeConverter.js

@@ -0,0 +1,1652 @@
+/**
+ * Claude转换器
+ * 处理Claude（Anthropic）协议与其他协议之间的转换
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { BaseConverter } from '../BaseConverter.js';
+import {
+    checkAndAssignOrDefault,
+    cleanJsonSchemaProperties as cleanJsonSchema,
+    determineReasoningEffortFromBudget,
+    OPENAI_DEFAULT_MAX_TOKENS,
+    OPENAI_DEFAULT_TEMPERATURE,
+    OPENAI_DEFAULT_TOP_P,
+    GEMINI_DEFAULT_MAX_TOKENS,
+    GEMINI_DEFAULT_TEMPERATURE,
+    GEMINI_DEFAULT_TOP_P,
+    GEMINI_DEFAULT_INPUT_TOKEN_LIMIT,
+    GEMINI_DEFAULT_OUTPUT_TOKEN_LIMIT
+} from '../utils.js';
+import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
+import {
+    generateResponseCreated,
+    generateResponseInProgress,
+    generateOutputItemAdded,
+    generateContentPartAdded,
+    generateOutputTextDone,
+    generateContentPartDone,
+    generateOutputItemDone,
+    generateResponseCompleted
+} from '../../providers/openai/openai-responses-core.mjs';
+
+/**
+ * Claude转换器类
+ * 实现Claude协议到其他协议的转换
+ */
+export class ClaudeConverter extends BaseConverter {
+    constructor() {
+        super('claude');
+    }
+
+    /**
+     * 转换请求
+     */
+    convertRequest(data, targetProtocol) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIRequest(data);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiRequest(data);
+            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
+                return this.toOpenAIResponsesRequest(data);
+            default:
+                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+        }
+    }
+
+    /**
+     * 转换响应
+     */
+    convertResponse(data, targetProtocol, model) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIResponse(data, model);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiResponse(data, model);
+            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
+                return this.toOpenAIResponsesResponse(data, model);
+            default:
+                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+        }
+    }
+
+    /**
+     * 转换流式响应块
+     */
+    convertStreamChunk(chunk, targetProtocol, model) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIStreamChunk(chunk, model);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiStreamChunk(chunk, model);
+            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
+                return this.toOpenAIResponsesStreamChunk(chunk, model);
+            default:
+                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+        }
+    }
+
+    /**
+     * 转换模型列表
+     */
+    convertModelList(data, targetProtocol) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIModelList(data);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiModelList(data);
+            default:
+                return data;
+        }
+    }
+
+    // =========================================================================
+    // Claude -> OpenAI 转换
+    // =========================================================================
+
+    /**
+     * Claude请求 -> OpenAI请求
+     */
+    toOpenAIRequest(claudeRequest) {
+        const openaiMessages = [];
+        let systemMessageContent = '';
+
+        // 添加系统消息
+        if (claudeRequest.system) {
+            systemMessageContent = claudeRequest.system;
+        }
+
+        // 处理消息
+        if (claudeRequest.messages && Array.isArray(claudeRequest.messages)) {
+            const tempOpenAIMessages = [];
+            for (const msg of claudeRequest.messages) {
+                const role = msg.role;
+
+                // 处理用户的工具结果消息
+                if (role === "user" && Array.isArray(msg.content)) {
+                    const hasToolResult = msg.content.some(
+                        item => item && typeof item === 'object' && item.type === "tool_result"
+                    );
+
+                    if (hasToolResult) {
+                        for (const item of msg.content) {
+                            if (item && typeof item === 'object' && item.type === "tool_result") {
+                                const toolUseId = item.tool_use_id || item.id || "";
+                                const contentStr = String(item.content || "");
+                                tempOpenAIMessages.push({
+                                    role: "tool",
+                                    tool_call_id: toolUseId,
+                                    content: contentStr,
+                                });
+                            }
+                        }
+                        continue;
+                    }
+                }
+
+                // 处理assistant消息中的工具调用
+                if (role === "assistant" && Array.isArray(msg.content) && msg.content.length > 0) {
+                    const firstPart = msg.content[0];
+                    if (firstPart.type === "tool_use") {
+                        const funcName = firstPart.name || "";
+                        const funcArgs = firstPart.input || {};
+                        tempOpenAIMessages.push({
+                            role: "assistant",
+                            content: '',
+                            tool_calls: [
+                                {
+                                    id: firstPart.id || `call_${funcName}_1`,
+                                    type: "function",
+                                    function: {
+                                        name: funcName,
+                                        arguments: JSON.stringify(funcArgs)
+                                    },
+                                    index: firstPart.index || 0
+                                }
+                            ]
+                        });
+                        continue;
+                    }
+                }
+
+                // 普通文本消息
+                const contentConverted = this.processClaudeContentToOpenAIContent(msg.content || "");
+                if (contentConverted && (Array.isArray(contentConverted) ? contentConverted.length > 0 : contentConverted.trim().length > 0)) {
+                    tempOpenAIMessages.push({
+                        role: role,
+                        content: contentConverted
+                    });
+                }
+            }
+
+            // OpenAI兼容性校验
+            const validatedMessages = [];
+            for (let idx = 0; idx < tempOpenAIMessages.length; idx++) {
+                const m = tempOpenAIMessages[idx];
+                if (m.role === "assistant" && m.tool_calls) {
+                    const callIds = m.tool_calls.map(tc => tc.id).filter(id => id);
+                    let unmatched = new Set(callIds);
+                    for (let laterIdx = idx + 1; laterIdx < tempOpenAIMessages.length; laterIdx++) {
+                        const later = tempOpenAIMessages[laterIdx];
+                        if (later.role === "tool" && unmatched.has(later.tool_call_id)) {
+                            unmatched.delete(later.tool_call_id);
+                        }
+                        if (unmatched.size === 0) break;
+                    }
+                    if (unmatched.size > 0) {
+                        m.tool_calls = m.tool_calls.filter(tc => !unmatched.has(tc.id));
+                        if (m.tool_calls.length === 0) {
+                            delete m.tool_calls;
+                            if (m.content === null) m.content = "";
+                        }
+                    }
+                }
+                validatedMessages.push(m);
+            }
+            openaiMessages.push(...validatedMessages);
+        }
+
+        const openaiRequest = {
+            model: claudeRequest.model,
+            messages: openaiMessages,
+            max_tokens: checkAndAssignOrDefault(claudeRequest.max_tokens, OPENAI_DEFAULT_MAX_TOKENS),
+            temperature: checkAndAssignOrDefault(claudeRequest.temperature, OPENAI_DEFAULT_TEMPERATURE),
+            top_p: checkAndAssignOrDefault(claudeRequest.top_p, OPENAI_DEFAULT_TOP_P),
+            stream: claudeRequest.stream,
+        };
+
+        // 处理工具
+        if (claudeRequest.tools) {
+            const openaiTools = [];
+            for (const tool of claudeRequest.tools) {
+                openaiTools.push({
+                    type: "function",
+                    function: {
+                        name: tool.name || "",
+                        description: tool.description || "",
+                        parameters: cleanJsonSchema(tool.input_schema || {})
+                    }
+                });
+            }
+            openaiRequest.tools = openaiTools;
+            openaiRequest.tool_choice = "auto";
+        }
+
+        // 处理thinking转换
+        if (claudeRequest.thinking && claudeRequest.thinking.type === "enabled") {
+            const budgetTokens = claudeRequest.thinking.budget_tokens;
+            const reasoningEffort = determineReasoningEffortFromBudget(budgetTokens);
+            openaiRequest.reasoning_effort = reasoningEffort;
+
+            let maxCompletionTokens = null;
+            if (claudeRequest.max_tokens !== undefined) {
+                maxCompletionTokens = claudeRequest.max_tokens;
+                delete openaiRequest.max_tokens;
+            } else {
+                const envMaxTokens = process.env.OPENAI_REASONING_MAX_TOKENS;
+                if (envMaxTokens) {
+                    try {
+                        maxCompletionTokens = parseInt(envMaxTokens, 10);
+                    } catch (e) {
+                        console.warn(`Invalid OPENAI_REASONING_MAX_TOKENS value '${envMaxTokens}'`);
+                    }
+                }
+                if (!envMaxTokens) {
+                    throw new Error("For OpenAI reasoning models, max_completion_tokens is required.");
+                }
+            }
+            openaiRequest.max_completion_tokens = maxCompletionTokens;
+        }
+
+        // 添加系统消息
+        if (systemMessageContent) {
+            let stringifiedSystemMessageContent = systemMessageContent;
+            if (Array.isArray(systemMessageContent)) {
+                stringifiedSystemMessageContent = systemMessageContent.map(item =>
+                    typeof item === 'string' ? item : item.text).join('\n');
+            }
+            openaiRequest.messages.unshift({ role: 'system', content: stringifiedSystemMessageContent });
+        }
+
+        return openaiRequest;
+    }
+
+    /**
+     * Claude响应 -> OpenAI响应
+     */
+    toOpenAIResponse(claudeResponse, model) {
+        if (!claudeResponse || !claudeResponse.content || claudeResponse.content.length === 0) {
+            return {
+                id: `chatcmpl-${uuidv4()}`,
+                object: "chat.completion",
+                created: Math.floor(Date.now() / 1000),
+                model: model,
+                choices: [{
+                    index: 0,
+                    message: {
+                        role: "assistant",
+                        content: "",
+                    },
+                    finish_reason: "stop",
+                }],
+                usage: {
+                    prompt_tokens: claudeResponse.usage?.input_tokens || 0,
+                    completion_tokens: claudeResponse.usage?.output_tokens || 0,
+                    total_tokens: (claudeResponse.usage?.input_tokens || 0) + (claudeResponse.usage?.output_tokens || 0),
+                },
+            };
+        }
+
+        // 检查是否包含 tool_use
+        const hasToolUse = claudeResponse.content.some(block => block && block.type === 'tool_use');
+        
+        let message = {
+            role: "assistant",
+            content: null
+        };
+
+        if (hasToolUse) {
+            // 处理包含工具调用的响应
+            const toolCalls = [];
+            let textContent = '';
+
+            for (const block of claudeResponse.content) {
+                if (!block) continue;
+
+                if (block.type === 'text') {
+                    textContent += block.text || '';
+                } else if (block.type === 'tool_use') {
+                    toolCalls.push({
+                        id: block.id || `call_${block.name}_${Date.now()}`,
+                        type: "function",
+                        function: {
+                            name: block.name || '',
+                            arguments: JSON.stringify(block.input || {})
+                        }
+                    });
+                }
+            }
+
+            message.content = textContent || null;
+            if (toolCalls.length > 0) {
+                message.tool_calls = toolCalls;
+            }
+        } else {
+            // 处理普通文本响应
+            message.content = this.processClaudeResponseContent(claudeResponse.content);
+        }
+
+        // 处理 finish_reason
+        let finishReason = 'stop';
+        if (claudeResponse.stop_reason === 'end_turn') {
+            finishReason = 'stop';
+        } else if (claudeResponse.stop_reason === 'max_tokens') {
+            finishReason = 'length';
+        } else if (claudeResponse.stop_reason === 'tool_use') {
+            finishReason = 'tool_calls';
+        } else if (claudeResponse.stop_reason) {
+            finishReason = claudeResponse.stop_reason;
+        }
+
+        return {
+            id: `chatcmpl-${uuidv4()}`,
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            model: model,
+            choices: [{
+                index: 0,
+                message: message,
+                finish_reason: finishReason,
+            }],
+            usage: {
+                prompt_tokens: claudeResponse.usage?.input_tokens || 0,
+                completion_tokens: claudeResponse.usage?.output_tokens || 0,
+                total_tokens: (claudeResponse.usage?.input_tokens || 0) + (claudeResponse.usage?.output_tokens || 0),
+                cached_tokens: claudeResponse.usage?.cache_read_input_tokens || 0,
+                prompt_tokens_details: {
+                    cached_tokens: claudeResponse.usage?.cache_read_input_tokens || 0
+                }
+            },
+        };
+    }
+
+    /**
+     * Claude流式响应 -> OpenAI流式响应
+     */
+    toOpenAIStreamChunk(claudeChunk, model) {
+        if (!claudeChunk) return null;
+
+        // 处理 Claude 流式事件
+        const chunkId = `chatcmpl-${uuidv4()}`;
+        const timestamp = Math.floor(Date.now() / 1000);
+
+        // message_start 事件
+        if (claudeChunk.type === 'message_start') {
+            return {
+                id: chunkId,
+                object: "chat.completion.chunk",
+                created: timestamp,
+                model: model,
+                system_fingerprint: "",
+                choices: [{
+                    index: 0,
+                    delta: {
+                        role: "assistant",
+                        content: ""
+                    },
+                    finish_reason: null
+                }],
+                usage: {
+                    prompt_tokens: claudeChunk.message?.usage?.input_tokens || 0,
+                    completion_tokens: 0,
+                    total_tokens: claudeChunk.message?.usage?.input_tokens || 0,
+                    cached_tokens: claudeChunk.message?.usage?.cache_read_input_tokens || 0
+                }
+            };
+        }
+
+        // content_block_start 事件
+        if (claudeChunk.type === 'content_block_start') {
+            const contentBlock = claudeChunk.content_block;
+            
+            // 处理 tool_use 类型
+            if (contentBlock && contentBlock.type === 'tool_use') {
+                return {
+                    id: chunkId,
+                    object: "chat.completion.chunk",
+                    created: timestamp,
+                    model: model,
+                    system_fingerprint: "",
+                    choices: [{
+                        index: 0,
+                        delta: {
+                            tool_calls: [{
+                                index: claudeChunk.index || 0,
+                                id: contentBlock.id,
+                                type: "function",
+                                function: {
+                                    name: contentBlock.name,
+                                    arguments: ""
+                                }
+                            }]
+                        },
+                        finish_reason: null
+                    }]
+                };
+            }
+
+            // 处理 text 类型
+            return {
+                id: chunkId,
+                object: "chat.completion.chunk",
+                created: timestamp,
+                model: model,
+                system_fingerprint: "",
+                choices: [{
+                    index: 0,
+                    delta: {
+                        content: ""
+                    },
+                    finish_reason: null
+                }]
+            };
+        }
+
+        // content_block_delta 事件
+        if (claudeChunk.type === 'content_block_delta') {
+            const delta = claudeChunk.delta;
+            
+            // 处理 text_delta
+            if (delta && delta.type === 'text_delta') {
+                return {
+                    id: chunkId,
+                    object: "chat.completion.chunk",
+                    created: timestamp,
+                    model: model,
+                    system_fingerprint: "",
+                    choices: [{
+                        index: 0,
+                        delta: {
+                            content: delta.text || ""
+                        },
+                        finish_reason: null
+                    }]
+                };
+            }
+
+            // 处理 thinking_delta (推理内容)
+            if (delta && delta.type === 'thinking_delta') {
+                return {
+                    id: chunkId,
+                    object: "chat.completion.chunk",
+                    created: timestamp,
+                    model: model,
+                    system_fingerprint: "",
+                    choices: [{
+                        index: 0,
+                        delta: {
+                            reasoning_content: delta.thinking || ""
+                        },
+                        finish_reason: null
+                    }]
+                };
+            }
+
+            // 处理 input_json_delta (tool arguments)
+            if (delta && delta.type === 'input_json_delta') {
+                return {
+                    id: chunkId,
+                    object: "chat.completion.chunk",
+                    created: timestamp,
+                    model: model,
+                    system_fingerprint: "",
+                    choices: [{
+                        index: 0,
+                        delta: {
+                            tool_calls: [{
+                                index: claudeChunk.index || 0,
+                                function: {
+                                    arguments: delta.partial_json || ""
+                                }
+                            }]
+                        },
+                        finish_reason: null
+                    }]
+                };
+            }
+        }
+
+        // content_block_stop 事件
+        if (claudeChunk.type === 'content_block_stop') {
+            return {
+                id: chunkId,
+                object: "chat.completion.chunk",
+                created: timestamp,
+                model: model,
+                system_fingerprint: "",
+                choices: [{
+                    index: 0,
+                    delta: {},
+                    finish_reason: null
+                }]
+            };
+        }
+
+        // message_delta 事件
+        if (claudeChunk.type === 'message_delta') {
+            const stopReason = claudeChunk.delta?.stop_reason;
+            const finishReason = stopReason === 'end_turn' ? 'stop' :
+                                stopReason === 'max_tokens' ? 'length' :
+                                stopReason === 'tool_use' ? 'tool_calls' :
+                                stopReason || 'stop';
+
+            return {
+                id: chunkId,
+                object: "chat.completion.chunk",
+                created: timestamp,
+                model: model,
+                system_fingerprint: "",
+                choices: [{
+                    index: 0,
+                    delta: {},
+                    finish_reason: finishReason
+                }],
+                usage: claudeChunk.usage ? {
+                    prompt_tokens: claudeChunk.usage.input_tokens || 0,
+                    completion_tokens: claudeChunk.usage.output_tokens || 0,
+                    total_tokens: (claudeChunk.usage.input_tokens || 0) + (claudeChunk.usage.output_tokens || 0),
+                    cached_tokens: claudeChunk.usage.cache_read_input_tokens || 0,
+                    prompt_tokens_details: {
+                        cached_tokens: claudeChunk.usage.cache_read_input_tokens || 0
+                    }
+                } : undefined
+            };
+        }
+
+        // message_stop 事件
+        if (claudeChunk.type === 'message_stop') {
+            return {
+                id: chunkId,
+                object: "chat.completion.chunk",
+                created: timestamp,
+                model: model,
+                system_fingerprint: "",
+                choices: [{
+                    index: 0,
+                    delta: {},
+                    finish_reason: 'stop'
+                }]
+            };
+        }
+
+        // 兼容旧格式：如果是字符串，直接作为文本内容
+        if (typeof claudeChunk === 'string') {
+            return {
+                id: chunkId,
+                object: "chat.completion.chunk",
+                created: timestamp,
+                model: model,
+                system_fingerprint: "",
+                choices: [{
+                    index: 0,
+                    delta: {
+                        content: claudeChunk
+                    },
+                    finish_reason: null
+                }]
+            };
+        }
+
+        return null;
+    }
+
+    /**
+     * Claude模型列表 -> OpenAI模型列表
+     */
+    toOpenAIModelList(claudeModels) {
+        return {
+            object: "list",
+            data: claudeModels.models.map(m => {
+                const modelId = m.id || m.name;
+                return {
+                    id: modelId,
+                    object: "model",
+                    created: Math.floor(Date.now() / 1000),
+                    owned_by: "anthropic",
+                    display_name: modelId,
+                };
+            }),
+        };
+    }
+
+    /**
+     * 将 Claude 模型列表转换为 Gemini 模型列表
+     */
+    toGeminiModelList(claudeModels) {
+        const models = claudeModels.models || [];
+        return {
+            models: models.map(m => ({
+                name: `models/${m.id || m.name}`,
+                version: m.version || "1.0.0",
+                displayName: m.displayName || m.id || m.name,
+                description: m.description || `A generative model for text and chat generation. ID: ${m.id || m.name}`,
+                inputTokenLimit: m.inputTokenLimit || GEMINI_DEFAULT_INPUT_TOKEN_LIMIT,
+                outputTokenLimit: m.outputTokenLimit || GEMINI_DEFAULT_OUTPUT_TOKEN_LIMIT,
+                supportedGenerationMethods: m.supportedGenerationMethods || ["generateContent", "streamGenerateContent"]
+            }))
+        };
+    }
+
+    /**
+     * 处理Claude内容到OpenAI格式
+     */
+    processClaudeContentToOpenAIContent(content) {
+        if (!content || !Array.isArray(content)) return [];
+        
+        const contentArray = [];
+        
+        content.forEach(block => {
+            if (!block) return;
+            
+            switch (block.type) {
+                case 'text':
+                    if (block.text) {
+                        contentArray.push({
+                            type: 'text',
+                            text: block.text
+                        });
+                    }
+                    break;
+                    
+                case 'image':
+                    if (block.source && block.source.type === 'base64') {
+                        contentArray.push({
+                            type: 'image_url',
+                            image_url: {
+                                url: `data:${block.source.media_type};base64,${block.source.data}`
+                            }
+                        });
+                    }
+                    break;
+                    
+                case 'tool_use':
+                    contentArray.push({
+                        type: 'text',
+                        text: `[Tool use: ${block.name}]`
+                    });
+                    break;
+                    
+                case 'tool_result':
+                    contentArray.push({
+                        type: 'text',
+                        text: typeof block.content === 'string' ? block.content : JSON.stringify(block.content)
+                    });
+                    break;
+                    
+                default:
+                    if (block.text) {
+                        contentArray.push({
+                            type: 'text',
+                            text: block.text
+                        });
+                    }
+            }
+        });
+        
+        return contentArray;
+    }
+
+    /**
+     * 处理Claude响应内容
+     */
+    processClaudeResponseContent(content) {
+        if (!content || !Array.isArray(content)) return '';
+        
+        const contentArray = [];
+        
+        content.forEach(block => {
+            if (!block) return;
+            
+            switch (block.type) {
+                case 'text':
+                    contentArray.push({
+                        type: 'text',
+                        text: block.text || ''
+                    });
+                    break;
+                    
+                case 'image':
+                    if (block.source && block.source.type === 'base64') {
+                        contentArray.push({
+                            type: 'image_url',
+                            image_url: {
+                                url: `data:${block.source.media_type};base64,${block.source.data}`
+                            }
+                        });
+                    }
+                    break;
+                    
+                default:
+                    if (block.text) {
+                        contentArray.push({
+                            type: 'text',
+                            text: block.text
+                        });
+                    }
+            }
+        });
+        
+        return contentArray.length === 1 && contentArray[0].type === 'text'
+            ? contentArray[0].text
+            : contentArray;
+    }
+
+    // =========================================================================
+    // Claude -> Gemini 转换
+    // =========================================================================
+
+    // Gemini Claude thought signature constant
+    static GEMINI_CLAUDE_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+
+    /**
+     * Claude请求 -> Gemini请求
+     */
+    toGeminiRequest(claudeRequest) {
+        if (!claudeRequest || typeof claudeRequest !== 'object') {
+            console.warn("Invalid claudeRequest provided to toGeminiRequest.");
+            return { contents: [] };
+        }
+
+        const geminiRequest = {
+            contents: []
+        };
+
+        // 处理系统指令 - 支持数组和字符串格式
+        if (claudeRequest.system) {
+            if (Array.isArray(claudeRequest.system)) {
+                // 数组格式的系统指令
+                const systemParts = [];
+                claudeRequest.system.forEach(systemPrompt => {
+                    if (systemPrompt && systemPrompt.type === 'text' && typeof systemPrompt.text === 'string') {
+                        systemParts.push({ text: systemPrompt.text });
+                    }
+                });
+                if (systemParts.length > 0) {
+                    geminiRequest.systemInstruction = {
+                        role: 'user',
+                        parts: systemParts
+                    };
+                }
+            } else if (typeof claudeRequest.system === 'string') {
+                // 字符串格式的系统指令
+                geminiRequest.systemInstruction = {
+                    parts: [{ text: claudeRequest.system }]
+                };
+            } else if (typeof claudeRequest.system === 'object') {
+                // 对象格式的系统指令
+                geminiRequest.systemInstruction = {
+                    parts: [{ text: JSON.stringify(claudeRequest.system) }]
+                };
+            }
+        }
+
+        // 处理消息
+        if (Array.isArray(claudeRequest.messages)) {
+            claudeRequest.messages.forEach(message => {
+                if (!message || typeof message !== 'object' || !message.role) {
+                    console.warn("Skipping invalid message in claudeRequest.messages.");
+                    return;
+                }
+
+                const geminiRole = message.role === 'assistant' ? 'model' : 'user';
+                const content = message.content;
+
+                // 处理内容
+                if (Array.isArray(content)) {
+                    const parts = [];
+                    
+                    content.forEach(block => {
+                        if (!block || typeof block !== 'object') return;
+                        
+                        switch (block.type) {
+                            case 'text':
+                                if (typeof block.text === 'string') {
+                                    parts.push({ text: block.text });
+                                }
+                                break;
+                            
+                            // [FIX] 参考 ag/request.rs 添加 thinking 块处理
+                            case 'thinking':
+                                if (typeof block.thinking === 'string' && block.thinking.length > 0) {
+                                    const thinkingPart = {
+                                        text: block.thinking,
+                                        thought: true
+                                    };
+                                    // 如果有签名，添加 thoughtSignature
+                                    if (block.signature && block.signature.length >= 50) {
+                                        thinkingPart.thoughtSignature = block.signature;
+                                    }
+                                    parts.push(thinkingPart);
+                                }
+                                break;
+                            
+                            // [FIX] 处理 redacted_thinking 块
+                            case 'redacted_thinking':
+                                // 将 redacted_thinking 转换为普通文本
+                                if (block.data) {
+                                    parts.push({ 
+                                        text: `[Redacted Thinking: ${block.data}]` 
+                                    });
+                                }
+                                break;
+                                
+                            case 'tool_use':
+                                // 转换为 Gemini functionCall 格式
+                                if (block.name && block.input) {
+                                    const args = typeof block.input === 'string'
+                                        ? block.input
+                                        : JSON.stringify(block.input);
+                                    
+                                    // 验证 args 是有效的 JSON 对象
+                                    try {
+                                        const parsedArgs = JSON.parse(args);
+                                        if (parsedArgs && typeof parsedArgs === 'object') {
+                                            parts.push({
+                                                thoughtSignature: ClaudeConverter.GEMINI_CLAUDE_THOUGHT_SIGNATURE,
+                                                functionCall: {
+                                                    name: block.name,
+                                                    args: parsedArgs
+                                                }
+                                            });
+                                        }
+                                    } catch (e) {
+                                        // 如果解析失败，尝试直接使用 input
+                                        if (block.input && typeof block.input === 'object') {
+                                            parts.push({
+                                                thoughtSignature: ClaudeConverter.GEMINI_CLAUDE_THOUGHT_SIGNATURE,
+                                                functionCall: {
+                                                    name: block.name,
+                                                    args: block.input
+                                                }
+                                            });
+                                        }
+                                    }
+                                }
+                                break;
+                                
+                            case 'tool_result':
+                                // 转换为 Gemini functionResponse 格式
+                                // [FIX] 参考 ag/request.rs 的实现，正确处理 tool_use_id 到函数名的映射
+                                const toolCallId = block.tool_use_id;
+                                if (toolCallId) {
+                                    // 尝试从之前的 tool_use 块中查找对应的函数名
+                                    // 如果找不到，则从 tool_use_id 中提取
+                                    let funcName = toolCallId;
+                                    
+                                    // 检查是否有缓存的 tool_id -> name 映射
+                                    // 格式通常是 "funcName-uuid" 或 "toolu_xxx"
+                                    if (toolCallId.startsWith('toolu_')) {
+                                        // Claude 格式的 tool_use_id，需要从上下文中查找函数名
+                                        // 这里我们保留原始 ID 作为 name（Gemini 会处理）
+                                        funcName = toolCallId;
+                                    } else {
+                                        const toolCallIdParts = toolCallId.split('-');
+                                        if (toolCallIdParts.length > 1) {
+                                            // 移除最后一个部分（UUID），保留函数名
+                                            funcName = toolCallIdParts.slice(0, -1).join('-');
+                                        }
+                                    }
+                                    
+                                    // 获取响应数据
+                                    let responseData = block.content;
+                                    
+                                    // [FIX] 参考 ag/request.rs 的 tool_result_compressor 逻辑
+                                    // 处理嵌套的 content 数组（如图片等）
+                                    if (Array.isArray(responseData)) {
+                                        // 提取文本内容
+                                        const textParts = responseData
+                                            .filter(item => item && item.type === 'text')
+                                            .map(item => item.text)
+                                            .join('\n');
+                                        responseData = textParts || JSON.stringify(responseData);
+                                    } else if (typeof responseData !== 'string') {
+                                        responseData = JSON.stringify(responseData);
+                                    }
+                                    
+                                    parts.push({
+                                        functionResponse: {
+                                            name: funcName,
+                                            response: {
+                                                result: responseData
+                                            }
+                                        }
+                                    });
+                                }
+                                break;
+                                
+                            case 'image':
+                                if (block.source && block.source.type === 'base64') {
+                                    parts.push({
+                                        inlineData: {
+                                            mimeType: block.source.media_type,
+                                            data: block.source.data
+                                        }
+                                    });
+                                }
+                                break;
+                        }
+                    });
+                    
+                    if (parts.length > 0) {
+                        geminiRequest.contents.push({
+                            role: geminiRole,
+                            parts: parts
+                        });
+                    }
+                } else if (typeof content === 'string') {
+                    // 字符串内容
+                    geminiRequest.contents.push({
+                        role: geminiRole,
+                        parts: [{ text: content }]
+                    });
+                }
+            });
+        }
+
+        // 添加生成配置
+        const generationConfig = {};
+        
+        if (claudeRequest.max_tokens !== undefined) {
+            generationConfig.maxOutputTokens = claudeRequest.max_tokens;
+        }
+        if (claudeRequest.temperature !== undefined) {
+            generationConfig.temperature = claudeRequest.temperature;
+        }
+        if (claudeRequest.top_p !== undefined) {
+            generationConfig.topP = claudeRequest.top_p;
+        }
+        if (claudeRequest.top_k !== undefined) {
+            generationConfig.topK = claudeRequest.top_k;
+        }
+        
+        // 处理 thinking 配置 - 转换为 Gemini thinkingBudget
+        if (claudeRequest.thinking && claudeRequest.thinking.type === 'enabled') {
+            if (claudeRequest.thinking.budget_tokens !== undefined) {
+                const budget = claudeRequest.thinking.budget_tokens;
+                if (!generationConfig.thinkingConfig) {
+                    generationConfig.thinkingConfig = {};
+                }
+                generationConfig.thinkingConfig.thinkingBudget = budget;
+                generationConfig.thinkingConfig.include_thoughts = true;
+            }
+        }
+        
+        if (Object.keys(generationConfig).length > 0) {
+            geminiRequest.generationConfig = generationConfig;
+        }
+
+        // 处理工具 - 使用 parametersJsonSchema 格式
+        if (Array.isArray(claudeRequest.tools) && claudeRequest.tools.length > 0) {
+            const functionDeclarations = [];
+            
+            claudeRequest.tools.forEach(tool => {
+                if (!tool || typeof tool !== 'object' || !tool.name) {
+                    console.warn("Skipping invalid tool declaration in claudeRequest.tools.");
+                    return;
+                }
+
+                // 清理 input_schema
+                let inputSchema = tool.input_schema;
+                if (inputSchema && typeof inputSchema === 'object') {
+                    // 创建副本以避免修改原始对象
+                    inputSchema = JSON.parse(JSON.stringify(inputSchema));
+                    // 清理不需要的字段
+                    delete inputSchema.$schema;
+                    // 清理 URL 格式（Gemini 不支持）
+                    this.cleanUrlFormatFromSchema(inputSchema);
+                }
+
+                const funcDecl = {
+                    name: String(tool.name),
+                    description: String(tool.description || '')
+                };
+                
+                // 使用 parametersJsonSchema 而不是 parameters
+                if (inputSchema) {
+                    funcDecl.parametersJsonSchema = inputSchema;
+                }
+                
+                functionDeclarations.push(funcDecl);
+            });
+            
+            if (functionDeclarations.length > 0) {
+                geminiRequest.tools = [{
+                    functionDeclarations: functionDeclarations
+                }];
+            }
+        }
+
+        // 处理tool_choice
+        if (claudeRequest.tool_choice) {
+            geminiRequest.toolConfig = this.buildGeminiToolConfigFromClaude(claudeRequest.tool_choice);
+        }
+
+        // 添加默认安全设置
+        geminiRequest.safetySettings = this.getDefaultSafetySettings();
+
+        return geminiRequest;
+    }
+
+    /**
+     * 清理 JSON Schema 中的 URL 格式
+     * Gemini 不支持 "format": "uri"
+     */
+    cleanUrlFormatFromSchema(schema) {
+        if (!schema || typeof schema !== 'object') return;
+        
+        // 如果是属性对象，检查并清理 format
+        if (schema.type === 'string' && schema.format === 'uri') {
+            delete schema.format;
+        }
+        
+        // 递归处理 properties
+        if (schema.properties && typeof schema.properties === 'object') {
+            Object.values(schema.properties).forEach(prop => {
+                this.cleanUrlFormatFromSchema(prop);
+            });
+        }
+        
+        // 递归处理 items（数组类型）
+        if (schema.items) {
+            this.cleanUrlFormatFromSchema(schema.items);
+        }
+        
+        // 递归处理 additionalProperties
+        if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+            this.cleanUrlFormatFromSchema(schema.additionalProperties);
+        }
+    }
+
+    /**
+     * 获取默认的 Gemini 安全设置
+     */
+    getDefaultSafetySettings() {
+        return [
+            { category: "HARM_CATEGORY_HARASSMENT", threshold: "OFF" },
+            { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "OFF" },
+            { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "OFF" },
+            { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "OFF" },
+            { category: "HARM_CATEGORY_CIVIC_INTEGRITY", threshold: "OFF" }
+        ];
+    }
+
+    /**
+     * Claude响应 -> Gemini响应
+     */
+    toGeminiResponse(claudeResponse, model) {
+        if (!claudeResponse || !claudeResponse.content || claudeResponse.content.length === 0) {
+            return { candidates: [], usageMetadata: {} };
+        }
+
+        const parts = [];
+
+        // 处理内容块
+        for (const block of claudeResponse.content) {
+            if (!block) continue;
+
+            switch (block.type) {
+                case 'text':
+                    if (block.text) {
+                        parts.push({ text: block.text });
+                    }
+                    break;
+
+                // [FIX] 参考 ag/response.rs 添加 thinking 块处理
+                case 'thinking':
+                    if (block.thinking) {
+                        const thinkingPart = {
+                            text: block.thinking,
+                            thought: true
+                        };
+                        // 如果有签名，添加 thoughtSignature
+                        if (block.signature && block.signature.length >= 50) {
+                            thinkingPart.thoughtSignature = block.signature;
+                        }
+                        parts.push(thinkingPart);
+                    }
+                    break;
+
+                case 'tool_use':
+                    // [FIX] 添加 id 和 thoughtSignature 支持
+                    const functionCallPart = {
+                        functionCall: {
+                            name: block.name,
+                            args: block.input || {}
+                        }
+                    };
+                    // 添加 id（如果存在）
+                    if (block.id) {
+                        functionCallPart.functionCall.id = block.id;
+                    }
+                    // 添加签名（如果存在）
+                    if (block.signature && block.signature.length >= 50) {
+                        functionCallPart.thoughtSignature = block.signature;
+                    }
+                    parts.push(functionCallPart);
+                    break;
+
+                case 'image':
+                    if (block.source && block.source.type === 'base64') {
+                        parts.push({
+                            inlineData: {
+                                mimeType: block.source.media_type,
+                                data: block.source.data
+                            }
+                        });
+                    }
+                    break;
+
+                default:
+                    if (block.text) {
+                        parts.push({ text: block.text });
+                    }
+            }
+        }
+
+        // 映射finish_reason
+        const finishReasonMap = {
+            'end_turn': 'STOP',
+            'max_tokens': 'MAX_TOKENS',
+            'tool_use': 'STOP',
+            'stop_sequence': 'STOP'
+        };
+
+        return {
+            candidates: [{
+                content: {
+                    role: 'model',
+                    parts: parts
+                },
+                finishReason: finishReasonMap[claudeResponse.stop_reason] || 'STOP'
+            }],
+            usageMetadata: claudeResponse.usage ? {
+                promptTokenCount: claudeResponse.usage.input_tokens || 0,
+                candidatesTokenCount: claudeResponse.usage.output_tokens || 0,
+                totalTokenCount: (claudeResponse.usage.input_tokens || 0) + (claudeResponse.usage.output_tokens || 0),
+                cachedContentTokenCount: claudeResponse.usage.cache_read_input_tokens || 0,
+                promptTokensDetails: [{
+                    modality: "TEXT",
+                    tokenCount: claudeResponse.usage.input_tokens || 0
+                }],
+                candidatesTokensDetails: [{
+                    modality: "TEXT",
+                    tokenCount: claudeResponse.usage.output_tokens || 0
+                }]
+            } : {}
+        };
+    }
+
+    /**
+     * Claude流式响应 -> Gemini流式响应
+     */
+    toGeminiStreamChunk(claudeChunk, model) {
+        if (!claudeChunk) return null;
+
+        // 处理Claude流式事件
+        if (typeof claudeChunk === 'object' && !Array.isArray(claudeChunk)) {
+            // content_block_start 事件 - 处理 thinking 块开始
+            if (claudeChunk.type === 'content_block_start') {
+                const contentBlock = claudeChunk.content_block;
+                if (contentBlock && contentBlock.type === 'thinking') {
+                    // thinking 块开始，返回空（等待 delta）
+                    return null;
+                }
+                if (contentBlock && contentBlock.type === 'tool_use') {
+                    // tool_use 块开始
+                    return {
+                        candidates: [{
+                            content: {
+                                role: "model",
+                                parts: [{
+                                    functionCall: {
+                                        name: contentBlock.name,
+                                        args: {},
+                                        id: contentBlock.id
+                                    }
+                                }]
+                            }
+                        }]
+                    };
+                }
+            }
+            
+            // content_block_delta 事件
+            if (claudeChunk.type === 'content_block_delta') {
+                const delta = claudeChunk.delta;
+                
+                // 处理 text_delta
+                if (delta && delta.type === 'text_delta') {
+                    return {
+                        candidates: [{
+                            content: {
+                                role: "model",
+                                parts: [{
+                                    text: delta.text || ""
+                                }]
+                            }
+                        }]
+                    };
+                }
+                
+                // [FIX] 处理 thinking_delta - 转换为 Gemini 的 thought 格式
+                if (delta && delta.type === 'thinking_delta') {
+                    return {
+                        candidates: [{
+                            content: {
+                                role: "model",
+                                parts: [{
+                                    text: delta.thinking || "",
+                                    thought: true
+                                }]
+                            }
+                        }]
+                    };
+                }
+                
+                // [FIX] 处理 signature_delta
+                if (delta && delta.type === 'signature_delta') {
+                    // 签名通常与前一个 thinking 块关联
+                    // 在流式场景中，我们可以忽略或记录
+                    return null;
+                }
+                
+                // [FIX] 处理 input_json_delta (tool arguments)
+                if (delta && delta.type === 'input_json_delta') {
+                    // 工具参数增量，Gemini 不支持增量参数，忽略
+                    return null;
+                }
+            }
+            
+            // message_delta 事件 - 流结束
+            if (claudeChunk.type === 'message_delta') {
+                const stopReason = claudeChunk.delta?.stop_reason;
+                const result = {
+                    candidates: [{
+                        finishReason: stopReason === 'end_turn' ? 'STOP' :
+                                    stopReason === 'max_tokens' ? 'MAX_TOKENS' :
+                                    stopReason === 'tool_use' ? 'STOP' :
+                                    'OTHER'
+                    }]
+                };
+                
+                // 添加 usage 信息
+                if (claudeChunk.usage) {
+                    result.usageMetadata = {
+                        promptTokenCount: claudeChunk.usage.input_tokens || 0,
+                        candidatesTokenCount: claudeChunk.usage.output_tokens || 0,
+                        totalTokenCount: (claudeChunk.usage.input_tokens || 0) + (claudeChunk.usage.output_tokens || 0),
+                        cachedContentTokenCount: claudeChunk.usage.cache_read_input_tokens || 0,
+                        promptTokensDetails: [{
+                            modality: "TEXT",
+                            tokenCount: claudeChunk.usage.input_tokens || 0
+                        }],
+                        candidatesTokensDetails: [{
+                            modality: "TEXT",
+                            tokenCount: claudeChunk.usage.output_tokens || 0
+                        }]
+                    };
+                }
+                
+                return result;
+            }
+        }
+
+        // 向后兼容：处理字符串格式
+        if (typeof claudeChunk === 'string') {
+            return {
+                candidates: [{
+                    content: {
+                        role: "model",
+                        parts: [{
+                            text: claudeChunk
+                        }]
+                    }
+                }]
+            };
+        }
+
+        return null;
+    }
+
+    /**
+     * 处理Claude内容到Gemini parts
+     */
+    processClaudeContentToGeminiParts(content) {
+        if (!content) return [];
+
+        if (typeof content === 'string') {
+            return [{ text: content }];
+        }
+
+        if (Array.isArray(content)) {
+            const parts = [];
+
+            content.forEach(block => {
+                if (!block || typeof block !== 'object' || !block.type) {
+                    console.warn("Skipping invalid content block.");
+                    return;
+                }
+
+                switch (block.type) {
+                    case 'text':
+                        if (typeof block.text === 'string') {
+                            parts.push({ text: block.text });
+                        }
+                        break;
+
+                    case 'image':
+                        if (block.source && typeof block.source === 'object' && 
+                            block.source.type === 'base64' &&
+                            typeof block.source.media_type === 'string' && 
+                            typeof block.source.data === 'string') {
+                            parts.push({
+                                inlineData: {
+                                    mimeType: block.source.media_type,
+                                    data: block.source.data
+                                }
+                            });
+                        }
+                        break;
+
+                    case 'tool_use':
+                        if (typeof block.name === 'string' && 
+                            block.input && typeof block.input === 'object') {
+                            parts.push({
+                                functionCall: {
+                                    name: block.name,
+                                    args: block.input
+                                }
+                            });
+                        }
+                        break;
+
+                    case 'tool_result':
+                        if (typeof block.tool_use_id === 'string') {
+                            parts.push({
+                                functionResponse: {
+                                    name: block.tool_use_id,
+                                    response: { content: block.content }
+                                }
+                            });
+                        }
+                        break;
+
+                    default:
+                        if (typeof block.text === 'string') {
+                            parts.push({ text: block.text });
+                        }
+                }
+            });
+
+            return parts;
+        }
+
+        return [];
+    }
+
+    /**
+     * 构建Gemini工具配置
+     */
+    buildGeminiToolConfigFromClaude(claudeToolChoice) {
+        if (!claudeToolChoice || typeof claudeToolChoice !== 'object' || !claudeToolChoice.type) {
+            console.warn("Invalid claudeToolChoice provided.");
+            return undefined;
+        }
+
+        switch (claudeToolChoice.type) {
+            case 'auto':
+                return { functionCallingConfig: { mode: 'AUTO' } };
+            case 'none':
+                return { functionCallingConfig: { mode: 'NONE' } };
+            case 'tool':
+                if (claudeToolChoice.name && typeof claudeToolChoice.name === 'string') {
+                    return { 
+                        functionCallingConfig: { 
+                            mode: 'ANY', 
+                            allowedFunctionNames: [claudeToolChoice.name] 
+                        } 
+                    };
+                }
+                console.warn("Invalid tool name in claudeToolChoice of type 'tool'.");
+                return undefined;
+            default:
+                console.warn(`Unsupported claudeToolChoice type: ${claudeToolChoice.type}`);
+                return undefined;
+        }
+    }
+
+    // =========================================================================
+    // Claude -> OpenAI Responses 转换
+    // =========================================================================
+
+    /**
+     * Claude请求 -> OpenAI Responses请求
+     */
+    toOpenAIResponsesRequest(claudeRequest) {
+        // 转换为OpenAI Responses格式
+        const responsesRequest = {
+            model: claudeRequest.model,
+            max_tokens: checkAndAssignOrDefault(claudeRequest.max_tokens, OPENAI_DEFAULT_MAX_TOKENS),
+            temperature: checkAndAssignOrDefault(claudeRequest.temperature, OPENAI_DEFAULT_TEMPERATURE),
+            top_p: checkAndAssignOrDefault(claudeRequest.top_p, OPENAI_DEFAULT_TOP_P),
+        };
+
+        // 处理系统指令
+        if (claudeRequest.system) {
+            responsesRequest.instructions = claudeRequest.system;
+        }
+
+        // 处理消息
+        if (claudeRequest.messages && Array.isArray(claudeRequest.messages)) {
+            responsesRequest.input = claudeRequest.messages;
+        }
+
+        return responsesRequest;
+    }
+
+    /**
+     * Claude响应 -> OpenAI Responses响应
+     */
+    toOpenAIResponsesResponse(claudeResponse, model) {
+        const content = this.processClaudeResponseContent(claudeResponse.content);
+        const textContent = typeof content === 'string' ? content : JSON.stringify(content);
+
+        let output = [];
+        output.push({
+            type: "message",
+            id: `msg_${uuidv4().replace(/-/g, '')}`,
+            summary: [],
+            role: "assistant",
+            status: "completed",
+            content: [{
+                annotations: [],
+                logprobs: [],
+                text: textContent,
+                type: "output_text"
+            }]
+        });
+
+        return {
+            background: false,
+            created_at: Math.floor(Date.now() / 1000),
+            error: null,
+            id: `resp_${uuidv4().replace(/-/g, '')}`,
+            incomplete_details: null,
+            max_output_tokens: null,
+            max_tool_calls: null,
+            metadata: {},
+            model: model || claudeResponse.model,
+            object: "response",
+            output: output,
+            parallel_tool_calls: true,
+            previous_response_id: null,
+            prompt_cache_key: null,
+            reasoning: {},
+            safety_identifier: "user-" + uuidv4().replace(/-/g, ''),
+            service_tier: "default",
+            status: "completed",
+            store: false,
+            temperature: 1,
+            text: {
+                format: { type: "text" },
+            },
+            tool_choice: "auto",
+            tools: [],
+            top_logprobs: 0,
+            top_p: 1,
+            truncation: "disabled",
+            usage: {
+                input_tokens: claudeResponse.usage?.input_tokens || 0,
+                input_tokens_details: {
+                    cached_tokens: claudeResponse.usage?.cache_read_input_tokens || 0
+                },
+                output_tokens: claudeResponse.usage?.output_tokens || 0,
+                output_tokens_details: {
+                    reasoning_tokens: 0
+                },
+                total_tokens: (claudeResponse.usage?.input_tokens || 0) + (claudeResponse.usage?.output_tokens || 0)
+            },
+            user: null
+        };
+    }
+
+    /**
+     * Claude流式响应 -> OpenAI Responses流式响应
+     */
+    toOpenAIResponsesStreamChunk(claudeChunk, model, requestId = null) {
+        if (!claudeChunk) return [];
+
+        const responseId = requestId || `resp_${uuidv4().replace(/-/g, '')}`;
+        const events = [];
+
+        // message_start 事件 - 流开始
+        if (claudeChunk.type === 'message_start') {
+            events.push(
+                generateResponseCreated(responseId, model || 'unknown'),
+                generateResponseInProgress(responseId),
+                generateOutputItemAdded(responseId),
+                generateContentPartAdded(responseId)
+            );
+        }
+
+        // content_block_start 事件
+        if (claudeChunk.type === 'content_block_start') {
+            const contentBlock = claudeChunk.content_block;
+            
+            // 对于 tool_use 类型，添加工具调用项
+            if (contentBlock && contentBlock.type === 'tool_use') {
+                events.push({
+                    item: {
+                        id: contentBlock.id,
+                        type: "function_call",
+                        name: contentBlock.name,
+                        arguments: "",
+                        status: "in_progress"
+                    },
+                    output_index: claudeChunk.index || 0,
+                    sequence_number: 2,
+                    type: "response.output_item.added"
+                });
+            }
+        }
+
+        // content_block_delta 事件
+        if (claudeChunk.type === 'content_block_delta') {
+            const delta = claudeChunk.delta;
+            
+            // 处理文本增量
+            if (delta && delta.type === 'text_delta') {
+                events.push({
+                    delta: delta.text || "",
+                    item_id: `msg_${uuidv4().replace(/-/g, '')}`,
+                    output_index: claudeChunk.index || 0,
+                    sequence_number: 3,
+                    type: "response.output_text.delta"
+                });
+            }
+            // 处理推理内容增量
+            else if (delta && delta.type === 'thinking_delta') {
+                events.push({
+                    delta: delta.thinking || "",
+                    item_id: `thinking_${uuidv4().replace(/-/g, '')}`,
+                    output_index: claudeChunk.index || 0,
+                    sequence_number: 3,
+                    type: "response.reasoning_summary_text.delta"
+                });
+            }
+            // 处理工具调用参数增量
+            else if (delta && delta.type === 'input_json_delta') {
+                events.push({
+                    delta: delta.partial_json || "",
+                    item_id: `call_${uuidv4().replace(/-/g, '')}`,
+                    output_index: claudeChunk.index || 0,
+                    sequence_number: 3,
+                    type: "response.custom_tool_call_input.delta"
+                });
+            }
+        }
+
+        // content_block_stop 事件
+        if (claudeChunk.type === 'content_block_stop') {
+            events.push({
+                item_id: `msg_${uuidv4().replace(/-/g, '')}`,
+                output_index: claudeChunk.index || 0,
+                sequence_number: 4,
+                type: "response.output_item.done"
+            });
+        }
+
+        // message_delta 事件 - 流结束
+        if (claudeChunk.type === 'message_delta') {
+            // events.push(
+            //     generateOutputTextDone(responseId),
+            //     generateContentPartDone(responseId),
+            //     generateOutputItemDone(responseId),
+            //     generateResponseCompleted(responseId)
+            // );
+            
+            // 如果有 usage 信息，更新最后一个事件
+            if (claudeChunk.usage && events.length > 0) {
+                const lastEvent = events[events.length - 1];
+                if (lastEvent.response) {
+                    lastEvent.response.usage = {
+                        input_tokens: claudeChunk.usage.input_tokens || 0,
+                        input_tokens_details: {
+                            cached_tokens: claudeChunk.usage.cache_read_input_tokens || 0
+                        },
+                        output_tokens: claudeChunk.usage.output_tokens || 0,
+                        output_tokens_details: {
+                            reasoning_tokens: 0
+                        },
+                        total_tokens: (claudeChunk.usage.input_tokens || 0) + (claudeChunk.usage.output_tokens || 0)
+                    };
+                }
+            }
+        }
+
+        // message_stop 事件
+        if (claudeChunk.type === 'message_stop') {
+            events.push(
+                generateOutputTextDone(responseId),
+                generateContentPartDone(responseId),
+                generateOutputItemDone(responseId),
+                generateResponseCompleted(responseId)
+            );
+        }
+
+        return events;
+    }
+}
+
+export default ClaudeConverter;

src/converters/strategies/CodexConverter.js

@@ -0,0 +1,489 @@
+/**
+ * Codex 转换器
+ * 处理 OpenAI 协议与 Codex 协议之间的转换
+ */
+
+import crypto from 'crypto';
+import { BaseConverter } from '../BaseConverter.js';
+import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
+
+export class CodexConverter extends BaseConverter {
+    constructor() {
+        super('codex');
+        this.toolNameMap = new Map(); // 工具名称缩短/恢复映射
+        this.reverseToolNameMap = new Map(); // 反向映射
+    }
+
+    /**
+     * 转换请求
+     */
+    convertRequest(data, targetProtocol) {
+        if (targetProtocol === 'codex') {
+            return this.toCodexRequest(data);
+        } else if (targetProtocol === MODEL_PROTOCOL_PREFIX.OPENAI) {
+            // Codex → OpenAI (通常不需要，因为 Codex 响应会直接转换)
+            return data;
+        }
+        throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+    }
+
+    /**
+     * 转换响应
+     */
+    convertResponse(data, targetProtocol, model) {
+        if (targetProtocol === MODEL_PROTOCOL_PREFIX.OPENAI) {
+            return this.toOpenAIResponse(data, model);
+        }
+        throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+    }
+
+    /**
+     * 转换流式响应块
+     */
+    convertStreamChunk(chunk, targetProtocol, model) {
+        if (targetProtocol === MODEL_PROTOCOL_PREFIX.OPENAI) {
+            return this.toOpenAIStreamChunk(chunk, model);
+        }
+        throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+    }
+
+    /**
+     * OpenAI → Codex 请求转换
+     */
+    toCodexRequest(data) {
+        const codexRequest = {
+            model: data.model,
+            instructions: this.buildInstructions(data),
+            input: this.convertMessages(data.messages || []),
+            stream: data.stream || false,
+            store: false,
+            reasoning: {
+                effort: 'medium',
+                summary: 'auto'
+            },
+            parallel_tool_calls: data.parallel_tool_calls !== false,
+            include: ['reasoning.encrypted_content']
+        };
+
+        // 添加工具
+        if (data.tools && data.tools.length > 0) {
+            codexRequest.tools = this.convertTools(data.tools);
+            codexRequest.tool_choice = data.tool_choice || 'auto';
+        }
+
+        // 添加响应格式
+        if (data.response_format) {
+            codexRequest.text = {
+                format: this.convertResponseFormat(data.response_format)
+            };
+        }
+
+        // 添加推理强度（如果指定）
+        if (data.reasoning_effort) {
+            codexRequest.reasoning.effort = data.reasoning_effort;
+        }
+
+        // 添加温度和其他参数
+        if (data.temperature !== undefined) {
+            codexRequest.temperature = data.temperature;
+        }
+        if (data.max_tokens !== undefined) {
+            codexRequest.max_output_tokens = data.max_tokens;
+        }
+        if (data.top_p !== undefined) {
+            codexRequest.top_p = data.top_p;
+        }
+
+        return codexRequest;
+    }
+
+    /**
+     * 构建指令
+     */
+    buildInstructions(data) {
+        // 提取系统消息
+        const systemMessages = (data.messages || []).filter(m => m.role === 'system');
+        if (systemMessages.length > 0) {
+            return systemMessages.map(m => {
+                if (typeof m.content === 'string') {
+                    return m.content;
+                } else if (Array.isArray(m.content)) {
+                    return m.content
+                        .filter(part => part.type === 'text')
+                        .map(part => part.text)
+                        .join('\n');
+                }
+                return '';
+            }).join('\n');
+        }
+        return 'You are a helpful assistant.';
+    }
+
+    /**
+     * 转换消息
+     */
+    convertMessages(messages) {
+        const input = [];
+        const nonSystemMessages = messages.filter(m => m.role !== 'system');
+
+        for (const msg of nonSystemMessages) {
+            if (msg.role === 'user' || msg.role === 'assistant') {
+                input.push({
+                    type: 'message',
+                    role: msg.role,
+                    content: this.convertMessageContent(msg.content, msg.role)
+                });
+
+                // 处理助手消息中的工具调用
+                if (msg.role === 'assistant' && msg.tool_calls) {
+                    for (const toolCall of msg.tool_calls) {
+                        const shortName = this.getShortToolName(toolCall.function.name);
+                        input.push({
+                            type: 'function_call',
+                            call_id: toolCall.id,
+                            name: shortName,
+                            arguments: JSON.parse(toolCall.function.arguments)
+                        });
+                    }
+                }
+            } else if (msg.role === 'tool') {
+                input.push({
+                    type: 'function_call_output',
+                    call_id: msg.tool_call_id,
+                    output: msg.content
+                });
+            }
+        }
+
+        return input;
+    }
+
+    /**
+     * 转换消息内容
+     */
+    convertMessageContent(content, role) {
+        if (typeof content === 'string') {
+            return [{
+                type: role === 'user' ? 'input_text' : 'output_text',
+                text: content
+            }];
+        }
+
+        if (Array.isArray(content)) {
+            return content.map(part => {
+                if (part.type === 'text') {
+                    return {
+                        type: role === 'user' ? 'input_text' : 'output_text',
+                        text: part.text
+                    };
+                } else if (part.type === 'image_url') {
+                    return {
+                        type: 'input_image',
+                        image_url: part.image_url.url
+                    };
+                }
+                return part;
+            });
+        }
+
+        return [];
+    }
+
+    /**
+     * 转换工具
+     */
+    convertTools(tools) {
+        this.toolNameMap.clear();
+        this.reverseToolNameMap.clear();
+
+        return tools.map(tool => {
+            const originalName = tool.function.name;
+            const shortName = this.shortenToolName(originalName);
+
+            this.toolNameMap.set(originalName, shortName);
+            this.reverseToolNameMap.set(shortName, originalName);
+
+            return {
+                type: 'function',
+                name: shortName,
+                description: tool.function.description,
+                parameters: tool.function.parameters
+            };
+        });
+    }
+
+    /**
+     * 缩短工具名称（最多 64 字符）
+     */
+    shortenToolName(name) {
+        if (name.length <= 64) {
+            return name;
+        }
+
+        // 保留 mcp__ 前缀和最后一段
+        if (name.startsWith('mcp__')) {
+            const parts = name.split('__');
+            if (parts.length > 2) {
+                const prefix = 'mcp__';
+                const lastPart = parts[parts.length - 1];
+                const maxLastPartLength = 64 - prefix.length - 1; // -1 for underscore
+
+                if (lastPart.length <= maxLastPartLength) {
+                    return prefix + lastPart;
+                } else {
+                    return prefix + lastPart.slice(0, maxLastPartLength);
+                }
+            }
+        }
+
+        // 使用哈希创建唯一的短名称
+        const hash = crypto.createHash('md5').update(name).digest('hex').slice(0, 8);
+        return name.slice(0, 55) + '_' + hash;
+    }
+
+    /**
+     * 获取短工具名称
+     */
+    getShortToolName(originalName) {
+        return this.toolNameMap.get(originalName) || originalName;
+    }
+
+    /**
+     * 获取原始工具名称
+     */
+    getOriginalToolName(shortName) {
+        return this.reverseToolNameMap.get(shortName) || shortName;
+    }
+
+    /**
+     * 转换响应格式
+     */
+    convertResponseFormat(responseFormat) {
+        if (responseFormat.type === 'json_schema') {
+            return {
+                type: 'json_schema',
+                name: responseFormat.json_schema?.name || 'response',
+                schema: responseFormat.json_schema?.schema || {}
+            };
+        } else if (responseFormat.type === 'json_object') {
+            return {
+                type: 'json_object'
+            };
+        }
+        return responseFormat;
+    }
+
+    /**
+     * Codex → OpenAI 响应转换（非流式）
+     */
+    toOpenAIResponse(data, model) {
+        const response = data.response || data;
+
+        const message = {
+            role: 'assistant',
+            content: ''
+        };
+
+        // 提取文本内容和工具调用
+        const textParts = [];
+        const toolCalls = [];
+
+        if (response.output) {
+            for (const item of response.output) {
+                if (item.type === 'message') {
+                    for (const content of item.content || []) {
+                        if (content.type === 'output_text') {
+                            textParts.push(content.text);
+                        }
+                    }
+                } else if (item.type === 'function_call') {
+                    const originalName = this.getOriginalToolName(item.name);
+                    toolCalls.push({
+                        id: item.call_id,
+                        type: 'function',
+                        function: {
+                            name: originalName,
+                            arguments: JSON.stringify(item.arguments)
+                        }
+                    });
+                }
+            }
+        }
+
+        message.content = textParts.join('');
+        if (toolCalls.length > 0) {
+            message.tool_calls = toolCalls;
+        }
+
+        // 提取推理内容
+        let reasoningContent = '';
+        if (response.output) {
+            for (const item of response.output) {
+                if (item.summary) {
+                    reasoningContent = item.summary;
+                    break;
+                }
+            }
+        }
+
+        return {
+            id: response.id || `chatcmpl-${Date.now()}`,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: model,
+            choices: [{
+                index: 0,
+                message: message,
+                finish_reason: this.mapFinishReason(response.status),
+                ...(reasoningContent && { reasoning_content: reasoningContent })
+            }],
+            usage: {
+                prompt_tokens: response.usage?.input_tokens || 0,
+                completion_tokens: response.usage?.output_tokens || 0,
+                total_tokens: response.usage?.total_tokens || 0,
+                ...(response.usage?.input_tokens_details?.cached_tokens && {
+                    prompt_tokens_details: {
+                        cached_tokens: response.usage.input_tokens_details.cached_tokens
+                    }
+                }),
+                ...(response.usage?.output_tokens_details?.reasoning_tokens && {
+                    completion_tokens_details: {
+                        reasoning_tokens: response.usage.output_tokens_details.reasoning_tokens
+                    }
+                })
+            }
+        };
+    }
+
+    /**
+     * Codex → OpenAI 流式响应块转换
+     */
+    toOpenAIStreamChunk(chunk, model) {
+        const type = chunk.type;
+
+        // response.created - 存储元数据
+        if (type === 'response.created') {
+            return {
+                id: chunk.response.id,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: model,
+                choices: [{
+                    index: 0,
+                    delta: { role: 'assistant' },
+                    finish_reason: null
+                }]
+            };
+        }
+
+        // response.output_text.delta - 文本内容
+        if (type === 'response.output_text.delta') {
+            return {
+                id: `chatcmpl-${Date.now()}`,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: model,
+                choices: [{
+                    index: 0,
+                    delta: { content: chunk.delta },
+                    finish_reason: null
+                }]
+            };
+        }
+
+        // response.reasoning_summary_text.delta - 推理内容
+        if (type === 'response.reasoning_summary_text.delta') {
+            return {
+                id: `chatcmpl-${Date.now()}`,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: model,
+                choices: [{
+                    index: 0,
+                    delta: { reasoning_content: chunk.delta },
+                    finish_reason: null
+                }]
+            };
+        }
+
+        // response.output_item.done - 工具调用完成
+        if (type === 'response.output_item.done' && chunk.item?.type === 'function_call') {
+            const originalName = this.getOriginalToolName(chunk.item.name);
+            return {
+                id: `chatcmpl-${Date.now()}`,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: model,
+                choices: [{
+                    index: 0,
+                    delta: {
+                        tool_calls: [{
+                            index: 0,
+                            id: chunk.item.call_id,
+                            type: 'function',
+                            function: {
+                                name: originalName,
+                                arguments: JSON.stringify(chunk.item.arguments)
+                            }
+                        }]
+                    },
+                    finish_reason: null
+                }]
+            };
+        }
+
+        // response.completed - 完成
+        if (type === 'response.completed') {
+            return {
+                id: chunk.response.id,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: model,
+                choices: [{
+                    index: 0,
+                    delta: {},
+                    finish_reason: this.mapFinishReason(chunk.response.status)
+                }],
+                usage: {
+                    prompt_tokens: chunk.response.usage?.input_tokens || 0,
+                    completion_tokens: chunk.response.usage?.output_tokens || 0,
+                    total_tokens: chunk.response.usage?.total_tokens || 0,
+                    ...(chunk.response.usage?.input_tokens_details?.cached_tokens && {
+                        prompt_tokens_details: {
+                            cached_tokens: chunk.response.usage.input_tokens_details.cached_tokens
+                        }
+                    }),
+                    ...(chunk.response.usage?.output_tokens_details?.reasoning_tokens && {
+                        completion_tokens_details: {
+                            reasoning_tokens: chunk.response.usage.output_tokens_details.reasoning_tokens
+                        }
+                    })
+                }
+            };
+        }
+
+        // 其他事件类型暂时忽略
+        return null;
+    }
+
+    /**
+     * 映射完成原因
+     */
+    mapFinishReason(status) {
+        const mapping = {
+            'completed': 'stop',
+            'incomplete': 'length',
+            'failed': 'error',
+            'cancelled': 'stop'
+        };
+        return mapping[status] || 'stop';
+    }
+
+    /**
+     * 转换模型列表
+     */
+    convertModelList(data, targetProtocol) {
+        // Codex 使用 OpenAI 格式的模型列表，无需转换
+        return data;
+    }
+}

src/converters/strategies/GeminiConverter.js

@@ -0,0 +1,1226 @@
+/**
+ * Gemini转换器
+ * 处理Gemini（Google）协议与其他协议之间的转换
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { BaseConverter } from '../BaseConverter.js';
+import {
+    checkAndAssignOrDefault,
+    OPENAI_DEFAULT_MAX_TOKENS,
+    OPENAI_DEFAULT_TEMPERATURE,
+    OPENAI_DEFAULT_TOP_P,
+    CLAUDE_DEFAULT_MAX_TOKENS,
+    CLAUDE_DEFAULT_TEMPERATURE,
+    CLAUDE_DEFAULT_TOP_P
+} from '../utils.js';
+import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
+import {
+    generateResponseCreated,
+    generateResponseInProgress,
+    generateOutputItemAdded,
+    generateContentPartAdded,
+    generateOutputTextDone,
+    generateContentPartDone,
+    generateOutputItemDone,
+    generateResponseCompleted
+} from '../../providers/openai/openai-responses-core.mjs';
+
+/**
+ * [FIX] 参考 ag/response.rs 和 ag/streaming.rs 的 remap_function_call_args 函数
+ * 修复 Gemini 返回的工具参数名称问题
+ * Gemini 有时会使用不同的参数名称，需要映射到 Claude Code 期望的格式
+ */
+function remapFunctionCallArgs(toolName, args) {
+    if (!args || typeof args !== 'object') return args;
+    
+    const remappedArgs = { ...args };
+    const toolNameLower = toolName.toLowerCase();
+    
+    // [IMPORTANT] Claude Code CLI 的 EnterPlanMode 工具禁止携带任何参数
+    if (toolName === 'EnterPlanMode') {
+        return {};
+    }
+    
+    switch (toolNameLower) {
+        case 'grep':
+        case 'search':
+        case 'search_code_definitions':
+        case 'search_code_snippets':
+            // [FIX] Gemini hallucination: maps parameter description to "description" field
+            if (remappedArgs.description && !remappedArgs.pattern) {
+                remappedArgs.pattern = remappedArgs.description;
+                delete remappedArgs.description;
+            }
+            
+            // Gemini uses "query", Claude Code expects "pattern"
+            if (remappedArgs.query && !remappedArgs.pattern) {
+                remappedArgs.pattern = remappedArgs.query;
+                delete remappedArgs.query;
+            }
+            
+            // [CRITICAL FIX] Claude Code uses "path" (string), NOT "paths" (array)!
+            if (!remappedArgs.path) {
+                if (remappedArgs.paths) {
+                    if (Array.isArray(remappedArgs.paths)) {
+                        remappedArgs.path = remappedArgs.paths[0] || '.';
+                    } else if (typeof remappedArgs.paths === 'string') {
+                        remappedArgs.path = remappedArgs.paths;
+                    } else {
+                        remappedArgs.path = '.';
+                    }
+                    delete remappedArgs.paths;
+                } else {
+                    // Default to current directory if missing
+                    remappedArgs.path = '.';
+                }
+            }
+            // Note: We keep "-n" and "output_mode" if present as they are valid in Grep schema
+            break;
+            
+        case 'glob':
+            // [FIX] Gemini hallucination: maps parameter description to "description" field
+            if (remappedArgs.description && !remappedArgs.pattern) {
+                remappedArgs.pattern = remappedArgs.description;
+                delete remappedArgs.description;
+            }
+            
+            // Gemini uses "query", Claude Code expects "pattern"
+            if (remappedArgs.query && !remappedArgs.pattern) {
+                remappedArgs.pattern = remappedArgs.query;
+                delete remappedArgs.query;
+            }
+            
+            // [CRITICAL FIX] Claude Code uses "path" (string), NOT "paths" (array)!
+            // [NOTE] 与 grep 不同，glob 不添加默认 path（参考 Rust 代码）
+            if (!remappedArgs.path) {
+                if (remappedArgs.paths) {
+                    if (Array.isArray(remappedArgs.paths)) {
+                        remappedArgs.path = remappedArgs.paths[0] || '.';
+                    } else if (typeof remappedArgs.paths === 'string') {
+                        remappedArgs.path = remappedArgs.paths;
+                    } else {
+                        remappedArgs.path = '.';
+                    }
+                    delete remappedArgs.paths;
+                }
+                // [FIX] glob 不添加默认 path，与 Rust 代码保持一致
+            }
+            break;
+            
+        case 'read':
+            // Gemini might use "path" vs "file_path"
+            if (remappedArgs.path && !remappedArgs.file_path) {
+                remappedArgs.file_path = remappedArgs.path;
+                delete remappedArgs.path;
+            }
+            break;
+            
+        case 'ls':
+            // LS tool: ensure "path" parameter exists
+            if (!remappedArgs.path) {
+                remappedArgs.path = '.';
+            }
+            break;
+            
+        default:
+            // [NEW] [Issue #785] Generic Property Mapping for all tools
+            // If a tool has "paths" (array of 1) but no "path", convert it.
+            // [FIX] 与 Rust 代码保持一致：只在 paths.length === 1 时转换，不删除原始 paths
+            if (!remappedArgs.path && remappedArgs.paths) {
+                if (Array.isArray(remappedArgs.paths) && remappedArgs.paths.length === 1) {
+                    const pathValue = remappedArgs.paths[0];
+                    if (typeof pathValue === 'string') {
+                        remappedArgs.path = pathValue;
+                        // [FIX] Rust 代码中不删除 paths，这里也不删除
+                    }
+                }
+            }
+            break;
+    }
+    
+    return remappedArgs;
+}
+
+/**
+ * [FIX] 规范化工具名称
+ * Gemini 有时会返回 "search" 而不是 "Grep"
+ */
+function normalizeToolName(name) {
+    if (!name) return name;
+    
+    const nameLower = name.toLowerCase();
+    if (nameLower === 'search') {
+        return 'Grep';
+    }
+    return name;
+}
+
+/**
+ * Gemini转换器类
+ * 实现Gemini协议到其他协议的转换
+ */
+export class GeminiConverter extends BaseConverter {
+    constructor() {
+        super('gemini');
+    }
+
+    /**
+     * 转换请求
+     */
+    convertRequest(data, targetProtocol) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIRequest(data);
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeRequest(data);
+            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
+                return this.toOpenAIResponsesRequest(data);
+            default:
+                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+        }
+    }
+
+    /**
+     * 转换响应
+     */
+    convertResponse(data, targetProtocol, model) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIResponse(data, model);
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeResponse(data, model);
+            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
+                return this.toOpenAIResponsesResponse(data, model);
+            default:
+                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+        }
+    }
+
+    /**
+     * 转换流式响应块
+     */
+    convertStreamChunk(chunk, targetProtocol, model) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIStreamChunk(chunk, model);
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeStreamChunk(chunk, model);
+            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
+                return this.toOpenAIResponsesStreamChunk(chunk, model);
+            default:
+                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+        }
+    }
+
+    /**
+     * 转换模型列表
+     */
+    convertModelList(data, targetProtocol) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIModelList(data);
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeModelList(data);
+            default:
+                return data;
+        }
+    }
+
+    // =========================================================================
+    // Gemini -> OpenAI 转换
+    // =========================================================================
+
+    /**
+     * Gemini请求 -> OpenAI请求
+     */
+    toOpenAIRequest(geminiRequest) {
+        const openaiRequest = {
+            messages: [],
+            model: geminiRequest.model,
+            max_tokens: checkAndAssignOrDefault(geminiRequest.max_tokens, OPENAI_DEFAULT_MAX_TOKENS),
+            temperature: checkAndAssignOrDefault(geminiRequest.temperature, OPENAI_DEFAULT_TEMPERATURE),
+            top_p: checkAndAssignOrDefault(geminiRequest.top_p, OPENAI_DEFAULT_TOP_P),
+        };
+
+        // 处理系统指令
+        if (geminiRequest.systemInstruction && Array.isArray(geminiRequest.systemInstruction.parts)) {
+            const systemContent = this.processGeminiPartsToOpenAIContent(geminiRequest.systemInstruction.parts);
+            if (systemContent) {
+                openaiRequest.messages.push({
+                    role: 'system',
+                    content: systemContent
+                });
+            }
+        }
+
+        // 处理内容
+        if (geminiRequest.contents && Array.isArray(geminiRequest.contents)) {
+            geminiRequest.contents.forEach(content => {
+                if (content && Array.isArray(content.parts)) {
+                    const openaiContent = this.processGeminiPartsToOpenAIContent(content.parts);
+                    if (openaiContent && openaiContent.length > 0) {
+                        const openaiRole = content.role === 'model' ? 'assistant' : content.role;
+                        openaiRequest.messages.push({
+                            role: openaiRole,
+                            content: openaiContent
+                        });
+                    }
+                }
+            });
+        }
+
+        return openaiRequest;
+    }
+
+    /**
+     * Gemini响应 -> OpenAI响应
+     */
+    toOpenAIResponse(geminiResponse, model) {
+        const content = this.processGeminiResponseContent(geminiResponse);
+        
+        return {
+            id: `chatcmpl-${uuidv4()}`,
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            model: model,
+            choices: [{
+                index: 0,
+                message: {
+                    role: "assistant",
+                    content: content
+                },
+                finish_reason: "stop",
+            }],
+            usage: geminiResponse.usageMetadata ? {
+                prompt_tokens: geminiResponse.usageMetadata.promptTokenCount || 0,
+                completion_tokens: geminiResponse.usageMetadata.candidatesTokenCount || 0,
+                total_tokens: geminiResponse.usageMetadata.totalTokenCount || 0,
+                cached_tokens: geminiResponse.usageMetadata.cachedContentTokenCount || 0,
+                prompt_tokens_details: {
+                    cached_tokens: geminiResponse.usageMetadata.cachedContentTokenCount || 0
+                },
+                completion_tokens_details: {
+                    reasoning_tokens: geminiResponse.usageMetadata.thoughtsTokenCount || 0
+                }
+            } : {
+                prompt_tokens: 0,
+                completion_tokens: 0,
+                total_tokens: 0,
+                cached_tokens: 0,
+                prompt_tokens_details: {
+                    cached_tokens: 0
+                },
+                completion_tokens_details: {
+                    reasoning_tokens: 0
+                }
+            },
+        };
+    }
+
+    /**
+     * Gemini流式响应 -> OpenAI流式响应
+     */
+    toOpenAIStreamChunk(geminiChunk, model) {
+        if (!geminiChunk) return null;
+
+        const candidate = geminiChunk.candidates?.[0];
+        if (!candidate) return null;
+
+        let content = '';
+        const toolCalls = [];
+        
+        // 从parts中提取文本和tool calls
+        const parts = candidate.content?.parts;
+        if (parts && Array.isArray(parts)) {
+            for (const part of parts) {
+                if (part.text) {
+                    content += part.text;
+                }
+                if (part.functionCall) {
+                    toolCalls.push({
+                        index: toolCalls.length,
+                        id: part.functionCall.id || `call_${uuidv4()}`,
+                        type: 'function',
+                        function: {
+                            name: part.functionCall.name,
+                            arguments: typeof part.functionCall.args === 'string' 
+                                ? part.functionCall.args 
+                                : JSON.stringify(part.functionCall.args)
+                        }
+                    });
+                }
+                // thoughtSignature is ignored (internal Gemini data)
+            }
+        }
+
+        // 处理finishReason
+        let finishReason = null;
+        if (candidate.finishReason) {
+            finishReason = candidate.finishReason === 'STOP' ? 'stop' :
+                         candidate.finishReason === 'MAX_TOKENS' ? 'length' :
+                         candidate.finishReason.toLowerCase();
+        }
+
+        // 如果包含工具调用，且完成原因为 stop，则将完成原因修改为 tool_calls
+        if (toolCalls.length > 0 && finishReason === 'stop') {
+            finishReason = 'tool_calls';
+        }
+
+        // 构建delta对象
+        const delta = {};
+        if (content) delta.content = content;
+        if (toolCalls.length > 0) delta.tool_calls = toolCalls;
+
+        // Don't return empty delta chunks
+        if (Object.keys(delta).length === 0 && !finishReason) {
+            return null;
+        }
+
+        return {
+            id: `chatcmpl-${uuidv4()}`,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: model,
+            choices: [{
+                index: 0,
+                delta: delta,
+                finish_reason: finishReason,
+            }],
+            usage: geminiChunk.usageMetadata ? {
+                prompt_tokens: geminiChunk.usageMetadata.promptTokenCount || 0,
+                completion_tokens: geminiChunk.usageMetadata.candidatesTokenCount || 0,
+                total_tokens: geminiChunk.usageMetadata.totalTokenCount || 0,
+                cached_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0,
+                prompt_tokens_details: {
+                    cached_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0
+                },
+                completion_tokens_details: {
+                    reasoning_tokens: geminiChunk.usageMetadata.thoughtsTokenCount || 0
+                }
+            } : {
+                prompt_tokens: 0,
+                completion_tokens: 0,
+                total_tokens: 0,
+                cached_tokens: 0,
+                prompt_tokens_details: {
+                    cached_tokens: 0
+                },
+                completion_tokens_details: {
+                    reasoning_tokens: 0
+                }
+            },
+        };
+    }
+
+    /**
+     * Gemini模型列表 -> OpenAI模型列表
+     */
+    toOpenAIModelList(geminiModels) {
+        return {
+            object: "list",
+            data: geminiModels.models.map(m => {
+                const modelId = m.name.startsWith('models/') ? m.name.substring(7) : m.name;
+                return {
+                    id: modelId,
+                    object: "model",
+                    created: Math.floor(Date.now() / 1000),
+                    owned_by: "google",
+                    display_name: m.displayName || modelId,
+                };
+            }),
+        };
+    }
+
+    /**
+     * 处理Gemini parts到OpenAI内容
+     */
+    processGeminiPartsToOpenAIContent(parts) {
+        if (!parts || !Array.isArray(parts)) return '';
+        
+        const contentArray = [];
+        
+        parts.forEach(part => {
+            if (!part) return;
+            
+            if (typeof part.text === 'string') {
+                contentArray.push({
+                    type: 'text',
+                    text: part.text
+                });
+            }
+            
+            if (part.inlineData) {
+                const { mimeType, data } = part.inlineData;
+                if (mimeType && data) {
+                    contentArray.push({
+                        type: 'image_url',
+                        image_url: {
+                            url: `data:${mimeType};base64,${data}`
+                        }
+                    });
+                }
+            }
+            
+            if (part.fileData) {
+                const { mimeType, fileUri } = part.fileData;
+                if (mimeType && fileUri) {
+                    if (mimeType.startsWith('image/')) {
+                        contentArray.push({
+                            type: 'image_url',
+                            image_url: {
+                                url: fileUri
+                            }
+                        });
+                    } else if (mimeType.startsWith('audio/')) {
+                        contentArray.push({
+                            type: 'text',
+                            text: `[Audio file: ${fileUri}]`
+                        });
+                    }
+                }
+            }
+        });
+        
+        return contentArray.length === 1 && contentArray[0].type === 'text'
+            ? contentArray[0].text
+            : contentArray;
+    }
+
+    /**
+     * 处理Gemini响应内容
+     */
+    processGeminiResponseContent(geminiResponse) {
+        if (!geminiResponse || !geminiResponse.candidates) return '';
+        
+        const contents = [];
+        
+        geminiResponse.candidates.forEach(candidate => {
+            if (candidate.content && candidate.content.parts) {
+                candidate.content.parts.forEach(part => {
+                    if (part.text) {
+                        contents.push(part.text);
+                    }
+                });
+            }
+        });
+        
+        return contents.join('\n');
+    }
+
+    // =========================================================================
+    // Gemini -> Claude 转换
+    // =========================================================================
+
+    /**
+     * Gemini请求 -> Claude请求
+     */
+    toClaudeRequest(geminiRequest) {
+        const claudeRequest = {
+            model: geminiRequest.model || 'claude-3-opus',
+            messages: [],
+            max_tokens: checkAndAssignOrDefault(geminiRequest.generationConfig?.maxOutputTokens, CLAUDE_DEFAULT_MAX_TOKENS),
+            temperature: checkAndAssignOrDefault(geminiRequest.generationConfig?.temperature, CLAUDE_DEFAULT_TEMPERATURE),
+            top_p: checkAndAssignOrDefault(geminiRequest.generationConfig?.topP, CLAUDE_DEFAULT_TOP_P),
+        };
+
+        // 处理系统指令
+        if (geminiRequest.systemInstruction && geminiRequest.systemInstruction.parts) {
+            const systemText = geminiRequest.systemInstruction.parts
+                .filter(p => p.text)
+                .map(p => p.text)
+                .join('\n');
+            if (systemText) {
+                claudeRequest.system = systemText;
+            }
+        }
+
+        // 处理内容
+        if (geminiRequest.contents && Array.isArray(geminiRequest.contents)) {
+            geminiRequest.contents.forEach(content => {
+                if (!content || !content.parts) return;
+
+                const role = content.role === 'model' ? 'assistant' : 'user';
+                const claudeContent = this.processGeminiPartsToClaudeContent(content.parts);
+
+                if (claudeContent.length > 0) {
+                    claudeRequest.messages.push({
+                        role: role,
+                        content: claudeContent
+                    });
+                }
+            });
+        }
+
+        // 处理工具
+        if (geminiRequest.tools && geminiRequest.tools[0]?.functionDeclarations) {
+            claudeRequest.tools = geminiRequest.tools[0].functionDeclarations.map(func => ({
+                name: func.name,
+                description: func.description || '',
+                input_schema: func.parameters || { type: 'object', properties: {} }
+            }));
+        }
+
+        return claudeRequest;
+    }
+
+    /**
+     * Gemini响应 -> Claude响应
+     */
+    toClaudeResponse(geminiResponse, model) {
+        if (!geminiResponse || !geminiResponse.candidates || geminiResponse.candidates.length === 0) {
+            return {
+                id: `msg_${uuidv4()}`,
+                type: "message",
+                role: "assistant",
+                content: [],
+                model: model,
+                stop_reason: "end_turn",
+                stop_sequence: null,
+                usage: {
+                    input_tokens: geminiResponse?.usageMetadata?.promptTokenCount || 0,
+                    output_tokens: geminiResponse?.usageMetadata?.candidatesTokenCount || 0
+                }
+            };
+        }
+
+        const candidate = geminiResponse.candidates[0];
+        const { content, hasToolUse } = this.processGeminiResponseToClaudeContent(geminiResponse);
+        const finishReason = candidate.finishReason;
+        let stopReason = "end_turn";
+
+        // [FIX] 参考 ag/response.rs - 如果有工具调用，stop_reason 应该是 "tool_use"
+        if (hasToolUse) {
+            stopReason = 'tool_use';
+        } else if (finishReason) {
+            switch (finishReason) {
+                case 'STOP':
+                    stopReason = 'end_turn';
+                    break;
+                case 'MAX_TOKENS':
+                    stopReason = 'max_tokens';
+                    break;
+                case 'SAFETY':
+                    stopReason = 'safety';
+                    break;
+                case 'RECITATION':
+                    stopReason = 'recitation';
+                    break;
+                case 'OTHER':
+                    stopReason = 'other';
+                    break;
+                default:
+                    stopReason = 'end_turn';
+            }
+        }
+
+        return {
+            id: `msg_${uuidv4()}`,
+            type: "message",
+            role: "assistant",
+            content: content,
+            model: model,
+            stop_reason: stopReason,
+            stop_sequence: null,
+            usage: {
+                input_tokens: geminiResponse.usageMetadata?.promptTokenCount || 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: geminiResponse.usageMetadata?.cachedContentTokenCount || 0,
+                output_tokens: geminiResponse.usageMetadata?.candidatesTokenCount || 0
+            }
+        };
+    }
+
+    /**
+     * Gemini流式响应 -> Claude流式响应
+     */
+    toClaudeStreamChunk(geminiChunk, model) {
+        if (!geminiChunk) return null;
+
+        // 处理完整的Gemini chunk对象
+        if (typeof geminiChunk === 'object' && !Array.isArray(geminiChunk)) {
+            const candidate = geminiChunk.candidates?.[0];
+            
+            if (candidate) {
+                const parts = candidate.content?.parts;
+                
+                // [FIX] 参考 ag/streaming.rs 处理 thinking 和 text 块
+                if (parts && Array.isArray(parts)) {
+                    const results = [];
+                    let hasToolUse = false;
+                    
+                    for (const part of parts) {
+                        if (!part) continue;
+                        
+                        if (typeof part.text === 'string') {
+                            if (part.thought === true) {
+                                // [FIX] 这是一个 thinking 块
+                                const thinkingResult = {
+                                    type: "content_block_delta",
+                                    index: 0,
+                                    delta: {
+                                        type: "thinking_delta",
+                                        thinking: part.text
+                                    }
+                                };
+                                results.push(thinkingResult);
+                                
+                                // 如果有签名，发送 signature_delta
+                                // [FIX] 同时检查 thoughtSignature 和 thought_signature
+                                const rawSignature = part.thoughtSignature || part.thought_signature;
+                                if (rawSignature) {
+                                    let signature = rawSignature;
+                                    try {
+                                        const decoded = Buffer.from(signature, 'base64').toString('utf-8');
+                                        if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
+                                            signature = decoded;
+                                        }
+                                    } catch (e) {
+                                        // 解码失败，保持原样
+                                    }
+                                    results.push({
+                                        type: "content_block_delta",
+                                        index: 0,
+                                        delta: {
+                                            type: "signature_delta",
+                                            signature: signature
+                                        }
+                                    });
+                                }
+                            } else {
+                                // 普通文本
+                                results.push({
+                                    type: "content_block_delta",
+                                    index: 0,
+                                    delta: {
+                                        type: "text_delta",
+                                        text: part.text
+                                    }
+                                });
+                            }
+                        }
+                        
+                        // [FIX] 处理 functionCall
+                        if (part.functionCall) {
+                            hasToolUse = true;
+                            // [FIX] 规范化工具名称和参数映射
+                            const toolName = normalizeToolName(part.functionCall.name);
+                            const remappedArgs = remapFunctionCallArgs(toolName, part.functionCall.args || {});
+                            
+                            // 发送 tool_use 开始
+                            const toolId = part.functionCall.id || `${toolName}-${uuidv4().split('-')[0]}`;
+                            results.push({
+                                type: "content_block_start",
+                                index: 0,
+                                content_block: {
+                                    type: "tool_use",
+                                    id: toolId,
+                                    name: toolName,
+                                    input: {}
+                                }
+                            });
+                            // 发送参数
+                            results.push({
+                                type: "content_block_delta",
+                                index: 0,
+                                delta: {
+                                    type: "input_json_delta",
+                                    partial_json: JSON.stringify(remappedArgs)
+                                }
+                            });
+                        }
+                    }
+                    
+                    // [FIX] 如果有工具调用，添加 message_delta 事件设置 stop_reason 为 tool_use
+                    if (hasToolUse && candidate.finishReason) {
+                        const messageDelta = {
+                            type: "message_delta",
+                            delta: {
+                                stop_reason: 'tool_use'
+                            }
+                        };
+                        if (geminiChunk.usageMetadata) {
+                            messageDelta.usage = {
+                                input_tokens: geminiChunk.usageMetadata.promptTokenCount || 0,
+                                cache_creation_input_tokens: 0,
+                                cache_read_input_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0,
+                                output_tokens: geminiChunk.usageMetadata.candidatesTokenCount || 0
+                            };
+                        }
+                        results.push(messageDelta);
+                    }
+                    
+                    // 如果有多个结果，返回数组；否则返回单个或 null
+                    if (results.length > 1) {
+                        return results;
+                    } else if (results.length === 1) {
+                        return results[0];
+                    }
+                }
+                
+                // 处理finishReason
+                if (candidate.finishReason) {
+                    const result = {
+                        type: "message_delta",
+                        delta: {
+                            stop_reason: candidate.finishReason === 'STOP' ? 'end_turn' :
+                                       candidate.finishReason === 'MAX_TOKENS' ? 'max_tokens' :
+                                       candidate.finishReason.toLowerCase()
+                        }
+                    };
+                    
+                    // 添加 usage 信息
+                    if (geminiChunk.usageMetadata) {
+                        result.usage = {
+                            input_tokens: geminiChunk.usageMetadata.promptTokenCount || 0,
+                            cache_creation_input_tokens: 0,
+                            cache_read_input_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0,
+                            output_tokens: geminiChunk.usageMetadata.candidatesTokenCount || 0,
+                            prompt_tokens: geminiChunk.usageMetadata.promptTokenCount || 0,
+                            completion_tokens: geminiChunk.usageMetadata.candidatesTokenCount || 0,
+                            total_tokens: geminiChunk.usageMetadata.totalTokenCount || 0,
+                            cached_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0
+                        };
+                    }
+                    
+                    return result;
+                }
+            }
+        }
+
+        // 向后兼容：处理字符串格式
+        if (typeof geminiChunk === 'string') {
+            return {
+                type: "content_block_delta",
+                index: 0,
+                delta: {
+                    type: "text_delta",
+                    text: geminiChunk
+                }
+            };
+        }
+
+        return null;
+    }
+
+    /**
+     * Gemini模型列表 -> Claude模型列表
+     */
+    toClaudeModelList(geminiModels) {
+        return {
+            models: geminiModels.models.map(m => ({
+                name: m.name.startsWith('models/') ? m.name.substring(7) : m.name,
+                description: "",
+            })),
+        };
+    }
+
+    /**
+     * 处理Gemini parts到Claude内容
+     */
+    processGeminiPartsToClaudeContent(parts) {
+        if (!parts || !Array.isArray(parts)) return [];
+
+        const content = [];
+
+        parts.forEach(part => {
+            if (!part) return;
+
+            // [FIX] 参考 ag/response.rs 处理 thinking 块
+            // Gemini 使用 thought: true 和 thoughtSignature 表示思考内容
+            // [FIX] 同时支持 thoughtSignature 和 thought_signature（Gemini CLI 可能使用下划线格式）
+            if (part.text) {
+                if (part.thought === true) {
+                    // 这是一个 thinking 块
+                    const thinkingBlock = {
+                        type: 'thinking',
+                        thinking: part.text
+                    };
+                    // 处理签名 - 可能是 Base64 编码的
+                    // [FIX] 同时检查 thoughtSignature 和 thought_signature
+                    const rawSignature = part.thoughtSignature || part.thought_signature;
+                    if (rawSignature) {
+                        let signature = rawSignature;
+                        // 尝试 Base64 解码
+                        try {
+                            const decoded = Buffer.from(signature, 'base64').toString('utf-8');
+                            // 检查解码后是否是有效的 UTF-8 字符串
+                            if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
+                                signature = decoded;
+                            }
+                        } catch (e) {
+                            // 解码失败，保持原样
+                        }
+                        thinkingBlock.signature = signature;
+                    }
+                    content.push(thinkingBlock);
+                } else {
+                    // 普通文本
+                    content.push({
+                        type: 'text',
+                        text: part.text
+                    });
+                }
+            }
+
+            if (part.inlineData) {
+                content.push({
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: part.inlineData.mimeType,
+                        data: part.inlineData.data
+                    }
+                });
+            }
+
+            if (part.functionCall) {
+                // [FIX] 规范化工具名称和参数映射
+                const toolName = normalizeToolName(part.functionCall.name);
+                const remappedArgs = remapFunctionCallArgs(toolName, part.functionCall.args || {});
+                
+                // [FIX] 使用 Gemini 提供的 id，如果没有则生成
+                const toolUseBlock = {
+                    type: 'tool_use',
+                    id: part.functionCall.id || `${toolName}-${uuidv4().split('-')[0]}`,
+                    name: toolName,
+                    input: remappedArgs
+                };
+                // [FIX] 如果有签名，添加到 tool_use 块
+                // [FIX] 同时检查 thoughtSignature 和 thought_signature
+                const rawSignature = part.thoughtSignature || part.thought_signature;
+                if (rawSignature) {
+                    let signature = rawSignature;
+                    try {
+                        const decoded = Buffer.from(signature, 'base64').toString('utf-8');
+                        if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
+                            signature = decoded;
+                        }
+                    } catch (e) {
+                        // 解码失败，保持原样
+                    }
+                    toolUseBlock.signature = signature;
+                }
+                content.push(toolUseBlock);
+            }
+
+            if (part.functionResponse) {
+                // [FIX] 正确处理 functionResponse
+                let responseContent = part.functionResponse.response;
+                // 如果 response 是对象且有 result 字段，提取它
+                if (responseContent && typeof responseContent === 'object' && responseContent.result !== undefined) {
+                    responseContent = responseContent.result;
+                }
+                content.push({
+                    type: 'tool_result',
+                    tool_use_id: part.functionResponse.name,
+                    content: typeof responseContent === 'string' ? responseContent : JSON.stringify(responseContent)
+                });
+            }
+        });
+
+        return content;
+    }
+
+    /**
+     * 处理Gemini响应到Claude内容
+     * @returns {{ content: Array, hasToolUse: boolean }}
+     */
+    processGeminiResponseToClaudeContent(geminiResponse) {
+        if (!geminiResponse || !geminiResponse.candidates || geminiResponse.candidates.length === 0) {
+            return { content: [], hasToolUse: false };
+        }
+
+        const content = [];
+        let hasToolUse = false;
+
+        for (const candidate of geminiResponse.candidates) {
+            if (candidate.finishReason && candidate.finishReason !== 'STOP') {
+                if (candidate.finishMessage) {
+                    content.push({
+                        type: 'text',
+                        text: `Error: ${candidate.finishMessage}`
+                    });
+                }
+                continue;
+            }
+
+            if (candidate.content && candidate.content.parts) {
+                for (const part of candidate.content.parts) {
+                    // [FIX] 参考 ag/response.rs 处理 thinking 块
+                    if (part.text) {
+                        if (part.thought === true) {
+                            // 这是一个 thinking 块
+                            const thinkingBlock = {
+                                type: 'thinking',
+                                thinking: part.text
+                            };
+                            // 处理签名
+                            // [FIX] 同时检查 thoughtSignature 和 thought_signature
+                            const rawSignature = part.thoughtSignature || part.thought_signature;
+                            if (rawSignature) {
+                                let signature = rawSignature;
+                                try {
+                                    const decoded = Buffer.from(signature, 'base64').toString('utf-8');
+                                    if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
+                                        signature = decoded;
+                                    }
+                                } catch (e) {
+                                    // 解码失败，保持原样
+                                }
+                                thinkingBlock.signature = signature;
+                            }
+                            content.push(thinkingBlock);
+                        } else {
+                            // 普通文本
+                            content.push({
+                                type: 'text',
+                                text: part.text
+                            });
+                        }
+                    } else if (part.inlineData) {
+                        content.push({
+                            type: 'image',
+                            source: {
+                                type: 'base64',
+                                media_type: part.inlineData.mimeType,
+                                data: part.inlineData.data
+                            }
+                        });
+                    } else if (part.functionCall) {
+                        hasToolUse = true;
+                        // [FIX] 规范化工具名称和参数映射
+                        const toolName = normalizeToolName(part.functionCall.name);
+                        const remappedArgs = remapFunctionCallArgs(toolName, part.functionCall.args || {});
+                        
+                        // [FIX] 使用 Gemini 提供的 id
+                        const toolUseBlock = {
+                            type: 'tool_use',
+                            id: part.functionCall.id || `${toolName}-${uuidv4().split('-')[0]}`,
+                            name: toolName,
+                            input: remappedArgs
+                        };
+                        // 添加签名（如果存在）
+                        // [FIX] 同时检查 thoughtSignature 和 thought_signature
+                        const rawSignature = part.thoughtSignature || part.thought_signature;
+                        if (rawSignature) {
+                            let signature = rawSignature;
+                            try {
+                                const decoded = Buffer.from(signature, 'base64').toString('utf-8');
+                                if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
+                                    signature = decoded;
+                                }
+                            } catch (e) {
+                                // 解码失败，保持原样
+                            }
+                            toolUseBlock.signature = signature;
+                        }
+                        content.push(toolUseBlock);
+                    }
+                }
+            }
+        }
+
+        return { content, hasToolUse };
+    }
+
+    // =========================================================================
+    // Gemini -> OpenAI Responses 转换
+    // =========================================================================
+
+    /**
+     * Gemini请求 -> OpenAI Responses请求
+     */
+    toOpenAIResponsesRequest(geminiRequest) {
+        const responsesRequest = {
+            model: geminiRequest.model,
+            max_tokens: checkAndAssignOrDefault(geminiRequest.generationConfig?.maxOutputTokens, OPENAI_DEFAULT_MAX_TOKENS),
+            temperature: checkAndAssignOrDefault(geminiRequest.generationConfig?.temperature, OPENAI_DEFAULT_TEMPERATURE),
+            top_p: checkAndAssignOrDefault(geminiRequest.generationConfig?.topP, OPENAI_DEFAULT_TOP_P),
+        };
+
+        // 处理系统指令
+        if (geminiRequest.systemInstruction && geminiRequest.systemInstruction.parts) {
+            const instructionsText = geminiRequest.systemInstruction.parts
+                .filter(p => p.text)
+                .map(p => p.text)
+                .join('\n');
+            if (instructionsText) {
+                responsesRequest.instructions = instructionsText;
+            }
+        }
+
+        // 处理输入
+        if (geminiRequest.contents && Array.isArray(geminiRequest.contents)) {
+            const lastContent = geminiRequest.contents[geminiRequest.contents.length - 1];
+            if (lastContent && lastContent.parts) {
+                const inputText = lastContent.parts
+                    .filter(p => p.text)
+                    .map(p => p.text)
+                    .join(' ');
+                if (inputText) {
+                    responsesRequest.input = inputText;
+                }
+            }
+        }
+
+        return responsesRequest;
+    }
+
+    /**
+     * Gemini响应 -> OpenAI Responses响应
+     */
+    toOpenAIResponsesResponse(geminiResponse, model) {
+        const content = this.processGeminiResponseContent(geminiResponse);
+        const textContent = typeof content === 'string' ? content : JSON.stringify(content);
+
+        let output = [];
+        output.push({
+            id: `msg_${uuidv4().replace(/-/g, '')}`,
+            summary: [],
+            type: "message",
+            role: "assistant",
+            status: "completed",
+            content: [{
+                annotations: [],
+                logprobs: [],
+                text: textContent,
+                type: "output_text"
+            }]
+        });
+
+        return {
+            background: false,
+            created_at: Math.floor(Date.now() / 1000),
+            error: null,
+            id: `resp_${uuidv4().replace(/-/g, '')}`,
+            incomplete_details: null,
+            max_output_tokens: null,
+            max_tool_calls: null,
+            metadata: {},
+            model: model,
+            object: "response",
+            output: output,
+            parallel_tool_calls: true,
+            previous_response_id: null,
+            prompt_cache_key: null,
+            reasoning: {},
+            safety_identifier: "user-" + uuidv4().replace(/-/g, ''),
+            service_tier: "default",
+            status: "completed",
+            store: false,
+            temperature: 1,
+            text: {
+                format: { type: "text" },
+            },
+            tool_choice: "auto",
+            tools: [],
+            top_logprobs: 0,
+            top_p: 1,
+            truncation: "disabled",
+            usage: {
+                input_tokens: geminiResponse.usageMetadata?.promptTokenCount || 0,
+                input_tokens_details: {
+                    cached_tokens: geminiResponse.usageMetadata?.cachedContentTokenCount || 0
+                },
+                output_tokens: geminiResponse.usageMetadata?.candidatesTokenCount || 0,
+                output_tokens_details: {
+                    reasoning_tokens: geminiResponse.usageMetadata?.thoughtsTokenCount || 0
+                },
+                total_tokens: geminiResponse.usageMetadata?.totalTokenCount || 0
+            },
+            user: null
+        };
+    }
+
+    /**
+     * Gemini流式响应 -> OpenAI Responses流式响应
+     */
+    toOpenAIResponsesStreamChunk(geminiChunk, model, requestId = null) {
+        if (!geminiChunk) return [];
+
+        const responseId = requestId || `resp_${uuidv4().replace(/-/g, '')}`;
+        const events = [];
+
+        // 处理完整的Gemini chunk对象
+        if (typeof geminiChunk === 'object' && !Array.isArray(geminiChunk)) {
+            const candidate = geminiChunk.candidates?.[0];
+            
+            if (candidate) {
+                const parts = candidate.content?.parts;
+                
+                // 第一个chunk - 检测是否是开始（有role）
+                if (candidate.content?.role === 'model' && parts && parts.length > 0) {
+                    // 只在第一次有内容时发送开始事件
+                    const hasContent = parts.some(part => part && typeof part.text === 'string' && part.text.length > 0);
+                    if (hasContent) {
+                        events.push(
+                            generateResponseCreated(responseId, model || 'unknown'),
+                            generateResponseInProgress(responseId),
+                            generateOutputItemAdded(responseId),
+                            generateContentPartAdded(responseId)
+                        );
+                    }
+                }
+                
+                // 提取文本内容
+                if (parts && Array.isArray(parts)) {
+                    const textParts = parts.filter(part => part && typeof part.text === 'string');
+                    if (textParts.length > 0) {
+                        const text = textParts.map(part => part.text).join('');
+                        events.push({
+                            delta: text,
+                            item_id: `msg_${uuidv4().replace(/-/g, '')}`,
+                            output_index: 0,
+                            sequence_number: 3,
+                            type: "response.output_text.delta"
+                        });
+                    }
+                }
+                
+                // 处理finishReason
+                if (candidate.finishReason) {
+                    events.push(
+                        generateOutputTextDone(responseId),
+                        generateContentPartDone(responseId),
+                        generateOutputItemDone(responseId),
+                        generateResponseCompleted(responseId)
+                    );
+                    
+                    // 如果有 usage 信息，更新最后一个事件
+                    if (geminiChunk.usageMetadata && events.length > 0) {
+                        const lastEvent = events[events.length - 1];
+                        if (lastEvent.response) {
+                            lastEvent.response.usage = {
+                                input_tokens: geminiChunk.usageMetadata.promptTokenCount || 0,
+                                input_tokens_details: {
+                                    cached_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0
+                                },
+                                output_tokens: geminiChunk.usageMetadata.candidatesTokenCount || 0,
+                                output_tokens_details: {
+                                    reasoning_tokens: geminiChunk.usageMetadata.thoughtsTokenCount || 0
+                                },
+                                total_tokens: geminiChunk.usageMetadata.totalTokenCount || 0
+                            };
+                        }
+                    }
+                }
+            }
+        }
+
+        // 向后兼容：处理字符串格式
+        if (typeof geminiChunk === 'string') {
+            events.push({
+                delta: geminiChunk,
+                item_id: `msg_${uuidv4().replace(/-/g, '')}`,
+                output_index: 0,
+                sequence_number: 3,
+                type: "response.output_text.delta"
+            });
+        }
+
+        return events;
+    }
+}
+
+export default GeminiConverter;

src/converters/strategies/OllamaConverter.js

@@ -0,0 +1,690 @@
+/**
+ * Ollama转换器
+ * 处理Ollama协议与其他协议之间的转换
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { createHash } from 'crypto';
+import { BaseConverter } from '../BaseConverter.js';
+import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
+import {
+    OLLAMA_DEFAULT_CONTEXT_LENGTH,
+    OLLAMA_DEFAULT_MAX_OUTPUT_TOKENS,
+    OLLAMA_CLAUDE_DEFAULT_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_SONNET_45_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_SONNET_45_MAX_OUTPUT_TOKENS,
+    OLLAMA_CLAUDE_HAIKU_45_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_HAIKU_45_MAX_OUTPUT_TOKENS,
+    OLLAMA_CLAUDE_OPUS_41_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_OPUS_41_MAX_OUTPUT_TOKENS,
+    OLLAMA_CLAUDE_SONNET_40_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_SONNET_40_MAX_OUTPUT_TOKENS,
+    OLLAMA_CLAUDE_SONNET_37_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_SONNET_37_MAX_OUTPUT_TOKENS,
+    OLLAMA_CLAUDE_OPUS_40_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_OPUS_40_MAX_OUTPUT_TOKENS,
+    OLLAMA_CLAUDE_HAIKU_35_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_HAIKU_35_MAX_OUTPUT_TOKENS,
+    OLLAMA_CLAUDE_HAIKU_30_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_HAIKU_30_MAX_OUTPUT_TOKENS,
+    OLLAMA_CLAUDE_SONNET_35_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_SONNET_35_MAX_OUTPUT_TOKENS,
+    OLLAMA_CLAUDE_OPUS_30_CONTEXT_LENGTH,
+    OLLAMA_CLAUDE_OPUS_30_MAX_OUTPUT_TOKENS,
+    OLLAMA_GEMINI_25_PRO_CONTEXT_LENGTH,
+    OLLAMA_GEMINI_25_PRO_MAX_OUTPUT_TOKENS,
+    OLLAMA_GEMINI_25_FLASH_CONTEXT_LENGTH,
+    OLLAMA_GEMINI_25_FLASH_MAX_OUTPUT_TOKENS,
+    OLLAMA_GEMINI_25_IMAGE_CONTEXT_LENGTH,
+    OLLAMA_GEMINI_25_IMAGE_MAX_OUTPUT_TOKENS,
+    OLLAMA_GEMINI_25_LIVE_CONTEXT_LENGTH,
+    OLLAMA_GEMINI_25_LIVE_MAX_OUTPUT_TOKENS,
+    OLLAMA_GEMINI_25_TTS_CONTEXT_LENGTH,
+    OLLAMA_GEMINI_25_TTS_MAX_OUTPUT_TOKENS,
+    OLLAMA_GEMINI_20_FLASH_CONTEXT_LENGTH,
+    OLLAMA_GEMINI_20_FLASH_MAX_OUTPUT_TOKENS,
+    OLLAMA_GEMINI_20_IMAGE_CONTEXT_LENGTH,
+    OLLAMA_GEMINI_20_IMAGE_MAX_OUTPUT_TOKENS,
+    OLLAMA_GEMINI_15_PRO_CONTEXT_LENGTH,
+    OLLAMA_GEMINI_15_PRO_MAX_OUTPUT_TOKENS,
+    OLLAMA_GEMINI_15_FLASH_CONTEXT_LENGTH,
+    OLLAMA_GEMINI_15_FLASH_MAX_OUTPUT_TOKENS,
+    OLLAMA_GEMINI_DEFAULT_CONTEXT_LENGTH,
+    OLLAMA_GEMINI_DEFAULT_MAX_OUTPUT_TOKENS,
+    OLLAMA_GPT4_TURBO_CONTEXT_LENGTH,
+    OLLAMA_GPT4_TURBO_MAX_OUTPUT_TOKENS,
+    OLLAMA_GPT4_32K_CONTEXT_LENGTH,
+    OLLAMA_GPT4_32K_MAX_OUTPUT_TOKENS,
+    OLLAMA_GPT4_BASE_CONTEXT_LENGTH,
+    OLLAMA_GPT4_BASE_MAX_OUTPUT_TOKENS,
+    OLLAMA_GPT35_16K_CONTEXT_LENGTH,
+    OLLAMA_GPT35_16K_MAX_OUTPUT_TOKENS,
+    OLLAMA_GPT35_BASE_CONTEXT_LENGTH,
+    OLLAMA_GPT35_BASE_MAX_OUTPUT_TOKENS,
+    OLLAMA_QWEN_CODER_PLUS_CONTEXT_LENGTH,
+    OLLAMA_QWEN_CODER_PLUS_MAX_OUTPUT_TOKENS,
+    OLLAMA_QWEN_VL_PLUS_CONTEXT_LENGTH,
+    OLLAMA_QWEN_VL_PLUS_MAX_OUTPUT_TOKENS,
+    OLLAMA_QWEN_CODER_FLASH_CONTEXT_LENGTH,
+    OLLAMA_QWEN_CODER_FLASH_MAX_OUTPUT_TOKENS,
+    OLLAMA_QWEN_DEFAULT_CONTEXT_LENGTH,
+    OLLAMA_QWEN_DEFAULT_MAX_OUTPUT_TOKENS,
+    OLLAMA_DEFAULT_FILE_TYPE,
+    OLLAMA_DEFAULT_QUANTIZATION_VERSION,
+    OLLAMA_DEFAULT_ROPE_FREQ_BASE,
+    OLLAMA_DEFAULT_TEMPERATURE,
+    OLLAMA_DEFAULT_TOP_P,
+    OLLAMA_DEFAULT_QUANTIZATION_LEVEL,
+    OLLAMA_SHOW_QUANTIZATION_LEVEL
+} from '../utils.js';
+
+
+
+/**
+ * Ollama转换器类
+ * 实现Ollama协议到其他协议的转换
+ */
+export class OllamaConverter extends BaseConverter {
+    constructor() {
+        super('ollama');
+    }
+
+    /**
+     * 转换请求 - Ollama -> 其他协议
+     */
+    convertRequest(data, targetProtocol) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toOpenAIRequest(data);
+            default:
+                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+        }
+    }
+
+    /**
+     * 转换响应 - 其他协议 -> Ollama
+     */
+    convertResponse(data, sourceProtocol, model) {
+        return this.toOllamaChatResponse(data, model);
+    }
+
+    /**
+     * 转换流式响应块 - 其他协议 -> Ollama
+     */
+    convertStreamChunk(chunk, sourceProtocol, model, isDone = false) {
+        return this.toOllamaStreamChunk(chunk, model, isDone);
+    }
+
+    /**
+     * 转换模型列表 - 其他协议 -> Ollama
+     */
+    convertModelList(data, sourceProtocol) {
+        return this.toOllamaTags(data, sourceProtocol);
+    }
+
+    // =========================================================================
+    // Ollama -> OpenAI 转换
+    // =========================================================================
+
+    /**
+     * Ollama请求 -> OpenAI请求
+     */
+    toOpenAIRequest(ollamaRequest) {
+        const openaiRequest = {
+            model: ollamaRequest.model || 'default',
+            messages: [],
+            stream: ollamaRequest.stream !== undefined ? ollamaRequest.stream : false
+        };
+
+        // Map Ollama messages to OpenAI format
+        if (ollamaRequest.messages && Array.isArray(ollamaRequest.messages)) {
+            openaiRequest.messages = ollamaRequest.messages.map(msg => ({
+                role: msg.role || 'user',
+                content: msg.content || ''
+            }));
+        }
+
+        // Map Ollama options to OpenAI parameters
+        if (ollamaRequest.options) {
+            const opts = ollamaRequest.options;
+            if (opts.temperature !== undefined) openaiRequest.temperature = opts.temperature;
+            if (opts.top_p !== undefined) openaiRequest.top_p = opts.top_p;
+            if (opts.top_k !== undefined) openaiRequest.top_k = opts.top_k;
+            if (opts.num_predict !== undefined) openaiRequest.max_tokens = opts.num_predict;
+            if (opts.stop !== undefined) openaiRequest.stop = opts.stop;
+        }
+
+        // Handle system prompt
+        if (ollamaRequest.system) {
+            openaiRequest.messages.unshift({
+                role: 'system',
+                content: ollamaRequest.system
+            });
+        }
+
+        // Handle template/prompt for generate endpoint
+        if (ollamaRequest.prompt) {
+            openaiRequest.messages = [{
+                role: 'user',
+                content: ollamaRequest.prompt
+            }];
+            
+            // Add system prompt if provided
+            if (ollamaRequest.system) {
+                openaiRequest.messages.unshift({
+                    role: 'system',
+                    content: ollamaRequest.system
+                });
+            }
+        }
+
+        return openaiRequest;
+    }
+
+    // =========================================================================
+    // OpenAI/Claude/Gemini -> Ollama 转换
+    // =========================================================================
+
+    /**
+     * OpenAI/Claude/Gemini响应 -> Ollama chat响应
+     */
+    toOllamaChatResponse(response, model) {
+        const ollamaResponse = {
+            model: model || response.model || 'unknown',
+            created_at: new Date().toISOString(),
+            done: true
+        };
+
+        // Handle OpenAI format (choices array)
+        if (response.choices && response.choices.length > 0) {
+            const choice = response.choices[0];
+            ollamaResponse.message = {
+                role: choice.message?.role || 'assistant',
+                content: choice.message?.content || ''
+            };
+
+            // Map finish reason
+            if (choice.finish_reason) {
+                ollamaResponse.done_reason = choice.finish_reason === 'stop' ? 'stop' : choice.finish_reason;
+            }
+        }
+        // Handle Claude format (content array)
+        else if (response.content && Array.isArray(response.content)) {
+            let textContent = '';
+            response.content.forEach(block => {
+                if (block.type === 'text' && block.text) {
+                    textContent += block.text;
+                }
+            });
+            
+            ollamaResponse.message = {
+                role: response.role || 'assistant',
+                content: textContent
+            };
+
+            if (response.stop_reason) {
+                ollamaResponse.done_reason = response.stop_reason === 'end_turn' ? 'stop' : response.stop_reason;
+            }
+        }
+        // Handle Gemini format (candidates array)
+        else if (response.candidates && response.candidates.length > 0) {
+            const candidate = response.candidates[0];
+            let textContent = '';
+            if (candidate.content && candidate.content.parts) {
+                textContent = candidate.content.parts
+                    .filter(part => part.text)
+                    .map(part => part.text)
+                    .join('');
+            }
+            
+            ollamaResponse.message = {
+                role: candidate.content?.role || 'assistant',
+                content: textContent
+            };
+
+            if (candidate.finishReason) {
+                ollamaResponse.done_reason = candidate.finishReason.toLowerCase();
+            }
+        }
+
+        // Add usage statistics if available
+        const usage = response.usage || response.usageMetadata;
+        if (usage) {
+            ollamaResponse.prompt_eval_count = usage.prompt_tokens || usage.input_tokens || usage.promptTokenCount || 0;
+            ollamaResponse.eval_count = usage.completion_tokens || usage.output_tokens || usage.candidatesTokenCount || 0;
+            ollamaResponse.total_duration = 0;
+            ollamaResponse.load_duration = 0;
+            ollamaResponse.prompt_eval_duration = 0;
+            ollamaResponse.eval_duration = 0;
+        }
+
+        return ollamaResponse;
+    }
+
+    /**
+     * OpenAI/Claude/Gemini generate响应 -> Ollama generate响应
+     */
+    toOllamaGenerateResponse(response, model) {
+        const ollamaResponse = {
+            model: model || response.model || 'unknown',
+            created_at: new Date().toISOString(),
+            done: true
+        };
+
+        // Handle OpenAI format
+        if (response.choices && response.choices.length > 0) {
+            const choice = response.choices[0];
+            ollamaResponse.response = choice.message?.content || choice.text || '';
+            
+            if (choice.finish_reason) {
+                ollamaResponse.done_reason = choice.finish_reason === 'stop' ? 'stop' : choice.finish_reason;
+            }
+        }
+        // Handle Claude format
+        else if (response.content && Array.isArray(response.content)) {
+            let textContent = '';
+            response.content.forEach(block => {
+                if (block.type === 'text' && block.text) {
+                    textContent += block.text;
+                }
+            });
+            ollamaResponse.response = textContent;
+
+            if (response.stop_reason) {
+                ollamaResponse.done_reason = response.stop_reason === 'end_turn' ? 'stop' : response.stop_reason;
+            }
+        }
+        // Handle Gemini format
+        else if (response.candidates && response.candidates.length > 0) {
+            const candidate = response.candidates[0];
+            let textContent = '';
+            if (candidate.content && candidate.content.parts) {
+                textContent = candidate.content.parts
+                    .filter(part => part.text)
+                    .map(part => part.text)
+                    .join('');
+            }
+            ollamaResponse.response = textContent;
+
+            if (candidate.finishReason) {
+                ollamaResponse.done_reason = candidate.finishReason.toLowerCase();
+            }
+        }
+
+        // Add usage statistics
+        const genUsage = response.usage || response.usageMetadata;
+        if (genUsage) {
+            ollamaResponse.prompt_eval_count = genUsage.prompt_tokens || genUsage.input_tokens || genUsage.promptTokenCount || 0;
+            ollamaResponse.eval_count = genUsage.completion_tokens || genUsage.output_tokens || genUsage.candidatesTokenCount || 0;
+            ollamaResponse.total_duration = 0;
+            ollamaResponse.load_duration = 0;
+            ollamaResponse.prompt_eval_duration = 0;
+            ollamaResponse.eval_duration = 0;
+        }
+
+        return ollamaResponse;
+    }
+
+    /**
+     * OpenAI/Claude/Gemini流式块 -> Ollama流式块
+     */
+    toOllamaStreamChunk(chunk, model, isDone = false) {
+        const ollamaChunk = {
+            model: model || 'unknown',
+            created_at: new Date().toISOString(),
+            done: isDone
+        };
+
+        // Handle Claude SSE format
+        if (chunk.type) {
+            if (chunk.type === 'content_block_delta' && chunk.delta) {
+                ollamaChunk.message = {
+                    role: 'assistant',
+                    content: chunk.delta.text || ''
+                };
+            } else if (chunk.type === 'message_delta' && chunk.usage) {
+                ollamaChunk.message = {
+                    role: 'assistant',
+                    content: ''
+                };
+                ollamaChunk.prompt_eval_count = 0;
+                ollamaChunk.eval_count = chunk.usage.output_tokens || 0;
+            } else {
+                ollamaChunk.message = {
+                    role: 'assistant',
+                    content: ''
+                };
+            }
+        }
+        // Handle Gemini format
+        else if (!isDone && chunk.candidates && chunk.candidates.length > 0) {
+            const candidate = chunk.candidates[0];
+            let content = '';
+            if (candidate.content && candidate.content.parts) {
+                content = candidate.content.parts
+                    .filter(part => part.text)
+                    .map(part => part.text)
+                    .join('');
+            }
+            ollamaChunk.message = {
+                role: 'assistant',
+                content: content
+            };
+        }
+        // Handle OpenAI format
+        else if (!isDone && chunk.choices && chunk.choices.length > 0) {
+            const delta = chunk.choices[0].delta;
+            ollamaChunk.message = {
+                role: delta.role || 'assistant',
+                content: delta.content || ''
+            };
+        } 
+        // Handle final chunk
+        else if (isDone) {
+            ollamaChunk.message = {
+                role: 'assistant',
+                content: ''
+            };
+            ollamaChunk.done_reason = 'stop';
+        }
+
+        return ollamaChunk;
+    }
+
+    /**
+     * OpenAI/Claude/Gemini流式块 -> Ollama generate流式块
+     */
+    toOllamaGenerateStreamChunk(chunk, model, isDone = false) {
+        const ollamaChunk = {
+            model: model || 'unknown',
+            created_at: new Date().toISOString(),
+            done: isDone
+        };
+
+        // Handle Claude SSE format
+        if (chunk.type) {
+            if (chunk.type === 'content_block_delta' && chunk.delta) {
+                ollamaChunk.response = chunk.delta.text || '';
+            } else if (chunk.type === 'message_delta' && chunk.usage) {
+                ollamaChunk.response = '';
+                ollamaChunk.prompt_eval_count = 0;
+                ollamaChunk.eval_count = chunk.usage.output_tokens || 0;
+            } else {
+                ollamaChunk.response = '';
+            }
+        }
+        // Handle OpenAI format
+        else if (!isDone && chunk.choices && chunk.choices.length > 0) {
+            const delta = chunk.choices[0].delta;
+            ollamaChunk.response = delta.content || '';
+        }
+        // Handle final chunk
+        else if (isDone) {
+            ollamaChunk.response = '';
+            ollamaChunk.done_reason = 'stop';
+        }
+
+        return ollamaChunk;
+    }
+
+    /**
+     * OpenAI/Claude/Gemini模型列表 -> Ollama tags
+     */
+    toOllamaTags(modelList, sourceProtocol = null) {
+        const models = [];
+
+        // Handle both OpenAI format (data array) and Gemini format (models array)
+        const sourceModels = modelList.data || modelList.models || [];
+        
+        if (Array.isArray(sourceModels)) {
+            sourceModels.forEach(model => {
+                // Get model name
+                let modelName = model.id || model.name || model.displayName || 'unknown';
+                
+                // Remove "models/" prefix if present (for Gemini)
+                if (modelName.startsWith('models/')) {
+                    modelName = modelName.substring(7); // Remove "models/"
+                }
+                
+                // Skip models with invalid names
+                if (modelName === 'unknown' || !modelName) {
+                    return;
+                }
+                
+                // IMPORTANT: Copilot expects family: "Ollama" with capital O!
+                const modelOwner = 'Ollama';
+                
+                models.push({
+                    name: modelName,
+                    model: modelName,
+                    modified_at: new Date().toISOString(),
+                    size: 0,  // As in the old patch
+                    digest: '',  // Empty string, as in the old patch
+                    details: {
+                        parent_model: '',
+                        format: 'gguf',
+                        family: modelOwner,  // "Ollama" with capital O
+                        families: [modelOwner],
+                        parameter_size: '0B',  // As in the old patch
+                        quantization_level: OLLAMA_DEFAULT_QUANTIZATION_LEVEL
+                    }
+                });
+            });
+        }
+
+        return { models };
+    }
+
+    /**
+     * Generate Ollama show response
+     */
+    toOllamaShowResponse(modelName) {
+        // Minimal implementation, as in the old patch
+        let contextLength = OLLAMA_DEFAULT_CONTEXT_LENGTH;
+        let maxOutputTokens = OLLAMA_DEFAULT_MAX_OUTPUT_TOKENS;
+        let family = 'Ollama';  // ВАЖНО: С большой буквы, как ожидает Copilot!
+        let architecture = 'transformer';
+        
+        const lowerName = modelName.toLowerCase();
+        
+        // Determine contextLength by model name
+        // Claude models
+        if (lowerName.includes('claude')) {
+            architecture = 'claude';
+            contextLength = OLLAMA_CLAUDE_DEFAULT_CONTEXT_LENGTH; // Default 200K
+            
+            // Claude Sonnet 4.5
+            if (lowerName.includes('sonnet-4-5') || lowerName.includes('sonnet-4.5')) {
+                contextLength = OLLAMA_CLAUDE_SONNET_45_CONTEXT_LENGTH; // 200K (1M beta available)
+                maxOutputTokens = OLLAMA_CLAUDE_SONNET_45_MAX_OUTPUT_TOKENS; // 64K output
+            }
+            // Claude Haiku 4.5
+            else if (lowerName.includes('haiku-4-5') || lowerName.includes('haiku-4.5')) {
+                contextLength = OLLAMA_CLAUDE_HAIKU_45_CONTEXT_LENGTH; // 200K
+                maxOutputTokens = OLLAMA_CLAUDE_HAIKU_45_MAX_OUTPUT_TOKENS; // 64K output
+            }
+            // Claude Opus 4.1
+            else if (lowerName.includes('opus-4-1') || lowerName.includes('opus-4.1')) {
+                contextLength = OLLAMA_CLAUDE_OPUS_41_CONTEXT_LENGTH; // 200K
+                maxOutputTokens = OLLAMA_CLAUDE_OPUS_41_MAX_OUTPUT_TOKENS; // 32K output
+            }
+            // Claude Sonnet 4.0 (legacy)
+            else if (lowerName.includes('sonnet-4-0') || lowerName.includes('sonnet-4.0') || lowerName.includes('sonnet-4-20')) {
+                contextLength = OLLAMA_CLAUDE_SONNET_40_CONTEXT_LENGTH; // 200K (1M beta available)
+                maxOutputTokens = OLLAMA_CLAUDE_SONNET_40_MAX_OUTPUT_TOKENS; // 64K output
+            }
+            // Claude Sonnet 3.7 (legacy)
+            else if (lowerName.includes('3-7') || lowerName.includes('3.7')) {
+                contextLength = OLLAMA_CLAUDE_SONNET_37_CONTEXT_LENGTH; // 200K
+                maxOutputTokens = OLLAMA_CLAUDE_SONNET_37_MAX_OUTPUT_TOKENS; // 64K output (128K beta available)
+            }
+            // Claude Opus 4.0 (legacy)
+            else if (lowerName.includes('opus-4-0') || lowerName.includes('opus-4.0') || lowerName.includes('opus-4-20')) {
+                contextLength = OLLAMA_CLAUDE_OPUS_40_CONTEXT_LENGTH; // 200K
+                maxOutputTokens = OLLAMA_CLAUDE_OPUS_40_MAX_OUTPUT_TOKENS; // 32K output
+            }
+            // Claude Haiku 3.5 (legacy)
+            else if (lowerName.includes('haiku-3-5') || lowerName.includes('haiku-3.5')) {
+                contextLength = OLLAMA_CLAUDE_HAIKU_35_CONTEXT_LENGTH; // 200K
+                maxOutputTokens = OLLAMA_CLAUDE_HAIKU_35_MAX_OUTPUT_TOKENS; // 8K output
+            }
+            // Claude Haiku 3.0 (legacy)
+            else if (lowerName.includes('haiku-3-0') || lowerName.includes('haiku-3.0') || lowerName.includes('haiku-20240307')) {
+                contextLength = OLLAMA_CLAUDE_HAIKU_30_CONTEXT_LENGTH; // 200K
+                maxOutputTokens = OLLAMA_CLAUDE_HAIKU_30_MAX_OUTPUT_TOKENS; // 4K output
+            }
+            // Claude Sonnet 3.5 (legacy)
+            else if (lowerName.includes('sonnet-3-5') || lowerName.includes('sonnet-3.5')) {
+                contextLength = OLLAMA_CLAUDE_SONNET_35_CONTEXT_LENGTH; // 200K
+                maxOutputTokens = OLLAMA_CLAUDE_SONNET_35_MAX_OUTPUT_TOKENS; // 8K output
+            }
+            // Claude Opus 3.0 (legacy)
+            else if (lowerName.includes('opus-3-0') || lowerName.includes('opus-3.0') || lowerName.includes('opus') && lowerName.includes('20240229')) {
+                contextLength = OLLAMA_CLAUDE_OPUS_30_CONTEXT_LENGTH; // 200K
+                maxOutputTokens = OLLAMA_CLAUDE_OPUS_30_MAX_OUTPUT_TOKENS; // 4K output
+            }
+            // Default for Claude
+            else {
+                contextLength = OLLAMA_CLAUDE_DEFAULT_CONTEXT_LENGTH; // 200K
+                maxOutputTokens = OLLAMA_CLAUDE_HAIKU_35_MAX_OUTPUT_TOKENS; // 8K output
+            }
+        }
+        // Gemini models
+        else if (lowerName.includes('gemini')) {
+            architecture = 'gemini';
+            
+            // Gemini 2.5 Pro
+            if (lowerName.includes('2.5') && lowerName.includes('pro')) {
+                contextLength = OLLAMA_GEMINI_25_PRO_CONTEXT_LENGTH; // 1M input tokens
+                maxOutputTokens = OLLAMA_GEMINI_25_PRO_MAX_OUTPUT_TOKENS; // 65K output tokens
+            }
+            // Gemini 2.5 Flash / Flash-Lite
+            else if (lowerName.includes('2.5') && (lowerName.includes('flash') || lowerName.includes('lite'))) {
+                contextLength = OLLAMA_GEMINI_25_FLASH_CONTEXT_LENGTH; // 1M input tokens
+                maxOutputTokens = OLLAMA_GEMINI_25_FLASH_MAX_OUTPUT_TOKENS; // 65K output tokens
+            }
+            // Gemini 2.5 Flash Image
+            else if (lowerName.includes('2.5') && lowerName.includes('image')) {
+                contextLength = OLLAMA_GEMINI_25_IMAGE_CONTEXT_LENGTH; // 65K input tokens
+                maxOutputTokens = OLLAMA_GEMINI_25_IMAGE_MAX_OUTPUT_TOKENS; // 32K output tokens
+            }
+            // Gemini 2.5 Flash Live / Native Audio
+            else if (lowerName.includes('2.5') && (lowerName.includes('live') || lowerName.includes('native-audio'))) {
+                contextLength = OLLAMA_GEMINI_25_LIVE_CONTEXT_LENGTH; // 131K input tokens
+                maxOutputTokens = OLLAMA_GEMINI_25_LIVE_MAX_OUTPUT_TOKENS; // 8K output tokens
+            }
+            // Gemini 2.5 TTS
+            else if (lowerName.includes('2.5') && lowerName.includes('tts')) {
+                contextLength = OLLAMA_GEMINI_25_TTS_CONTEXT_LENGTH; // 8K input tokens
+                maxOutputTokens = OLLAMA_GEMINI_25_TTS_MAX_OUTPUT_TOKENS; // 16K output tokens
+            }
+            // Gemini 2.0 Flash
+            else if (lowerName.includes('2.0') && lowerName.includes('flash')) {
+                contextLength = OLLAMA_GEMINI_20_FLASH_CONTEXT_LENGTH; // 1M input tokens
+                maxOutputTokens = OLLAMA_GEMINI_20_FLASH_MAX_OUTPUT_TOKENS; // 8K output tokens
+            }
+            // Gemini 2.0 Flash Image
+            else if (lowerName.includes('2.0') && lowerName.includes('image')) {
+                contextLength = OLLAMA_GEMINI_20_IMAGE_CONTEXT_LENGTH; // 32K input tokens
+                maxOutputTokens = OLLAMA_GEMINI_20_IMAGE_MAX_OUTPUT_TOKENS; // 8K output tokens
+            }
+            // Gemini 1.5 Pro (legacy)
+            else if (lowerName.includes('1.5') && lowerName.includes('pro')) {
+                contextLength = OLLAMA_GEMINI_15_PRO_CONTEXT_LENGTH; // 2M tokens
+                maxOutputTokens = OLLAMA_GEMINI_15_PRO_MAX_OUTPUT_TOKENS;
+            }
+            // Gemini 1.5 Flash (legacy)
+            else if (lowerName.includes('1.5') && lowerName.includes('flash')) {
+                contextLength = OLLAMA_GEMINI_15_FLASH_CONTEXT_LENGTH; // 1M tokens
+                maxOutputTokens = OLLAMA_GEMINI_15_FLASH_MAX_OUTPUT_TOKENS;
+            }
+            // Default for Gemini
+            else {
+                contextLength = OLLAMA_GEMINI_DEFAULT_CONTEXT_LENGTH; // 1M tokens
+                maxOutputTokens = OLLAMA_GEMINI_DEFAULT_MAX_OUTPUT_TOKENS;
+            }
+        }
+        // GPT-4 models
+        else if (lowerName.includes('gpt-4')) {
+            architecture = 'gpt';
+            
+            if (lowerName.includes('turbo') || lowerName.includes('preview')) {
+                contextLength = OLLAMA_GPT4_TURBO_CONTEXT_LENGTH; // GPT-4 Turbo
+                maxOutputTokens = OLLAMA_GPT4_TURBO_MAX_OUTPUT_TOKENS;
+            } else if (lowerName.includes('32k')) {
+                contextLength = OLLAMA_GPT4_32K_CONTEXT_LENGTH;
+                maxOutputTokens = OLLAMA_GPT4_32K_MAX_OUTPUT_TOKENS;
+            } else {
+                contextLength = OLLAMA_GPT4_BASE_CONTEXT_LENGTH; // GPT-4 base
+                maxOutputTokens = OLLAMA_GPT4_BASE_MAX_OUTPUT_TOKENS;
+            }
+        }
+        // GPT-3.5 models
+        else if (lowerName.includes('gpt-3.5')) {
+            architecture = 'gpt';
+            
+            if (lowerName.includes('16k')) {
+                contextLength = OLLAMA_GPT35_16K_CONTEXT_LENGTH;
+                maxOutputTokens = OLLAMA_GPT35_16K_MAX_OUTPUT_TOKENS;
+            } else {
+                contextLength = OLLAMA_GPT35_BASE_CONTEXT_LENGTH;
+                maxOutputTokens = OLLAMA_GPT35_BASE_MAX_OUTPUT_TOKENS;
+            }
+        }
+        // Qwen models
+        else if (lowerName.includes('qwen')) {
+            architecture = 'qwen';
+            
+            // Qwen3 Coder Plus (coder-model)
+            if (lowerName.includes('coder-plus') || lowerName.includes('coder_plus') || lowerName.includes('coder-model')) {
+                contextLength = OLLAMA_QWEN_CODER_PLUS_CONTEXT_LENGTH; // 128K tokens
+                maxOutputTokens = OLLAMA_QWEN_CODER_PLUS_MAX_OUTPUT_TOKENS; // 65K output
+            }
+            // Qwen3 VL Plus (vision-model)
+            else if (lowerName.includes('vl-plus') || lowerName.includes('vl_plus') || lowerName.includes('vision-model')) {
+                contextLength = OLLAMA_QWEN_VL_PLUS_CONTEXT_LENGTH; // 256K tokens
+                maxOutputTokens = OLLAMA_QWEN_VL_PLUS_MAX_OUTPUT_TOKENS; // 32K output
+            }
+            // Qwen3 Coder Flash
+            else if (lowerName.includes('coder-flash') || lowerName.includes('coder_flash')) {
+                contextLength = OLLAMA_QWEN_CODER_FLASH_CONTEXT_LENGTH; // 128K tokens
+                maxOutputTokens = OLLAMA_QWEN_CODER_FLASH_MAX_OUTPUT_TOKENS; // 65K output
+            }
+            // Default for Qwen
+            else {
+                contextLength = OLLAMA_QWEN_DEFAULT_CONTEXT_LENGTH; // 32K tokens
+                maxOutputTokens = OLLAMA_QWEN_DEFAULT_MAX_OUTPUT_TOKENS;
+            }
+        }
+        
+        // Minimal parameter_size, as in the old patch
+        let parameterSize = '0B';
+        
+        return {
+            license: '',
+            modelfile: `# Modelfile for ${modelName}\nFROM ${modelName}`,
+            parameters: `num_ctx ${contextLength}\nnum_predict ${maxOutputTokens}\ntemperature ${OLLAMA_DEFAULT_TEMPERATURE}\ntop_p ${OLLAMA_DEFAULT_TOP_P}`,
+            template: '{{ if .System }}{{ .System }}\n{{ end }}{{ .Prompt }}',
+            details: {
+                parent_model: '',
+                format: 'gguf',
+                family: family,
+                families: [family],
+                parameter_size: parameterSize,
+                quantization_level: OLLAMA_SHOW_QUANTIZATION_LEVEL
+            },
+            model_info: {
+                'general.architecture': architecture,
+                'general.file_type': OLLAMA_DEFAULT_FILE_TYPE,
+                'general.parameter_count': 0,
+                'general.quantization_version': OLLAMA_DEFAULT_QUANTIZATION_VERSION,
+                'general.context_length': contextLength,
+                'llama.context_length': contextLength,
+                'llama.rope.freq_base': OLLAMA_DEFAULT_ROPE_FREQ_BASE
+            },
+            capabilities: ['tools', 'vision', 'completion']  // Indicate that the model supports tool calling
+        };
+    }
+}

src/converters/strategies/OpenAIConverter.js

@@ -0,0 +1,1565 @@
+/**
+ * OpenAI转换器
+ * 处理OpenAI协议与其他协议之间的转换
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { BaseConverter } from '../BaseConverter.js';
+import { CodexConverter } from './CodexConverter.js';
+import {
+    extractAndProcessSystemMessages as extractSystemMessages,
+    extractTextFromMessageContent as extractText,
+    safeParseJSON,
+    checkAndAssignOrDefault,
+    extractThinkingFromOpenAIText,
+    mapFinishReason,
+    cleanJsonSchemaProperties as cleanJsonSchema,
+    CLAUDE_DEFAULT_MAX_TOKENS,
+    CLAUDE_DEFAULT_TEMPERATURE,
+    CLAUDE_DEFAULT_TOP_P,
+    GEMINI_DEFAULT_MAX_TOKENS,
+    GEMINI_DEFAULT_TEMPERATURE,
+    GEMINI_DEFAULT_TOP_P,
+    OPENAI_DEFAULT_INPUT_TOKEN_LIMIT,
+    OPENAI_DEFAULT_OUTPUT_TOKEN_LIMIT
+} from '../utils.js';
+import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
+import {
+    generateResponseCreated,
+    generateResponseInProgress,
+    generateOutputItemAdded,
+    generateContentPartAdded,
+    generateOutputTextDone,
+    generateContentPartDone,
+    generateOutputItemDone,
+    generateResponseCompleted
+} from '../../providers/openai/openai-responses-core.mjs';
+
+/**
+ * OpenAI转换器类
+ * 实现OpenAI协议到其他协议的转换
+ */
+export class OpenAIConverter extends BaseConverter {
+    constructor() {
+        super('openai');
+        // 创建 CodexConverter 实例用于委托
+        this.codexConverter = new CodexConverter();
+    }
+
+    /**
+     * 转换请求
+     */
+    convertRequest(data, targetProtocol) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeRequest(data);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiRequest(data);
+            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
+                return this.toOpenAIResponsesRequest(data);
+            case MODEL_PROTOCOL_PREFIX.CODEX:
+                return this.toCodexRequest(data);
+            default:
+                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+        }
+    }
+
+    /**
+     * 转换响应
+     */
+    convertResponse(data, targetProtocol, model) {
+        // OpenAI作为源格式时，通常不需要转换响应
+        // 因为其他协议会转换到OpenAI格式
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeResponse(data, model);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiResponse(data, model);
+            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
+                return this.toOpenAIResponsesResponse(data, model);
+            default:
+                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+        }
+    }
+
+    /**
+     * 转换流式响应块
+     */
+    convertStreamChunk(chunk, targetProtocol, model) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeStreamChunk(chunk, model);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiStreamChunk(chunk, model);
+            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
+                return this.toOpenAIResponsesStreamChunk(chunk, model);
+            default:
+                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
+        }
+    }
+
+    /**
+     * 转换模型列表
+     */
+    convertModelList(data, targetProtocol) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeModelList(data);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiModelList(data);
+            default:
+                return this.ensureDisplayName(data);
+        }
+    }
+
+    /**
+     * Ensure display_name field exists in OpenAI model list
+     */
+    ensureDisplayName(openaiModels) {
+        if (!openaiModels || !openaiModels.data) {
+            return openaiModels;
+        }
+
+        return {
+            ...openaiModels,
+            data: openaiModels.data.map(model => ({
+                ...model,
+                display_name: model.display_name || model.id,
+            })),
+        };
+    }
+
+    // =========================================================================
+    // OpenAI -> Claude 转换
+    // =========================================================================
+
+    /**
+     * OpenAI请求 -> Claude请求
+     */
+    toClaudeRequest(openaiRequest) {
+        const messages = openaiRequest.messages || [];
+        const { systemInstruction, nonSystemMessages } = extractSystemMessages(messages);
+
+        const claudeMessages = [];
+
+        for (const message of nonSystemMessages) {
+            const role = message.role === 'assistant' ? 'assistant' : 'user';
+            let content = [];
+
+            if (message.role === 'tool') {
+                // 工具结果消息
+                content.push({
+                    type: 'tool_result',
+                    tool_use_id: message.tool_call_id,
+                    content: safeParseJSON(message.content)
+                });
+                claudeMessages.push({ role: 'user', content: content });
+            } else if (message.role === 'assistant' && (message.tool_calls?.length || message.function_calls?.length)) {
+                // 助手工具调用消息 - 支持tool_calls和function_calls
+                const calls = message.tool_calls || message.function_calls || [];
+                const toolUseBlocks = calls.map(tc => ({
+                    type: 'tool_use',
+                    id: tc.id,
+                    name: tc.function.name,
+                    input: safeParseJSON(tc.function.arguments)
+                }));
+                claudeMessages.push({ role: 'assistant', content: toolUseBlocks });
+            } else {
+                // 普通消息
+                if (typeof message.content === 'string') {
+                    if (message.content) {
+                        content.push({ type: 'text', text: message.content.trim() });
+                    }
+                } else if (Array.isArray(message.content)) {
+                    message.content.forEach(item => {
+                        if (!item) return;
+                        switch (item.type) {
+                            case 'text':
+                                if (item.text) {
+                                    content.push({ type: 'text', text: item.text.trim() });
+                                }
+                                break;
+                            case 'image_url':
+                                if (item.image_url) {
+                                    const imageUrl = typeof item.image_url === 'string'
+                                        ? item.image_url
+                                        : item.image_url.url;
+                                    if (imageUrl.startsWith('data:')) {
+                                        const [header, data] = imageUrl.split(',');
+                                        const mediaType = header.match(/data:([^;]+)/)?.[1] || 'image/jpeg';
+                                        content.push({
+                                            type: 'image',
+                                            source: {
+                                                type: 'base64',
+                                                media_type: mediaType,
+                                                data: data
+                                            }
+                                        });
+                                    } else {
+                                        content.push({ type: 'text', text: `[Image: ${imageUrl}]` });
+                                    }
+                                }
+                                break;
+                            case 'audio':
+                                if (item.audio_url) {
+                                    const audioUrl = typeof item.audio_url === 'string'
+                                        ? item.audio_url
+                                        : item.audio_url.url;
+                                    content.push({ type: 'text', text: `[Audio: ${audioUrl}]` });
+                                }
+                                break;
+                        }
+                    });
+                }
+                if (content.length > 0) {
+                    claudeMessages.push({ role: role, content: content });
+                }
+            }
+        }
+        // 合并相邻相同 role 的消息
+        const mergedClaudeMessages = [];
+        for (let i = 0; i < claudeMessages.length; i++) {
+            const currentMessage = claudeMessages[i];
+
+            if (mergedClaudeMessages.length === 0) {
+                mergedClaudeMessages.push(currentMessage);
+            } else {
+                const lastMessage = mergedClaudeMessages[mergedClaudeMessages.length - 1];
+
+                // 如果当前消息的 role 与上一条消息的 role 相同，则合并 content 数组
+                if (lastMessage.role === currentMessage.role) {
+                    lastMessage.content = lastMessage.content.concat(currentMessage.content);
+                } else {
+                    mergedClaudeMessages.push(currentMessage);
+                }
+            }
+        }
+
+        // 清理最后一条 assistant 消息的尾部空白
+        if (mergedClaudeMessages.length > 0) {
+            const lastMessage = mergedClaudeMessages[mergedClaudeMessages.length - 1];
+            if (lastMessage.role === 'assistant' && Array.isArray(lastMessage.content)) {
+                // 从后往前找到最后一个 text 类型的内容块
+                for (let i = lastMessage.content.length - 1; i >= 0; i--) {
+                    const contentBlock = lastMessage.content[i];
+                    if (contentBlock.type === 'text' && contentBlock.text) {
+                        // 移除尾部空白字���
+                        contentBlock.text = contentBlock.text.trimEnd();
+                        break;
+                    }
+                }
+            }
+        }
+
+
+        const claudeRequest = {
+            model: openaiRequest.model,
+            messages: mergedClaudeMessages,
+            max_tokens: checkAndAssignOrDefault(openaiRequest.max_tokens, CLAUDE_DEFAULT_MAX_TOKENS),
+            temperature: checkAndAssignOrDefault(openaiRequest.temperature, CLAUDE_DEFAULT_TEMPERATURE),
+            top_p: checkAndAssignOrDefault(openaiRequest.top_p, CLAUDE_DEFAULT_TOP_P),
+        };
+
+        if (systemInstruction) {
+            claudeRequest.system = extractText(systemInstruction.parts[0].text);
+        }
+
+        if (openaiRequest.tools?.length) {
+            claudeRequest.tools = openaiRequest.tools.map(t => ({
+                name: t.function.name,
+                description: t.function.description || '',
+                input_schema: t.function.parameters || { type: 'object', properties: {} }
+            }));
+            claudeRequest.tool_choice = this.buildClaudeToolChoice(openaiRequest.tool_choice);
+        }
+
+        return claudeRequest;
+    }
+
+    /**
+     * OpenAI响应 -> Claude响应
+     */
+    toClaudeResponse(openaiResponse, model) {
+        if (!openaiResponse || !openaiResponse.choices || openaiResponse.choices.length === 0) {
+            return {
+                id: `msg_${uuidv4()}`,
+                type: "message",
+                role: "assistant",
+                content: [],
+                model: model,
+                stop_reason: "end_turn",
+                stop_sequence: null,
+                usage: {
+                    input_tokens: openaiResponse?.usage?.prompt_tokens || 0,
+                    output_tokens: openaiResponse?.usage?.completion_tokens || 0
+                }
+            };
+        }
+
+        const choice = openaiResponse.choices[0];
+        const contentList = [];
+
+        // 处理工具调用 - 支持tool_calls和function_calls
+        const toolCalls = choice.message?.tool_calls || choice.message?.function_calls || [];
+        for (const toolCall of toolCalls.filter(tc => tc && typeof tc === 'object')) {
+            if (toolCall.function) {
+                const func = toolCall.function;
+                const argStr = func.arguments || "{}";
+                let argObj;
+                try {
+                    argObj = typeof argStr === 'string' ? JSON.parse(argStr) : argStr;
+                } catch (e) {
+                    argObj = {};
+                }
+                contentList.push({
+                    type: "tool_use",
+                    id: toolCall.id || "",
+                    name: func.name || "",
+                    input: argObj,
+                });
+            }
+        }
+
+        // 处理reasoning_content（推理内容）
+        const reasoningContent = choice.message?.reasoning_content || "";
+        if (reasoningContent) {
+            contentList.push({
+                type: "thinking",
+                thinking: reasoningContent
+            });
+        }
+
+        // 处理文本内容
+        const contentText = choice.message?.content || "";
+        if (contentText) {
+            const extractedContent = extractThinkingFromOpenAIText(contentText);
+            if (Array.isArray(extractedContent)) {
+                contentList.push(...extractedContent);
+            } else {
+                contentList.push({ type: "text", text: extractedContent });
+            }
+        }
+
+        // 映射结束原因
+        const stopReason = mapFinishReason(
+            choice.finish_reason || "stop",
+            "openai",
+            "anthropic"
+        );
+
+        return {
+            id: `msg_${uuidv4()}`,
+            type: "message",
+            role: "assistant",
+            content: contentList,
+            model: model,
+            stop_reason: stopReason,
+            stop_sequence: null,
+            usage: {
+                input_tokens: openaiResponse.usage?.prompt_tokens || 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: openaiResponse.usage?.prompt_tokens_details?.cached_tokens || 0,
+                output_tokens: openaiResponse.usage?.completion_tokens || 0
+            }
+        };
+    }
+
+    /**
+     * OpenAI流式响应 -> Claude流式响应
+     *
+     * 这个方法实现了与 ClaudeConverter.toOpenAIStreamChunk 相反的转换逻辑
+     * 将 OpenAI 的流式 chunk 转换为 Claude 的流式事件
+     */
+    toClaudeStreamChunk(openaiChunk, model) {
+        if (!openaiChunk) return null;
+
+        // 处理 OpenAI chunk 对象
+        if (typeof openaiChunk === 'object' && !Array.isArray(openaiChunk)) {
+            const choice = openaiChunk.choices?.[0];
+            if (!choice) {
+                return null;
+            }
+
+            const delta = choice.delta;
+            const finishReason = choice.finish_reason;
+            const events = [];
+
+            // 注释部分是为了兼容claude code，但是不兼容cherry studio
+            // 1. 处理 role (对应 message_start) 
+            // if (delta?.role === "assistant") {
+            //     events.push({
+            //         type: "message_start",
+            //         message: {
+            //             id: openaiChunk.id || `msg_${uuidv4()}`,
+            //             type: "message",
+            //             role: "assistant",
+            //             content: [],
+            //             model: model || openaiChunk.model || "unknown",
+            //             stop_reason: null,
+            //             stop_sequence: null,
+            //             usage: {
+            //                 input_tokens: openaiChunk.usage?.prompt_tokens || 0,
+            //                 output_tokens: 0
+            //             }
+            //         }
+            //     });
+            //     events.push({
+            //         type: "content_block_start",
+            //         index: 0,
+            //         content_block: {
+            //             type: "text",
+            //             text: ""
+            //         }
+            //     });
+            // }
+
+            // 2. 处理 tool_calls (对应 content_block_start 和 content_block_delta)
+            // if (delta?.tool_calls) {
+            //     const toolCalls = delta.tool_calls;
+            //     for (const toolCall of toolCalls) {
+            //         // 如果有 function.name，说明是工具调用开始
+            //         if (toolCall.function?.name) {
+            //             events.push({
+            //                 type: "content_block_start",
+            //                 index: toolCall.index || 0,
+            //                 content_block: {
+            //                     type: "tool_use",
+            //                     id: toolCall.id || `tool_${uuidv4()}`,
+            //                     name: toolCall.function.name,
+            //                     input: {}
+            //                 }
+            //             });
+            //         }
+
+            //         // 如果有 function.arguments，说明是参数增量
+            //         if (toolCall.function?.arguments) {
+            //             events.push({
+            //                 type: "content_block_delta",
+            //                 index: toolCall.index || 0,
+            //                 delta: {
+            //                     type: "input_json_delta",
+            //                     partial_json: toolCall.function.arguments
+            //                 }
+            //             });
+            //         }
+            //     }
+            // }
+
+            // 3. 处理 reasoning_content (对应 thinking 类型的 content_block)
+            if (delta?.reasoning_content) {
+                // 注意：这里可能需要先发送 content_block_start，但由于状态管理复杂，
+                // 我们假设调用方会处理这个逻辑
+                events.push({
+                    type: "content_block_delta",
+                    index: 0,
+                    delta: {
+                        type: "thinking_delta",
+                        thinking: delta.reasoning_content
+                    }
+                });
+            }
+
+            // 4. 处理普通文本 content (对应 text 类型的 content_block)
+            if (delta?.content) {
+                events.push({
+                    type: "content_block_delta",
+                    index: 0,
+                    delta: {
+                        type: "text_delta",
+                        text: delta.content
+                    }
+                });
+            }
+
+            // 5. 处理 finish_reason (对应 message_delta 和 message_stop)
+            if (finishReason) {
+                // 映射 finish_reason
+                const stopReason = finishReason === "stop" ? "end_turn" :
+                    finishReason === "length" ? "max_tokens" :
+                        "end_turn";
+
+                events.push({
+                    type: "content_block_stop",
+                    index: 0
+                });
+                // 发送 message_delta
+                events.push({
+                    type: "message_delta",
+                    delta: {
+                        stop_reason: stopReason,
+                        stop_sequence: null
+                    },
+                    usage: {
+                        input_tokens: openaiChunk.usage?.prompt_tokens || 0,
+                        cache_creation_input_tokens: 0,
+                        cache_read_input_tokens: openaiChunk.usage?.prompt_tokens_details?.cached_tokens || 0,
+                        output_tokens: openaiChunk.usage?.completion_tokens || 0
+                    }
+                });
+
+                // 发送 message_stop
+                events.push({
+                    type: "message_stop"
+                });
+            }
+
+            return events.length > 0 ? events : null;
+        }
+
+        // 向后兼容：处理字符串格式
+        if (typeof openaiChunk === 'string') {
+            return {
+                type: "content_block_delta",
+                index: 0,
+                delta: {
+                    type: "text_delta",
+                    text: openaiChunk
+                }
+            };
+        }
+
+        return null;
+    }
+
+    /**
+     * OpenAI模型列表 -> Claude模型列表
+     */
+    toClaudeModelList(openaiModels) {
+        return {
+            models: openaiModels.data.map(m => ({
+                name: m.id,
+                description: "",
+            })),
+        };
+    }
+
+    /**
+     * 将 OpenAI 模型列表转换为 Gemini 模型列表
+     */
+    toGeminiModelList(openaiModels) {
+        const models = openaiModels.data || [];
+        return {
+            models: models.map(m => ({
+                name: `models/${m.id}`,
+                version: m.version || "1.0.0",
+                displayName: m.displayName || m.id,
+                description: m.description || `A generative model for text and chat generation. ID: ${m.id}`,
+                inputTokenLimit: m.inputTokenLimit || OPENAI_DEFAULT_INPUT_TOKEN_LIMIT,
+                outputTokenLimit: m.outputTokenLimit || OPENAI_DEFAULT_OUTPUT_TOKEN_LIMIT,
+                supportedGenerationMethods: m.supportedGenerationMethods || ["generateContent", "streamGenerateContent"]
+            }))
+        };
+    }
+
+    /**
+     * 构建Claude工具选择
+     */
+    buildClaudeToolChoice(toolChoice) {
+        if (typeof toolChoice === 'string') {
+            const mapping = { auto: 'auto', none: 'none', required: 'any' };
+            return { type: mapping[toolChoice] };
+        }
+        if (typeof toolChoice === 'object' && toolChoice.function) {
+            return { type: 'tool', name: toolChoice.function.name };
+        }
+        return undefined;
+    }
+
+    // =========================================================================
+    // OpenAI -> Gemini 转换
+    // =========================================================================
+
+    // Gemini Openai thought signature constant
+    static GEMINI_OPENAI_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+    /**
+     * OpenAI请求 -> Gemini请求
+     */
+    toGeminiRequest(openaiRequest) {
+        const messages = openaiRequest.messages || [];
+        const model = openaiRequest.model || '';
+        
+        // 构建 tool_call_id -> function_name 映射
+        const tcID2Name = {};
+        for (const message of messages) {
+            if (message.role === 'assistant' && message.tool_calls) {
+                for (const tc of message.tool_calls) {
+                    if (tc.type === 'function' && tc.id && tc.function?.name) {
+                        tcID2Name[tc.id] = tc.function.name;
+                    }
+                }
+            }
+        }
+
+        // 构建 tool_call_id -> response 映射
+        const toolResponses = {};
+        for (const message of messages) {
+            if (message.role === 'tool' && message.tool_call_id) {
+                toolResponses[message.tool_call_id] = message.content;
+            }
+        }
+
+        const processedMessages = [];
+        let systemInstruction = null;
+
+        for (let i = 0; i < messages.length; i++) {
+            const message = messages[i];
+            const role = message.role;
+            const content = message.content;
+
+            if (role === 'system') {
+                // system -> system_instruction
+                if (messages.length > 1) {
+                    if (typeof content === 'string') {
+                        systemInstruction = {
+                            role: 'user',
+                            parts: [{ text: content }]
+                        };
+                    } else if (Array.isArray(content)) {
+                        const parts = content
+                            .filter(item => item.type === 'text' && item.text)
+                            .map(item => ({ text: item.text }));
+                        if (parts.length > 0) {
+                            systemInstruction = {
+                                role: 'user',
+                                parts: parts
+                            };
+                        }
+                    } else if (typeof content === 'object' && content.type === 'text') {
+                        systemInstruction = {
+                            role: 'user',
+                            parts: [{ text: content.text }]
+                        };
+                    }
+                } else {
+                    // 只有一条 system 消息时，作为 user 消息处理
+                    const node = { role: 'user', parts: [] };
+                    if (typeof content === 'string') {
+                        node.parts.push({ text: content });
+                    } else if (Array.isArray(content)) {
+                        for (const item of content) {
+                            if (item.type === 'text' && item.text) {
+                                node.parts.push({ text: item.text });
+                            }
+                        }
+                    }
+                    if (node.parts.length > 0) {
+                        processedMessages.push(node);
+                    }
+                }
+            } else if (role === 'user') {
+                // user -> user content
+                const node = { role: 'user', parts: [] };
+                if (typeof content === 'string') {
+                    node.parts.push({ text: content });
+                } else if (Array.isArray(content)) {
+                    for (const item of content) {
+                        if (!item) continue;
+                        switch (item.type) {
+                            case 'text':
+                                if (item.text) {
+                                    node.parts.push({ text: item.text });
+                                }
+                                break;
+                            case 'image_url':
+                                if (item.image_url) {
+                                    const imageUrl = typeof item.image_url === 'string'
+                                        ? item.image_url
+                                        : item.image_url.url;
+                                    if (imageUrl && imageUrl.startsWith('data:')) {
+                                        const commaIndex = imageUrl.indexOf(',');
+                                        if (commaIndex > 5) {
+                                            const header = imageUrl.substring(5, commaIndex);
+                                            const semicolonIndex = header.indexOf(';');
+                                            if (semicolonIndex > 0) {
+                                                const mimeType = header.substring(0, semicolonIndex);
+                                                const data = imageUrl.substring(commaIndex + 1);
+                                                node.parts.push({
+                                                    inlineData: {
+                                                        mimeType: mimeType,
+                                                        data: data
+                                                    },
+                                                    thoughtSignature: OpenAIConverter.GEMINI_OPENAI_THOUGHT_SIGNATURE
+                                                });
+                                            }
+                                        }
+                                    } else if (imageUrl) {
+                                        node.parts.push({
+                                            fileData: {
+                                                mimeType: 'image/jpeg',
+                                                fileUri: imageUrl
+                                            }
+                                        });
+                                    }
+                                }
+                                break;
+                            case 'file':
+                                if (item.file) {
+                                    const filename = item.file.filename || '';
+                                    const fileData = item.file.file_data || '';
+                                    const ext = filename.includes('.')
+                                        ? filename.split('.').pop().toLowerCase()
+                                        : '';
+                                    const mimeTypes = {
+                                        'pdf': 'application/pdf',
+                                        'txt': 'text/plain',
+                                        'html': 'text/html',
+                                        'css': 'text/css',
+                                        'js': 'application/javascript',
+                                        'json': 'application/json',
+                                        'xml': 'application/xml',
+                                        'csv': 'text/csv',
+                                        'md': 'text/markdown',
+                                        'py': 'text/x-python',
+                                        'java': 'text/x-java',
+                                        'c': 'text/x-c',
+                                        'cpp': 'text/x-c++',
+                                        'h': 'text/x-c',
+                                        'hpp': 'text/x-c++',
+                                        'go': 'text/x-go',
+                                        'rs': 'text/x-rust',
+                                        'ts': 'text/typescript',
+                                        'tsx': 'text/typescript',
+                                        'jsx': 'text/javascript',
+                                        'png': 'image/png',
+                                        'jpg': 'image/jpeg',
+                                        'jpeg': 'image/jpeg',
+                                        'gif': 'image/gif',
+                                        'webp': 'image/webp',
+                                        'svg': 'image/svg+xml',
+                                        'mp3': 'audio/mpeg',
+                                        'wav': 'audio/wav',
+                                        'mp4': 'video/mp4',
+                                        'webm': 'video/webm'
+                                    };
+                                    const mimeType = mimeTypes[ext];
+                                    if (mimeType && fileData) {
+                                        node.parts.push({
+                                            inlineData: {
+                                                mimeType: mimeType,
+                                                data: fileData
+                                            }
+                                        });
+                                    }
+                                }
+                                break;
+                        }
+                    }
+                }
+                if (node.parts.length > 0) {
+                    processedMessages.push(node);
+                }
+            } else if (role === 'assistant') {
+                // assistant -> model content
+                const node = { role: 'model', parts: [] };
+                
+                // 处理文本内容
+                if (typeof content === 'string' && content) {
+                    node.parts.push({ text: content });
+                } else if (Array.isArray(content)) {
+                    for (const item of content) {
+                        if (!item) continue;
+                        if (item.type === 'text' && item.text) {
+                            node.parts.push({ text: item.text });
+                        } else if (item.type === 'image_url' && item.image_url) {
+                            const imageUrl = typeof item.image_url === 'string'
+                                ? item.image_url
+                                : item.image_url.url;
+                            if (imageUrl && imageUrl.startsWith('data:')) {
+                                const commaIndex = imageUrl.indexOf(',');
+                                if (commaIndex > 5) {
+                                    const header = imageUrl.substring(5, commaIndex);
+                                    const semicolonIndex = header.indexOf(';');
+                                    if (semicolonIndex > 0) {
+                                        const mimeType = header.substring(0, semicolonIndex);
+                                        const data = imageUrl.substring(commaIndex + 1);
+                                        node.parts.push({
+                                            inlineData: {
+                                                mimeType: mimeType,
+                                                data: data
+                                            },
+                                            thoughtSignature: OpenAIConverter.GEMINI_OPENAI_THOUGHT_SIGNATURE
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // 处理 tool_calls -> functionCall
+                if (message.tool_calls && Array.isArray(message.tool_calls)) {
+                    const functionCallIds = [];
+                    for (const tc of message.tool_calls) {
+                        if (tc.type !== 'function') continue;
+                        const fid = tc.id || '';
+                        const fname = tc.function?.name || '';
+                        const fargs = tc.function?.arguments || '{}';
+                        
+                        let argsObj;
+                        try {
+                            argsObj = typeof fargs === 'string' ? JSON.parse(fargs) : fargs;
+                        } catch (e) {
+                            argsObj = {};
+                        }
+                        
+                        node.parts.push({
+                            functionCall: {
+                                name: fname,
+                                args: argsObj
+                            },
+                            thoughtSignature: OpenAIConverter.GEMINI_OPENAI_THOUGHT_SIGNATURE
+                        });
+                        
+                        if (fid) {
+                            functionCallIds.push(fid);
+                        }
+                    }
+                    
+                    // 添加 model 消息
+                    if (node.parts.length > 0) {
+                        processedMessages.push(node);
+                    }
+                    
+                    // 添加对应的 functionResponse（作为 user 消息）
+                    if (functionCallIds.length > 0) {
+                        const toolNode = { role: 'user', parts: [] };
+                        for (const fid of functionCallIds) {
+                            const name = tcID2Name[fid];
+                            if (name) {
+                                let resp = toolResponses[fid] || '{}';
+                                // 确保 resp 是字符串
+                                if (typeof resp !== 'string') {
+                                    resp = JSON.stringify(resp);
+                                }
+                                toolNode.parts.push({
+                                    functionResponse: {
+                                        name: name,
+                                        response: {
+                                            result: resp
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                        if (toolNode.parts.length > 0) {
+                            processedMessages.push(toolNode);
+                        }
+                    }
+                } else {
+                    // 没有 tool_calls，直接添加
+                    if (node.parts.length > 0) {
+                        processedMessages.push(node);
+                    }
+                }
+            }
+            // tool 消息已经在 assistant 的 tool_calls 处理中合并了，这里跳过
+        }
+
+        // 构建 Gemini 请求
+        const geminiRequest = {
+            contents: processedMessages.filter(item => item.parts && item.parts.length > 0)
+        };
+
+        // 添加 model
+        if (model) {
+            geminiRequest.model = model;
+        }
+
+        // 添加 system_instruction
+        if (systemInstruction) {
+            geminiRequest.system_instruction = systemInstruction;
+        }
+
+        // 处理 reasoning_effort -> thinkingConfig
+        if (openaiRequest.reasoning_effort) {
+            const effort = String(openaiRequest.reasoning_effort).toLowerCase().trim();
+            if (this.modelSupportsThinking(model)) {
+                if (this.isGemini3Model(model)) {
+                    // Gemini 3 模型使用 thinkingLevel
+                    if (effort === 'none') {
+                        // 不添加 thinkingConfig
+                    } else if (effort === 'auto') {
+                        geminiRequest.generationConfig = geminiRequest.generationConfig || {};
+                        geminiRequest.generationConfig.thinkingConfig = {
+                            includeThoughts: true
+                        };
+                    } else {
+                        const level = this.validateGemini3ThinkingLevel(model, effort);
+                        if (level) {
+                            geminiRequest.generationConfig = geminiRequest.generationConfig || {};
+                            geminiRequest.generationConfig.thinkingConfig = {
+                                thinkingLevel: level
+                            };
+                        }
+                    }
+                } else if (!this.modelUsesThinkingLevels(model)) {
+                    // 使用 thinkingBudget 的模型
+                    geminiRequest.generationConfig = geminiRequest.generationConfig || {};
+                    geminiRequest.generationConfig.thinkingConfig = this.applyReasoningEffortToGemini(effort);
+                }
+            }
+        }
+
+        // 处理 extra_body.google.thinking_config（Cherry Studio 扩展）
+        if (!openaiRequest.reasoning_effort && openaiRequest.extra_body?.google?.thinking_config) {
+            const tc = openaiRequest.extra_body.google.thinking_config;
+            if (this.modelSupportsThinking(model) && !this.modelUsesThinkingLevels(model)) {
+                geminiRequest.generationConfig = geminiRequest.generationConfig || {};
+                geminiRequest.generationConfig.thinkingConfig = geminiRequest.generationConfig.thinkingConfig || {};
+                
+                let setBudget = false;
+                let budget = 0;
+                
+                if (tc.thinkingBudget !== undefined) {
+                    budget = parseInt(tc.thinkingBudget, 10);
+                    geminiRequest.generationConfig.thinkingConfig.thinkingBudget = budget;
+                    setBudget = true;
+                } else if (tc.thinking_budget !== undefined) {
+                    budget = parseInt(tc.thinking_budget, 10);
+                    geminiRequest.generationConfig.thinkingConfig.thinkingBudget = budget;
+                    setBudget = true;
+                }
+                
+                if (tc.includeThoughts !== undefined) {
+                    geminiRequest.generationConfig.thinkingConfig.includeThoughts = tc.includeThoughts;
+                } else if (tc.include_thoughts !== undefined) {
+                    geminiRequest.generationConfig.thinkingConfig.includeThoughts = tc.include_thoughts;
+                } else if (setBudget && budget !== 0) {
+                    geminiRequest.generationConfig.thinkingConfig.includeThoughts = true;
+                }
+            }
+        }
+
+        // 处理 modalities -> responseModalities
+        if (openaiRequest.modalities && Array.isArray(openaiRequest.modalities)) {
+            const responseMods = [];
+            for (const m of openaiRequest.modalities) {
+                const mod = String(m).toLowerCase();
+                if (mod === 'text') {
+                    responseMods.push('TEXT');
+                } else if (mod === 'image') {
+                    responseMods.push('IMAGE');
+                }
+            }
+            if (responseMods.length > 0) {
+                geminiRequest.generationConfig = geminiRequest.generationConfig || {};
+                geminiRequest.generationConfig.responseModalities = responseMods;
+            }
+        }
+
+        // 处理 image_config（OpenRouter 风格）
+        if (openaiRequest.image_config) {
+            const imgCfg = openaiRequest.image_config;
+            if (imgCfg.aspect_ratio) {
+                geminiRequest.generationConfig = geminiRequest.generationConfig || {};
+                geminiRequest.generationConfig.imageConfig = geminiRequest.generationConfig.imageConfig || {};
+                geminiRequest.generationConfig.imageConfig.aspectRatio = imgCfg.aspect_ratio;
+            }
+            if (imgCfg.image_size) {
+                geminiRequest.generationConfig = geminiRequest.generationConfig || {};
+                geminiRequest.generationConfig.imageConfig = geminiRequest.generationConfig.imageConfig || {};
+                geminiRequest.generationConfig.imageConfig.imageSize = imgCfg.image_size;
+            }
+        }
+
+        // 处理 tools -> functionDeclarations
+        if (openaiRequest.tools?.length) {
+            const functionDeclarations = [];
+            let hasGoogleSearch = false;
+            
+            for (const t of openaiRequest.tools) {
+                if (!t || typeof t !== 'object') continue;
+                
+                if (t.type === 'function' && t.function) {
+                    const func = t.function;
+                    let fnDecl = {
+                        name: String(func.name || ''),
+                        description: String(func.description || '')
+                    };
+                    
+                    // 处理 parameters -> parametersJsonSchema
+                    if (func.parameters) {
+                        fnDecl.parametersJsonSchema = cleanJsonSchema(func.parameters);
+                    } else {
+                        fnDecl.parametersJsonSchema = {
+                            type: 'object',
+                            properties: {}
+                        };
+                    }
+                    
+                    functionDeclarations.push(fnDecl);
+                }
+                
+                // 处理 google_search 工具
+                if (t.google_search) {
+                    hasGoogleSearch = true;
+                }
+            }
+            
+            if (functionDeclarations.length > 0 || hasGoogleSearch) {
+                geminiRequest.tools = [{}];
+                if (functionDeclarations.length > 0) {
+                    geminiRequest.tools[0].functionDeclarations = functionDeclarations;
+                }
+                if (hasGoogleSearch) {
+                    const googleSearchTool = openaiRequest.tools.find(t => t.google_search);
+                    geminiRequest.tools[0].googleSearch = googleSearchTool.google_search;
+                }
+            }
+        }
+
+        // 处理 tool_choice
+        if (openaiRequest.tool_choice) {
+            geminiRequest.toolConfig = this.buildGeminiToolConfig(openaiRequest.tool_choice);
+        }
+
+        // 构建 generationConfig
+        const config = this.buildGeminiGenerationConfig(openaiRequest, model);
+        if (Object.keys(config).length) {
+            geminiRequest.generationConfig = {
+                ...config,
+                ...(geminiRequest.generationConfig || {})
+            };
+        }
+
+        // 添加默认安全设置
+        geminiRequest.safetySettings = this.getDefaultSafetySettings();
+
+        return geminiRequest;
+    }
+
+    /**
+     * 检查模型是否支持 thinking
+     */
+    modelSupportsThinking(model) {
+        if (!model) return false;
+        const m = model.toLowerCase();
+        return m.includes('2.5') || m.includes('thinking') || m.includes('2.0-flash-thinking');
+    }
+
+    /**
+     * 检查是否是 Gemini 3 模型
+     */
+    isGemini3Model(model) {
+        if (!model) return false;
+        const m = model.toLowerCase();
+        return m.includes('gemini-3') || m.includes('gemini3');
+    }
+
+    /**
+     * 检查模型是否使用 thinking levels（而不是 budget）
+     */
+    modelUsesThinkingLevels(model) {
+        if (!model) return false;
+        // Gemini 3 模型使用 levels，其他使用 budget
+        return this.isGemini3Model(model);
+    }
+
+    /**
+     * 验证 Gemini 3 thinking level
+     */
+    validateGemini3ThinkingLevel(model, effort) {
+        const validLevels = ['low', 'medium', 'high'];
+        if (validLevels.includes(effort)) {
+            return effort.toUpperCase();
+        }
+        return null;
+    }
+
+    /**
+     * 将 reasoning_effort 转换为 Gemini thinkingConfig
+     */
+    applyReasoningEffortToGemini(effort) {
+        const effortToBudget = {
+            'low': 1024,
+            'medium': 8192,
+            'high': 24576
+        };
+        const budget = effortToBudget[effort] || effortToBudget['medium'];
+        return {
+            thinkingBudget: budget,
+            includeThoughts: true
+        };
+    }
+
+    /**
+     * 获取默认安全设置
+     */
+    getDefaultSafetySettings() {
+        return [
+            { category: "HARM_CATEGORY_HARASSMENT", threshold: "OFF" },
+            { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "OFF" },
+            { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "OFF" },
+            { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "OFF" },
+            { category: "HARM_CATEGORY_CIVIC_INTEGRITY", threshold: "OFF" }
+        ];
+    }
+
+    /**
+     * 处理OpenAI内容到Gemini parts
+     */
+    processOpenAIContentToGeminiParts(content) {
+        if (!content) return [];
+        if (typeof content === 'string') return [{ text: content }];
+
+        if (Array.isArray(content)) {
+            const parts = [];
+
+            for (const item of content) {
+                if (!item) continue;
+
+                if (item.type === 'text' && item.text) {
+                    parts.push({ text: item.text });
+                } else if (item.type === 'image_url' && item.image_url) {
+                    const imageUrl = typeof item.image_url === 'string'
+                        ? item.image_url
+                        : item.image_url.url;
+
+                    if (imageUrl.startsWith('data:')) {
+                        const [header, data] = imageUrl.split(',');
+                        const mimeType = header.match(/data:([^;]+)/)?.[1] || 'image/jpeg';
+                        parts.push({ inlineData: { mimeType, data } });
+                    } else {
+                        parts.push({
+                            fileData: { mimeType: 'image/jpeg', fileUri: imageUrl }
+                        });
+                    }
+                }
+            }
+
+            return parts;
+        }
+
+        return [];
+    }
+
+    /**
+     * 构建Gemini工具配置
+     */
+    buildGeminiToolConfig(toolChoice) {
+        if (typeof toolChoice === 'string' && ['none', 'auto'].includes(toolChoice)) {
+            return { functionCallingConfig: { mode: toolChoice.toUpperCase() } };
+        }
+        if (typeof toolChoice === 'object' && toolChoice.function) {
+            return { functionCallingConfig: { mode: 'ANY', allowedFunctionNames: [toolChoice.function.name] } };
+        }
+        return null;
+    }
+
+    /**
+     * 构建Gemini生成配置
+     */
+    buildGeminiGenerationConfig({ temperature, max_tokens, top_p, stop, tools, response_format }, model) {
+        const config = {};
+        config.temperature = checkAndAssignOrDefault(temperature, GEMINI_DEFAULT_TEMPERATURE);
+        config.maxOutputTokens = checkAndAssignOrDefault(max_tokens, GEMINI_DEFAULT_MAX_TOKENS);
+        config.topP = checkAndAssignOrDefault(top_p, GEMINI_DEFAULT_TOP_P);
+        if (stop !== undefined) config.stopSequences = Array.isArray(stop) ? stop : [stop];
+
+        // Handle response_format
+        if (response_format) {
+            if (response_format.type === 'json_object') {
+                config.responseMimeType = 'application/json';
+            } else if (response_format.type === 'json_schema' && response_format.json_schema) {
+                config.responseMimeType = 'application/json';
+                if (response_format.json_schema.schema) {
+                    config.responseSchema = response_format.json_schema.schema;
+                }
+            }
+        }
+
+        // Gemini 2.5 and thinking models require responseModalities: ["TEXT"]
+        // But this parameter cannot be added when using tools (causes 400 error)
+        const hasTools = tools && Array.isArray(tools) && tools.length > 0;
+        if (!hasTools && model && (model.includes('2.5') || model.includes('thinking') || model.includes('2.0-flash-thinking'))) {
+            console.log(`[OpenAI->Gemini] Adding responseModalities: ["TEXT"] for model: ${model}`);
+            config.responseModalities = ["TEXT"];
+        } else if (hasTools && model && (model.includes('2.5') || model.includes('thinking') || model.includes('2.0-flash-thinking'))) {
+            console.log(`[OpenAI->Gemini] Skipping responseModalities for model ${model} because tools are present`);
+        }
+
+        return config;
+    }
+    /**
+     * 将OpenAI响应转换为Gemini响应格式
+     */
+    toGeminiResponse(openaiResponse, model) {
+        if (!openaiResponse || !openaiResponse.choices || !openaiResponse.choices[0]) {
+            return { candidates: [], usageMetadata: {} };
+        }
+
+        const choice = openaiResponse.choices[0];
+        const message = choice.message || {};
+        const parts = [];
+
+        // 处理文本内容
+        if (message.content) {
+            parts.push({ text: message.content });
+        }
+
+        // 处理工具调用
+        if (message.tool_calls && message.tool_calls.length > 0) {
+            for (const toolCall of message.tool_calls) {
+                if (toolCall.type === 'function') {
+                    parts.push({
+                        functionCall: {
+                            name: toolCall.function.name,
+                            args: typeof toolCall.function.arguments === 'string'
+                                ? JSON.parse(toolCall.function.arguments)
+                                : toolCall.function.arguments
+                        }
+                    });
+                }
+            }
+        }
+
+        // 映射finish_reason
+        const finishReasonMap = {
+            'stop': 'STOP',
+            'length': 'MAX_TOKENS',
+            'tool_calls': 'STOP',
+            'content_filter': 'SAFETY'
+        };
+
+        return {
+            candidates: [{
+                content: {
+                    role: 'model',
+                    parts: parts
+                },
+                finishReason: finishReasonMap[choice.finish_reason] || 'STOP'
+            }],
+            usageMetadata: openaiResponse.usage ? {
+                promptTokenCount: openaiResponse.usage.prompt_tokens || 0,
+                candidatesTokenCount: openaiResponse.usage.completion_tokens || 0,
+                totalTokenCount: openaiResponse.usage.total_tokens || 0,
+                cachedContentTokenCount: openaiResponse.usage.prompt_tokens_details?.cached_tokens || 0,
+                promptTokensDetails: [{
+                    modality: "TEXT",
+                    tokenCount: openaiResponse.usage.prompt_tokens || 0
+                }],
+                candidatesTokensDetails: [{
+                    modality: "TEXT",
+                    tokenCount: openaiResponse.usage.completion_tokens || 0
+                }],
+                thoughtsTokenCount: openaiResponse.usage.completion_tokens_details?.reasoning_tokens || 0
+            } : {}
+        };
+    }
+
+    /**
+     * 将OpenAI流式响应块转换为Gemini流式响应格式
+     */
+    toGeminiStreamChunk(openaiChunk, model) {
+        if (!openaiChunk || !openaiChunk.choices || !openaiChunk.choices[0]) {
+            return null;
+        }
+
+        const choice = openaiChunk.choices[0];
+        const delta = choice.delta || {};
+        const parts = [];
+
+        // 处理文本内容
+        if (delta.content) {
+            parts.push({ text: delta.content });
+        }
+
+        // 处理工具调用
+        if (delta.tool_calls && delta.tool_calls.length > 0) {
+            for (const toolCall of delta.tool_calls) {
+                if (toolCall.function) {
+                    const functionCall = {
+                        name: toolCall.function.name || '',
+                        args: {}
+                    };
+
+                    if (toolCall.function.arguments) {
+                        try {
+                            functionCall.args = typeof toolCall.function.arguments === 'string'
+                                ? JSON.parse(toolCall.function.arguments)
+                                : toolCall.function.arguments;
+                        } catch (e) {
+                            // 部分参数，保持为字符串
+                            functionCall.args = { partial: toolCall.function.arguments };
+                        }
+                    }
+
+                    parts.push({ functionCall });
+                }
+            }
+        }
+
+        const result = {
+            candidates: [{
+                content: {
+                    role: 'model',
+                    parts: parts
+                }
+            }]
+        };
+
+        // 添加finish_reason（如果存在）
+        if (choice.finish_reason) {
+            const finishReasonMap = {
+                'stop': 'STOP',
+                'length': 'MAX_TOKENS',
+                'tool_calls': 'STOP',
+                'content_filter': 'SAFETY'
+            };
+            result.candidates[0].finishReason = finishReasonMap[choice.finish_reason] || 'STOP';
+        }
+
+        // 添加usage信息（如果存在）
+        if (openaiChunk.usage) {
+            result.usageMetadata = {
+                promptTokenCount: openaiChunk.usage.prompt_tokens || 0,
+                candidatesTokenCount: openaiChunk.usage.completion_tokens || 0,
+                totalTokenCount: openaiChunk.usage.total_tokens || 0,
+                cachedContentTokenCount: openaiChunk.usage.prompt_tokens_details?.cached_tokens || 0,
+                promptTokensDetails: [{
+                    modality: "TEXT",
+                    tokenCount: openaiChunk.usage.prompt_tokens || 0
+                }],
+                candidatesTokensDetails: [{
+                    modality: "TEXT",
+                    tokenCount: openaiChunk.usage.completion_tokens || 0
+                }],
+                thoughtsTokenCount: openaiChunk.usage.completion_tokens_details?.reasoning_tokens || 0
+            };
+        }
+
+        return result;
+    }
+
+    /**
+     * OpenAI请求 -> Codex请求（委托给 CodexConverter）
+     */
+    toCodexRequest(openaiRequest) {
+        return this.codexConverter.toCodexRequest(openaiRequest);
+    }
+
+    /**
+     * 将OpenAI请求转换为OpenAI Responses格式
+     */
+    toOpenAIResponsesRequest(openaiRequest) {
+        const responsesRequest = {
+            model: openaiRequest.model,
+            messages: []
+        };
+
+        // 转换messages
+        if (openaiRequest.messages && openaiRequest.messages.length > 0) {
+            responsesRequest.messages = openaiRequest.messages.map(msg => ({
+                role: msg.role,
+                content: typeof msg.content === 'string'
+                    ? [{ type: 'input_text', text: msg.content }]
+                    : msg.content
+            }));
+        }
+
+        // 转换其他参数
+        if (openaiRequest.temperature !== undefined) {
+            responsesRequest.temperature = openaiRequest.temperature;
+        }
+        if (openaiRequest.max_tokens !== undefined) {
+            responsesRequest.max_output_tokens = openaiRequest.max_tokens;
+        }
+        if (openaiRequest.top_p !== undefined) {
+            responsesRequest.top_p = openaiRequest.top_p;
+        }
+        if (openaiRequest.tools) {
+            responsesRequest.tools = openaiRequest.tools;
+        }
+        if (openaiRequest.tool_choice) {
+            responsesRequest.tool_choice = openaiRequest.tool_choice;
+        }
+
+        return responsesRequest;
+    }
+
+    /**
+     * 将OpenAI响应转换为OpenAI Responses格式
+     */
+    toOpenAIResponsesResponse(openaiResponse, model) {
+        if (!openaiResponse || !openaiResponse.choices || !openaiResponse.choices[0]) {
+            return {
+                id: `resp_${Date.now()}`,
+                object: 'response',
+                created_at: Math.floor(Date.now() / 1000),
+                status: 'completed',
+                model: model || 'unknown',
+                output: [],
+                usage: {
+                    input_tokens: 0,
+                    output_tokens: 0,
+                    total_tokens: 0
+                }
+            };
+        }
+
+        const choice = openaiResponse.choices[0];
+        const message = choice.message || {};
+        const output = [];
+
+        // 构建message输出
+        const messageContent = [];
+        if (message.content) {
+            messageContent.push({
+                type: 'output_text',
+                text: message.content
+            });
+        }
+
+        output.push({
+            type: 'message',
+            id: `msg_${Date.now()}`,
+            status: 'completed',
+            role: 'assistant',
+            content: messageContent
+        });
+
+        return {
+            id: openaiResponse.id || `resp_${Date.now()}`,
+            object: 'response',
+            created_at: openaiResponse.created || Math.floor(Date.now() / 1000),
+            status: choice.finish_reason === 'stop' ? 'completed' : 'in_progress',
+            model: model || openaiResponse.model || 'unknown',
+            output: output,
+            usage: openaiResponse.usage ? {
+                input_tokens: openaiResponse.usage.prompt_tokens || 0,
+                input_tokens_details: {
+                    cached_tokens: openaiResponse.usage.prompt_tokens_details?.cached_tokens || 0
+                },
+                output_tokens: openaiResponse.usage.completion_tokens || 0,
+                output_tokens_details: {
+                    reasoning_tokens: openaiResponse.usage.completion_tokens_details?.reasoning_tokens || 0
+                },
+                total_tokens: openaiResponse.usage.total_tokens || 0
+            } : {
+                input_tokens: 0,
+                input_tokens_details: {
+                    cached_tokens: 0
+                },
+                output_tokens: 0,
+                output_tokens_details: {
+                    reasoning_tokens: 0
+                },
+                total_tokens: 0
+            }
+        };
+    }
+
+    /**
+     * 将OpenAI流式响应转换为OpenAI Responses流式格式
+     * 参考 ClaudeConverter.toOpenAIResponsesStreamChunk 的实现逻辑
+     */
+    toOpenAIResponsesStreamChunk(openaiChunk, model, requestId = null) {
+        if (!openaiChunk || !openaiChunk.choices || !openaiChunk.choices[0]) {
+            return [];
+        }
+
+        const responseId = requestId || `resp_${uuidv4().replace(/-/g, '')}`;
+        const choice = openaiChunk.choices[0];
+        const delta = choice.delta || {};
+        const events = [];
+
+        // 第一个chunk - role为assistant时调用 getOpenAIResponsesStreamChunkBegin
+        if (delta.role === 'assistant') {
+            events.push(
+                generateResponseCreated(responseId, model || openaiChunk.model || 'unknown'),
+                generateResponseInProgress(responseId),
+                generateOutputItemAdded(responseId),
+                generateContentPartAdded(responseId)
+            );
+        }
+
+        // 处理 reasoning_content（推理内容）
+        if (delta.reasoning_content) {
+            events.push({
+                delta: delta.reasoning_content,
+                item_id: `thinking_${uuidv4().replace(/-/g, '')}`,
+                output_index: 0,
+                sequence_number: 3,
+                type: "response.reasoning_summary_text.delta"
+            });
+        }
+
+        // 处理 tool_calls（工具调用）
+        if (delta.tool_calls && delta.tool_calls.length > 0) {
+            for (const toolCall of delta.tool_calls) {
+                const outputIndex = toolCall.index || 0;
+
+                // 如果有 function.name，说明是工具调用开始
+                if (toolCall.function && toolCall.function.name) {
+                    events.push({
+                        item: {
+                            id: toolCall.id || `call_${uuidv4().replace(/-/g, '')}`,
+                            type: "function_call",
+                            name: toolCall.function.name,
+                            arguments: "",
+                            status: "in_progress"
+                        },
+                        output_index: outputIndex,
+                        sequence_number: 2,
+                        type: "response.output_item.added"
+                    });
+                }
+
+                // 如果有 function.arguments，说明是参数增量
+                if (toolCall.function && toolCall.function.arguments) {
+                    events.push({
+                        delta: toolCall.function.arguments,
+                        item_id: toolCall.id || `call_${uuidv4().replace(/-/g, '')}`,
+                        output_index: outputIndex,
+                        sequence_number: 3,
+                        type: "response.custom_tool_call_input.delta"
+                    });
+                }
+            }
+        }
+
+        // 处理普通文本内容
+        if (delta.content) {
+            events.push({
+                delta: delta.content,
+                item_id: `msg_${uuidv4().replace(/-/g, '')}`,
+                output_index: 0,
+                sequence_number: 3,
+                type: "response.output_text.delta"
+            });
+        }
+
+        // 处理完成状态 - 调用 getOpenAIResponsesStreamChunkEnd
+        if (choice.finish_reason) {
+            events.push(
+                generateOutputTextDone(responseId),
+                generateContentPartDone(responseId),
+                generateOutputItemDone(responseId),
+                generateResponseCompleted(responseId)
+            );
+
+            // 如果有 usage 信息，更新最后一个事件
+            if (openaiChunk.usage && events.length > 0) {
+                const lastEvent = events[events.length - 1];
+                if (lastEvent.response) {
+                    lastEvent.response.usage = {
+                        input_tokens: openaiChunk.usage.prompt_tokens || 0,
+                        input_tokens_details: {
+                            cached_tokens: openaiChunk.usage.prompt_tokens_details?.cached_tokens || 0
+                        },
+                        output_tokens: openaiChunk.usage.completion_tokens || 0,
+                        output_tokens_details: {
+                            reasoning_tokens: openaiChunk.usage.completion_tokens_details?.reasoning_tokens || 0
+                        },
+                        total_tokens: openaiChunk.usage.total_tokens || 0
+                    };
+                }
+            }
+        }
+
+        return events;
+    }
+
+}
+
+export default OpenAIConverter;

src/converters/strategies/OpenAIResponsesConverter.js

@@ -0,0 +1,582 @@
+/**
+ * OpenAI Responses API 转换器
+ * 处理 OpenAI Responses API 格式与其他协议之间的转换
+ */
+
+import { BaseConverter } from '../BaseConverter.js';
+import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
+import {
+    extractAndProcessSystemMessages as extractSystemMessages,
+    extractTextFromMessageContent as extractText,
+    CLAUDE_DEFAULT_MAX_TOKENS,
+    GEMINI_DEFAULT_INPUT_TOKEN_LIMIT,
+    GEMINI_DEFAULT_OUTPUT_TOKEN_LIMIT
+} from '../utils.js';
+
+/**
+ * OpenAI Responses API 转换器类
+ * 支持 OpenAI Responses 格式与 OpenAI、Claude、Gemini 之间的转换
+ */
+export class OpenAIResponsesConverter extends BaseConverter {
+    constructor() {
+        super(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
+    }
+
+    // =============================================================================
+    // 请求转换
+    // =============================================================================
+
+    /**
+     * 转换请求到目标协议
+     */
+    convertRequest(data, toProtocol) {
+        switch (toProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIRequest(data);
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeRequest(data);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiRequest(data);
+            default:
+                throw new Error(`Unsupported target protocol: ${toProtocol}`);
+        }
+    }
+
+    /**
+     * 转换响应到目标协议
+     */
+    convertResponse(data, toProtocol, model) {
+        switch (toProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIResponse(data, model);
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeResponse(data, model);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiResponse(data, model);
+            default:
+                throw new Error(`Unsupported target protocol: ${toProtocol}`);
+        }
+    }
+
+    /**
+     * 转换流式响应块到目标协议
+     */
+    convertStreamChunk(chunk, toProtocol, model) {
+        switch (toProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIStreamChunk(chunk, model);
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeStreamChunk(chunk, model);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiStreamChunk(chunk, model);
+            default:
+                throw new Error(`Unsupported target protocol: ${toProtocol}`);
+        }
+    }
+
+    /**
+     * 转换模型列表到目标协议
+     */
+    convertModelList(data, targetProtocol) {
+        switch (targetProtocol) {
+            case MODEL_PROTOCOL_PREFIX.OPENAI:
+                return this.toOpenAIModelList(data);
+            case MODEL_PROTOCOL_PREFIX.CLAUDE:
+                return this.toClaudeModelList(data);
+            case MODEL_PROTOCOL_PREFIX.GEMINI:
+                return this.toGeminiModelList(data);
+            default:
+                return data;
+        }
+    }
+
+    // =============================================================================
+    // 转换到 OpenAI 格式
+    // =============================================================================
+
+    /**
+     * 将 OpenAI Responses 请求转换为标准 OpenAI 请求
+     */
+    toOpenAIRequest(responsesRequest) {
+        const openaiRequest = {
+            model: responsesRequest.model,
+            messages: [],
+            stream: responsesRequest.stream || false
+        };
+
+        // OpenAI Responses API 使用 instructions 和 input 字段
+        // 需要转换为标准的 messages 格式
+        if (responsesRequest.instructions) {
+            // instructions 作为系统消息
+            openaiRequest.messages.push({
+                role: 'system',
+                content: responsesRequest.instructions
+            });
+        }
+
+        // input 包含用户消息和历史对话
+        if (responsesRequest.input && Array.isArray(responsesRequest.input)) {
+            responsesRequest.input.forEach(item => {
+                if (item.type === 'message') {
+                    // 提取消息内容
+                    const content = item.content
+                        .filter(c => c.type === 'input_text')
+                        .map(c => c.text)
+                        .join('\n');
+                    
+                    if (content) {
+                        openaiRequest.messages.push({
+                            role: item.role,
+                            content: content
+                        });
+                    }
+                }
+            });
+        }
+
+        // 如果有标准的 messages 字段，也支持
+        if (responsesRequest.messages && Array.isArray(responsesRequest.messages)) {
+            responsesRequest.messages.forEach(msg => {
+                openaiRequest.messages.push({
+                    role: msg.role,
+                    content: msg.content
+                });
+            });
+        }
+
+        // 复制其他参数
+        if (responsesRequest.temperature !== undefined) {
+            openaiRequest.temperature = responsesRequest.temperature;
+        }
+        if (responsesRequest.max_tokens !== undefined) {
+            openaiRequest.max_tokens = responsesRequest.max_tokens;
+        }
+        if (responsesRequest.top_p !== undefined) {
+            openaiRequest.top_p = responsesRequest.top_p;
+        }
+
+        return openaiRequest;
+    }
+
+    /**
+     * 将 OpenAI Responses 响应转换为标准 OpenAI 响应
+     */
+    toOpenAIResponse(responsesResponse, model) {
+        // OpenAI Responses 格式已经很接近标准 OpenAI 格式
+        return {
+            id: responsesResponse.id || `chatcmpl-${Date.now()}`,
+            object: 'chat.completion',
+            created: responsesResponse.created || Math.floor(Date.now() / 1000),
+            model: model || responsesResponse.model,
+            choices: responsesResponse.choices || [{
+                index: 0,
+                message: {
+                    role: 'assistant',
+                    content: responsesResponse.content || ''
+                },
+                finish_reason: responsesResponse.finish_reason || 'stop'
+            }],
+            usage: responsesResponse.usage ? {
+                prompt_tokens: responsesResponse.usage.input_tokens || 0,
+                completion_tokens: responsesResponse.usage.output_tokens || 0,
+                total_tokens: responsesResponse.usage.total_tokens || 0,
+                prompt_tokens_details: {
+                    cached_tokens: responsesResponse.usage.input_tokens_details?.cached_tokens || 0
+                },
+                completion_tokens_details: {
+                    reasoning_tokens: responsesResponse.usage.output_tokens_details?.reasoning_tokens || 0
+                }
+            } : {
+                prompt_tokens: 0,
+                completion_tokens: 0,
+                total_tokens: 0,
+                prompt_tokens_details: {
+                    cached_tokens: 0
+                },
+                completion_tokens_details: {
+                    reasoning_tokens: 0
+                }
+            }
+        };
+    }
+
+    /**
+     * 将 OpenAI Responses 流式块转换为标准 OpenAI 流式块
+     */
+    toOpenAIStreamChunk(responsesChunk, model) {
+        return {
+            id: responsesChunk.id || `chatcmpl-${Date.now()}`,
+            object: 'chat.completion.chunk',
+            created: responsesChunk.created || Math.floor(Date.now() / 1000),
+            model: model || responsesChunk.model,
+            choices: responsesChunk.choices || [{
+                index: 0,
+                delta: {
+                    content: responsesChunk.delta?.content || ''
+                },
+                finish_reason: responsesChunk.finish_reason || null
+            }]
+        };
+    }
+
+    // =============================================================================
+    // 转换到 Claude 格式
+    // =============================================================================
+
+    /**
+     * 将 OpenAI Responses 请求转换为 Claude 请求
+     */
+    toClaudeRequest(responsesRequest) {
+        const claudeRequest = {
+            model: responsesRequest.model,
+            messages: [],
+            max_tokens: responsesRequest.max_tokens || CLAUDE_DEFAULT_MAX_TOKENS,
+            stream: responsesRequest.stream || false
+        };
+
+        // 处理 instructions 作为系统消息
+        if (responsesRequest.instructions) {
+            claudeRequest.system = responsesRequest.instructions;
+        }
+
+        // 处理 input 数组中的消息
+        if (responsesRequest.input && Array.isArray(responsesRequest.input)) {
+            responsesRequest.input.forEach(item => {
+                if (item.type === 'message') {
+                    const content = item.content
+                        .filter(c => c.type === 'input_text')
+                        .map(c => c.text)
+                        .join('\n');
+                    
+                    if (content) {
+                        claudeRequest.messages.push({
+                            role: item.role === 'assistant' ? 'assistant' : 'user',
+                            content: content
+                        });
+                    }
+                }
+            });
+        }
+
+        // 如果有标准的 messages 字段，也支持
+        if (responsesRequest.messages && Array.isArray(responsesRequest.messages)) {
+            const { systemMessages, otherMessages } = extractSystemMessages(
+                responsesRequest.messages
+            );
+            
+            if (!claudeRequest.system && systemMessages.length > 0) {
+                const systemTexts = systemMessages.map(msg => extractText(msg.content));
+                claudeRequest.system = systemTexts.join('\n');
+            }
+
+            otherMessages.forEach(msg => {
+                claudeRequest.messages.push({
+                    role: msg.role === 'assistant' ? 'assistant' : 'user',
+                    content: typeof msg.content === 'string' ? msg.content : extractText(msg.content)
+                });
+            });
+        }
+
+        // 复制其他参数
+        if (responsesRequest.temperature !== undefined) {
+            claudeRequest.temperature = responsesRequest.temperature;
+        }
+        if (responsesRequest.top_p !== undefined) {
+            claudeRequest.top_p = responsesRequest.top_p;
+        }
+
+        return claudeRequest;
+    }
+
+    /**
+     * 将 OpenAI Responses 响应转换为 Claude 响应
+     */
+    toClaudeResponse(responsesResponse, model) {
+        const content = responsesResponse.choices?.[0]?.message?.content || 
+                       responsesResponse.content || '';
+
+        return {
+            id: responsesResponse.id || `msg_${Date.now()}`,
+            type: 'message',
+            role: 'assistant',
+            content: [{
+                type: 'text',
+                text: content
+            }],
+            model: model || responsesResponse.model,
+            stop_reason: responsesResponse.choices?.[0]?.finish_reason || 'end_turn',
+            usage: {
+                input_tokens: responsesResponse.usage?.input_tokens || responsesResponse.usage?.prompt_tokens || 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: responsesResponse.usage?.input_tokens_details?.cached_tokens || 0,
+                output_tokens: responsesResponse.usage?.output_tokens || responsesResponse.usage?.completion_tokens || 0,
+                prompt_tokens: responsesResponse.usage?.input_tokens || responsesResponse.usage?.prompt_tokens || 0,
+                completion_tokens: responsesResponse.usage?.output_tokens || responsesResponse.usage?.completion_tokens || 0,
+                total_tokens: responsesResponse.usage?.total_tokens ||
+                    ((responsesResponse.usage?.input_tokens || responsesResponse.usage?.prompt_tokens || 0) +
+                     (responsesResponse.usage?.output_tokens || responsesResponse.usage?.completion_tokens || 0)),
+                cached_tokens: responsesResponse.usage?.input_tokens_details?.cached_tokens || 0
+            }
+        };
+    }
+
+    /**
+     * 将 OpenAI Responses 流式块转换为 Claude 流式块
+     */
+    toClaudeStreamChunk(responsesChunk, model) {
+        const delta = responsesChunk.choices?.[0]?.delta || responsesChunk.delta || {};
+        const finishReason = responsesChunk.choices?.[0]?.finish_reason || 
+                           responsesChunk.finish_reason;
+
+        if (finishReason) {
+            return {
+                type: 'message_stop'
+            };
+        }
+
+        if (delta.content) {
+            return {
+                type: 'content_block_delta',
+                index: 0,
+                delta: {
+                    type: 'text_delta',
+                    text: delta.content
+                }
+            };
+        }
+
+        return {
+            type: 'message_start',
+            message: {
+                id: responsesChunk.id || `msg_${Date.now()}`,
+                type: 'message',
+                role: 'assistant',
+                content: [],
+                model: model || responsesChunk.model
+            }
+        };
+    }
+
+    // =============================================================================
+    // 转换到 Gemini 格式
+    // =============================================================================
+
+    /**
+     * 将 OpenAI Responses 请求转换为 Gemini 请求
+     */
+    toGeminiRequest(responsesRequest) {
+        const geminiRequest = {
+            contents: [],
+            generationConfig: {}
+        };
+
+        // 处理 instructions 作为系统指令
+        if (responsesRequest.instructions) {
+            geminiRequest.systemInstruction = {
+                parts: [{
+                    text: responsesRequest.instructions
+                }]
+            };
+        }
+
+        // 处理 input 数组中的消息
+        if (responsesRequest.input && Array.isArray(responsesRequest.input)) {
+            responsesRequest.input.forEach(item => {
+                // 如果 item 没有 type 属性，默认为 message
+                // 或者 item.type 明确为 message
+                if (!item.type || item.type === 'message') {
+                    let content = '';
+                    if (Array.isArray(item.content)) {
+                        content = item.content
+                            .filter(c => c.type === 'input_text')
+                            .map(c => c.text)
+                            .join('\n');
+                    } else if (typeof item.content === 'string') {
+                        content = item.content;
+                    }
+                    
+                    if (content) {
+                        geminiRequest.contents.push({
+                            role: item.role === 'assistant' ? 'model' : 'user',
+                            parts: [{
+                                text: content
+                            }]
+                        });
+                    }
+                }
+            });
+        }
+
+        // 如果有标准的 messages 字段，也支持
+        if (responsesRequest.messages && Array.isArray(responsesRequest.messages)) {
+            const { systemMessages, otherMessages } = extractSystemMessages(
+                responsesRequest.messages
+            );
+
+            if (!geminiRequest.systemInstruction && systemMessages.length > 0) {
+                const systemTexts = systemMessages.map(msg => extractText(msg.content));
+                geminiRequest.systemInstruction = {
+                    parts: [{
+                        text: systemTexts.join('\n')
+                    }]
+                };
+            }
+
+            otherMessages.forEach(msg => {
+                geminiRequest.contents.push({
+                    role: msg.role === 'assistant' ? 'model' : 'user',
+                    parts: [{
+                        text: typeof msg.content === 'string' ? msg.content : extractText(msg.content)
+                    }]
+                });
+            });
+        }
+
+        // 设置生成配置
+        if (responsesRequest.temperature !== undefined) {
+            geminiRequest.generationConfig.temperature = responsesRequest.temperature;
+        }
+        if (responsesRequest.max_tokens !== undefined) {
+            geminiRequest.generationConfig.maxOutputTokens = responsesRequest.max_tokens;
+        }
+        if (responsesRequest.top_p !== undefined) {
+            geminiRequest.generationConfig.topP = responsesRequest.top_p;
+        }
+
+        return geminiRequest;
+    }
+
+    /**
+     * 将 OpenAI Responses 响应转换为 Gemini 响应
+     */
+    toGeminiResponse(responsesResponse, model) {
+        const content = responsesResponse.choices?.[0]?.message?.content || 
+                       responsesResponse.content || '';
+
+        return {
+            candidates: [{
+                content: {
+                    parts: [{
+                        text: content
+                    }],
+                    role: 'model'
+                },
+                finishReason: this.mapFinishReason(
+                    responsesResponse.choices?.[0]?.finish_reason || 'STOP'
+                ),
+                index: 0
+            }],
+            usageMetadata: {
+                promptTokenCount: responsesResponse.usage?.input_tokens || responsesResponse.usage?.prompt_tokens || 0,
+                candidatesTokenCount: responsesResponse.usage?.output_tokens || responsesResponse.usage?.completion_tokens || 0,
+                totalTokenCount: responsesResponse.usage?.total_tokens ||
+                    ((responsesResponse.usage?.input_tokens || responsesResponse.usage?.prompt_tokens || 0) +
+                     (responsesResponse.usage?.output_tokens || responsesResponse.usage?.completion_tokens || 0)),
+                cachedContentTokenCount: responsesResponse.usage?.input_tokens_details?.cached_tokens || 0,
+                promptTokensDetails: [{
+                    modality: "TEXT",
+                    tokenCount: responsesResponse.usage?.input_tokens || responsesResponse.usage?.prompt_tokens || 0
+                }],
+                candidatesTokensDetails: [{
+                    modality: "TEXT",
+                    tokenCount: responsesResponse.usage?.output_tokens || responsesResponse.usage?.completion_tokens || 0
+                }],
+                thoughtsTokenCount: responsesResponse.usage?.output_tokens_details?.reasoning_tokens || 0
+            }
+        };
+    }
+
+    /**
+     * 将 OpenAI Responses 流式块转换为 Gemini 流式块
+     */
+    toGeminiStreamChunk(responsesChunk, model) {
+        const delta = responsesChunk.choices?.[0]?.delta || responsesChunk.delta || {};
+        const finishReason = responsesChunk.choices?.[0]?.finish_reason || 
+                           responsesChunk.finish_reason;
+
+        return {
+            candidates: [{
+                content: {
+                    parts: delta.content ? [{
+                        text: delta.content
+                    }] : [],
+                    role: 'model'
+                },
+                finishReason: finishReason ? this.mapFinishReason(finishReason) : null,
+                index: 0
+            }]
+        };
+    }
+
+    // =============================================================================
+    // 辅助方法
+    // =============================================================================
+
+    /**
+     * 映射完成原因
+     */
+    mapFinishReason(reason) {
+        const reasonMap = {
+            'stop': 'STOP',
+            'length': 'MAX_TOKENS',
+            'content_filter': 'SAFETY',
+            'end_turn': 'STOP'
+        };
+        return reasonMap[reason] || 'STOP';
+    }
+
+    /**
+     * 将 OpenAI Responses 模型列表转换为标准 OpenAI 模型列表
+     */
+    toOpenAIModelList(responsesModels) {
+        // OpenAI Responses 格式的模型列表已经是标准 OpenAI 格式
+        // 如果输入已经是标准格式,直接返回
+        if (responsesModels.object === 'list' && responsesModels.data) {
+            return responsesModels;
+        }
+
+        // 如果是其他格式,转换为标准格式
+        return {
+            object: "list",
+            data: (responsesModels.models || responsesModels.data || []).map(m => ({
+                id: m.id || m.name,
+                object: "model",
+                created: m.created || Math.floor(Date.now() / 1000),
+                owned_by: m.owned_by || "openai",
+            })),
+        };
+    }
+
+    /**
+     * 将 OpenAI Responses 模型列表转换为 Claude 模型列表
+     */
+    toClaudeModelList(responsesModels) {
+        const models = responsesModels.data || responsesModels.models || [];
+        return {
+            models: models.map(m => ({
+                name: m.id || m.name,
+                description: m.description || "",
+            })),
+        };
+    }
+
+    /**
+     * 将 OpenAI Responses 模型列表转换为 Gemini 模型列表
+     */
+    toGeminiModelList(responsesModels) {
+        const models = responsesModels.data || responsesModels.models || [];
+        return {
+            models: models.map(m => ({
+                name: `models/${m.id || m.name}`,
+                version: m.version || "1.0.0",
+                displayName: m.displayName || m.id || m.name,
+                description: m.description || `A generative model for text and chat generation. ID: ${m.id || m.name}`,
+                inputTokenLimit: m.inputTokenLimit || GEMINI_DEFAULT_INPUT_TOKEN_LIMIT,
+                outputTokenLimit: m.outputTokenLimit || GEMINI_DEFAULT_OUTPUT_TOKEN_LIMIT,
+                supportedGenerationMethods: m.supportedGenerationMethods || ["generateContent", "streamGenerateContent"]
+            }))
+        };
+    }
+
+}
+

src/converters/utils.js

@@ -0,0 +1,433 @@
+/**
+ * 转换器公共工具函数模块
+ * 提供各种协议转换所需的通用辅助函数
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+
+// =============================================================================
+// 常量定义
+// =============================================================================
+
+// 通用默认值
+export const DEFAULT_MAX_TOKENS = 8192;
+export const DEFAULT_TEMPERATURE = 1;
+export const DEFAULT_TOP_P = 0.95;
+
+// =============================================================================
+// OpenAI 相关常量
+// =============================================================================
+export const OPENAI_DEFAULT_MAX_TOKENS = 128000;
+export const OPENAI_DEFAULT_TEMPERATURE = 1;
+export const OPENAI_DEFAULT_TOP_P = 0.95;
+export const OPENAI_DEFAULT_INPUT_TOKEN_LIMIT = 32768;
+export const OPENAI_DEFAULT_OUTPUT_TOKEN_LIMIT = 128000;
+
+// =============================================================================
+// Claude 相关常量
+// =============================================================================
+export const CLAUDE_DEFAULT_MAX_TOKENS = 200000;
+export const CLAUDE_DEFAULT_TEMPERATURE = 1;
+export const CLAUDE_DEFAULT_TOP_P = 0.95;
+
+// =============================================================================
+// Gemini 相关常量
+// =============================================================================
+export const GEMINI_DEFAULT_MAX_TOKENS = 65534;
+export const GEMINI_DEFAULT_TEMPERATURE = 1;
+export const GEMINI_DEFAULT_TOP_P = 0.95;
+export const GEMINI_DEFAULT_INPUT_TOKEN_LIMIT = 32768;
+export const GEMINI_DEFAULT_OUTPUT_TOKEN_LIMIT = 65534;
+
+// =============================================================================
+// OpenAI Responses 相关常量
+// =============================================================================
+export const OPENAI_RESPONSES_DEFAULT_MAX_TOKENS = 128000;
+export const OPENAI_RESPONSES_DEFAULT_TEMPERATURE = 1;
+export const OPENAI_RESPONSES_DEFAULT_TOP_P = 0.95;
+export const OPENAI_RESPONSES_DEFAULT_INPUT_TOKEN_LIMIT = 32768;
+export const OPENAI_RESPONSES_DEFAULT_OUTPUT_TOKEN_LIMIT = 128000;
+
+// =============================================================================
+// Ollama 相关常量
+// =============================================================================
+export const OLLAMA_DEFAULT_CONTEXT_LENGTH = 65534;
+export const OLLAMA_DEFAULT_MAX_OUTPUT_TOKENS = 8192;
+
+// Claude 模型上下文长度
+export const OLLAMA_CLAUDE_DEFAULT_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_SONNET_45_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_SONNET_45_MAX_OUTPUT_TOKENS = 200000;
+export const OLLAMA_CLAUDE_HAIKU_45_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_HAIKU_45_MAX_OUTPUT_TOKENS = 200000;
+export const OLLAMA_CLAUDE_OPUS_41_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_OPUS_41_MAX_OUTPUT_TOKENS = 32000;
+export const OLLAMA_CLAUDE_SONNET_40_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_SONNET_40_MAX_OUTPUT_TOKENS = 200000;
+export const OLLAMA_CLAUDE_SONNET_37_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_SONNET_37_MAX_OUTPUT_TOKENS = 200000;
+export const OLLAMA_CLAUDE_OPUS_40_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_OPUS_40_MAX_OUTPUT_TOKENS = 32000;
+export const OLLAMA_CLAUDE_HAIKU_35_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_HAIKU_35_MAX_OUTPUT_TOKENS = 200000;
+export const OLLAMA_CLAUDE_HAIKU_30_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_HAIKU_30_MAX_OUTPUT_TOKENS = 8192;
+export const OLLAMA_CLAUDE_SONNET_35_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_SONNET_35_MAX_OUTPUT_TOKENS = 200000;
+export const OLLAMA_CLAUDE_OPUS_30_CONTEXT_LENGTH = 200000;
+export const OLLAMA_CLAUDE_OPUS_30_MAX_OUTPUT_TOKENS = 8192;
+
+// Gemini 模型上下文长度
+export const OLLAMA_GEMINI_25_PRO_CONTEXT_LENGTH = 1048576;
+export const OLLAMA_GEMINI_25_PRO_MAX_OUTPUT_TOKENS = 65534;
+export const OLLAMA_GEMINI_25_FLASH_CONTEXT_LENGTH = 1048576;
+export const OLLAMA_GEMINI_25_FLASH_MAX_OUTPUT_TOKENS = 65534;
+export const OLLAMA_GEMINI_25_IMAGE_CONTEXT_LENGTH = 65534;
+export const OLLAMA_GEMINI_25_IMAGE_MAX_OUTPUT_TOKENS = 32768;
+export const OLLAMA_GEMINI_25_LIVE_CONTEXT_LENGTH = 131072;
+export const OLLAMA_GEMINI_25_LIVE_MAX_OUTPUT_TOKENS = 65534;
+export const OLLAMA_GEMINI_25_TTS_CONTEXT_LENGTH = 65534;
+export const OLLAMA_GEMINI_25_TTS_MAX_OUTPUT_TOKENS = 16384;
+export const OLLAMA_GEMINI_20_FLASH_CONTEXT_LENGTH = 1048576;
+export const OLLAMA_GEMINI_20_FLASH_MAX_OUTPUT_TOKENS = 65534;
+export const OLLAMA_GEMINI_20_IMAGE_CONTEXT_LENGTH = 32768;
+export const OLLAMA_GEMINI_20_IMAGE_MAX_OUTPUT_TOKENS = 65534;
+export const OLLAMA_GEMINI_15_PRO_CONTEXT_LENGTH = 2097152;
+export const OLLAMA_GEMINI_15_PRO_MAX_OUTPUT_TOKENS = 65534;
+export const OLLAMA_GEMINI_15_FLASH_CONTEXT_LENGTH = 1048576;
+export const OLLAMA_GEMINI_15_FLASH_MAX_OUTPUT_TOKENS = 65534;
+export const OLLAMA_GEMINI_DEFAULT_CONTEXT_LENGTH = 1048576;
+export const OLLAMA_GEMINI_DEFAULT_MAX_OUTPUT_TOKENS = 65534;
+
+// GPT 模型上下文长度
+export const OLLAMA_GPT4_TURBO_CONTEXT_LENGTH = 128000;
+export const OLLAMA_GPT4_TURBO_MAX_OUTPUT_TOKENS = 8192;
+export const OLLAMA_GPT4_32K_CONTEXT_LENGTH = 32768;
+export const OLLAMA_GPT4_32K_MAX_OUTPUT_TOKENS = 8192;
+export const OLLAMA_GPT4_BASE_CONTEXT_LENGTH = 200000;
+export const OLLAMA_GPT4_BASE_MAX_OUTPUT_TOKENS = 8192;
+export const OLLAMA_GPT35_16K_CONTEXT_LENGTH = 16385;
+export const OLLAMA_GPT35_16K_MAX_OUTPUT_TOKENS = 8192;
+export const OLLAMA_GPT35_BASE_CONTEXT_LENGTH = 8192;
+export const OLLAMA_GPT35_BASE_MAX_OUTPUT_TOKENS = 8192;
+
+// Qwen 模型上下文长度
+export const OLLAMA_QWEN_CODER_PLUS_CONTEXT_LENGTH = 128000;
+export const OLLAMA_QWEN_CODER_PLUS_MAX_OUTPUT_TOKENS = 65534;
+export const OLLAMA_QWEN_VL_PLUS_CONTEXT_LENGTH = 262144;
+export const OLLAMA_QWEN_VL_PLUS_MAX_OUTPUT_TOKENS = 32768;
+export const OLLAMA_QWEN_CODER_FLASH_CONTEXT_LENGTH = 128000;
+export const OLLAMA_QWEN_CODER_FLASH_MAX_OUTPUT_TOKENS = 65534;
+export const OLLAMA_QWEN_DEFAULT_CONTEXT_LENGTH = 32768;
+export const OLLAMA_QWEN_DEFAULT_MAX_OUTPUT_TOKENS = 200000;
+
+export const OLLAMA_DEFAULT_FILE_TYPE = 2;
+export const OLLAMA_DEFAULT_QUANTIZATION_VERSION = 2;
+export const OLLAMA_DEFAULT_ROPE_FREQ_BASE = 10000.0;
+export const OLLAMA_DEFAULT_TEMPERATURE = 0.7;
+export const OLLAMA_DEFAULT_TOP_P = 0.9;
+export const OLLAMA_DEFAULT_QUANTIZATION_LEVEL = 'Q4_0';
+export const OLLAMA_SHOW_QUANTIZATION_LEVEL = 'Q4_K_M';
+
+// =============================================================================
+// 通用辅助函数
+// =============================================================================
+
+/**
+ * 判断值是否为 undefined 或 0，并返回默认值
+ * @param {*} value - 要检查的值
+ * @param {*} defaultValue - 默认值
+ * @returns {*} 处理后的值
+ */
+export function checkAndAssignOrDefault(value, defaultValue) {
+    if (value !== undefined && value !== 0) {
+        return value;
+    }
+    return defaultValue;
+}
+
+/**
+ * 生成唯一ID
+ * @param {string} prefix - ID前缀
+ * @returns {string} 生成的ID
+ */
+export function generateId(prefix = '') {
+    return prefix ? `${prefix}_${uuidv4()}` : uuidv4();
+}
+
+/**
+ * 安全解析JSON字符串
+ * @param {string} str - JSON字符串
+ * @returns {*} 解析后的对象或原始字符串
+ */
+export function safeParseJSON(str) {
+    if (!str) {
+        return str;
+    }
+    let cleanedStr = str;
+
+    // 处理可能被截断的转义序列
+    if (cleanedStr.endsWith('\\') && !cleanedStr.endsWith('\\\\')) {
+        cleanedStr = cleanedStr.substring(0, cleanedStr.length - 1);
+    } else if (cleanedStr.endsWith('\\u') || cleanedStr.endsWith('\\u0') || cleanedStr.endsWith('\\u00')) {
+        const idx = cleanedStr.lastIndexOf('\\u');
+        cleanedStr = cleanedStr.substring(0, idx);
+    }
+
+    try {
+        return JSON.parse(cleanedStr || '{}');
+    } catch (e) {
+        return str;
+    }
+}
+
+/**
+ * 提取消息内容中的文本
+ * @param {string|Array} content - 消息内容
+ * @returns {string} 提取的文本
+ */
+export function extractTextFromMessageContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content
+            .filter(part => part.type === 'text' && part.text)
+            .map(part => part.text)
+            .join('\n');
+    }
+    return '';
+}
+
+/**
+ * 提取并处理系统消息
+ * @param {Array} messages - 消息数组
+ * @returns {{systemInstruction: Object|null, nonSystemMessages: Array}}
+ */
+export function extractAndProcessSystemMessages(messages) {
+    const systemContents = [];
+    const nonSystemMessages = [];
+
+    for (const message of messages) {
+        if (message.role === 'system') {
+            systemContents.push(extractTextFromMessageContent(message.content));
+        } else {
+            nonSystemMessages.push(message);
+        }
+    }
+
+    let systemInstruction = null;
+    if (systemContents.length > 0) {
+        systemInstruction = {
+            parts: [{
+                text: systemContents.join('\n')
+            }]
+        };
+    }
+    return { systemInstruction, nonSystemMessages };
+}
+
+/**
+ * 清理JSON Schema属性（移除Gemini不支持的属性）
+ * Google Gemini API 只支持有限的 JSON Schema 属性，不支持以下属性：
+ * - exclusiveMinimum, exclusiveMaximum, minimum, maximum
+ * - minLength, maxLength, minItems, maxItems
+ * - pattern, format, default, const
+ * - additionalProperties, $schema, $ref, $id
+ * - allOf, anyOf, oneOf, not
+ * @param {Object} schema - JSON Schema
+ * @returns {Object} 清理后的JSON Schema
+ */
+export function cleanJsonSchemaProperties(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+
+    // 如果是数组，递归处理每个元素
+    if (Array.isArray(schema)) {
+        return schema.map(item => cleanJsonSchemaProperties(item));
+    }
+
+    // Gemini 支持的 JSON Schema 属性白名���
+    const allowedKeys = [
+        "type",
+        "description",
+        "properties",
+        "required",
+        "enum",
+        "items",
+        "nullable"
+    ];
+
+    const sanitized = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (allowedKeys.includes(key)) {
+            // 对于需要递归处理的属性
+            if (key === 'properties' && typeof value === 'object' && value !== null) {
+                const cleanProperties = {};
+                for (const [propName, propSchema] of Object.entries(value)) {
+                    cleanProperties[propName] = cleanJsonSchemaProperties(propSchema);
+                }
+                sanitized[key] = cleanProperties;
+            } else if (key === 'items') {
+                sanitized[key] = cleanJsonSchemaProperties(value);
+            } else {
+                sanitized[key] = value;
+            }
+        }
+        // 其他属性（如 exclusiveMinimum, minimum, maximum, pattern 等）被忽略
+    }
+
+    return sanitized;
+}
+
+/**
+ * 映射结束原因
+ * @param {string} reason - 结束原因
+ * @param {string} sourceFormat - 源格式
+ * @param {string} targetFormat - 目标格式
+ * @returns {string} 映射后的结束原因
+ */
+export function mapFinishReason(reason, sourceFormat, targetFormat) {
+    const reasonMappings = {
+        openai: {
+            anthropic: {
+                stop: "end_turn",
+                length: "max_tokens",
+                content_filter: "stop_sequence",
+                tool_calls: "tool_use"
+            }
+        },
+        gemini: {
+            anthropic: {
+                STOP: "end_turn",
+                MAX_TOKENS: "max_tokens",
+                SAFETY: "stop_sequence",
+                RECITATION: "stop_sequence",
+                stop: "end_turn",
+                length: "max_tokens",
+                safety: "stop_sequence",
+                recitation: "stop_sequence",
+                other: "end_turn"
+            }
+        }
+    };
+
+    try {
+        return reasonMappings[sourceFormat][targetFormat][reason] || "end_turn";
+    } catch (e) {
+        return "end_turn";
+    }
+}
+
+/**
+ * 根据budget_tokens智能判断OpenAI reasoning_effort等级
+ * @param {number|null} budgetTokens - Anthropic thinking的budget_tokens值
+ * @returns {string} OpenAI reasoning_effort等级
+ */
+export function determineReasoningEffortFromBudget(budgetTokens) {
+    if (budgetTokens === null || budgetTokens === undefined) {
+        console.info("No budget_tokens provided, defaulting to reasoning_effort='high'");
+        return "high";
+    }
+
+    const LOW_THRESHOLD = 50;
+    const HIGH_THRESHOLD = 200;
+
+    console.debug(`Threshold configuration: low <= ${LOW_THRESHOLD}, medium <= ${HIGH_THRESHOLD}, high > ${HIGH_THRESHOLD}`);
+
+    let effort;
+    if (budgetTokens <= LOW_THRESHOLD) {
+        effort = "low";
+    } else if (budgetTokens <= HIGH_THRESHOLD) {
+        effort = "medium";
+    } else {
+        effort = "high";
+    }
+
+    console.info(`🎯 Budget tokens ${budgetTokens} -> reasoning_effort '${effort}' (thresholds: low<=${LOW_THRESHOLD}, high<=${HIGH_THRESHOLD})`);
+    return effort;
+}
+
+/**
+ * 从OpenAI文本中提取thinking内容
+ * @param {string} text - 文本内容
+ * @returns {string|Array} 提取后的内容
+ */
+export function extractThinkingFromOpenAIText(text) {
+    const thinkingPattern = /<thinking>\s*(.*?)\s*<\/thinking>/gs;
+    const matches = [...text.matchAll(thinkingPattern)];
+
+    const contentBlocks = [];
+    let lastEnd = 0;
+
+    for (const match of matches) {
+        const beforeText = text.substring(lastEnd, match.index).trim();
+        if (beforeText) {
+            contentBlocks.push({
+                type: "text",
+                text: beforeText
+            });
+        }
+
+        const thinkingText = match[1].trim();
+        if (thinkingText) {
+            contentBlocks.push({
+                type: "thinking",
+                thinking: thinkingText
+            });
+        }
+
+        lastEnd = match.index + match[0].length;
+    }
+
+    const afterText = text.substring(lastEnd).trim();
+    if (afterText) {
+        contentBlocks.push({
+            type: "text",
+            text: afterText
+        });
+    }
+
+    if (contentBlocks.length === 0) {
+        return text;
+    }
+
+    if (contentBlocks.length === 1 && contentBlocks[0].type === "text") {
+        return contentBlocks[0].text;
+    }
+
+    return contentBlocks;
+}
+
+// =============================================================================
+// 工具状态管理器（单例模式）
+// =============================================================================
+
+/**
+ * 全局工具状态管理器
+ */
+class ToolStateManager {
+    constructor() {
+        if (ToolStateManager.instance) {
+            return ToolStateManager.instance;
+        }
+        ToolStateManager.instance = this;
+        this._toolMappings = {};
+        return this;
+    }
+
+    storeToolMapping(funcName, toolId) {
+        this._toolMappings[funcName] = toolId;
+    }
+
+    getToolId(funcName) {
+        return this._toolMappings[funcName] || null;
+    }
+
+    clearMappings() {
+        this._toolMappings = {};
+    }
+}
+
+export const toolStateManager = new ToolStateManager();

src/core/config-manager.js

@@ -0,0 +1,257 @@
+import * as fs from 'fs';
+import { promises as pfs } from 'fs';
+import { INPUT_SYSTEM_PROMPT_FILE, MODEL_PROVIDER } from '../utils/common.js';
+
+export let CONFIG = {}; // Make CONFIG exportable
+export let PROMPT_LOG_FILENAME = ''; // Make PROMPT_LOG_FILENAME exportable
+
+const ALL_MODEL_PROVIDERS = Object.values(MODEL_PROVIDER);
+
+function normalizeConfiguredProviders(config) {
+    const fallbackProvider = MODEL_PROVIDER.GEMINI_CLI;
+    const dedupedProviders = [];
+
+    const addProvider = (value) => {
+        if (typeof value !== 'string') {
+            return;
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return;
+        }
+        const matched = ALL_MODEL_PROVIDERS.find((provider) => provider.toLowerCase() === trimmed.toLowerCase());
+        if (!matched) {
+            console.warn(`[Config Warning] Unknown model provider '${trimmed}'. This entry will be ignored.`);
+            return;
+        }
+        if (!dedupedProviders.includes(matched)) {
+            dedupedProviders.push(matched);
+        }
+    };
+
+    const rawValue = config.MODEL_PROVIDER;
+    if (Array.isArray(rawValue)) {
+        rawValue.forEach((entry) => addProvider(typeof entry === 'string' ? entry : String(entry)));
+    } else if (typeof rawValue === 'string') {
+        rawValue.split(',').forEach(addProvider);
+    } else if (rawValue != null) {
+        addProvider(String(rawValue));
+    }
+
+    if (dedupedProviders.length === 0) {
+        dedupedProviders.push(fallbackProvider);
+    }
+
+    config.DEFAULT_MODEL_PROVIDERS = dedupedProviders;
+    config.MODEL_PROVIDER = dedupedProviders[0];
+}
+
+/**
+ * Initializes the server configuration from config.json and command-line arguments.
+ * @param {string[]} args - Command-line arguments.
+ * @param {string} [configFilePath='configs/config.json'] - Path to the configuration file.
+ * @returns {Object} The initialized configuration object.
+ */
+export async function initializeConfig(args = process.argv.slice(2), configFilePath = 'configs/config.json') {
+    let currentConfig = {};
+
+    try {
+        const configData = fs.readFileSync(configFilePath, 'utf8');
+        currentConfig = JSON.parse(configData);
+        console.log('[Config] Loaded configuration from configs/config.json');
+    } catch (error) {
+        console.error('[Config Error] Failed to load configs/config.json:', error.message);
+        // Fallback to default values if config.json is not found or invalid
+        currentConfig = {
+            REQUIRED_API_KEY: "123456",
+            SERVER_PORT: 3000,
+            HOST: '0.0.0.0',
+            MODEL_PROVIDER: MODEL_PROVIDER.GEMINI_CLI,
+            SYSTEM_PROMPT_FILE_PATH: INPUT_SYSTEM_PROMPT_FILE, // Default value
+            SYSTEM_PROMPT_MODE: 'append',
+            PROXY_URL: null, // HTTP/HTTPS/SOCKS5 代理地址，如 http://127.0.0.1:7890 或 socks5://127.0.0.1:1080
+            PROXY_ENABLED_PROVIDERS: [], // 启用代理的提供商列表，如 ['gemini-cli-oauth', 'claude-kiro-oauth']
+            PROMPT_LOG_BASE_NAME: "prompt_log",
+            PROMPT_LOG_MODE: "none",
+            REQUEST_MAX_RETRIES: 3,
+            REQUEST_BASE_DELAY: 1000,
+            CREDENTIAL_SWITCH_MAX_RETRIES: 5, // 坏凭证切换最大重试次数（用于认证错误后切换凭证）
+            CRON_NEAR_MINUTES: 15,
+            CRON_REFRESH_TOKEN: false,
+            PROVIDER_POOLS_FILE_PATH: null, // 新增号池配置文件路径
+            MAX_ERROR_COUNT: 10, // 提供商最大错误次数
+            providerFallbackChain: {} // 跨类型 Fallback 链配置
+        };
+        console.log('[Config] Using default configuration.');
+    }
+
+    // Parse command-line arguments
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--api-key') {
+            if (i + 1 < args.length) {
+                currentConfig.REQUIRED_API_KEY = args[i + 1];
+                i++;
+            } else {
+                console.warn(`[Config Warning] --api-key flag requires a value.`);
+            }
+        } else if (args[i] === '--log-prompts') {
+            if (i + 1 < args.length) {
+                const mode = args[i + 1];
+                if (mode === 'console' || mode === 'file') {
+                    currentConfig.PROMPT_LOG_MODE = mode;
+                } else {
+                    console.warn(`[Config Warning] Invalid mode for --log-prompts. Expected 'console' or 'file'. Prompt logging is disabled.`);
+                }
+                i++;
+            } else {
+                console.warn(`[Config Warning] --log-prompts flag requires a value.`);
+            }
+        } else if (args[i] === '--port') {
+            if (i + 1 < args.length) {
+                currentConfig.SERVER_PORT = parseInt(args[i + 1], 10);
+                i++;
+            } else {
+                console.warn(`[Config Warning] --port flag requires a value.`);
+            }
+        } else if (args[i] === '--model-provider') {
+            if (i + 1 < args.length) {
+                currentConfig.MODEL_PROVIDER = args[i + 1];
+                i++;
+            } else {
+                console.warn(`[Config Warning] --model-provider flag requires a value.`);
+            }
+        } else if (args[i] === '--system-prompt-file') {
+            if (i + 1 < args.length) {
+                currentConfig.SYSTEM_PROMPT_FILE_PATH = args[i + 1];
+                i++;
+            } else {
+                console.warn(`[Config Warning] --system-prompt-file flag requires a value.`);
+            }
+        } else if (args[i] === '--system-prompt-mode') {
+            if (i + 1 < args.length) {
+                const mode = args[i + 1];
+                if (mode === 'overwrite' || mode === 'append') {
+                    currentConfig.SYSTEM_PROMPT_MODE = mode;
+                } else {
+                    console.warn(`[Config Warning] Invalid mode for --system-prompt-mode. Expected 'overwrite' or 'append'. Using default 'overwrite'.`);
+                }
+                i++;
+            } else {
+                console.warn(`[Config Warning] --system-prompt-mode flag requires a value.`);
+            }
+        } else if (args[i] === '--host') {
+            if (i + 1 < args.length) {
+                currentConfig.HOST = args[i + 1];
+                i++;
+            } else {
+                console.warn(`[Config Warning] --host flag requires a value.`);
+            }
+        } else if (args[i] === '--prompt-log-base-name') {
+            if (i + 1 < args.length) {
+                currentConfig.PROMPT_LOG_BASE_NAME = args[i + 1];
+                i++;
+            } else {
+                console.warn(`[Config Warning] --prompt-log-base-name flag requires a value.`);
+            }
+        } else if (args[i] === '--cron-near-minutes') {
+            if (i + 1 < args.length) {
+                currentConfig.CRON_NEAR_MINUTES = parseInt(args[i + 1], 10);
+                i++;
+            } else {
+                console.warn(`[Config Warning] --cron-near-minutes flag requires a value.`);
+            }
+        } else if (args[i] === '--cron-refresh-token') {
+            if (i + 1 < args.length) {
+                currentConfig.CRON_REFRESH_TOKEN = args[i + 1].toLowerCase() === 'true';
+                i++;
+            } else {
+                console.warn(`[Config Warning] --cron-refresh-token flag requires a value.`);
+            }
+        } else if (args[i] === '--provider-pools-file') {
+            if (i + 1 < args.length) {
+                currentConfig.PROVIDER_POOLS_FILE_PATH = args[i + 1];
+                i++;
+            } else {
+                console.warn(`[Config Warning] --provider-pools-file flag requires a value.`);
+            }
+        } else if (args[i] === '--max-error-count') {
+            if (i + 1 < args.length) {
+                currentConfig.MAX_ERROR_COUNT = parseInt(args[i + 1], 10);
+                i++;
+            } else {
+                console.warn(`[Config Warning] --max-error-count flag requires a value.`);
+            }
+        }
+    }
+
+    normalizeConfiguredProviders(currentConfig);
+
+    if (!currentConfig.SYSTEM_PROMPT_FILE_PATH) {
+        currentConfig.SYSTEM_PROMPT_FILE_PATH = INPUT_SYSTEM_PROMPT_FILE;
+    }
+    currentConfig.SYSTEM_PROMPT_CONTENT = await getSystemPromptFileContent(currentConfig.SYSTEM_PROMPT_FILE_PATH);
+
+    // 加载号池配置
+    if (!currentConfig.PROVIDER_POOLS_FILE_PATH) {
+        currentConfig.PROVIDER_POOLS_FILE_PATH = 'configs/provider_pools.json';
+    }
+    if (currentConfig.PROVIDER_POOLS_FILE_PATH) {
+        try {
+            const poolsData = await pfs.readFile(currentConfig.PROVIDER_POOLS_FILE_PATH, 'utf8');
+            currentConfig.providerPools = JSON.parse(poolsData);
+            console.log(`[Config] Loaded provider pools from ${currentConfig.PROVIDER_POOLS_FILE_PATH}`);
+        } catch (error) {
+            console.error(`[Config Error] Failed to load provider pools from ${currentConfig.PROVIDER_POOLS_FILE_PATH}: ${error.message}`);
+            currentConfig.providerPools = {};
+        }
+    } else {
+        currentConfig.providerPools = {};
+    }
+
+    // Set PROMPT_LOG_FILENAME based on the determined config
+    if (currentConfig.PROMPT_LOG_MODE === 'file') {
+        const now = new Date();
+        const pad = (num) => String(num).padStart(2, '0');
+        const timestamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+        PROMPT_LOG_FILENAME = `${currentConfig.PROMPT_LOG_BASE_NAME}-${timestamp}.log`;
+    } else {
+        PROMPT_LOG_FILENAME = ''; // Clear if not logging to file
+    }
+
+    // Assign to the exported CONFIG
+    Object.assign(CONFIG, currentConfig);
+    return CONFIG;
+}
+
+/**
+ * Gets system prompt content from the specified file path.
+ * @param {string} filePath - Path to the system prompt file.
+ * @returns {Promise<string|null>} File content, or null if the file does not exist, is empty, or an error occurs.
+ */
+export async function getSystemPromptFileContent(filePath) {
+    try {
+        await pfs.access(filePath, pfs.constants.F_OK);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            console.warn(`[System Prompt] Specified system prompt file not found: ${filePath}`);
+        } else {
+            console.error(`[System Prompt] Error accessing system prompt file ${filePath}: ${error.message}`);
+        }
+        return null;
+    }
+
+    try {
+        const content = await pfs.readFile(filePath, 'utf8');
+        if (!content.trim()) {
+            return null;
+        }
+        console.log(`[System Prompt] Loaded system prompt from ${filePath}`);
+        return content;
+    } catch (error) {
+        console.error(`[System Prompt] Error reading system prompt file ${filePath}: ${error.message}`);
+        return null;
+    }
+}
+
+export { ALL_MODEL_PROVIDERS };
+

src/core/master.js

@@ -0,0 +1,378 @@
+/**
+ * 主进程 (Master Process)
+ * 
+ * 负责管理子进程的生命周期，包括：
+ * - 启动子进程
+ * - 监控子进程状态
+ * - 处理子进程重启请求
+ * - 提供 IPC 通信
+ * 
+ * 使用方式：
+ * node src/core/master.js [原有的命令行参数]
+ */
+
+import { fork } from 'child_process';
+import * as http from 'http';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 子进程实例
+let workerProcess = null;
+
+// 子进程状态
+let workerStatus = {
+    pid: null,
+    startTime: null,
+    restartCount: 0,
+    lastRestartTime: null,
+    isRestarting: false
+};
+
+// 配置
+const config = {
+    workerScript: path.join(__dirname, '../services/api-server.js'),
+    maxRestartAttempts: 10,
+    restartDelay: 1000, // 重启延迟（毫秒）
+    masterPort: parseInt(process.env.MASTER_PORT) || 3100, // 主进程管理端口
+    args: process.argv.slice(2) // 传递给子进程的参数
+};
+
+/**
+ * 启动子进程
+ */
+function startWorker() {
+    if (workerProcess) {
+        console.log('[Master] Worker process already running, PID:', workerProcess.pid);
+        return;
+    }
+
+    console.log('[Master] Starting worker process...');
+    console.log('[Master] Worker script:', config.workerScript);
+    console.log('[Master] Worker args:', config.args.join(' '));
+
+    workerProcess = fork(config.workerScript, config.args, {
+        stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        env: {
+            ...process.env,
+            IS_WORKER_PROCESS: 'true'
+        }
+    });
+
+    workerStatus.pid = workerProcess.pid;
+    workerStatus.startTime = new Date().toISOString();
+
+    console.log('[Master] Worker process started, PID:', workerProcess.pid);
+
+    // 监听子进程消息
+    workerProcess.on('message', (message) => {
+        console.log('[Master] Received message from worker:', message);
+        handleWorkerMessage(message);
+    });
+
+    // 监听子进程退出
+    workerProcess.on('exit', (code, signal) => {
+        console.log(`[Master] Worker process exited with code ${code}, signal ${signal}`);
+        workerProcess = null;
+        workerStatus.pid = null;
+
+        // 如果不是主动重启导致的退出，尝试自动重启
+        if (!workerStatus.isRestarting && code !== 0) {
+            console.log('[Master] Worker crashed, attempting auto-restart...');
+            scheduleRestart();
+        }
+    });
+
+    // 监听子进程错误
+    workerProcess.on('error', (error) => {
+        console.error('[Master] Worker process error:', error.message);
+    });
+}
+
+/**
+ * 停止子进程
+ * @param {boolean} graceful - 是否优雅关闭
+ * @returns {Promise<void>}
+ */
+function stopWorker(graceful = true) {
+    return new Promise((resolve) => {
+        if (!workerProcess) {
+            console.log('[Master] No worker process to stop');
+            resolve();
+            return;
+        }
+
+        console.log('[Master] Stopping worker process, PID:', workerProcess.pid);
+
+        const timeout = setTimeout(() => {
+            if (workerProcess) {
+                console.log('[Master] Force killing worker process...');
+                workerProcess.kill('SIGKILL');
+            }
+            resolve();
+        }, 5000); // 5秒超时后强制杀死
+
+        workerProcess.once('exit', () => {
+            clearTimeout(timeout);
+            workerProcess = null;
+            workerStatus.pid = null;
+            console.log('[Master] Worker process stopped');
+            resolve();
+        });
+
+        if (graceful) {
+            // 发送优雅关闭信号
+            workerProcess.send({ type: 'shutdown' });
+            workerProcess.kill('SIGTERM');
+        } else {
+            workerProcess.kill('SIGKILL');
+        }
+    });
+}
+
+/**
+ * 重启子进程
+ * @returns {Promise<Object>}
+ */
+async function restartWorker() {
+    if (workerStatus.isRestarting) {
+        console.log('[Master] Restart already in progress');
+        return { success: false, message: 'Restart already in progress' };
+    }
+
+    workerStatus.isRestarting = true;
+    workerStatus.restartCount++;
+    workerStatus.lastRestartTime = new Date().toISOString();
+
+    console.log('[Master] Restarting worker process...');
+
+    try {
+        await stopWorker(true);
+        
+        // 等待一小段时间确保端口释放
+        await new Promise(resolve => setTimeout(resolve, config.restartDelay));
+        
+        startWorker();
+        workerStatus.isRestarting = false;
+
+        return {
+            success: true,
+            message: 'Worker restarted successfully',
+            pid: workerStatus.pid,
+            restartCount: workerStatus.restartCount
+        };
+    } catch (error) {
+        workerStatus.isRestarting = false;
+        console.error('[Master] Failed to restart worker:', error.message);
+        return {
+            success: false,
+            message: 'Failed to restart worker: ' + error.message
+        };
+    }
+}
+
+/**
+ * 计划重启（用于崩溃后自动重启）
+ */
+function scheduleRestart() {
+    if (workerStatus.restartCount >= config.maxRestartAttempts) {
+        console.error('[Master] Max restart attempts reached, giving up');
+        return;
+    }
+
+    const delay = Math.min(config.restartDelay * Math.pow(2, workerStatus.restartCount), 30000);
+    console.log(`[Master] Scheduling restart in ${delay}ms...`);
+
+    setTimeout(() => {
+        restartWorker();
+    }, delay);
+}
+
+/**
+ * 处理来自子进程的消息
+ * @param {Object} message - 消息对象
+ */
+function handleWorkerMessage(message) {
+    if (!message || !message.type) return;
+
+    switch (message.type) {
+        case 'ready':
+            console.log('[Master] Worker is ready');
+            break;
+        case 'restart_request':
+            console.log('[Master] Worker requested restart');
+            restartWorker();
+            break;
+        case 'status':
+            console.log('[Master] Worker status:', message.data);
+            break;
+        default:
+            console.log('[Master] Unknown message type:', message.type);
+    }
+}
+
+/**
+ * 获取状态信息
+ * @returns {Object}
+ */
+function getStatus() {
+    return {
+        master: {
+            pid: process.pid,
+            uptime: process.uptime(),
+            memoryUsage: process.memoryUsage()
+        },
+        worker: {
+            pid: workerStatus.pid,
+            startTime: workerStatus.startTime,
+            restartCount: workerStatus.restartCount,
+            lastRestartTime: workerStatus.lastRestartTime,
+            isRestarting: workerStatus.isRestarting,
+            isRunning: workerProcess !== null
+        }
+    };
+}
+
+/**
+ * 创建主进程管理 HTTP 服务器
+ */
+function createMasterServer() {
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        const path = url.pathname;
+        const method = req.method;
+
+        // 设置 CORS 头
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+
+        if (method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+
+        // 状态端点
+        if (method === 'GET' && path === '/master/status') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(getStatus()));
+            return;
+        }
+
+        // 重启端点
+        if (method === 'POST' && path === '/master/restart') {
+            console.log('[Master] Restart requested via API');
+            const result = await restartWorker();
+            res.writeHead(result.success ? 200 : 500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(result));
+            return;
+        }
+
+        // 停止端点
+        if (method === 'POST' && path === '/master/stop') {
+            console.log('[Master] Stop requested via API');
+            await stopWorker(true);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, message: 'Worker stopped' }));
+            return;
+        }
+
+        // 启动端点
+        if (method === 'POST' && path === '/master/start') {
+            console.log('[Master] Start requested via API');
+            if (workerProcess) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: false, message: 'Worker already running' }));
+                return;
+            }
+            startWorker();
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, message: 'Worker started', pid: workerStatus.pid }));
+            return;
+        }
+
+        // 健康检查
+        if (method === 'GET' && path === '/master/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                status: 'healthy',
+                workerRunning: workerProcess !== null,
+                timestamp: new Date().toISOString()
+            }));
+            return;
+        }
+
+        // 404
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not Found' }));
+    });
+
+    server.listen(config.masterPort, () => {
+        console.log(`[Master] Management server listening on port ${config.masterPort}`);
+        console.log(`[Master] Available endpoints:`);
+        console.log(`  GET  /master/status  - Get master and worker status`);
+        console.log(`  GET  /master/health  - Health check`);
+        console.log(`  POST /master/restart - Restart worker process`);
+        console.log(`  POST /master/stop    - Stop worker process`);
+        console.log(`  POST /master/start   - Start worker process`);
+    });
+
+    return server;
+}
+
+/**
+ * 处理进程信号
+ */
+function setupSignalHandlers() {
+    // 优雅关闭
+    process.on('SIGTERM', async () => {
+        console.log('[Master] Received SIGTERM, shutting down...');
+        await stopWorker(true);
+        process.exit(0);
+    });
+
+    process.on('SIGINT', async () => {
+        console.log('[Master] Received SIGINT, shutting down...');
+        await stopWorker(true);
+        process.exit(0);
+    });
+
+    // 未捕获的异常
+    process.on('uncaughtException', (error) => {
+        console.error('[Master] Uncaught exception:', error);
+    });
+
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error('[Master] Unhandled rejection at:', promise, 'reason:', reason);
+    });
+}
+
+/**
+ * 主函数
+ */
+async function main() {
+    console.log('='.repeat(50));
+    console.log('[Master] AIClient2API Master Process');
+    console.log('[Master] PID:', process.pid);
+    console.log('[Master] Node version:', process.version);
+    console.log('[Master] Working directory:', process.cwd());
+    console.log('='.repeat(50));
+
+    // 设置信号处理
+    setupSignalHandlers();
+
+    // 创建管理服务器
+    createMasterServer();
+
+    // 启动子进程
+    startWorker();
+}
+
+// 启动主进程
+main().catch(error => {
+    console.error('[Master] Failed to start:', error);
+    process.exit(1);
+});

src/core/plugin-manager.js

@@ -0,0 +1,522 @@
+/**
+ * 插件管理器 - 可插拔插件系统核心
+ * 
+ * 功能：
+ * 1. 插件注册与加载
+ * 2. 生命周期管理（init/destroy）
+ * 3. 扩展点管理（中间件、路由、钩子）
+ * 4. 插件配置管理
+ */
+
+import { promises as fs } from 'fs';
+import { existsSync } from 'fs';
+import path from 'path';
+
+// 插件配置文件路径
+const PLUGINS_CONFIG_FILE = path.join(process.cwd(), 'configs', 'plugins.json');
+
+/**
+ * 插件类型常量
+ */
+export const PLUGIN_TYPE = {
+    AUTH: 'auth',           // 认证插件，参与认证流程
+    MIDDLEWARE: 'middleware' // 普通中间件，不参与认证
+};
+
+/**
+ * 插件接口定义（JSDoc 类型）
+ * @typedef {Object} Plugin
+ * @property {string} name - 插件名称（唯一标识）
+ * @property {string} version - 插件版本
+ * @property {string} [description] - 插件描述
+ * @property {string} [type] - 插件类型：'auth'（认证插件）或 'middleware'（普通中间件，默认）
+ * @property {boolean} [enabled] - 是否启用（默认 true）
+ * @property {number} [_priority] - 优先级，数字越小越先执行（默认 100）
+ * @property {boolean} [_builtin] - 是否为内置插件（内置插件最后执行）
+ * @property {Function} [init] - 初始化钩子 (config) => Promise<void>
+ * @property {Function} [destroy] - 销毁钩子 () => Promise<void>
+ * @property {Function} [middleware] - 请求中间件 (req, res, requestUrl, config) => Promise<{handled: boolean, data?: Object}>
+ * @property {Function} [authenticate] - 认证方法（仅 type='auth' 时有效）(req, res, requestUrl, config) => Promise<{handled: boolean, authorized: boolean|null, error?: Object, data?: Object}>
+ * @property {Array<{method: string, path: string|RegExp, handler: Function}>} [routes] - 路由定义
+ * @property {string[]} [staticPaths] - 静态文件路径（相对于 static 目录）
+ * @property {Object} [hooks] - 钩子函数
+ * @property {Function} [hooks.onBeforeRequest] - 请求前钩子 (req, config) => Promise<void>
+ * @property {Function} [hooks.onAfterResponse] - 响应后钩子 (req, res, config) => Promise<void>
+ * @property {Function} [hooks.onContentGenerated] - 内容生成后钩子 (config) => Promise<void>
+ */
+
+/**
+ * 插件管理器类
+ */
+class PluginManager {
+    constructor() {
+        /** @type {Map<string, Plugin>} */
+        this.plugins = new Map();
+        /** @type {Object} */
+        this.pluginsConfig = { plugins: {} };
+        /** @type {boolean} */
+        this.initialized = false;
+    }
+
+    /**
+     * 加载插件配置文件
+     */
+    async loadConfig() {
+        try {
+            if (existsSync(PLUGINS_CONFIG_FILE)) {
+                const content = await fs.readFile(PLUGINS_CONFIG_FILE, 'utf8');
+                this.pluginsConfig = JSON.parse(content);
+            } else {
+                // 扫描 plugins 目录生成默认配置
+                this.pluginsConfig = await this.generateDefaultConfig();
+                await this.saveConfig();
+            }
+        } catch (error) {
+            console.error('[PluginManager] Failed to load config:', error.message);
+            this.pluginsConfig = { plugins: {} };
+        }
+    }
+
+    /**
+     * 扫描 plugins 目录生成默认配置
+     * @returns {Promise<Object>} 默认插件配置
+     */
+    async generateDefaultConfig() {
+        const defaultConfig = { plugins: {} };
+        const pluginsDir = path.join(process.cwd(), 'src', 'plugins');
+        
+        try {
+            if (!existsSync(pluginsDir)) {
+                return defaultConfig;
+            }
+            
+            const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+            
+            for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+                
+                const pluginPath = path.join(pluginsDir, entry.name, 'index.js');
+                if (!existsSync(pluginPath)) continue;
+                
+                try {
+                    // 动态导入插件以获取其元信息
+                    const pluginModule = await import(`file://${pluginPath}`);
+                    const plugin = pluginModule.default || pluginModule;
+                    
+                    if (plugin && plugin.name) {
+                        defaultConfig.plugins[plugin.name] = {
+                            enabled: true,
+                            description: plugin.description || ''
+                        };
+                        console.log(`[PluginManager] Found plugin for default config: ${plugin.name}`);
+                    }
+                } catch (importError) {
+                    // 如果导入失败，使用目录名作为插件名
+                    defaultConfig.plugins[entry.name] = {
+                        enabled: true,
+                        description: ''
+                    };
+                    console.warn(`[PluginManager] Could not import plugin ${entry.name}, using directory name:`, importError.message);
+                }
+            }
+        } catch (error) {
+            console.error('[PluginManager] Failed to scan plugins directory:', error.message);
+        }
+        
+        return defaultConfig;
+    }
+
+    /**
+     * 保存插件配置文件
+     */
+    async saveConfig() {
+        try {
+            const dir = path.dirname(PLUGINS_CONFIG_FILE);
+            if (!existsSync(dir)) {
+                await fs.mkdir(dir, { recursive: true });
+            }
+            await fs.writeFile(PLUGINS_CONFIG_FILE, JSON.stringify(this.pluginsConfig, null, 2), 'utf8');
+        } catch (error) {
+            console.error('[PluginManager] Failed to save config:', error.message);
+        }
+    }
+
+    /**
+     * 注册插件
+     * @param {Plugin} plugin - 插件对象
+     */
+    register(plugin) {
+        if (!plugin.name) {
+            throw new Error('Plugin must have a name');
+        }
+        if (this.plugins.has(plugin.name)) {
+            console.warn(`[PluginManager] Plugin "${plugin.name}" is already registered, skipping`);
+            return;
+        }
+        this.plugins.set(plugin.name, plugin);
+        console.log(`[PluginManager] Registered plugin: ${plugin.name} v${plugin.version || '1.0.0'}`);
+    }
+
+    /**
+     * 初始化所有已启用的插件
+     * @param {Object} config - 服务器配置
+     */
+    async initAll(config) {
+        await this.loadConfig();
+        
+        for (const [name, plugin] of this.plugins) {
+            const pluginConfig = this.pluginsConfig.plugins[name] || {};
+            const enabled = pluginConfig.enabled !== false; // 默认启用
+            
+            if (!enabled) {
+                console.log(`[PluginManager] Plugin "${name}" is disabled, skipping init`);
+                continue;
+            }
+
+            try {
+                if (typeof plugin.init === 'function') {
+                    await plugin.init(config);
+                    console.log(`[PluginManager] Initialized plugin: ${name}`);
+                }
+                plugin._enabled = true;
+            } catch (error) {
+                console.error(`[PluginManager] Failed to init plugin "${name}":`, error.message);
+                plugin._enabled = false;
+            }
+        }
+        
+        this.initialized = true;
+    }
+
+    /**
+     * 销毁所有插件
+     */
+    async destroyAll() {
+        for (const [name, plugin] of this.plugins) {
+            if (!plugin._enabled) continue;
+            
+            try {
+                if (typeof plugin.destroy === 'function') {
+                    await plugin.destroy();
+                    console.log(`[PluginManager] Destroyed plugin: ${name}`);
+                }
+            } catch (error) {
+                console.error(`[PluginManager] Failed to destroy plugin "${name}":`, error.message);
+            }
+        }
+        this.initialized = false;
+    }
+
+    /**
+     * 检查插件是否启用
+     * @param {string} name - 插件名称
+     * @returns {boolean}
+     */
+    isEnabled(name) {
+        const plugin = this.plugins.get(name);
+        return plugin && plugin._enabled === true;
+    }
+
+    /**
+     * 获取所有启用的插件（按优先级排序）
+     * 优先级数字越小越先执行，内置插件（_builtin: true）最后执行
+     * @returns {Plugin[]}
+     */
+    getEnabledPlugins() {
+        return Array.from(this.plugins.values())
+            .filter(p => p._enabled)
+            .sort((a, b) => {
+                // 内置插件排在最后
+                const aBuiltin = a._builtin ? 1 : 0;
+                const bBuiltin = b._builtin ? 1 : 0;
+                if (aBuiltin !== bBuiltin) return aBuiltin - bBuiltin;
+                
+                // 按优先级排序（数字越小越先执行）
+                const aPriority = a._priority || 100;
+                const bPriority = b._priority || 100;
+                return aPriority - bPriority;
+            });
+    }
+
+    /**
+     * 获取所有认证插件（按优先级排序）
+     * @returns {Plugin[]}
+     */
+    getAuthPlugins() {
+        return this.getEnabledPlugins().filter(p =>
+            p.type === PLUGIN_TYPE.AUTH && typeof p.authenticate === 'function'
+        );
+    }
+
+    /**
+     * 获取所有普通中间件插件（按优先级排序）
+     * @returns {Plugin[]}
+     */
+    getMiddlewarePlugins() {
+        return this.getEnabledPlugins().filter(p =>
+            p.type !== PLUGIN_TYPE.AUTH && typeof p.middleware === 'function'
+        );
+    }
+
+    /**
+     * 执行认证流程
+     * 只有 type='auth' 的插件会参与认证
+     *
+     * 认证插件返回值说明：
+     * - { handled: true } - 请求已被处理（如发送了错误响应），停止后续处理
+     * - { authorized: true, data: {...} } - 认证成功，可附带数据
+     * - { authorized: false } - 认证失败，已发送错误响应
+     * - { authorized: null } - 此插件不处理该请求，继续下一个认证插件
+     *
+     * @param {http.IncomingMessage} req - HTTP 请求
+     * @param {http.ServerResponse} res - HTTP 响应
+     * @param {URL} requestUrl - 解析后的 URL
+     * @param {Object} config - 服务器配置
+     * @returns {Promise<{handled: boolean, authorized: boolean}>}
+     */
+    async executeAuth(req, res, requestUrl, config) {
+        const authPlugins = this.getAuthPlugins();
+        
+        for (const plugin of authPlugins) {
+            try {
+                const result = await plugin.authenticate(req, res, requestUrl, config);
+                
+                if (!result) continue;
+                
+                // 如果请求已被处理（如发送了错误响应），停止执行
+                if (result.handled) {
+                    return { handled: true, authorized: false };
+                }
+                
+                // 如果认证失败，停止执行
+                if (result.authorized === false) {
+                    return { handled: true, authorized: false };
+                }
+                
+                // 如果认证成功，合并数据并返回
+                if (result.authorized === true) {
+                    if (result.data) {
+                        Object.assign(config, result.data);
+                    }
+                    return { handled: false, authorized: true };
+                }
+                
+                // authorized === null 表示此插件不处理，继续下一个
+            } catch (error) {
+                console.error(`[PluginManager] Auth error in plugin "${plugin.name}":`, error.message);
+            }
+        }
+        
+        // 没有任何认证插件处理，返回未授权
+        return { handled: false, authorized: false };
+    }
+
+    /**
+     * 执行普通中间件
+     * 只有 type!='auth' 的插件会执行
+     *
+     * 中间件返回值说明：
+     * - { handled: true } - 请求已被处理，停止后续处理
+     * - { handled: false, data: {...} } - 继续处理，可附带数据
+     * - null/undefined - 继续执行下一个中间件
+     *
+     * @param {http.IncomingMessage} req - HTTP 请求
+     * @param {http.ServerResponse} res - HTTP 响应
+     * @param {URL} requestUrl - 解析后的 URL
+     * @param {Object} config - 服务器配置
+     * @returns {Promise<{handled: boolean}>}
+     */
+    async executeMiddleware(req, res, requestUrl, config) {
+        const middlewarePlugins = this.getMiddlewarePlugins();
+        
+        for (const plugin of middlewarePlugins) {
+            try {
+                const result = await plugin.middleware(req, res, requestUrl, config);
+                
+                if (!result) continue;
+                
+                // 如果请求已被处理，停止执行
+                if (result.handled) {
+                    return { handled: true };
+                }
+                
+                // 合并数据
+                if (result.data) {
+                    Object.assign(config, result.data);
+                }
+            } catch (error) {
+                console.error(`[PluginManager] Middleware error in plugin "${plugin.name}":`, error.message);
+            }
+        }
+        
+        return { handled: false };
+    }
+
+    /**
+     * 执行所有插件的路由处理
+     * @param {string} method - HTTP 方法
+     * @param {string} path - 请求路径
+     * @param {http.IncomingMessage} req - HTTP 请求
+     * @param {http.ServerResponse} res - HTTP 响应
+     * @returns {Promise<boolean>} - 是否已处理
+     */
+    async executeRoutes(method, path, req, res) {
+        for (const plugin of this.getEnabledPlugins()) {
+            if (!Array.isArray(plugin.routes)) continue;
+            
+            for (const route of plugin.routes) {
+                const methodMatch = route.method === '*' || route.method.toUpperCase() === method;
+                if (!methodMatch) continue;
+                
+                let pathMatch = false;
+                if (route.path instanceof RegExp) {
+                    pathMatch = route.path.test(path);
+                } else if (typeof route.path === 'string') {
+                    pathMatch = path === route.path || path.startsWith(route.path + '/');
+                }
+                
+                if (pathMatch) {
+                    try {
+                        const handled = await route.handler(method, path, req, res);
+                        if (handled) return true;
+                    } catch (error) {
+                        console.error(`[PluginManager] Route error in plugin "${plugin.name}":`, error.message);
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 获取所有插件的静态文件路径
+     * @returns {string[]}
+     */
+    getStaticPaths() {
+        const paths = [];
+        for (const plugin of this.getEnabledPlugins()) {
+            if (Array.isArray(plugin.staticPaths)) {
+                paths.push(...plugin.staticPaths);
+            }
+        }
+        return paths;
+    }
+
+    /**
+     * 检查路径是否是插件静态文件
+     * @param {string} path - 请求路径
+     * @returns {boolean}
+     */
+    isPluginStaticPath(path) {
+        const staticPaths = this.getStaticPaths();
+        return staticPaths.some(sp => path === sp || path === '/' + sp);
+    }
+
+    /**
+     * 执行钩子函数
+     * @param {string} hookName - 钩子名称
+     * @param  {...any} args - 钩子参数
+     */
+    async executeHook(hookName, ...args) {
+        for (const plugin of this.getEnabledPlugins()) {
+            if (!plugin.hooks || typeof plugin.hooks[hookName] !== 'function') continue;
+            
+            try {
+                await plugin.hooks[hookName](...args);
+            } catch (error) {
+                console.error(`[PluginManager] Hook "${hookName}" error in plugin "${plugin.name}":`, error.message);
+            }
+        }
+    }
+
+    /**
+     * 获取插件列表（用于 API）
+     * @returns {Object[]}
+     */
+    getPluginList() {
+        const list = [];
+        for (const [name, plugin] of this.plugins) {
+            const pluginConfig = this.pluginsConfig.plugins[name] || {};
+            list.push({
+                name: plugin.name,
+                version: plugin.version || '1.0.0',
+                description: plugin.description || pluginConfig.description || '',
+                enabled: plugin._enabled === true,
+                hasMiddleware: typeof plugin.middleware === 'function',
+                hasRoutes: Array.isArray(plugin.routes) && plugin.routes.length > 0,
+                hasHooks: plugin.hooks && Object.keys(plugin.hooks).length > 0
+            });
+        }
+        return list;
+    }
+
+    /**
+     * 启用/禁用插件
+     * @param {string} name - 插件名称
+     * @param {boolean} enabled - 是否启用
+     */
+    async setPluginEnabled(name, enabled) {
+        if (!this.pluginsConfig.plugins[name]) {
+            this.pluginsConfig.plugins[name] = {};
+        }
+        this.pluginsConfig.plugins[name].enabled = enabled;
+        await this.saveConfig();
+        
+        const plugin = this.plugins.get(name);
+        if (plugin) {
+            plugin._enabled = enabled;
+        }
+    }
+}
+
+// 单例实例
+const pluginManager = new PluginManager();
+
+/**
+ * 自动发现并加载插件
+ * 扫描 src/plugins/ 目录下的所有插件
+ */
+export async function discoverPlugins() {
+    const pluginsDir = path.join(process.cwd(), 'src', 'plugins');
+    
+    try {
+        if (!existsSync(pluginsDir)) {
+            await fs.mkdir(pluginsDir, { recursive: true });
+            console.log('[PluginManager] Created plugins directory');
+        }
+        
+        const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+            if (!entry.isDirectory()) continue;
+            
+            const pluginPath = path.join(pluginsDir, entry.name, 'index.js');
+            if (!existsSync(pluginPath)) continue;
+            
+            try {
+                // 动态导入插件
+                const pluginModule = await import(`file://${pluginPath}`);
+                const plugin = pluginModule.default || pluginModule;
+                
+                if (plugin && plugin.name) {
+                    pluginManager.register(plugin);
+                }
+            } catch (error) {
+                console.error(`[PluginManager] Failed to load plugin from ${entry.name}:`, error.message);
+            }
+        }
+    } catch (error) {
+        console.error('[PluginManager] Failed to discover plugins:', error.message);
+    }
+}
+
+/**
+ * 获取插件管理器实例
+ * @returns {PluginManager}
+ */
+export function getPluginManager() {
+    return pluginManager;
+}
+
+// 导出类和实例
+export { PluginManager, pluginManager };

src/example/claude/oldResponse1762501965597.json

@@ -0,0 +1 @@
+{"id":"msg_chatcmpl-690da54ca66df0e03c78831b","type":"message","role":"assistant","content":[{"type":"text","text":"I"}],"model":"claude-haiku-4-5-20251001","stop_reason":"max_tokens","stop_sequence":null,"usage":{"input_tokens":10855,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"output_tokens":1,"prompt_tokens":10855,"cached_tokens":10855,"completion_tokens":1,"total_tokens":10856}}

src/example/claude/oldResponseChunk1762501803864.json

@@ -0,0 +1,19 @@
+{"type":"message_start","message":{"id":"msg_chatcmpl-690da4a34b300f384a5563b3","type":"message","role":"assistant","content":[],"model":"claude-sonnet-4-5-20250929","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":22969,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"output_tokens":0,"service_tier":"standard","prompt_tokens":22969,"cached_tokens":0}}}
+{"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"TodoWrite_3","name":"TodoWrite","input":{}}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"{\""}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"t"}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"odos"}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"\":[{\""}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"content"}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"\":\""}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"读取"}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"当前的"}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"README"}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"文件"}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"\",\""}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"status"}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"\"}"}}
+{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"]}"}}
+{"type":"content_block_stop","index":0}
+{"type":"message_delta","delta":{"stop_reason":"tool_use","stop_sequence":null},"usage":{"input_tokens":22969,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"output_tokens":80,"prompt_tokens":22969,"completion_tokens":80,"total_tokens":23049,"cached_tokens":15872}}
+{"type":"message_stop"}

src/example/claude/originalRequestBody1762501795790.json

@@ -0,0 +1 @@
+{"model":"claude-sonnet-4-5-20250929","messages":[{"role":"user","content":[{"type":"text","text":"<ide_opened_file>The user opened the file d:\\ai\\code\\AIClient2API\\src\\example\\openai\\oldResponse1762501667708.json in the IDE. This may or may not be related to the current task.</ide_opened_file>"},{"type":"text","text":"更新readme，写入一行随机数"}]},{"role":"assistant","content":[{"type":"text","text":"我将帮您更新README文件，添加一行随机数。"},{"type":"tool_use","id":"TodoWrite_0","name":"TodoWrite","input":{"todos":[{"content":"读取当前的README文件","status":"pending","activeForm":"读取当前的README文件"},{"content":"在README文件中添加一行随机数","status":"pending","activeForm":"在README文件中添加一行随机数"},{"content":"保存更新后的README文件","status":"pending","activeForm":"保存更新后的README文件"}]}}]},{"role":"user","content":[{"tool_use_id":"TodoWrite_0","type":"tool_result","content":"Todos have been modified successfully. Ensure that you continue to use the todo list to track your progress. Please proceed with the current tasks if applicable"}]},{"role":"assistant","content":[{"type":"tool_use","id":"TodoWrite_1","name":"TodoWrite","input":{"todos":[{"content":"读取当前的README文件","status":"in_progress","activeForm":"正在读取README文件"},{"content":"在README文件中添加一行随机数","status":"pending","activeForm":"在README文件中添加一行随机数"},{"content":"保存更新后的README文件","status":"pending","activeForm":"保存更新后的README文件"}]}}]},{"role":"user","content":[{"tool_use_id":"TodoWrite_1","type":"tool_result","content":"Todos have been modified successfully. Ensure that you continue to use the todo list to track your progress. Please proceed with the current tasks if applicable"}]},{"role":"assistant","content":[{"type":"tool_use","id":"Read_2","name":"Read","input":{"file_path":"D:\\ai\\code\\AIClient2API\\README.md"},"cache_control":{"type":"ephemeral"}}]},{"role":"user","content":[{"tool_use_id":"Read_2","type":"tool_result","content":"     1→<div align=\"center\">\n     2→\n     3→![logo](src/img/logo-min.webp)\n     4→\n     5→# AIClient-2-API 🚀\n     6→\n     7→**A powerful proxy that can unify the requests of various large model APIs (Gemini CLI, Qwen Code Plus, Kiro Claude...) that are only used within the client into a local OpenAI compatible interface.**\n     8→\n     9→</div>\n    10→\n    11→<div align=\"center\">\n    12→\n    13→<a href=\"https://deepwiki.com/justlovemaki/AIClient-2-API\"><img src=\"https://deepwiki.com/badge.svg\" alt=\"Ask DeepWiki\"  style=\"width: 134px; height: 23px;margin-bottom: 3px;\"></a>\n    14→\n    15→[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)\n    16→[![Node.js](https://img.shields.io/badge/Node.js-≥20.0.0-green.svg)](https://nodejs.org/)\n    17→[![Docker](https://img.shields.io/badge/docker-≥20.0.0-blue.svg)](https://aiproxy.justlikemaki.vip/en/docs/installation/docker-deployment.html)\n    18→\n    19→\n    20→[**中文**](./README-ZH.md) | [**English**](./README.md) | [**日本語**](./README-JA.md) | [**📚 Complete Documentation**](https://aiproxy.justlikemaki.vip/en/)\n    21→\n    22→</div>\n    23→\n    24→`AIClient2API` is an API proxy service that breaks through client limitations, converting free large models originally restricted to client use only (such as Gemini CLI, Qwen Code Plus, Kiro Claude) into standard OpenAI-compatible interfaces that can be called by any application. Built on Node.js, it supports intelligent conversion between three major protocols (OpenAI, Claude, Gemini), enabling tools like Cherry-Studio, NextChat, and Cline to freely use advanced models such as Claude Sonnet 4.5, Gemini 2.5 Flash, and Qwen3 Coder Plus at scale. The project adopts a modular architecture based on strategy and adapter patterns, with built-in account pool management, intelligent polling, automatic failover, and health check mechanisms, ensuring 99.9% service availability.\n    25→\n    26→> [!NOTE]\n    27→> **🎉 Important Milestone**\n    28→>\n    29→> - Thanks to Ruan Yifeng for the recommendation in [Weekly Issue 359](https://www.ruanyifeng.com/blog/2025/08/weekly-issue-359.html)\n    30→>\n    31→> **📅 Version Update Log**\n    32→>\n    33→> - **2025.11.06** - Added support for Gemini 3 Preview, enhanced model compatibility and performance optimization\n    34→> - **2025.10.18** - Kiro open registration, new accounts get 500 credits, full support for Claude Sonnet 4.5\n    35→> - **2025.09.01** - Integrated Qwen Code CLI, added `qwen3-coder-plus` model support\n    36→> - **2025.08.29** - Released account pool management feature, supporting multi-account polling, intelligent failover, and automatic degradation strategies\n    37→>   - Configuration: Add `PROVIDER_POOLS_FILE_PATH` parameter in config.json\n    38→>   - Reference configuration: [provider_pools.json](./provider_pools.json.example)\n    39→\n    40→---\n    41→\n    42→## 💡 Core Advantages\n    43→\n    44→### 🎯 Unified Access, One-Stop Management\n    45→*   **Multi-Model Unified Interface**: Through standard OpenAI-compatible protocol, configure once to access mainstream large models including Gemini, Claude, GPT, Qwen Code, Kimi K2, GLM-4.6\n    46→*   **Flexible Switching Mechanism**: Support dynamic model switching via startup parameters, Path routing, or environment variables to meet different scenario requirements\n    47→*   **Zero-Cost Migration**: Fully compatible with OpenAI API specifications, tools like Cherry-Studio, NextChat, Cline can be used without modification\n    48→*   **Multi-Protocol Intelligent Conversion**: Support intelligent conversion between OpenAI, Claude, and Gemini protocols for cross-protocol model invocation\n    49→    *   Call Claude models using OpenAI protocol: Use `claude-custom` or `claude-kiro-oauth` providers\n    50→    *   Call Gemini models using OpenAI protocol: Use `gemini-cli-oauth` provider\n    51→    *   Call Gemini models using Claude protocol: Use `gemini-cli-oauth` provider\n    52→    *   Call OpenAI models using Claude protocol: Use `openai-custom` or `openai-qwen-oauth` providers\n    53→\n    54→### 🚀 Break Through Limitations, Improve Efficiency\n    55→*   **Bypass Official Restrictions**: Utilize OAuth authorization mechanism to effectively break through rate and quota limits of free APIs like Gemini\n    56→*   **Free Advanced Models**: Use Claude Sonnet 4.5 for free via Kiro API mode, use Qwen3 Coder Plus via Qwen OAuth mode, reducing usage costs\n    57→*   **Intelligent Account Pool Scheduling**: Support multi-account polling, automatic failover, and configuration degradation, ensuring 99.9% service availability\n    58→\n    59→### 🛡️ Secure and Controllable, Data Transparent\n    60→*   **Full-Chain Log Recording**: Capture all request and response data, supporting auditing and debugging\n    61→*   **Private Dataset Construction**: Quickly build proprietary training datasets based on log data\n    62→*   **System Prompt Management**: Support override and append modes, achieving perfect combination of unified base instructions and personalized extensions\n    63→\n    64→### 🔧 Developer-Friendly, Easy to Extend\n    65→*   **Modular Architecture**: Based on strategy and adapter patterns, adding new model providers requires only 3 steps\n    66→*   **Complete Test Coverage**: Integration and unit test coverage 90%+, ensuring code quality\n    67→*   **Containerized Deployment**: Provides Docker support, one-click deployment, cross-platform operation\n    68→*   **MCP Protocol Support**: Perfectly compatible with Model Context Protocol, easily extend functionality\n    69→\n    70→---\n    71→\n    72→## 📑 Quick Navigation\n    73→\n    74→- [🐳 Docker Deployment](https://aiproxy.justlikemaki.vip/en/docs/installation/docker-deployment.html)\n    75→- [🎨 Model Protocol and Provider Relationship Diagram](#-model-protocol-and-provider-relationship-diagram)\n    76→- [🔧 Usage Instructions](#-usage-instructions)\n    77→- [🚀 Project Startup Parameters](#-project-startup-parameters)\n    78→- [📄 Open Source License](#-open-source-license)\n    79→- [🙏 Acknowledgements](#-acknowledgements)\n    80→- [⚠️ Disclaimer](#-disclaimer)\n    81→\n    82→---\n    83→\n    84→## 🎨 Model Protocol and Provider Relationship Diagram\n    85→\n    86→This project supports multiple model providers through different protocols. The following is an overview of their relationships:\n    87→\n    88→*   **OpenAI Protocol (P_OPENAI)**: Implemented by `openai-custom`, `gemini-cli-oauth`, `claude-custom`, `claude-kiro-oauth`, and `openai-qwen-oauth` model providers.\n    89→*   **Claude Protocol (P_CLAUDE)**: Implemented by `claude-custom`, `claude-kiro-oauth`, `gemini-cli-oauth`, `openai-custom`, and `openai-qwen-oauth` model providers.\n    90→*   **Gemini Protocol (P_GEMINI)**: Implemented by `gemini-cli-oauth` model provider.\n    91→\n    92→Detailed relationship diagram:\n    93→\n    94→  ```mermaid\n    95→   \n    96→   graph TD\n    97→       subgraph Core_Protocols[\"Core Protocols\"]\n    98→           P_OPENAI[OpenAI Protocol]\n    99→           P_GEMINI[Gemini Protocol]\n   100→           P_CLAUDE[Claude Protocol]\n   101→       end\n   102→   \n   103→       subgraph Supported_Model_Providers[\"Supported Model Providers\"]\n   104→           MP_OPENAI[openai-custom]\n   105→           MP_GEMINI[gemini-cli-oauth]\n   106→           MP_CLAUDE_C[claude-custom]\n   107→           MP_CLAUDE_K[claude-kiro-oauth]\n   108→           MP_QWEN[openai-qwen-oauth]\n   109→       end\n   110→   \n   111→       P_OPENAI ---|Support| MP_OPENAI\n   112→       P_OPENAI ---|Support| MP_QWEN\n   113→       P_OPENAI ---|Support| MP_GEMINI\n   114→       P_OPENAI ---|Support| MP_CLAUDE_C\n   115→       P_OPENAI ---|Support| MP_CLAUDE_K\n   116→   \n   117→       P_GEMINI ---|Support| MP_GEMINI\n   118→   \n   119→       P_CLAUDE ---|Support| MP_CLAUDE_C\n   120→       P_CLAUDE ---|Support| MP_CLAUDE_K\n   121→       P_CLAUDE ---|Support| MP_GEMINI\n   122→       P_CLAUDE ---|Support| MP_OPENAI\n   123→       P_CLAUDE ---|Support| MP_QWEN\n   124→   \n   125→       style P_OPENAI fill:#f9f,stroke:#333,stroke-width:2px\n   126→       style P_GEMINI fill:#ccf,stroke:#333,stroke-width:2px\n   127→       style P_CLAUDE fill:#cfc,stroke:#333,stroke-width:2px\n   128→\n   129→   ```\n   130→\n   131→---\n   132→\n   133→## 🔧 Usage Instructions\n   134→\n   135→### 📋 Core Features\n   136→\n   137→#### MCP Protocol Support\n   138→This project is fully compatible with **Model Context Protocol (MCP)**, enabling seamless integration with MCP-supporting clients for powerful functional extensions.\n   139→\n   140→#### Multimodal Input Capabilities\n   141→Supports various input types including images and documents, providing richer interactive experiences and more powerful application scenarios.\n   142→\n   143→#### Latest Model Support\n   144→Seamlessly supports the following latest large models, simply configure the corresponding OpenAI or Claude compatible interface in [`config.json`](./config.json):\n   145→*   **Kimi K2** - Moonshot AI's latest flagship model\n   146→*   **GLM-4.5** - Zhipu AI's latest version\n   147→*   **Qwen Code** - Alibaba Tongyi Qianwen code-specific model\n   148→\n   149→---\n   150→\n   151→### 🔐 Authorization Configuration Guide\n   152→\n   153→#### Gemini CLI OAuth Configuration\n   154→1. **Obtain OAuth Credentials**: Visit [Google Cloud Console](https://console.cloud.google.com/) to create a project and enable Gemini API\n   155→2. **First Authorization**: After using Gemini service, the command line will print Google authorization page, copy the page to browser for authorization, then return to command line\n   156→3. **Credential Storage**: After successful authorization, `oauth_creds.json` file will be automatically generated and saved to `~/.gemini` directory\n   157→4. **Project Configuration**: Need to provide a valid Google Cloud project ID, can be specified via startup parameter `--project-id`\n   158→\n   159→#### Qwen Code OAuth Configuration\n   160→1. **First Authorization**: After starting the service, the system will automatically open the authorization page in the browser\n   161→2. **Credential Storage**: After successful authorization, `oauth_creds.json` file will be automatically generated and saved to `~/.qwen` directory\n   162→3. **Recommended Parameters**: Use official default parameters for best results\n   163→   ```json\n   164→   {\n   165→     \"temperature\": 0,\n   166→     \"top_p\": 1\n   167→   }\n   168→   ```\n   169→\n   170→#### Kiro API Configuration\n   171→1. **Environment Preparation**: [Download and install Kiro client](https://aibook.ren/archives/kiro-install)\n   172→2. **Complete Authorization**: Log in to your account in the client to generate `kiro-auth-token.json` credential file\n   173→3. **Best Practice**: Recommended to use with **Claude Code** for optimal experience\n   174→4. **Important Notice**: Kiro service usage policy has been updated, please visit the official website for the latest usage restrictions and terms\n   175→\n   176→#### OpenAI Responses API\n   177→*   **Application Scenario**: Suitable for scenarios requiring structured dialogue using OpenAI Responses API, such as Codex\n   178→*   **Configuration Method**:\n   179→    *   Method 1: Set `MODEL_PROVIDER` to `openaiResponses-custom` in [`config.json`](./config.json)\n   180→    *   Method 2: Use startup parameter `--model-provider openaiResponses-custom`\n   181→    *   Method 3: Use path routing `/openaiResponses-custom`\n   182→*   **Required Parameters**: Provide valid API key and base URL\n   183→\n   184→---\n   185→\n   186→### 🔄 Model Provider Switching\n   187→\n   188→This project provides two flexible model switching methods to meet different usage scenario requirements.\n   189→\n   190→#### Method 1: Startup Parameter Switching\n   191→\n   192→Specify the default model provider via command line parameters:\n   193→\n   194→```bash\n   195→# Use Gemini provider\n   196→node src/api-server.js --model-provider gemini-cli-oauth --project-id your-project-id\n   197→\n   198→# Use Claude Kiro provider\n   199→node src/api-server.js --model-provider claude-kiro-oauth\n   200→\n   201→# Use Qwen provider\n   202→node src/api-server.js --model-provider openai-qwen-oauth\n   203→```\n   204→\n   205→**Available Model Provider Identifiers**:\n   206→- `openai-custom` - Standard OpenAI API\n   207→- `claude-custom` - Official Claude API\n   208→- `gemini-cli-oauth` - Gemini CLI OAuth\n   209→- `claude-kiro-oauth` - Kiro Claude OAuth\n   210→- `openai-qwen-oauth` - Qwen Code OAuth\n   211→- `openaiResponses-custom` - OpenAI Responses API\n   212→\n   213→#### Method 2: Path Routing Switching (Recommended)\n   214→\n   215→Achieve instant switching by specifying provider identifier in API request path:\n   216→\n   217→| Route Path | Description | Use Case |\n   218→|---------|------|---------|\n   219→| `/claude-custom` | Use Claude API from config file | Official Claude API calls |\n   220→| `/claude-kiro-oauth` | Access Claude via Kiro OAuth | Free use of Claude Sonnet 4.5 |\n   221→| `/openai-custom` | Use OpenAI provider to handle requests | Standard OpenAI API calls |\n   222→| `/gemini-cli-oauth` | Access via Gemini CLI OAuth | Break through Gemini free limits |\n   223→| `/openai-qwen-oauth` | Access via Qwen OAuth | Use Qwen Code Plus |\n   224→| `/openaiResponses-custom` | OpenAI Responses API | Structured dialogue scenarios |\n   225→\n   226→**Usage Examples**:\n   227→```bash\n   228→# Configure in programming agents like Cline, Kilo\n   229→API_ENDPOINT=http://localhost:3000/claude-kiro-oauth\n   230→\n   231→# Direct API call\n   232→curl http://localhost:3000/gemini-cli-oauth/v1/chat/completions \\\n   233→  -H \"Content-Type: application/json\" \\\n   234→  -d '{\"model\":\"gemini-2.0-flash-exp\",\"messages\":[...]}'\n   235→```\n   236→\n   237→---\n   238→\n   239→### 📁 Authorization File Storage Paths\n   240→\n   241→Default storage locations for authorization credential files of each service:\n   242→\n   243→| Service | Default Path | Description |\n   244→|------|---------|------|\n   245→| **Gemini** | `~/.gemini/oauth_creds.json` | OAuth authentication credentials |\n   246→| **Kiro** | `~/.aws/sso/cache/kiro-auth-token.json` | Kiro authentication token |\n   247→| **Qwen** | `~/.qwen/oauth_creds.json` | Qwen OAuth credentials |\n   248→\n   249→> **Note**: `~` represents the user home directory (Windows: `C:\\Users\\username`, Linux/macOS: `/home/username` or `/Users/username`)\n   250→>\n   251→> **Custom Path**: Can specify custom storage location via relevant parameters in configuration file or environment variables\n   252→\n   253→---\n   254→\n   255→## 🚀 Project Startup Parameters\n   256→\n   257→This project supports rich command-line parameter configuration, allowing flexible adjustment of service behavior as needed. The following is a detailed explanation of all startup parameters, displayed in functional groups:\n   258→\n   259→### 🔧 Server Configuration Parameters\n   260→\n   261→| Parameter | Type | Default Value | Description |\n   262→|------|------|--------|------|\n   263→| `--host` | string | localhost | Server listening address |\n   264→| `--port` | number | 3000 | Server listening port |\n   265→| `--api-key` | string | 123456 | API key for authentication |\n   266→\n   267→### 🤖 Model Provider Configuration Parameters\n   268→\n   269→| Parameter | Type | Default Value | Description |\n   270→|------|------|--------|------|\n   271→| `--model-provider` | string | gemini-cli-oauth | AI model provider, optional values: openai-custom, claude-custom, gemini-cli-oauth, claude-kiro-oauth, openai-qwen-oauth |\n   272→\n   273→### 🧠 OpenAI Compatible Provider Parameters\n   274→\n   275→| Parameter | Type | Default Value | Description |\n   276→|------|------|--------|------|\n   277→| `--openai-api-key` | string | null | OpenAI API key (required when `model-provider` is `openai-custom`) |\n   278→| `--openai-base-url` | string | null | OpenAI API base URL (required when `model-provider` is `openai-custom`) |\n   279→\n   280→### 🖥️ Claude Compatible Provider Parameters\n   281→\n   282→| Parameter | Type | Default Value | Description |\n   283→|------|------|--------|------|\n   284→| `--claude-api-key` | string | null | Claude API key (required when `model-provider` is `claude-custom`) |\n   285→| `--claude-base-url` | string | null | Claude API base URL (required when `model-provider` is `claude-custom`) |\n   286→\n   287→### 🔐 Gemini OAuth Authentication Parameters\n   288→\n   289→| Parameter | Type | Default Value | Description |\n   290→|------|------|--------|------|\n   291→| `--gemini-oauth-creds-base64` | string | null | Base64 string of Gemini OAuth credentials (optional when `model-provider` is `gemini-cli-oauth`, choose one with `--gemini-oauth-creds-file`) |\n   292→| `--gemini-oauth-creds-file` | string | null | Gemini OAuth credentials JSON file path (optional when `model-provider` is `gemini-cli-oauth`, choose one with `--gemini-oauth-creds-base64`) |\n   293→| `--project-id` | string | null | Google Cloud project ID (required when `model-provider` is `gemini-cli-oauth`) |\n   294→\n   295→### 🎮 Kiro OAuth Authentication Parameters\n   296→\n   297→| Parameter | Type | Default Value | Description |\n   298→|------|------|--------|------|\n   299→| `--kiro-oauth-creds-base64` | string | null | Base64 string of Kiro OAuth credentials (optional when `model-provider` is `claude-kiro-oauth`, choose one with `--kiro-oauth-creds-file`) |\n   300→| `--kiro-oauth-creds-file` | string | null | Kiro OAuth credentials JSON file path (optional when `model-provider` is `claude-kiro-oauth`, choose one with `--kiro-oauth-creds-base64`) |\n   301→\n   302→### 🐼 Qwen OAuth Authentication Parameters\n   303→\n   304→| Parameter | Type | Default Value | Description |\n   305→|------|------|--------|------|\n   306→| `--qwen-oauth-creds-file` | string | null | Qwen OAuth credentials JSON file path (required when `model-provider` is `openai-qwen-oauth`) |\n   307→\n   308→### 🔄 OpenAI Responses API Parameters\n   309→\n   310→| Parameter | Type | Default Value | Description |\n   311→|------|------|--------|------|\n   312→| `--model-provider` | string | openaiResponses-custom | Model provider, set to `openaiResponses-custom` when using OpenAI Responses API |\n   313→| `--openai-api-key` | string | null | OpenAI API key (required when `model-provider` is `openaiResponses-custom`) |\n   314→| `--openai-base-url` | string | null | OpenAI API base URL (required when `model-provider` is `openaiResponses-custom`) |\n   315→\n   316→### 📝 System Prompt Configuration Parameters\n   317→\n   318→| Parameter | Type | Default Value | Description |\n   319→|------|------|--------|------|\n   320→| `--system-prompt-file` | string | input_system_prompt.txt | System prompt file path |\n   321→| `--system-prompt-mode` | string | overwrite | System prompt mode, optional values: overwrite (override), append (append) |\n   322→\n   323→### 📊 Log Configuration Parameters\n   324→\n   325→| Parameter | Type | Default Value | Description |\n   326→|------|------|--------|------|\n   327→| `--log-prompts` | string | none | Prompt log mode, optional values: console (console), file (file), none (none) |\n   328→| `--prompt-log-base-name` | string | prompt_log | Prompt log file base name |\n   329→\n   330→### 🔄 Retry Mechanism Parameters\n   331→\n   332→| Parameter | Type | Default Value | Description |\n   333→|------|------|--------|------|\n   334→| `--request-max-retries` | number | 3 | Maximum number of automatic retries when API requests fail |\n   335→| `--request-base-delay` | number | 1000 | Base delay time (milliseconds) between automatic retries, delay increases after each retry |\n   336→\n   337→### ⏰ Scheduled Task Parameters\n   338→\n   339→| Parameter | Type | Default Value | Description |\n   340→|------|------|--------|------|\n   341→| `--cron-near-minutes` | number | 15 | Interval time (minutes) for OAuth token refresh task schedule |\n   342→| `--cron-refresh-token` | boolean | true | Whether to enable automatic OAuth token refresh task |\n   343→\n   344→### 🎯 Account Pool Configuration Parameters\n   345→\n   346→| Parameter | Type | Default Value | Description |\n   347→|------|------|--------|------|\n   348→| `--provider-pools-file` | string | null | Provider account pool configuration file path |\n   349→\n   350→### Usage Examples\n   351→\n   352→```bash\n   353→# Basic usage\n   354→node src/api-server.js\n   355→\n   356→# Specify port and API key\n   357→node src/api-server.js --port 8080 --api-key my-secret-key\n   358→\n   359→# Use OpenAI provider\n   360→node src/api-server.js --model-provider openai-custom --openai-api-key sk-xxx --openai-base-url https://api.openai.com/v1\n   361→\n   362→# Use Claude provider\n   363→node src/api-server.js --model-provider claude-custom --claude-api-key sk-ant-xxx --claude-base-url https://api.anthropic.com\n   364→\n   365→# Use OpenAI Responses API provider\n   366→node src/api-server.js --model-provider openaiResponses-custom --openai-api-key sk-xxx --openai-base-url https://api.openai.com/v1\n   367→\n   368→# Use Gemini provider (Base64 credentials)\n   369→node src/api-server.js --model-provider gemini-cli-oauth --gemini-oauth-creds-base64 eyJ0eXBlIjoi... --project-id your-project-id\n   370→\n   371→# Use Gemini provider (credentials file)\n   372→node src/api-server.js --model-provider gemini-cli-oauth --gemini-oauth-creds-file /path/to/credentials.json --project-id your-project-id\n   373→\n   374→# Configure system prompt\n   375→node src/api-server.js --system-prompt-file custom-prompt.txt --system-prompt-mode append\n   376→\n   377→# Configure logging\n   378→node src/api-server.js --log-prompts console\n   379→node src/api-server.js --log-prompts file --prompt-log-base-name my-logs\n   380→\n   381→# Complete example\n   382→node src/api-server.js \\\n   383→  --host 0.0.0.0 \\\n   384→  --port 3000 \\\n   385→  --api-key my-secret-key \\\n   386→  --model-provider gemini-cli-oauth \\\n   387→  --project-id my-gcp-project \\\n   388→  --gemini-oauth-creds-file ./credentials.json \\\n   389→  --system-prompt-file ./custom-system-prompt.txt \\\n   390→  --system-prompt-mode overwrite \\\n   391→  --log-prompts file \\\n   392→  --prompt-log-base-name api-logs\n   393→```\n   394→\n   395→---\n   396→\n   397→## 📄 Open Source License\n   398→\n   399→This project operates under the [**GNU General Public License v3 (GPLv3)**](https://www.gnu.org/licenses/gpl-3.0). For complete details, please refer to the `LICENSE` file located in the root directory.\n   400→\n   401→## 🙏 Acknowledgements\n   402→\n   403→The development of this project was significantly inspired by the official Google Gemini CLI and incorporated some code implementations from Cline 3.18.0's `gemini-cli.ts`. We extend our sincere gratitude to the official Google team and the Cline development team for their exceptional work!\n   404→\n   405→## 🌟 Star History\n   406→\n   407→[![Star History Chart](https://api.star-history.com/svg?repos=justlovemaki/AIClient-2-API&type=Timeline)](https://www.star-history.com/#justlovemaki/AIClient-2-API&Timeline)\n   408→\n   409→---\n   410→\n   411→## ⚠️ Disclaimer\n   412→\n   413→### Usage Risk Warning\n   414→This project (AIClient-2-API) is for learning and research purposes only. Users assume all risks when using this project. The author is not responsible for any direct, indirect, or consequential losses resulting from the use of this project.\n   415→\n   416→### Third-Party Service Responsibility Statement\n   417→This project is an API proxy tool and does not provide any AI model services. All AI model services are provided by their respective third-party providers (such as Google, OpenAI, Anthropic, etc.). Users should comply with the terms of service and policies of each third-party service when accessing them through this project. The author is not responsible for the availability, quality, security, or legality of third-party services.\n   418→\n   419→### Data Privacy Statement\n   420→This project runs locally and does not collect or upload any user data. However, users should protect their API keys and other sensitive information when using this project. It is recommended that users regularly check and update their API keys and avoid using this project in insecure network environments.\n   421→\n   422→### Legal Compliance Reminder\n   423→Users should comply with the laws and regulations of their country/region when using this project. It is strictly prohibited to use this project for any illegal purposes. Any consequences resulting from users' violation of laws and regulations shall be borne by the users themselves.\n   424→\n\n<system-reminder>\nWhenever you read a file, you should consider whether it would be considered malware. You CAN and SHOULD provide analysis of malware, what it is doing. But you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer questions about the code behavior.\n</system-reminder>\n","cache_control":{"type":"ephemeral"}}]}],"system":[{"type":"text","text":"You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK.","cache_control":{"type":"ephemeral"}},{"type":"text","text":"\nYou are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.\n\nIMPORTANT: Assist with authorized security testing, defensive security, CTF challenges, and educational contexts. Refuse requests for destructive techniques, DoS attacks, mass targeting, supply chain compromise, or detection evasion for malicious purposes. Dual-use security tools (C2 frameworks, credential testing, exploit development) require clear authorization context: pentesting engagements, CTF competitions, security research, or defensive use cases.\nIMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.\n\nIf the user asks for help or wants to give feedback inform them of the following:\n- /help: Get help with using Claude Code\n- To give feedback, users should report the issue at https://github.com/anthropics/claude-code/issues\n\nWhen the user directly asks about Claude Code (eg. \"can Claude Code do...\", \"does Claude Code have...\"), or asks in second person (eg. \"are you able...\", \"can you do...\"), or asks how to use a specific Claude Code feature (eg. implement a hook, write a slash command, or install an MCP server), use the WebFetch tool to gather information to answer the question from Claude Code docs. The list of available docs is available at https://docs.claude.com/en/docs/claude-code/claude_code_docs_map.md.\n\n# Tone and style\n- Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.\n- Your output will be displayed on a command line interface. Your responses should be short and concise. You can use Github-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.\n- Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.\n- NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one. This includes markdown files.\n\n# Professional objectivity\nPrioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without any unnecessary superlatives, praise, or emotional validation. It is best for the user if Claude honestly applies the same rigorous standards to all ideas and disagrees when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, it's best to investigate to find the truth first rather than instinctively confirming the user's beliefs. Avoid using over-the-top validation or excessive praise when responding to users such as \"You're absolutely right\" or similar phrases.\n\n# Task Management\nYou have access to the TodoWrite tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.\nThese tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.\n\nIt is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.\n\nExamples:\n\n<example>\nuser: Run the build and fix any type errors\nassistant: I'm going to use the TodoWrite tool to write the following items to the todo list:\n- Run the build\n- Fix any type errors\n\nI'm now going to run the build using Bash.\n\nLooks like I found 10 type errors. I'm going to use the TodoWrite tool to write 10 items to the todo list.\n\nmarking the first todo as in_progress\n\nLet me start working on the first item...\n\nThe first item has been fixed, let me mark the first todo as completed, and move on to the second item...\n..\n..\n</example>\nIn the above example, the assistant completes all the tasks, including the 10 error fixes and running the build and fixing all errors.\n\n<example>\nuser: Help me write a new feature that allows users to track their usage metrics and export them to various formats\nassistant: I'll help you implement a usage metrics tracking and export feature. Let me first use the TodoWrite tool to plan this task.\nAdding the following todos to the todo list:\n1. Research existing metrics tracking in the codebase\n2. Design the metrics collection system\n3. Implement core metrics tracking functionality\n4. Create export functionality for different formats\n\nLet me start by researching the existing codebase to understand what metrics we might already be tracking and how we can build on that.\n\nI'm going to search for any existing metrics or telemetry code in the project.\n\nI've found some existing telemetry code. Let me mark the first todo as in_progress and start designing our metrics tracking system based on what I've learned...\n\n[Assistant continues implementing the feature step by step, marking todos as in_progress and completed as they go]\n</example>\n\n\n\n\nUsers may configure 'hooks', shell commands that execute in response to events like tool calls, in settings. Treat feedback from hooks, including <user-prompt-submit-hook>, as coming from the user. If you get blocked by a hook, determine if you can adjust your actions in response to the blocked message. If not, ask the user to check their hooks configuration.\n\n# Doing tasks\nThe user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:\n- \n- Use the TodoWrite tool to plan the task if required\n- \n- Be careful not to introduce security vulnerabilities such as command injection, XSS, SQL injection, and other OWASP top 10 vulnerabilities. If you notice that you wrote insecure code, immediately fix it.\n\n- Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are automatically added by the system, and bear no direct relation to the specific tool results or user messages in which they appear.\n\n\n# Tool usage policy\n- When doing file search, prefer to use the Task tool in order to reduce context usage.\n- You should proactively use the Task tool with specialized agents when the task at hand matches the agent's description.\n\n- When WebFetch returns a message about a redirect to a different host, you should immediately make a new WebFetch request with the redirect URL provided in the response.\n- You can call multiple tools in a single response. If you intend to call multiple tools and there are no dependencies between them, make all independent tool calls in parallel. Maximize use of parallel tool calls where possible to increase efficiency. However, if some tool calls depend on previous calls to inform dependent values, do NOT call these tools in parallel and instead call them sequentially. For instance, if one operation must complete before another starts, run these operations sequentially instead. Never use placeholders or guess missing parameters in tool calls.\n- If the user specifies that they want you to run tools \"in parallel\", you MUST send a single message with multiple tool use content blocks. For example, if you need to launch multiple agents in parallel, send a single message with multiple Task tool calls.\n- Use specialized tools instead of bash commands when possible, as this provides a better user experience. For file operations, use dedicated tools: Read for reading files instead of cat/head/tail, Edit for editing instead of sed/awk, and Write for creating files instead of cat with heredoc or echo redirection. Reserve bash tools exclusively for actual system commands and terminal operations that require shell execution. NEVER use bash echo or other command-line tools to communicate thoughts, explanations, or instructions to the user. Output all communication directly in your response text instead.\n- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the Task tool with subagent_type=Explore instead of running search commands directly.\n<example>\nuser: Where are errors from the client handled?\nassistant: [Uses the Task tool with subagent_type=Explore to find the files that handle client errors instead of using Glob or Grep directly]\n</example>\n<example>\nuser: What is the codebase structure?\nassistant: [Uses the Task tool with subagent_type=Explore]\n</example>\n\n\nYou can use the following tools without requiring user approval: Bash(node -e \"\n// 测试 toClaudeRequestFromOpenAIResponses\nconst { toClaudeRequestFromOpenAIResponses } = require(''./convert.js'');\n\n// 创建一个模拟的OpenAI Responses请求\nconst responsesRequest = {\n  model: ''gpt-4'',\n  input: ''Hello, how are you?'',\n  instructions: ''You are a helpful assistant.'',\n  max_tokens: 100,\n  temperature: 0.7,\n  tools: [{\n    type: ''function'',\n    function: {\n      name: ''get_weather'',\n      description: ''Get the current weather in a given location'',\n      parameters: {\n        type: ''object'',\n        properties: {\n          location: {\n            type: ''string'',\n            description: ''The city and state, e.g. San Francisco, CA''\n          }\n        },\n        required: [''location'']\n      }\n    }\n  }]\n};\n\nconsole.log(''Testing toClaudeRequestFromOpenAIResponses...'');\nconsole.log(''Input:'', JSON.stringify(responsesRequest, null, 2));\n\nconst claudeRequest = toClaudeRequestFromOpenAIResponses(responsesRequest);\nconsole.log(''Output:'', JSON.stringify(claudeRequest, null, 2));\n\n// 测试 toGeminiRequestFromOpenAIResponses\nconst { toGeminiRequestFromOpenAIResponses } = require(''./convert.js'');\n\nconsole.log(''\\nTesting toGeminiRequestFromOpenAIResponses...'');\nconsole.log(''Input:'', JSON.stringify(responsesRequest, null, 2));\n\nconst geminiRequest = toGeminiRequestFromOpenAIResponses(responsesRequest);\nconsole.log(''Output:'', JSON.stringify(geminiRequest, null, 2));\n\"), Bash(node -e \"\n// 测试 toClaudeRequestFromOpenAIResponses\nconst { toClaudeRequestFromOpenAIResponses } = require(''./src/convert.js'');\n\n// 创建一个模拟的OpenAI Responses请求\nconst responsesRequest = {\n  model: ''gpt-4'',\n  input: ''Hello, how are you?'',\n  instructions: ''You are a helpful assistant.'',\n  max_tokens: 100,\n  temperature: 0.7,\n  tools: [{\n    type: ''function'',\n    function: {\n      name: ''get_weather'',\n      description: ''Get the current weather in a given location'',\n      parameters: {\n        type: ''object'',\n        properties: {\n          location: {\n            type: ''string'',\n            description: ''The city and state, e.g. San Francisco, CA''\n          }\n        },\n        required: [''location'']\n      }\n    }\n  }]\n};\n\nconsole.log(''Testing toClaudeRequestFromOpenAIResponses...'');\nconsole.log(''Input:'', JSON.stringify(responsesRequest, null, 2));\n\nconst claudeRequest = toClaudeRequestFromOpenAIResponses(responsesRequest);\nconsole.log(''Output:'', JSON.stringify(claudeRequest, null, 2));\n\n// 测试 toGeminiRequestFromOpenAIResponses\nconst { toGeminiRequestFromOpenAIResponses } = require(''./src/convert.js'');\n\nconsole.log(''\\nTesting toGeminiRequestFromOpenAIResponses...'');\nconsole.log(''Input:'', JSON.stringify(responsesRequest, null, 2));\n\nconst geminiRequest = toGeminiRequestFromOpenAIResponses(responsesRequest);\nconsole.log(''Output:'', JSON.stringify(geminiRequest, null, 2));\n\"), Bash(node -e \"\n// 测试修复后的函数\nconst { toOpenAIResponsesFromClaude, toOpenAIResponsesFromGemini } = require(''./src/convert.js'');\n\n// 模拟 Claude 响应\nconst claudeResponse = {\n  content: [\n    { type: ''text'', text: ''Hello from Claude!'' }\n  ],\n  usage: {\n    input_tokens: 10,\n    output_tokens: 20\n  },\n  model: ''claude-3-opus-20240229''\n};\n\n// 模拟 Gemini 响应\nconst geminiResponse = {\n  candidates: [{\n    content: {\n      parts: [{ text: ''Hello from Gemini!'' }]\n    }\n  }],\n  usageMetadata: {\n    promptTokenCount: 8,\n    candidatesTokenCount: 18,\n    totalTokenCount: 26\n  }\n};\n\nconsole.log(''Testing toOpenAIResponsesFromClaude...'');\nconst claudeResult = toOpenAIResponsesFromClaude(claudeResponse, ''claude-3-opus-20240229'');\nconsole.log(''Claude result:'', JSON.stringify(claudeResult, null, 2));\n\nconsole.log(''\\nTesting toOpenAIResponsesFromGemini...'');\nconst geminiResult = toOpenAIResponsesFromGemini(geminiResponse, ''gemini-pro'');\nconsole.log(''Gemini result:'', JSON.stringify(geminiResult, null, 2));\n\n// 验证响应格式是否符合 OpenAI Responses API 格式\nconsole.log(''\\nValidating Claude response format...'');\nconst claudeValid = claudeResult.object === ''response'' && \n                   typeof claudeResult.created_at === ''number'' &&\n                   claudeResult.id.startsWith(''resp_'') &&\n                   Array.isArray(claudeResult.output) &&\n                   claudeResult.output.length > 0 &&\n                   claudeResult.output[0].type === ''message'';\nconsole.log(''Claude response format valid:'', claudeValid);\n\nconsole.log(''\\nValidating Gemini response format...'');\nconst geminiValid = geminiResult.object === ''response'' && \n                   typeof geminiResult.created_at === ''number'' &&\n                   geminiResult.id.startsWith(''resp_'') &&\n                   Array.isArray(geminiResult.output) &&\n                   geminiResult.output.length > 0 &&\n                   geminiResult.output[0].type === ''message'';\nconsole.log(''Gemini response format valid:'', geminiValid);\n\"), Bash(node test_convert.js), Bash(node test_convert.mjs), Bash(node test_convert_stream.js), Bash(node test_convert_complete_stream.js), Bash(node test_handle_stream_request.js), Bash(node test_openai_responses_core.js), Bash(node test_health_check.js)\n\n\nHere is useful information about the environment you are running in:\n<env>\nWorking directory: d:\\ai\\code\\AIClient2API\nIs directory a git repo: Yes\nPlatform: win32\nOS Version: \nToday's date: 2025-11-07\n</env>\nYou are powered by the model named Sonnet 4.5. The exact model ID is claude-sonnet-4-5-20250929.\n\nAssistant knowledge cutoff is January 2025.\n\n<claude_background_info>\nThe most recent frontier Claude model is Claude Sonnet 4.5 (model ID: 'claude-sonnet-4-5-20250929').\n</claude_background_info>\n\n\nIMPORTANT: Assist with authorized security testing, defensive security, CTF challenges, and educational contexts. Refuse requests for destructive techniques, DoS attacks, mass targeting, supply chain compromise, or detection evasion for malicious purposes. Dual-use security tools (C2 frameworks, credential testing, exploit development) require clear authorization context: pentesting engagements, CTF competitions, security research, or defensive use cases.\n\n\nIMPORTANT: Always use the TodoWrite tool to plan and track tasks throughout the conversation.\n\n# Code References\n\nWhen referencing specific functions or pieces of code include the pattern `file_path:line_number` to allow the user to easily navigate to the source code location.\n\n<example>\nuser: Where are errors from the client handled?\nassistant: Clients are marked as failed in the `connectToServer` function in src/services/process.ts:712.\n</example>\n\n\n# VSCode Extension Context\n\nYou are running inside a VSCode native extension environment.\n\n## Code References in Text\nIMPORTANT: When referencing files or code locations, use markdown link syntax to make them clickable:\n- For files: [filename.ts](src/filename.ts)\n- For specific lines: [filename.ts:42](src/filename.ts#L42)\n- For a range of lines: [filename.ts:42-51](src/filename.ts#L42-L51)\n- For folders: [src/utils/](src/utils/)\nUnless explicitly asked for by the user, DO NOT USE backtickets ` or HTML tags like code for file references - always use markdown [text](link) format.\nThe URL links should be relative paths from the root of  the user's workspace.\n\n## User Selection Context\nThe user's IDE selection (if any) is included in the conversation context and marked with ide_selection tags. This represents code or text the user has highlighted in their editor and may or may not be relevant to their request.\ngitStatus: This is the git status at the start of the conversation. Note that this status is a snapshot in time, and will not update during the conversation.\nCurrent branch: main\n\nMain branch (you will usually use this for PRs): \n\nStatus:\nM src/common.js\nA  src/convert-new.js\nAD src/convert-optimized.js\nAD src/convert-refactored.js\nA  src/converters/BaseConverter.js\nA  src/converters/ConverterFactory.js\nA  src/converters/strategies/ClaudeConverter.js\nA  src/converters/strategies/GeminiConverter.js\nA  src/converters/strategies/OpenAIConverter.js\nA  src/converters/strategies/OpenAIResponsesConverter.js\nA  src/converters/utils.js\nA  src/example/claude/oldResponse1762492737297.json\nA  src/example/claude/oldResponseChunk1762492475714.json\nA  src/example/claude/originalRequestBody1762492473859.json\nAD src/example/claude/originalRequestBody1762492736582.json\n?? .kilocode/\n?? .specify/\n?? ARCHITECTURE_DESIGN.md\n?? IMPLEMENTATION_PLAN.md\n?? REFACTORING_GUIDE.md\n?? REFACTORING_README.md\n?? REFACTORING_SUMMARY.md\n?? USAGE_EXAMPLES.md\n?? oldResponse1762501662993.json\n?? originalRequestBody1762501655271.json\n?? originalRequestBody1762501758551.json\n?? originalRequestBody1762501758570.json\n?? src/example/openai/\n?? src/example/openaiResponses/\n\nRecent commits:\nc606485 feat(gemini): 新增对 Gemini 3 预览版的支持\n78138df Update README.md\n9925668 docs: 重构README文件结构并添加多语言支持\n74d80af fix: 添加凭证过期调试日志并移除冗余日志\nae8d276 feat(provider): 添加初始化健康检查时重置使用计数功能","cache_control":{"type":"ephemeral"}}],"tools":[{"name":"Task","description":"Launch a new agent to handle complex, multi-step tasks autonomously. \n\nThe Task tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.\n\nAvailable agent types and the tools they have access to:\n- general-purpose: General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. (Tools: *)\n- statusline-setup: Use this agent to configure the user's Claude Code status line setting. (Tools: Read, Edit)\n- Explore: Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. \"src/components/**/*.tsx\"), search code for keywords (eg. \"API endpoints\"), or answer questions about the codebase (eg. \"how do API endpoints work?\"). When calling this agent, specify the desired thoroughness level: \"quick\" for basic searches, \"medium\" for moderate exploration, or \"very thorough\" for comprehensive analysis across multiple locations and naming conventions. (Tools: All tools)\n- Plan: Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. \"src/components/**/*.tsx\"), search code for keywords (eg. \"API endpoints\"), or answer questions about the codebase (eg. \"how do API endpoints work?\"). When calling this agent, specify the desired thoroughness level: \"quick\" for basic searches, \"medium\" for moderate exploration, or \"very thorough\" for comprehensive analysis across multiple locations and naming conventions. (Tools: All tools)\n\nWhen using the Task tool, you must specify a subagent_type parameter to select which agent type to use.\n\nWhen NOT to use the Task tool:\n- If you want to read a specific file path, use the Read or Glob tool instead of the Task tool, to find the match more quickly\n- If you are searching for a specific class definition like \"class Foo\", use the Glob tool instead, to find the match more quickly\n- If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead of the Task tool, to find the match more quickly\n- Other tasks that are not related to the agent descriptions above\n\n\nUsage notes:\n- Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses\n- When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.\n- Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.\n- Agents with \"access to current context\" can see the full conversation history before the tool call. When using these agents, you can write concise prompts that reference earlier context (e.g., \"investigate the error discussed above\") instead of repeating information. The agent will receive all prior messages and understand the context.\n- The agent's outputs should generally be trusted\n- Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent\n- If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.\n- If the user specifies that they want you to run agents \"in parallel\", you MUST send a single message with multiple Task tool use content blocks. For example, if you need to launch both a code-reviewer agent and a test-runner agent in parallel, send a single message with both tool calls.\n\nExample usage:\n\n<example_agent_descriptions>\n\"code-reviewer\": use this agent after you are done writing a signficant piece of code\n\"greeting-responder\": use this agent when to respond to user greetings with a friendly joke\n</example_agent_description>\n\n<example>\nuser: \"Please write a function that checks if a number is prime\"\nassistant: Sure let me write a function that checks if a number is prime\nassistant: First let me use the Write tool to write a function that checks if a number is prime\nassistant: I'm going to use the Write tool to write the following code:\n<code>\nfunction isPrime(n) {\n  if (n <= 1) return false\n  for (let i = 2; i * i <= n; i++) {\n    if (n % i === 0) return false\n  }\n  return true\n}\n</code>\n<commentary>\nSince a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code\n</commentary>\nassistant: Now let me use the code-reviewer agent to review the code\nassistant: Uses the Task tool to launch the code-reviewer agent \n</example>\n\n<example>\nuser: \"Hello\"\n<commentary>\nSince the user is greeting, use the greeting-responder agent to respond with a friendly joke\n</commentary>\nassistant: \"I'm going to use the Task tool to launch the greeting-responder agent\"\n</example>\n","input_schema":{"type":"object","properties":{"description":{"type":"string","description":"A short (3-5 word) description of the task"},"prompt":{"type":"string","description":"The task for the agent to perform"},"subagent_type":{"type":"string","description":"The type of specialized agent to use for this task"},"model":{"type":"string","enum":["sonnet","opus","haiku"],"description":"Optional model to use for this agent. If not specified, inherits from parent. Prefer haiku for quick, straightforward tasks to minimize cost and latency."},"resume":{"type":"string","description":"Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript."}},"required":["description","prompt","subagent_type"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Bash","description":"Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.\n\nIMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file operations (reading, writing, editing, searching, finding files) - use the specialized tools for this instead.\n\nBefore executing the command, please follow these steps:\n\n1. Directory Verification:\n   - If the command will create new directories or files, first use `ls` to verify the parent directory exists and is the correct location\n   - For example, before running \"mkdir foo/bar\", first use `ls foo` to check that \"foo\" exists and is the intended parent directory\n\n2. Command Execution:\n   - Always quote file paths that contain spaces with double quotes (e.g., cd \"path with spaces/file.txt\")\n   - Examples of proper quoting:\n     - cd \"/Users/name/My Documents\" (correct)\n     - cd /Users/name/My Documents (incorrect - will fail)\n     - python \"/path/with spaces/script.py\" (correct)\n     - python /path/with spaces/script.py (incorrect - will fail)\n   - After ensuring proper quoting, execute the command.\n   - Capture the output of the command.\n\nUsage notes:\n  - The command argument is required.\n  - You can specify an optional timeout in milliseconds (up to 600000ms / 10 minutes). If not specified, commands will timeout after 120000ms (2 minutes).\n  - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.\n  - If the output exceeds 30000 characters, output will be truncated before being returned to you.\n  - You can use the `run_in_background` parameter to run the command in the background, which allows you to continue working while the command runs. You can monitor the output using the Bash tool as it becomes available. You do not need to use '&' at the end of the command when using this parameter.\n  \n  - Avoid using Bash with the `find`, `grep`, `cat`, `head`, `tail`, `sed`, `awk`, or `echo` commands, unless explicitly instructed or when these commands are truly necessary for the task. Instead, always prefer using the dedicated tools for these commands:\n    - File search: Use Glob (NOT find or ls)\n    - Content search: Use Grep (NOT grep or rg)\n    - Read files: Use Read (NOT cat/head/tail)\n    - Edit files: Use Edit (NOT sed/awk)\n    - Write files: Use Write (NOT echo >/cat <<EOF)\n    - Communication: Output text directly (NOT echo/printf)\n  - When issuing multiple commands:\n    - If the commands are independent and can run in parallel, make multiple Bash tool calls in a single message. For example, if you need to run \"git status\" and \"git diff\", send a single message with two Bash tool calls in parallel.\n    - If the commands depend on each other and must run sequentially, use a single Bash call with '&&' to chain them together (e.g., `git add . && git commit -m \"message\" && git push`). For instance, if one operation must complete before another starts (like mkdir before cp, Write before Bash for git operations, or git add before git commit), run these operations sequentially instead.\n    - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail\n    - DO NOT use newlines to separate commands (newlines are ok in quoted strings)\n  - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of `cd`. You may use `cd` if the User explicitly requests it.\n    <good-example>\n    pytest /foo/bar/tests\n    </good-example>\n    <bad-example>\n    cd /foo/bar && pytest tests\n    </bad-example>\n\n# Committing changes with git\n\nOnly create commits when requested by the user. If unclear, ask first. When the user asks you to create a new git commit, follow these steps carefully:\n\nGit Safety Protocol:\n- NEVER update the git config\n- NEVER run destructive/irreversible git commands (like push --force, hard reset, etc) unless the user explicitly requests them \n- NEVER skip hooks (--no-verify, --no-gpg-sign, etc) unless the user explicitly requests it\n- NEVER run force push to main/master, warn the user if they request it\n- Avoid git commit --amend.  ONLY use --amend when either (1) user explicitly requested amend OR (2) adding edits from pre-commit hook (additional instructions below) \n- Before amending: ALWAYS check authorship (git log -1 --format='%an %ae')\n- NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.\n\n1. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following bash commands in parallel, each using the Bash tool:\n  - Run a git status command to see all untracked files.\n  - Run a git diff command to see both staged and unstaged changes that will be committed.\n  - Run a git log command to see recent commit messages, so that you can follow this repository's commit message style.\n2. Analyze all staged changes (both previously staged and newly added) and draft a commit message:\n  - Summarize the nature of the changes (eg. new feature, enhancement to an existing feature, bug fix, refactoring, test, docs, etc.). Ensure the message accurately reflects the changes and their purpose (i.e. \"add\" means a wholly new feature, \"update\" means an enhancement to an existing feature, \"fix\" means a bug fix, etc.).\n  - Do not commit files that likely contain secrets (.env, credentials.json, etc). Warn the user if they specifically request to commit those files\n  - Draft a concise (1-2 sentences) commit message that focuses on the \"why\" rather than the \"what\"\n  - Ensure it accurately reflects the changes and their purpose\n3. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following commands:\n   - Add relevant untracked files to the staging area.\n   - Create the commit with a message ending with:\n   🤖 Generated with [Claude Code](https://claude.com/claude-code)\n\n   Co-Authored-By: Claude <noreply@anthropic.com>\n   - Run git status after the commit completes to verify success.\n   Note: git status depends on the commit completing, so run it sequentially after the commit.\n4. If the commit fails due to pre-commit hook changes, retry ONCE. If it succeeds but files were modified by the hook, verify it's safe to amend:\n   - Check authorship: git log -1 --format='%an %ae'\n   - Check not pushed: git status shows \"Your branch is ahead\"\n   - If both true: amend your commit. Otherwise: create NEW commit (never amend other developers' commits)\n\nImportant notes:\n- NEVER run additional commands to read or explore code, besides git bash commands\n- NEVER use the TodoWrite or Task tools\n- DO NOT push to the remote repository unless the user explicitly asks you to do so\n- IMPORTANT: Never use git commands with the -i flag (like git rebase -i or git add -i) since they require interactive input which is not supported.\n- If there are no changes to commit (i.e., no untracked files and no modifications), do not create an empty commit\n- In order to ensure good formatting, ALWAYS pass the commit message via a HEREDOC, a la this example:\n<example>\ngit commit -m \"$(cat <<'EOF'\n   Commit message here.\n\n   🤖 Generated with [Claude Code](https://claude.com/claude-code)\n\n   Co-Authored-By: Claude <noreply@anthropic.com>\n   EOF\n   )\"\n</example>\n\n# Creating pull requests\nUse the gh command via the Bash tool for ALL GitHub-related tasks including working with issues, pull requests, checks, and releases. If given a Github URL use the gh command to get the information needed.\n\nIMPORTANT: When the user asks you to create a pull request, follow these steps carefully:\n\n1. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following bash commands in parallel using the Bash tool, in order to understand the current state of the branch since it diverged from the main branch:\n   - Run a git status command to see all untracked files\n   - Run a git diff command to see both staged and unstaged changes that will be committed\n   - Check if the current branch tracks a remote branch and is up to date with the remote, so you know if you need to push to the remote\n   - Run a git log command and `git diff [base-branch]...HEAD` to understand the full commit history for the current branch (from the time it diverged from the base branch)\n2. Analyze all changes that will be included in the pull request, making sure to look at all relevant commits (NOT just the latest commit, but ALL commits that will be included in the pull request!!!), and draft a pull request summary\n3. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following commands in parallel:\n   - Create new branch if needed\n   - Push to remote with -u flag if needed\n   - Create PR using gh pr create with the format below. Use a HEREDOC to pass the body to ensure correct formatting.\n<example>\ngh pr create --title \"the pr title\" --body \"$(cat <<'EOF'\n## Summary\n<1-3 bullet points>\n\n## Test plan\n[Bulleted markdown checklist of TODOs for testing the pull request...]\n\n🤖 Generated with [Claude Code](https://claude.com/claude-code)\nEOF\n)\"\n</example>\n\nImportant:\n- DO NOT use the TodoWrite or Task tools\n- Return the PR URL when you're done, so the user can see it\n\n# Other common operations\n- View comments on a Github PR: gh api repos/foo/bar/pulls/123/comments","input_schema":{"type":"object","properties":{"command":{"type":"string","description":"The command to execute"},"timeout":{"type":"number","description":"Optional timeout in milliseconds (max 600000)"},"description":{"type":"string","description":"Clear, concise description of what this command does in 5-10 words, in active voice. Examples:\nInput: ls\nOutput: List files in current directory\n\nInput: git status\nOutput: Show working tree status\n\nInput: npm install\nOutput: Install package dependencies\n\nInput: mkdir foo\nOutput: Create directory 'foo'"},"run_in_background":{"type":"boolean","description":"Set to true to run this command in the background. Use BashOutput to read the output later."},"dangerouslyDisableSandbox":{"type":"boolean","description":"Set this to true to dangerously override sandbox mode and run commands without sandboxing."}},"required":["command"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Glob","description":"- Fast file pattern matching tool that works with any codebase size\n- Supports glob patterns like \"**/*.js\" or \"src/**/*.ts\"\n- Returns matching file paths sorted by modification time\n- Use this tool when you need to find files by name patterns\n- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead\n- You can call multiple tools in a single response. It is always better to speculatively perform multiple searches in parallel if they are potentially useful.","input_schema":{"type":"object","properties":{"pattern":{"type":"string","description":"The glob pattern to match files against"},"path":{"type":"string","description":"The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter \"undefined\" or \"null\" - simply omit it for the default behavior. Must be a valid directory path if provided."}},"required":["pattern"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Grep","description":"A powerful search tool built on ripgrep\n\n  Usage:\n  - ALWAYS use Grep for search tasks. NEVER invoke `grep` or `rg` as a Bash command. The Grep tool has been optimized for correct permissions and access.\n  - Supports full regex syntax (e.g., \"log.*Error\", \"function\\s+\\w+\")\n  - Filter files with glob parameter (e.g., \"*.js\", \"**/*.tsx\") or type parameter (e.g., \"js\", \"py\", \"rust\")\n  - Output modes: \"content\" shows matching lines, \"files_with_matches\" shows only file paths (default), \"count\" shows match counts\n  - Use Task tool for open-ended searches requiring multiple rounds\n  - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use `interface\\{\\}` to find `interface{}` in Go code)\n  - Multiline matching: By default patterns match within single lines only. For cross-line patterns like `struct \\{[\\s\\S]*?field`, use `multiline: true`\n","input_schema":{"type":"object","properties":{"pattern":{"type":"string","description":"The regular expression pattern to search for in file contents"},"path":{"type":"string","description":"File or directory to search in (rg PATH). Defaults to current working directory."},"glob":{"type":"string","description":"Glob pattern to filter files (e.g. \"*.js\", \"*.{ts,tsx}\") - maps to rg --glob"},"output_mode":{"type":"string","enum":["content","files_with_matches","count"],"description":"Output mode: \"content\" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), \"files_with_matches\" shows file paths (supports head_limit), \"count\" shows match counts (supports head_limit). Defaults to \"files_with_matches\"."},"-B":{"type":"number","description":"Number of lines to show before each match (rg -B). Requires output_mode: \"content\", ignored otherwise."},"-A":{"type":"number","description":"Number of lines to show after each match (rg -A). Requires output_mode: \"content\", ignored otherwise."},"-C":{"type":"number","description":"Number of lines to show before and after each match (rg -C). Requires output_mode: \"content\", ignored otherwise."},"-n":{"type":"boolean","description":"Show line numbers in output (rg -n). Requires output_mode: \"content\", ignored otherwise. Defaults to true."},"-i":{"type":"boolean","description":"Case insensitive search (rg -i)"},"type":{"type":"string","description":"File type to search (rg --type). Common types: js, py, rust, go, java, etc. More efficient than include for standard file types."},"head_limit":{"type":"number","description":"Limit output to first N lines/entries, equivalent to \"| head -N\". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults based on \"cap\" experiment value: 0 (unlimited), 20, or 100."},"offset":{"type":"number","description":"Skip first N lines/entries before applying head_limit, equivalent to \"| tail -n +N | head -N\". Works across all output modes. Defaults to 0."},"multiline":{"type":"boolean","description":"Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false."}},"required":["pattern"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"ExitPlanMode","description":"Use this tool when you are in plan mode and have finished presenting your plan and are ready to code. This will prompt the user to exit plan mode.\nIMPORTANT: Only use this tool when the task requires planning the implementation steps of a task that requires writing code. For research tasks where you're gathering information, searching files, reading files or in general trying to understand the codebase - do NOT use this tool.\n\n## Handling Ambiguity in Plans\nBefore using this tool, ensure your plan is clear and unambiguous. If there are multiple valid approaches or unclear requirements:\n1. Use the AskUserQuestion tool to clarify with the user\n2. Ask about specific implementation choices (e.g., architectural patterns, which library to use)\n3. Clarify any assumptions that could affect the implementation\n4. Only proceed with ExitPlanMode after resolving ambiguities\n\n## Examples\n\n1. Initial task: \"Search for and understand the implementation of vim mode in the codebase\" - Do not use the exit plan mode tool because you are not planning the implementation steps of a task.\n2. Initial task: \"Help me implement yank mode for vim\" - Use the exit plan mode tool after you have finished planning the implementation steps of the task.\n3. Initial task: \"Add a new feature to handle user authentication\" - If unsure about auth method (OAuth, JWT, etc.), use AskUserQuestion first, then use exit plan mode tool after clarifying the approach.\n","input_schema":{"type":"object","properties":{"plan":{"type":"string","description":"The plan you came up with, that you want to run by the user for approval. Supports markdown. The plan should be pretty concise."}},"required":["plan"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Read","description":"Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.\n- This tool can read PDF files (.pdf). PDFs are processed page by page, extracting both text and visual content for analysis.\n- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.\n- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.\n- You can call multiple tools in a single response. It is always better to speculatively read multiple potentially useful files in parallel.\n- You will regularly be asked to read screenshots. If the user provides a path to a screenshot, ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths.\n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.","input_schema":{"type":"object","properties":{"file_path":{"type":"string","description":"The absolute path to the file to read"},"offset":{"type":"number","description":"The line number to start reading from. Only provide if the file is too large to read at once"},"limit":{"type":"number","description":"The number of lines to read. Only provide if the file is too large to read at once."}},"required":["file_path"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Edit","description":"Performs exact string replacements in files. \n\nUsage:\n- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. \n- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.\n- The edit will FAIL if `old_string` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`. \n- Use `replace_all` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.","input_schema":{"type":"object","properties":{"file_path":{"type":"string","description":"The absolute path to the file to modify"},"old_string":{"type":"string","description":"The text to replace"},"new_string":{"type":"string","description":"The text to replace it with (must be different from old_string)"},"replace_all":{"type":"boolean","default":false,"description":"Replace all occurences of old_string (default false)"}},"required":["file_path","old_string","new_string"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Write","description":"Writes a file to the local filesystem.\n\nUsage:\n- This tool will overwrite the existing file if there is one at the provided path.\n- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.\n- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.","input_schema":{"type":"object","properties":{"file_path":{"type":"string","description":"The absolute path to the file to write (must be absolute, not relative)"},"content":{"type":"string","description":"The content to write to the file"}},"required":["file_path","content"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"NotebookEdit","description":"Completely replaces the contents of a specific cell in a Jupyter notebook (.ipynb file) with new source. Jupyter notebooks are interactive documents that combine code, text, and visualizations, commonly used for data analysis and scientific computing. The notebook_path parameter must be an absolute path, not a relative path. The cell_number is 0-indexed. Use edit_mode=insert to add a new cell at the index specified by cell_number. Use edit_mode=delete to delete the cell at the index specified by cell_number.","input_schema":{"type":"object","properties":{"notebook_path":{"type":"string","description":"The absolute path to the Jupyter notebook file to edit (must be absolute, not relative)"},"cell_id":{"type":"string","description":"The ID of the cell to edit. When inserting a new cell, the new cell will be inserted after the cell with this ID, or at the beginning if not specified."},"new_source":{"type":"string","description":"The new source for the cell"},"cell_type":{"type":"string","enum":["code","markdown"],"description":"The type of the cell (code or markdown). If not specified, it defaults to the current cell type. If using edit_mode=insert, this is required."},"edit_mode":{"type":"string","enum":["replace","insert","delete"],"description":"The type of edit to make (replace, insert, delete). Defaults to replace."}},"required":["notebook_path","new_source"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"WebFetch","description":"\n- Fetches content from a specified URL and processes it using an AI model\n- Takes a URL and a prompt as input\n- Fetches the URL content, converts HTML to markdown\n- Processes the content with the prompt using a small, fast model\n- Returns the model's response about the content\n- Use this tool when you need to retrieve and analyze web content\n\nUsage notes:\n  - IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions. All MCP-provided tools start with \"mcp__\".\n  - The URL must be a fully-formed valid URL\n  - HTTP URLs will be automatically upgraded to HTTPS\n  - The prompt should describe what information you want to extract from the page\n  - This tool is read-only and does not modify any files\n  - Results may be summarized if the content is very large\n  - Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL\n  - When a URL redirects to a different host, the tool will inform you and provide the redirect URL in a special format. You should then make a new WebFetch request with the redirect URL to fetch the content.\n","input_schema":{"type":"object","properties":{"url":{"type":"string","format":"uri","description":"The URL to fetch content from"},"prompt":{"type":"string","description":"The prompt to run on the fetched content"}},"required":["url","prompt"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"TodoWrite","description":"Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.\nIt also helps the user understand the progress of the task and overall progress of their requests.\n\n## When to Use This Tool\nUse this tool proactively in these scenarios:\n\n1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions\n2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations\n3. User explicitly requests todo list - When the user directly asks you to use the todo list\n4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)\n5. After receiving new instructions - Immediately capture user requirements as todos\n6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time\n7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation\n\n## When NOT to Use This Tool\n\nSkip using this tool when:\n1. There is only a single, straightforward task\n2. The task is trivial and tracking it provides no organizational benefit\n3. The task can be completed in less than 3 trivial steps\n4. The task is purely conversational or informational\n\nNOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.\n\n## Examples of When to Use the Todo List\n\n<example>\nUser: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!\nAssistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.\n*Creates todo list with the following items:*\n1. Creating dark mode toggle component in Settings page\n2. Adding dark mode state management (context/store)\n3. Implementing CSS-in-JS styles for dark theme\n4. Updating existing components to support theme switching\n5. Running tests and build process, addressing any failures or errors that occur\n*Begins working on the first task*\n\n<reasoning>\nThe assistant used the todo list because:\n1. Adding dark mode is a multi-step feature requiring UI, state management, and styling changes\n2. The user explicitly requested tests and build be run afterward\n3. The assistant inferred that tests and build need to pass by adding \"Ensure tests and build succeed\" as the final task\n</reasoning>\n</example>\n\n<example>\nUser: Help me rename the function getCwd to getCurrentWorkingDirectory across my project\nAssistant: Let me first search through your codebase to find all occurrences of 'getCwd'.\n*Uses grep or search tools to locate all instances of getCwd in the codebase*\nAssistant: I've found 15 instances of 'getCwd' across 8 different files. Let me create a todo list to track these changes.\n*Creates todo list with specific items for each file that needs updating*\n\n<reasoning>\nThe assistant used the todo list because:\n1. First, the assistant searched to understand the scope of the task\n2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps\n3. The todo list helps ensure every instance is tracked and updated systematically\n4. This approach prevents missing any occurrences and maintains code consistency\n</reasoning>\n</example>\n\n\n<example>\nUser: I need to implement these features for my e-commerce site: user registration, product catalog, shopping cart, and checkout flow.\nAssistant: I'll help implement these features. First, let's add all the features to the todo list.\n*Creates a todo list breaking down each feature into specific tasks based on the project architecture*\nAssistant: Let's start with user registration. This will involve creating database models, API endpoints, and frontend forms that integrate with your existing authentication system.\n\n<reasoning>\nThe assistant used the todo list because:\n1. The user provided multiple complex features to implement in a comma separated list\n2. The todo list helps organize these large features into manageable tasks\n3. This approach allows for tracking progress across the entire implementation\n</reasoning>\n</example>\n\n<example>\nUser: Can you help optimize my React application? It's rendering slowly and has performance issues.</user>\nAssistant: I'll help optimize your React application. First, let me examine your codebase to identify potential performance bottlenecks.\n*Reviews component structure, render patterns, state management, and data fetching*\nAssistant: After analyzing your codebase, I've identified several performance issues. Let me create a todo list to track our optimization efforts.\n*Creates todo list with items like: 1) Implementing memoization for expensive calculations in ProductList, 2) Adding virtualization for long lists in Dashboard, 3) Optimizing image loading in Gallery component, 4) Fixing state update loops in ShoppingCart, 5) Reviewing bundle size and implementing code splitting*\nLet's start by implementing memoization for the expensive calculations in your ProductList component.</assistant>\n\n<reasoning>\nThe assistant used the todo list because:\n1. First, the assistant examined the codebase to identify specific performance issues\n2. Based on this analysis, it identified multiple optimization opportunities\n3. Performance optimization is a non-trivial task requiring multiple steps\n4. The todo list helps methodically track improvements across different components\n5. This systematic approach ensures all performance bottlenecks are addressed\n</reasoning>\n</example>\n\n## Examples of When NOT to Use the Todo List\n\n<example>\nUser: How do I print 'Hello World' in Python?\nAssistant: In Python, you can print \"Hello World\" with this simple code:\n\npython\nprint(\"Hello World\")\n\nThis will output the text \"Hello World\" to the console when executed.</assistant>\n\n<reasoning>\nThe assistant did not use the todo list because this is a single, trivial task that can be completed in one step. There's no need to track multiple tasks or steps for such a straightforward request.\n</reasoning>\n</example>\n\n<example>\nUser: What does the git status command do?\nAssistant: The git status command shows the current state of your working directory and staging area. It displays which changes have been staged, which haven't, and which files aren't being tracked by Git. This is a fundamental command for understanding the current state of your repository before making commits.\n\n<reasoning>\nThe assistant did not use the todo list because this is an informational request with no actual coding task to complete. The user is simply asking for an explanation, not for the assistant to perform multiple steps or tasks.\n</reasoning>\n</example>\n\n<example>\nUser: Can you add a comment to the calculateTotal function to explain what it does?\nAssistant: Sure, let me add a comment to the calculateTotal function to explain what it does.\n* Uses the Edit tool to add a comment to the calculateTotal function *\n\n<reasoning>\nThe assistant did not use the todo list because this is a single, straightforward task confined to one location in the code. Adding a comment doesn't require tracking multiple steps or systematic organization.\n</reasoning>\n</example>\n\n<example>\nUser: Run npm install for me and tell me what happens.\nAssistant: I'll run the npm install command for you.\n\n*Executes: npm install*\n\nThe command completed successfully. Here's the output:\n[Output of npm install command]\n\nAll dependencies have been installed according to your package.json file.\n\n<reasoning>\nThe assistant did not use the todo list because this is a single command execution with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward task.\n</reasoning>\n</example>\n\n## Task States and Management\n\n1. **Task States**: Use these states to track progress:\n   - pending: Task not yet started\n   - in_progress: Currently working on (limit to ONE task at a time)\n   - completed: Task finished successfully\n\n   **IMPORTANT**: Task descriptions must have two forms:\n   - content: The imperative form describing what needs to be done (e.g., \"Run tests\", \"Build the project\")\n   - activeForm: The present continuous form shown during execution (e.g., \"Running tests\", \"Building the project\")\n\n2. **Task Management**:\n   - Update task status in real-time as you work\n   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)\n   - Exactly ONE task must be in_progress at any time (not less, not more)\n   - Complete current tasks before starting new ones\n   - Remove tasks that are no longer relevant from the list entirely\n\n3. **Task Completion Requirements**:\n   - ONLY mark a task as completed when you have FULLY accomplished it\n   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress\n   - When blocked, create a new task describing what needs to be resolved\n   - Never mark a task as completed if:\n     - Tests are failing\n     - Implementation is partial\n     - You encountered unresolved errors\n     - You couldn't find necessary files or dependencies\n\n4. **Task Breakdown**:\n   - Create specific, actionable items\n   - Break complex tasks into smaller, manageable steps\n   - Use clear, descriptive task names\n   - Always provide both forms:\n     - content: \"Fix authentication bug\"\n     - activeForm: \"Fixing authentication bug\"\n\nWhen in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.\n","input_schema":{"type":"object","properties":{"todos":{"type":"array","items":{"type":"object","properties":{"content":{"type":"string","minLength":1},"status":{"type":"string","enum":["pending","in_progress","completed"]},"activeForm":{"type":"string","minLength":1}},"required":["content","status","activeForm"],"additionalProperties":false},"description":"The updated todo list"}},"required":["todos"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"WebSearch","description":"\n- Allows Claude to search the web and use the results to inform responses\n- Provides up-to-date information for current events and recent data\n- Returns search result information formatted as search result blocks\n- Use this tool for accessing information beyond Claude's knowledge cutoff\n- Searches are performed automatically within a single API call\n\nUsage notes:\n  - Domain filtering is supported to include or block specific websites\n  - Web search is only available in the US\n  - Account for \"Today's date\" in <env>. For example, if <env> says \"Today's date: 2025-07-01\", and the user wants the latest docs, do not use 2024 in the search query. Use 2025.\n","input_schema":{"type":"object","properties":{"query":{"type":"string","minLength":2,"description":"The search query to use"},"allowed_domains":{"type":"array","items":{"type":"string"},"description":"Only include search results from these domains"},"blocked_domains":{"type":"array","items":{"type":"string"},"description":"Never include search results from these domains"}},"required":["query"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"BashOutput","description":"\n- Retrieves output from a running or completed background bash shell\n- Takes a shell_id parameter identifying the shell\n- Always returns only new output since the last check\n- Returns stdout and stderr output along with shell status\n- Supports optional regex filtering to show only lines matching a pattern\n- Use this tool when you need to monitor or check the output of a long-running shell\n- Shell IDs can be found using the /bashes command\n","input_schema":{"type":"object","properties":{"bash_id":{"type":"string","description":"The ID of the background shell to retrieve output from"},"filter":{"type":"string","description":"Optional regular expression to filter the output lines. Only lines matching this regex will be included in the result. Any lines that do not match will no longer be available to read."}},"required":["bash_id"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"KillShell","description":"\n- Kills a running background bash shell by its ID\n- Takes a shell_id parameter identifying the shell to kill\n- Returns a success or failure status \n- Use this tool when you need to terminate a long-running shell\n- Shell IDs can be found using the /bashes command\n","input_schema":{"type":"object","properties":{"shell_id":{"type":"string","description":"The ID of the background shell to kill"}},"required":["shell_id"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Skill","description":"Execute a skill within the main conversation\n\n<skills_instructions>\nWhen users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.\n\nHow to use skills:\n- Invoke skills using this tool with the skill name only (no arguments)\n- When you invoke a skill, you will see <command-message>The \"{name}\" skill is loading</command-message>\n- The skill's prompt will expand and provide detailed instructions on how to complete the task\n- Examples:\n  - `command: \"pdf\"` - invoke the pdf skill\n  - `command: \"xlsx\"` - invoke the xlsx skill\n  - `command: \"ms-office-suite:pdf\"` - invoke using fully qualified name\n\nImportant:\n- Only use skills listed in <available_skills> below\n- Do not invoke a skill that is already running\n- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)\n</skills_instructions>\n\n<available_skills>\n\n</available_skills>\n","input_schema":{"type":"object","properties":{"command":{"type":"string","description":"The skill name (no arguments). E.g., \"pdf\" or \"xlsx\""}},"required":["command"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"SlashCommand","description":"Execute a slash command within the main conversation\n\n**IMPORTANT - Intent Matching:**\nBefore starting any task, CHECK if the user's request matches one of the slash commands listed below. This tool exists to route user intentions to specialized workflows.\n\nHow slash commands work:\nWhen you use this tool or when a user types a slash command, you will see <command-message>{name} is running…</command-message> followed by the expanded prompt. For example, if .claude/commands/foo.md contains \"Print today's date\", then /foo expands to that prompt in the next message.\n\nUsage:\n- `command` (required): The slash command to execute, including any arguments\n- Example: `command: \"/review-pr 123\"`\n\nIMPORTANT: Only use this tool for custom slash commands that appear in the Available Commands list below. Do NOT use for:\n- Built-in CLI commands (like /help, /clear, etc.)\n- Commands not shown in the list\n- Commands you think might exist but aren't listed\n\nNotes:\n- When a user requests multiple slash commands, execute each one sequentially and check for <command-message>{name} is running…</command-message> to verify each has been processed\n- Do not invoke a command that is already running. For example, if you see <command-message>foo is running…</command-message>, do NOT use this tool with \"/foo\" - process the expanded prompt in the following message\n- Only custom slash commands with descriptions are listed in Available Commands. If a user's command is not listed, ask them to check the slash command file and consult the docs.\n","input_schema":{"type":"object","properties":{"command":{"type":"string","description":"The slash command to execute with its arguments, e.g., \"/review-pr 123\""}},"required":["command"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}}],"metadata":{"user_id":"user_f432cd46d7f1eb89e6257e31d6af7ba2a1daa1af69a817ea1784e5c15a24edf5_account__session_b2ba6439-15a7-45d6-a81b-f30266b89346"},"max_tokens":32000,"stream":true}

src/example/claude/originalRequestBody1762501964743.json

@@ -0,0 +1 @@
+{"model":"claude-haiku-4-5-20251001","max_tokens":1,"messages":[{"role":"user","content":"count"}],"tools":[{"name":"Task","description":"Launch a new agent to handle complex, multi-step tasks autonomously. \n\nThe Task tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.\n\nAvailable agent types and the tools they have access to:\n\n\nWhen using the Task tool, you must specify a subagent_type parameter to select which agent type to use.\n\nWhen NOT to use the Task tool:\n- If you want to read a specific file path, use the Read or Glob tool instead of the Task tool, to find the match more quickly\n- If you are searching for a specific class definition like \"class Foo\", use the Glob tool instead, to find the match more quickly\n- If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead of the Task tool, to find the match more quickly\n- Other tasks that are not related to the agent descriptions above\n\n\nUsage notes:\n- Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses\n- When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.\n- Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.\n- Agents with \"access to current context\" can see the full conversation history before the tool call. When using these agents, you can write concise prompts that reference earlier context (e.g., \"investigate the error discussed above\") instead of repeating information. The agent will receive all prior messages and understand the context.\n- The agent's outputs should generally be trusted\n- Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent\n- If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.\n- If the user specifies that they want you to run agents \"in parallel\", you MUST send a single message with multiple Task tool use content blocks. For example, if you need to launch both a code-reviewer agent and a test-runner agent in parallel, send a single message with both tool calls.\n\nExample usage:\n\n<example_agent_descriptions>\n\"code-reviewer\": use this agent after you are done writing a signficant piece of code\n\"greeting-responder\": use this agent when to respond to user greetings with a friendly joke\n</example_agent_description>\n\n<example>\nuser: \"Please write a function that checks if a number is prime\"\nassistant: Sure let me write a function that checks if a number is prime\nassistant: First let me use the Write tool to write a function that checks if a number is prime\nassistant: I'm going to use the Write tool to write the following code:\n<code>\nfunction isPrime(n) {\n  if (n <= 1) return false\n  for (let i = 2; i * i <= n; i++) {\n    if (n % i === 0) return false\n  }\n  return true\n}\n</code>\n<commentary>\nSince a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code\n</commentary>\nassistant: Now let me use the code-reviewer agent to review the code\nassistant: Uses the Task tool to launch the code-reviewer agent \n</example>\n\n<example>\nuser: \"Hello\"\n<commentary>\nSince the user is greeting, use the greeting-responder agent to respond with a friendly joke\n</commentary>\nassistant: \"I'm going to use the Task tool to launch the greeting-responder agent\"\n</example>\n","input_schema":{"type":"object","properties":{"description":{"type":"string","description":"A short (3-5 word) description of the task"},"prompt":{"type":"string","description":"The task for the agent to perform"},"subagent_type":{"type":"string","description":"The type of specialized agent to use for this task"},"model":{"type":"string","enum":["sonnet","opus","haiku"],"description":"Optional model to use for this agent. If not specified, inherits from parent. Prefer haiku for quick, straightforward tasks to minimize cost and latency."},"resume":{"type":"string","description":"Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript."}},"required":["description","prompt","subagent_type"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Bash","description":"Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.\n\nIMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file operations (reading, writing, editing, searching, finding files) - use the specialized tools for this instead.\n\nBefore executing the command, please follow these steps:\n\n1. Directory Verification:\n   - If the command will create new directories or files, first use `ls` to verify the parent directory exists and is the correct location\n   - For example, before running \"mkdir foo/bar\", first use `ls foo` to check that \"foo\" exists and is the intended parent directory\n\n2. Command Execution:\n   - Always quote file paths that contain spaces with double quotes (e.g., cd \"path with spaces/file.txt\")\n   - Examples of proper quoting:\n     - cd \"/Users/name/My Documents\" (correct)\n     - cd /Users/name/My Documents (incorrect - will fail)\n     - python \"/path/with spaces/script.py\" (correct)\n     - python /path/with spaces/script.py (incorrect - will fail)\n   - After ensuring proper quoting, execute the command.\n   - Capture the output of the command.\n\nUsage notes:\n  - The command argument is required.\n  - You can specify an optional timeout in milliseconds (up to 600000ms / 10 minutes). If not specified, commands will timeout after 120000ms (2 minutes).\n  - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.\n  - If the output exceeds 30000 characters, output will be truncated before being returned to you.\n  - You can use the `run_in_background` parameter to run the command in the background, which allows you to continue working while the command runs. You can monitor the output using the Bash tool as it becomes available. You do not need to use '&' at the end of the command when using this parameter.\n  \n  - Avoid using Bash with the `find`, `grep`, `cat`, `head`, `tail`, `sed`, `awk`, or `echo` commands, unless explicitly instructed or when these commands are truly necessary for the task. Instead, always prefer using the dedicated tools for these commands:\n    - File search: Use Glob (NOT find or ls)\n    - Content search: Use Grep (NOT grep or rg)\n    - Read files: Use Read (NOT cat/head/tail)\n    - Edit files: Use Edit (NOT sed/awk)\n    - Write files: Use Write (NOT echo >/cat <<EOF)\n    - Communication: Output text directly (NOT echo/printf)\n  - When issuing multiple commands:\n    - If the commands are independent and can run in parallel, make multiple Bash tool calls in a single message. For example, if you need to run \"git status\" and \"git diff\", send a single message with two Bash tool calls in parallel.\n    - If the commands depend on each other and must run sequentially, use a single Bash call with '&&' to chain them together (e.g., `git add . && git commit -m \"message\" && git push`). For instance, if one operation must complete before another starts (like mkdir before cp, Write before Bash for git operations, or git add before git commit), run these operations sequentially instead.\n    - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail\n    - DO NOT use newlines to separate commands (newlines are ok in quoted strings)\n  - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of `cd`. You may use `cd` if the User explicitly requests it.\n    <good-example>\n    pytest /foo/bar/tests\n    </good-example>\n    <bad-example>\n    cd /foo/bar && pytest tests\n    </bad-example>\n\n# Committing changes with git\n\nOnly create commits when requested by the user. If unclear, ask first. When the user asks you to create a new git commit, follow these steps carefully:\n\nGit Safety Protocol:\n- NEVER update the git config\n- NEVER run destructive/irreversible git commands (like push --force, hard reset, etc) unless the user explicitly requests them \n- NEVER skip hooks (--no-verify, --no-gpg-sign, etc) unless the user explicitly requests it\n- NEVER run force push to main/master, warn the user if they request it\n- Avoid git commit --amend.  ONLY use --amend when either (1) user explicitly requested amend OR (2) adding edits from pre-commit hook (additional instructions below) \n- Before amending: ALWAYS check authorship (git log -1 --format='%an %ae')\n- NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.\n\n1. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following bash commands in parallel, each using the Bash tool:\n  - Run a git status command to see all untracked files.\n  - Run a git diff command to see both staged and unstaged changes that will be committed.\n  - Run a git log command to see recent commit messages, so that you can follow this repository's commit message style.\n2. Analyze all staged changes (both previously staged and newly added) and draft a commit message:\n  - Summarize the nature of the changes (eg. new feature, enhancement to an existing feature, bug fix, refactoring, test, docs, etc.). Ensure the message accurately reflects the changes and their purpose (i.e. \"add\" means a wholly new feature, \"update\" means an enhancement to an existing feature, \"fix\" means a bug fix, etc.).\n  - Do not commit files that likely contain secrets (.env, credentials.json, etc). Warn the user if they specifically request to commit those files\n  - Draft a concise (1-2 sentences) commit message that focuses on the \"why\" rather than the \"what\"\n  - Ensure it accurately reflects the changes and their purpose\n3. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following commands:\n   - Add relevant untracked files to the staging area.\n   - Create the commit with a message ending with:\n   🤖 Generated with [Claude Code](https://claude.com/claude-code)\n\n   Co-Authored-By: Claude <noreply@anthropic.com>\n   - Run git status after the commit completes to verify success.\n   Note: git status depends on the commit completing, so run it sequentially after the commit.\n4. If the commit fails due to pre-commit hook changes, retry ONCE. If it succeeds but files were modified by the hook, verify it's safe to amend:\n   - Check authorship: git log -1 --format='%an %ae'\n   - Check not pushed: git status shows \"Your branch is ahead\"\n   - If both true: amend your commit. Otherwise: create NEW commit (never amend other developers' commits)\n\nImportant notes:\n- NEVER run additional commands to read or explore code, besides git bash commands\n- NEVER use the TodoWrite or Task tools\n- DO NOT push to the remote repository unless the user explicitly asks you to do so\n- IMPORTANT: Never use git commands with the -i flag (like git rebase -i or git add -i) since they require interactive input which is not supported.\n- If there are no changes to commit (i.e., no untracked files and no modifications), do not create an empty commit\n- In order to ensure good formatting, ALWAYS pass the commit message via a HEREDOC, a la this example:\n<example>\ngit commit -m \"$(cat <<'EOF'\n   Commit message here.\n\n   🤖 Generated with [Claude Code](https://claude.com/claude-code)\n\n   Co-Authored-By: Claude <noreply@anthropic.com>\n   EOF\n   )\"\n</example>\n\n# Creating pull requests\nUse the gh command via the Bash tool for ALL GitHub-related tasks including working with issues, pull requests, checks, and releases. If given a Github URL use the gh command to get the information needed.\n\nIMPORTANT: When the user asks you to create a pull request, follow these steps carefully:\n\n1. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following bash commands in parallel using the Bash tool, in order to understand the current state of the branch since it diverged from the main branch:\n   - Run a git status command to see all untracked files\n   - Run a git diff command to see both staged and unstaged changes that will be committed\n   - Check if the current branch tracks a remote branch and is up to date with the remote, so you know if you need to push to the remote\n   - Run a git log command and `git diff [base-branch]...HEAD` to understand the full commit history for the current branch (from the time it diverged from the base branch)\n2. Analyze all changes that will be included in the pull request, making sure to look at all relevant commits (NOT just the latest commit, but ALL commits that will be included in the pull request!!!), and draft a pull request summary\n3. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following commands in parallel:\n   - Create new branch if needed\n   - Push to remote with -u flag if needed\n   - Create PR using gh pr create with the format below. Use a HEREDOC to pass the body to ensure correct formatting.\n<example>\ngh pr create --title \"the pr title\" --body \"$(cat <<'EOF'\n## Summary\n<1-3 bullet points>\n\n## Test plan\n[Bulleted markdown checklist of TODOs for testing the pull request...]\n\n🤖 Generated with [Claude Code](https://claude.com/claude-code)\nEOF\n)\"\n</example>\n\nImportant:\n- DO NOT use the TodoWrite or Task tools\n- Return the PR URL when you're done, so the user can see it\n\n# Other common operations\n- View comments on a Github PR: gh api repos/foo/bar/pulls/123/comments","input_schema":{"type":"object","properties":{"command":{"type":"string","description":"The command to execute"},"timeout":{"type":"number","description":"Optional timeout in milliseconds (max 600000)"},"description":{"type":"string","description":"Clear, concise description of what this command does in 5-10 words, in active voice. Examples:\nInput: ls\nOutput: List files in current directory\n\nInput: git status\nOutput: Show working tree status\n\nInput: npm install\nOutput: Install package dependencies\n\nInput: mkdir foo\nOutput: Create directory 'foo'"},"run_in_background":{"type":"boolean","description":"Set to true to run this command in the background. Use BashOutput to read the output later."},"dangerouslyDisableSandbox":{"type":"boolean","description":"Set this to true to dangerously override sandbox mode and run commands without sandboxing."}},"required":["command"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Glob","description":"- Fast file pattern matching tool that works with any codebase size\n- Supports glob patterns like \"**/*.js\" or \"src/**/*.ts\"\n- Returns matching file paths sorted by modification time\n- Use this tool when you need to find files by name patterns\n- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead\n- You can call multiple tools in a single response. It is always better to speculatively perform multiple searches in parallel if they are potentially useful.","input_schema":{"type":"object","properties":{"pattern":{"type":"string","description":"The glob pattern to match files against"},"path":{"type":"string","description":"The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter \"undefined\" or \"null\" - simply omit it for the default behavior. Must be a valid directory path if provided."}},"required":["pattern"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Grep","description":"A powerful search tool built on ripgrep\n\n  Usage:\n  - ALWAYS use Grep for search tasks. NEVER invoke `grep` or `rg` as a Bash command. The Grep tool has been optimized for correct permissions and access.\n  - Supports full regex syntax (e.g., \"log.*Error\", \"function\\s+\\w+\")\n  - Filter files with glob parameter (e.g., \"*.js\", \"**/*.tsx\") or type parameter (e.g., \"js\", \"py\", \"rust\")\n  - Output modes: \"content\" shows matching lines, \"files_with_matches\" shows only file paths (default), \"count\" shows match counts\n  - Use Task tool for open-ended searches requiring multiple rounds\n  - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use `interface\\{\\}` to find `interface{}` in Go code)\n  - Multiline matching: By default patterns match within single lines only. For cross-line patterns like `struct \\{[\\s\\S]*?field`, use `multiline: true`\n","input_schema":{"type":"object","properties":{"pattern":{"type":"string","description":"The regular expression pattern to search for in file contents"},"path":{"type":"string","description":"File or directory to search in (rg PATH). Defaults to current working directory."},"glob":{"type":"string","description":"Glob pattern to filter files (e.g. \"*.js\", \"*.{ts,tsx}\") - maps to rg --glob"},"output_mode":{"type":"string","enum":["content","files_with_matches","count"],"description":"Output mode: \"content\" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), \"files_with_matches\" shows file paths (supports head_limit), \"count\" shows match counts (supports head_limit). Defaults to \"files_with_matches\"."},"-B":{"type":"number","description":"Number of lines to show before each match (rg -B). Requires output_mode: \"content\", ignored otherwise."},"-A":{"type":"number","description":"Number of lines to show after each match (rg -A). Requires output_mode: \"content\", ignored otherwise."},"-C":{"type":"number","description":"Number of lines to show before and after each match (rg -C). Requires output_mode: \"content\", ignored otherwise."},"-n":{"type":"boolean","description":"Show line numbers in output (rg -n). Requires output_mode: \"content\", ignored otherwise. Defaults to true."},"-i":{"type":"boolean","description":"Case insensitive search (rg -i)"},"type":{"type":"string","description":"File type to search (rg --type). Common types: js, py, rust, go, java, etc. More efficient than include for standard file types."},"head_limit":{"type":"number","description":"Limit output to first N lines/entries, equivalent to \"| head -N\". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults based on \"cap\" experiment value: 0 (unlimited), 20, or 100."},"offset":{"type":"number","description":"Skip first N lines/entries before applying head_limit, equivalent to \"| tail -n +N | head -N\". Works across all output modes. Defaults to 0."},"multiline":{"type":"boolean","description":"Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false."}},"required":["pattern"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"ExitPlanMode","description":"Use this tool when you are in plan mode and have finished presenting your plan and are ready to code. This will prompt the user to exit plan mode.\nIMPORTANT: Only use this tool when the task requires planning the implementation steps of a task that requires writing code. For research tasks where you're gathering information, searching files, reading files or in general trying to understand the codebase - do NOT use this tool.\n\n## Handling Ambiguity in Plans\nBefore using this tool, ensure your plan is clear and unambiguous. If there are multiple valid approaches or unclear requirements:\n1. Use the AskUserQuestion tool to clarify with the user\n2. Ask about specific implementation choices (e.g., architectural patterns, which library to use)\n3. Clarify any assumptions that could affect the implementation\n4. Only proceed with ExitPlanMode after resolving ambiguities\n\n## Examples\n\n1. Initial task: \"Search for and understand the implementation of vim mode in the codebase\" - Do not use the exit plan mode tool because you are not planning the implementation steps of a task.\n2. Initial task: \"Help me implement yank mode for vim\" - Use the exit plan mode tool after you have finished planning the implementation steps of the task.\n3. Initial task: \"Add a new feature to handle user authentication\" - If unsure about auth method (OAuth, JWT, etc.), use AskUserQuestion first, then use exit plan mode tool after clarifying the approach.\n","input_schema":{"type":"object","properties":{"plan":{"type":"string","description":"The plan you came up with, that you want to run by the user for approval. Supports markdown. The plan should be pretty concise."}},"required":["plan"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Read","description":"Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.\n- This tool can read PDF files (.pdf). PDFs are processed page by page, extracting both text and visual content for analysis.\n- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.\n- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.\n- You can call multiple tools in a single response. It is always better to speculatively read multiple potentially useful files in parallel.\n- You will regularly be asked to read screenshots. If the user provides a path to a screenshot, ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths.\n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.","input_schema":{"type":"object","properties":{"file_path":{"type":"string","description":"The absolute path to the file to read"},"offset":{"type":"number","description":"The line number to start reading from. Only provide if the file is too large to read at once"},"limit":{"type":"number","description":"The number of lines to read. Only provide if the file is too large to read at once."}},"required":["file_path"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Edit","description":"Performs exact string replacements in files. \n\nUsage:\n- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. \n- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.\n- The edit will FAIL if `old_string` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`. \n- Use `replace_all` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.","input_schema":{"type":"object","properties":{"file_path":{"type":"string","description":"The absolute path to the file to modify"},"old_string":{"type":"string","description":"The text to replace"},"new_string":{"type":"string","description":"The text to replace it with (must be different from old_string)"},"replace_all":{"type":"boolean","default":false,"description":"Replace all occurences of old_string (default false)"}},"required":["file_path","old_string","new_string"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Write","description":"Writes a file to the local filesystem.\n\nUsage:\n- This tool will overwrite the existing file if there is one at the provided path.\n- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.\n- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.","input_schema":{"type":"object","properties":{"file_path":{"type":"string","description":"The absolute path to the file to write (must be absolute, not relative)"},"content":{"type":"string","description":"The content to write to the file"}},"required":["file_path","content"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"NotebookEdit","description":"Completely replaces the contents of a specific cell in a Jupyter notebook (.ipynb file) with new source. Jupyter notebooks are interactive documents that combine code, text, and visualizations, commonly used for data analysis and scientific computing. The notebook_path parameter must be an absolute path, not a relative path. The cell_number is 0-indexed. Use edit_mode=insert to add a new cell at the index specified by cell_number. Use edit_mode=delete to delete the cell at the index specified by cell_number.","input_schema":{"type":"object","properties":{"notebook_path":{"type":"string","description":"The absolute path to the Jupyter notebook file to edit (must be absolute, not relative)"},"cell_id":{"type":"string","description":"The ID of the cell to edit. When inserting a new cell, the new cell will be inserted after the cell with this ID, or at the beginning if not specified."},"new_source":{"type":"string","description":"The new source for the cell"},"cell_type":{"type":"string","enum":["code","markdown"],"description":"The type of the cell (code or markdown). If not specified, it defaults to the current cell type. If using edit_mode=insert, this is required."},"edit_mode":{"type":"string","enum":["replace","insert","delete"],"description":"The type of edit to make (replace, insert, delete). Defaults to replace."}},"required":["notebook_path","new_source"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"WebFetch","description":"\n- Fetches content from a specified URL and processes it using an AI model\n- Takes a URL and a prompt as input\n- Fetches the URL content, converts HTML to markdown\n- Processes the content with the prompt using a small, fast model\n- Returns the model's response about the content\n- Use this tool when you need to retrieve and analyze web content\n\nUsage notes:\n  - IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions. All MCP-provided tools start with \"mcp__\".\n  - The URL must be a fully-formed valid URL\n  - HTTP URLs will be automatically upgraded to HTTPS\n  - The prompt should describe what information you want to extract from the page\n  - This tool is read-only and does not modify any files\n  - Results may be summarized if the content is very large\n  - Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL\n  - When a URL redirects to a different host, the tool will inform you and provide the redirect URL in a special format. You should then make a new WebFetch request with the redirect URL to fetch the content.\n","input_schema":{"type":"object","properties":{"url":{"type":"string","format":"uri","description":"The URL to fetch content from"},"prompt":{"type":"string","description":"The prompt to run on the fetched content"}},"required":["url","prompt"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"TodoWrite","description":"Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.\nIt also helps the user understand the progress of the task and overall progress of their requests.\n\n## When to Use This Tool\nUse this tool proactively in these scenarios:\n\n1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions\n2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations\n3. User explicitly requests todo list - When the user directly asks you to use the todo list\n4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)\n5. After receiving new instructions - Immediately capture user requirements as todos\n6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time\n7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation\n\n## When NOT to Use This Tool\n\nSkip using this tool when:\n1. There is only a single, straightforward task\n2. The task is trivial and tracking it provides no organizational benefit\n3. The task can be completed in less than 3 trivial steps\n4. The task is purely conversational or informational\n\nNOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.\n\n## Examples of When to Use the Todo List\n\n<example>\nUser: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!\nAssistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.\n*Creates todo list with the following items:*\n1. Creating dark mode toggle component in Settings page\n2. Adding dark mode state management (context/store)\n3. Implementing CSS-in-JS styles for dark theme\n4. Updating existing components to support theme switching\n5. Running tests and build process, addressing any failures or errors that occur\n*Begins working on the first task*\n\n<reasoning>\nThe assistant used the todo list because:\n1. Adding dark mode is a multi-step feature requiring UI, state management, and styling changes\n2. The user explicitly requested tests and build be run afterward\n3. The assistant inferred that tests and build need to pass by adding \"Ensure tests and build succeed\" as the final task\n</reasoning>\n</example>\n\n<example>\nUser: Help me rename the function getCwd to getCurrentWorkingDirectory across my project\nAssistant: Let me first search through your codebase to find all occurrences of 'getCwd'.\n*Uses grep or search tools to locate all instances of getCwd in the codebase*\nAssistant: I've found 15 instances of 'getCwd' across 8 different files. Let me create a todo list to track these changes.\n*Creates todo list with specific items for each file that needs updating*\n\n<reasoning>\nThe assistant used the todo list because:\n1. First, the assistant searched to understand the scope of the task\n2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps\n3. The todo list helps ensure every instance is tracked and updated systematically\n4. This approach prevents missing any occurrences and maintains code consistency\n</reasoning>\n</example>\n\n\n<example>\nUser: I need to implement these features for my e-commerce site: user registration, product catalog, shopping cart, and checkout flow.\nAssistant: I'll help implement these features. First, let's add all the features to the todo list.\n*Creates a todo list breaking down each feature into specific tasks based on the project architecture*\nAssistant: Let's start with user registration. This will involve creating database models, API endpoints, and frontend forms that integrate with your existing authentication system.\n\n<reasoning>\nThe assistant used the todo list because:\n1. The user provided multiple complex features to implement in a comma separated list\n2. The todo list helps organize these large features into manageable tasks\n3. This approach allows for tracking progress across the entire implementation\n</reasoning>\n</example>\n\n<example>\nUser: Can you help optimize my React application? It's rendering slowly and has performance issues.</user>\nAssistant: I'll help optimize your React application. First, let me examine your codebase to identify potential performance bottlenecks.\n*Reviews component structure, render patterns, state management, and data fetching*\nAssistant: After analyzing your codebase, I've identified several performance issues. Let me create a todo list to track our optimization efforts.\n*Creates todo list with items like: 1) Implementing memoization for expensive calculations in ProductList, 2) Adding virtualization for long lists in Dashboard, 3) Optimizing image loading in Gallery component, 4) Fixing state update loops in ShoppingCart, 5) Reviewing bundle size and implementing code splitting*\nLet's start by implementing memoization for the expensive calculations in your ProductList component.</assistant>\n\n<reasoning>\nThe assistant used the todo list because:\n1. First, the assistant examined the codebase to identify specific performance issues\n2. Based on this analysis, it identified multiple optimization opportunities\n3. Performance optimization is a non-trivial task requiring multiple steps\n4. The todo list helps methodically track improvements across different components\n5. This systematic approach ensures all performance bottlenecks are addressed\n</reasoning>\n</example>\n\n## Examples of When NOT to Use the Todo List\n\n<example>\nUser: How do I print 'Hello World' in Python?\nAssistant: In Python, you can print \"Hello World\" with this simple code:\n\npython\nprint(\"Hello World\")\n\nThis will output the text \"Hello World\" to the console when executed.</assistant>\n\n<reasoning>\nThe assistant did not use the todo list because this is a single, trivial task that can be completed in one step. There's no need to track multiple tasks or steps for such a straightforward request.\n</reasoning>\n</example>\n\n<example>\nUser: What does the git status command do?\nAssistant: The git status command shows the current state of your working directory and staging area. It displays which changes have been staged, which haven't, and which files aren't being tracked by Git. This is a fundamental command for understanding the current state of your repository before making commits.\n\n<reasoning>\nThe assistant did not use the todo list because this is an informational request with no actual coding task to complete. The user is simply asking for an explanation, not for the assistant to perform multiple steps or tasks.\n</reasoning>\n</example>\n\n<example>\nUser: Can you add a comment to the calculateTotal function to explain what it does?\nAssistant: Sure, let me add a comment to the calculateTotal function to explain what it does.\n* Uses the Edit tool to add a comment to the calculateTotal function *\n\n<reasoning>\nThe assistant did not use the todo list because this is a single, straightforward task confined to one location in the code. Adding a comment doesn't require tracking multiple steps or systematic organization.\n</reasoning>\n</example>\n\n<example>\nUser: Run npm install for me and tell me what happens.\nAssistant: I'll run the npm install command for you.\n\n*Executes: npm install*\n\nThe command completed successfully. Here's the output:\n[Output of npm install command]\n\nAll dependencies have been installed according to your package.json file.\n\n<reasoning>\nThe assistant did not use the todo list because this is a single command execution with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward task.\n</reasoning>\n</example>\n\n## Task States and Management\n\n1. **Task States**: Use these states to track progress:\n   - pending: Task not yet started\n   - in_progress: Currently working on (limit to ONE task at a time)\n   - completed: Task finished successfully\n\n   **IMPORTANT**: Task descriptions must have two forms:\n   - content: The imperative form describing what needs to be done (e.g., \"Run tests\", \"Build the project\")\n   - activeForm: The present continuous form shown during execution (e.g., \"Running tests\", \"Building the project\")\n\n2. **Task Management**:\n   - Update task status in real-time as you work\n   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)\n   - Exactly ONE task must be in_progress at any time (not less, not more)\n   - Complete current tasks before starting new ones\n   - Remove tasks that are no longer relevant from the list entirely\n\n3. **Task Completion Requirements**:\n   - ONLY mark a task as completed when you have FULLY accomplished it\n   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress\n   - When blocked, create a new task describing what needs to be resolved\n   - Never mark a task as completed if:\n     - Tests are failing\n     - Implementation is partial\n     - You encountered unresolved errors\n     - You couldn't find necessary files or dependencies\n\n4. **Task Breakdown**:\n   - Create specific, actionable items\n   - Break complex tasks into smaller, manageable steps\n   - Use clear, descriptive task names\n   - Always provide both forms:\n     - content: \"Fix authentication bug\"\n     - activeForm: \"Fixing authentication bug\"\n\nWhen in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.\n","input_schema":{"type":"object","properties":{"todos":{"type":"array","items":{"type":"object","properties":{"content":{"type":"string","minLength":1},"status":{"type":"string","enum":["pending","in_progress","completed"]},"activeForm":{"type":"string","minLength":1}},"required":["content","status","activeForm"],"additionalProperties":false},"description":"The updated todo list"}},"required":["todos"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"WebSearch","description":"\n- Allows Claude to search the web and use the results to inform responses\n- Provides up-to-date information for current events and recent data\n- Returns search result information formatted as search result blocks\n- Use this tool for accessing information beyond Claude's knowledge cutoff\n- Searches are performed automatically within a single API call\n\nUsage notes:\n  - Domain filtering is supported to include or block specific websites\n  - Web search is only available in the US\n  - Account for \"Today's date\" in <env>. For example, if <env> says \"Today's date: 2025-07-01\", and the user wants the latest docs, do not use 2024 in the search query. Use 2025.\n","input_schema":{"type":"object","properties":{"query":{"type":"string","minLength":2,"description":"The search query to use"},"allowed_domains":{"type":"array","items":{"type":"string"},"description":"Only include search results from these domains"},"blocked_domains":{"type":"array","items":{"type":"string"},"description":"Never include search results from these domains"}},"required":["query"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"BashOutput","description":"\n- Retrieves output from a running or completed background bash shell\n- Takes a shell_id parameter identifying the shell\n- Always returns only new output since the last check\n- Returns stdout and stderr output along with shell status\n- Supports optional regex filtering to show only lines matching a pattern\n- Use this tool when you need to monitor or check the output of a long-running shell\n- Shell IDs can be found using the /bashes command\n","input_schema":{"type":"object","properties":{"bash_id":{"type":"string","description":"The ID of the background shell to retrieve output from"},"filter":{"type":"string","description":"Optional regular expression to filter the output lines. Only lines matching this regex will be included in the result. Any lines that do not match will no longer be available to read."}},"required":["bash_id"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"KillShell","description":"\n- Kills a running background bash shell by its ID\n- Takes a shell_id parameter identifying the shell to kill\n- Returns a success or failure status \n- Use this tool when you need to terminate a long-running shell\n- Shell IDs can be found using the /bashes command\n","input_schema":{"type":"object","properties":{"shell_id":{"type":"string","description":"The ID of the background shell to kill"}},"required":["shell_id"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"Skill","description":"Execute a skill within the main conversation\n\n<skills_instructions>\nWhen users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.\n\nHow to use skills:\n- Invoke skills using this tool with the skill name only (no arguments)\n- When you invoke a skill, you will see <command-message>The \"{name}\" skill is loading</command-message>\n- The skill's prompt will expand and provide detailed instructions on how to complete the task\n- Examples:\n  - `command: \"pdf\"` - invoke the pdf skill\n  - `command: \"xlsx\"` - invoke the xlsx skill\n  - `command: \"ms-office-suite:pdf\"` - invoke using fully qualified name\n\nImportant:\n- Only use skills listed in <available_skills> below\n- Do not invoke a skill that is already running\n- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)\n</skills_instructions>\n\n<available_skills>\n\n</available_skills>\n","input_schema":{"type":"object","properties":{"command":{"type":"string","description":"The skill name (no arguments). E.g., \"pdf\" or \"xlsx\""}},"required":["command"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}},{"name":"SlashCommand","description":"Execute a slash command within the main conversation\n\n**IMPORTANT - Intent Matching:**\nBefore starting any task, CHECK if the user's request matches one of the slash commands listed below. This tool exists to route user intentions to specialized workflows.\n\nHow slash commands work:\nWhen you use this tool or when a user types a slash command, you will see <command-message>{name} is running…</command-message> followed by the expanded prompt. For example, if .claude/commands/foo.md contains \"Print today's date\", then /foo expands to that prompt in the next message.\n\nUsage:\n- `command` (required): The slash command to execute, including any arguments\n- Example: `command: \"/review-pr 123\"`\n\nIMPORTANT: Only use this tool for custom slash commands that appear in the Available Commands list below. Do NOT use for:\n- Built-in CLI commands (like /help, /clear, etc.)\n- Commands not shown in the list\n- Commands you think might exist but aren't listed\n\nNotes:\n- When a user requests multiple slash commands, execute each one sequentially and check for <command-message>{name} is running…</command-message> to verify each has been processed\n- Do not invoke a command that is already running. For example, if you see <command-message>foo is running…</command-message>, do NOT use this tool with \"/foo\" - process the expanded prompt in the following message\n- Only custom slash commands with descriptions are listed in Available Commands. If a user's command is not listed, ask them to check the slash command file and consult the docs.\n","input_schema":{"type":"object","properties":{"command":{"type":"string","description":"The slash command to execute with its arguments, e.g., \"/review-pr 123\""}},"required":["command"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}}],"metadata":{"user_id":"user_f432cd46d7f1eb89e6257e31d6af7ba2a1daa1af69a817ea1784e5c15a24edf5_account__session_ed2d8ac7-3aba-4db0-a755-ee9ce121461e"}}