Upload 5 files

deprecated_javascript_version/README.md

@@ -0,0 +1,233 @@
+# AI Studio Proxy Server (Javascript Version - DEPRECATED)
+
+**⚠️ 警告：此 Javascript 版本 (`server.cjs`, `auto_connect_aistudio.cjs`) 已被弃用且不再维护。推荐使用项目根目录下的 Python 版本，该版本采用了模块化架构设计，具有更好的稳定性和可维护性。**
+
+**📖 查看最新文档**: 请参考项目根目录下的 [`README.md`](../README.md) 了解当前Python版本的完整使用说明。
+
+---
+
+[点击查看项目使用演示视频](https://drive.google.com/file/d/1efR-cNG2CNboNpogHA1ASzmx45wO579p/view?usp=drive_link)
+
+这是一个 Node.js + Playwright 服务器，通过模拟 OpenAI API 的方式来访问 Google AI Studio 网页版，服务器无缝交互转发 Gemini 对话。这使得兼容 OpenAI API 的客户端（如 Open WebUI, NextChat 等）可以使用 AI Studio 的无限额度及能力。
+
+## ✨ 特性 (Javascript 版本)
+
+*   **OpenAI API 兼容**: 提供 `/v1/chat/completions` 和 `/v1/models` 端点，兼容大多数 OpenAI 客户端。
+*   **流式响应**: 支持 `stream=true`，实现打字机效果。
+*   **非流式响应**: 支持 `stream=false`，一次性返回完整 JSON 响应。
+*   **系统提示词 (System Prompt)**: 支持通过请求体中的 `messages` 数组的 `system` 角色或额外的 `system_prompt` 字段传递系统提示词。
+*   **内部 Prompt 优化**: 自动包装用户输入，指导 AI Studio 输出特定格式（流式为 Markdown 代码块，非流式为 JSON），并包含起始标记 `<<<START_RESPONSE>>>` 以便解析。
+*   **自动连接脚本 (`auto_connect_aistudio.cjs`)**:
+    *   自动查找并启动 Chrome/Chromium 浏览器，开启调试端口，**并设置特定窗口宽度 (460px)** 以优化布局，确保"清空聊天"按钮可见。
+    *   自动检测并尝试连接已存在的 Chrome 调试实例。
+    *   提供交互式选项，允许用户选择连接现有实例或自动结束冲突进程。
+    *   自动查找或打开 AI Studio 的 `New chat` 页面。
+    *   自动启动 `server.cjs`。
+*   **服务端 (`server.cjs`)**:
+    *   连接到由 `auto_connect_aistudio.cjs` 管理的 Chrome 实例。
+    *   **自动清空上下文**: 当检测到来自客户端的请求可能是"新对话"时（基于消息历史长度），自动模拟点击 AI Studio 页面上的"Clear chat"按钮及其确认对话框，并验证清空效果，以实现更好的会话隔离。
+    *   处理 API 请求，通过 Playwright 操作 AI Studio 页面。
+    *   解析 AI Studio 的响应，提取有效内容。
+    *   提供简单的 Web UI (`/`) 进行基本测试。
+    *   提供健康检查端点 (`/health`)。
+*   **错误快照**: 在 Playwright 操作、响应解析或**清空聊天**出错时，自动在项目根目录下的 `errors/` 目录下保存页面截图和 HTML，方便调试。(注意: Python 版本错误快照在 `errors_py/`)
+*   **依赖检测**: 两个脚本在启动时都会检查所需依赖，并提供安装指导。
+*   **跨平台设计**: 旨在支持 macOS, Linux 和 Windows (WSL 推荐)。
+
+## ⚠️ 重要提示 (Javascript 版本)
+
+*   **非官方项目**: 本项目与 Google 无关，依赖于对 AI Studio Web 界面的自动化操作，可能因 AI Studio 页面更新而失效。
+*   **自动清空功能的脆弱性**: 自动清空上下文的功能依赖于精确的 UI 元素选择器 (`CLEAR_CHAT_BUTTON_SELECTOR`, `CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR` 在 `server.cjs` 中)。如果 AI Studio 页面结构发生变化，此功能可能会失效。届时需要更新这些选择器。
+*   **不支持历史编辑/分叉**: 即使实现了新对话的上下文清空，本代理仍然无法支持客户端进行历史消息编辑并从该点重新生成对话的功能。AI Studio 内部维护的对话历史是线性的。
+*   **固定窗口宽度**: `auto_connect_aistudio.cjs` 会以固定的宽度 (460px) 启动 Chrome 窗口，以确保清空按钮可见。
+*   **安全性**: 启动 Chrome 时开启了远程调试端口 (默认为 `8848`)，请确保此端口仅在受信任的网络环境中使用，或通过防火墙规则限制访问。切勿将此端口暴露到公网。
+*   **稳定性**: 由于依赖浏览器自动化，其稳定性不如官方 API。长时间运行或频繁请求可能导致页面无响应或连接中断，可能需要重启浏览器或服务器。
+*   **AI Studio 限制**: AI Studio 本身可能有请求频率限制、内容策略限制等，代理服务器无法绕过这些限制。
+*   **参数配置**: **像模型选择、温度、输出长度等参数，需要您直接在 AI Studio 页面的右侧设置面板中进行调整。本代理服务器目前不处理或转发这些通过 API 请求传递的参数。** 您需要预先在 AI Studio Web UI 中设置好所需的模型和参数。
+
+## 🛠️ 配置 (Javascript 版本)
+
+虽然不建议频繁修改，但了解以下常量可能有助于理解脚本行为或在特殊情况下进行调整：
+
+**`auto_connect_aistudio.cjs`:**
+
+*   `DEBUGGING_PORT`: (默认 `8848`) Chrome 浏览器启动时使用的远程调试端口。
+*   `TARGET_URL`: (默认 `'https://aistudio.google.com/prompts/new_chat'`) 脚本尝试打开或导航到的 AI Studio 页面。
+*   `SERVER_SCRIPT_FILENAME`: (默认 `'server.cjs'`) 由此脚本自动启动的 API 服务器文件名。
+*   `CONNECT_TIMEOUT_MS`: (默认 `20000`) 连接到 Chrome 调试端口的超时时间 (毫秒)。
+*   `NAVIGATION_TIMEOUT_MS`: (默认 `35000`) Playwright 等待页面导航完成的超时时间 (毫秒)。
+*   `--window-size=460,...`: 启动 Chrome 时传递的参数，固定宽度以保证 UI 元素（如清空按钮）位置相对稳定。
+
+**`server.cjs`:**
+
+*   `SERVER_PORT`: (默认 `2048`) API 服务器监听的端口。
+*   `AI_STUDIO_URL_PATTERN`: (默认 `'aistudio.google.com/'`) 用于识别 AI Studio 页面的 URL 片段。
+*   `RESPONSE_COMPLETION_TIMEOUT`: (默认 `300000`) 等待 AI Studio 响应完成的总超时时间 (毫秒，5分钟)。
+*   `POLLING_INTERVAL`: (默认 `300`) 轮询检查 AI Studio 页面状态的间隔 (毫秒)。
+*   `SILENCE_TIMEOUT_MS`: (默认 `3000`) 判断 AI Studio 是否停止输出的静默超时时间 (毫秒)。
+*   `CLEAR_CHAT_VERIFY_TIMEOUT_MS`: (默认 `5000`) 等待并验证清空聊天操作完成的超时时间 (毫秒)。
+*   **CSS 选择器**: (`INPUT_SELECTOR`, `SUBMIT_BUTTON_SELECTOR`, `RESPONSE_CONTAINER_SELECTOR`, `LOADING_SPINNER_SELECTOR`, `ERROR_TOAST_SELECTOR`, `CLEAR_CHAT_BUTTON_SELECTOR`, `CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR`) 这些常量定义了脚本用于查找页面元素的选择器。**修改这些值需要具备前端知识，并且如果 AI Studio 页面更新，这些是最可能需要调整的部分。**
+
+## ⚙️ Prompt 内部处理 (Javascript 版本)
+
+为了让代理能够解析 AI Studio 的输出，`server.cjs` 会在将你的 Prompt 发送到 AI Studio 前进行包装，加入特定的指令，要求 AI：
+
+1.  **对于非流式请求 (`stream=false`)**: 将整个回复包裹在一个 JSON 对象中，格式为 `{"response": "<<<START_RESPONSE>>>[AI的实际回复]"}`。
+2.  **对于流式请求 (`stream=true`)**: 将整个回复（包括开始和结束）包裹在一个 Markdown 代码块 (```) 中，并在实际回复前加上标记 `<<<START_RESPONSE>>>`，形如：
+    ```markdown
+    ```
+    <<<START_RESPONSE>>>[AI的实际回复第一部分]
+    [AI的实际回复第二部分]
+    ...
+    ```
+    ```
+
+`server.cjs` 会查找 `<<<START_RESPONSE>>>` 标记来提取真正的回复内容。这意味着你通过 API 得到的回复是经过这个内部处理流程的，AI Studio 页面的原始输出格式会被改变。
+
+## 🚀 开始使用 (Javascript 版本)
+
+### 1. 先决条件
+
+*   **Node.js**: v16 或更高版本。
+*   **NPM / Yarn / PNPM**: 用于安装依赖。
+*   **Google Chrome / Chromium**: 需要安装浏览器本体。
+*   **Google AI Studio 账号**: 并能正常访问和使用。
+
+### 2. 安装
+
+1.  **进入弃用版本目录**:
+    ```bash
+    cd deprecated_javascript_version
+    ```
+
+2.  **安装依赖**:
+    根据 `package.json` 文件，脚本运行需要以下核心依赖：
+    *   `express`: Web 框架，用于构建 API 服务器。
+    *   `cors`: 处理跨域资源共享。
+    *   `playwright`: 浏览器自动化库。
+    *   `@playwright/test`: Playwright 的测试库，`server.cjs` 使用其 `expect` 功能进行断言。
+
+    使用你的包管理器安装：
+    ```bash
+    npm install
+    # 或
+    yarn install
+    # 或
+    pnpm install
+    ```
+
+### 3. 运行
+
+只需要运行 `auto_connect_aistudio.cjs` 脚本即可启动所有服务：
+
+```bash
+node auto_connect_aistudio.cjs
+```
+
+这个脚本会执行以下操作：
+
+1.  **检查依赖**: 确认上述 Node.js 模块已安装，且 `server.cjs` 文件存在。
+2.  **检查 Chrome 调试端口 (`8848`)**:
+    *   如果端口空闲，尝试自动查找并启动一个新的 Chrome 实例（窗口宽度固定为 460px），并打开远程调试端口。
+    *   如果端口被占用，询问用户是连接现有实例还是尝试清理端口后启动新实例。
+3.  **连接 Playwright**: 尝试连接到 Chrome 的调试端口 (`http://127.0.0.1:8848`)。
+4.  **管理 AI Studio 页面**: 查找或打开 AI Studio 的 `New chat` 页面 (`https://aistudio.google.com/prompts/new_chat`)，并尝试置于前台。
+5.  **启动 API 服务器**: 如果以上步骤成功，脚本会自动在后台启动 `node server.cjs`。
+
+当 `server.cjs` 成功启动并连接到 Playwright 后，您将在终端看到类似以下的输出（来自 `server.cjs`）：
+
+```
+=============================================================
+          🚀 AI Studio Proxy Server (vX.XX - Queue & Auto Clear) 🚀
+=============================================================
+🔗 监听地址: http://localhost:2048
+   - Web UI (测试): http://localhost:2048/
+   - API 端点:   http://localhost:2048/v1/chat/completions
+   - 模型接口:   http://localhost:2048/v1/models
+   - 健康检查:   http://localhost:2048/health
+-------------------------------------------------------------
+✅ Playwright 连接成功，服务已准备就绪！
+-------------------------------------------------------------
+```
+*(版本号可能不同)*
+
+此时，代理服务已准备就绪，监听在 `http://localhost:2048`。
+
+### 4. 配置客户端 (以 Open WebUI 为例)
+
+1.  打开 Open WebUI。
+2.  进入 "设置" -> "连接"。
+3.  在 "模型" 部分，点击 "添加模型"。
+4.  **模型名称**: 输入你想要的名字，例如 `aistudio-gemini-cjs`。
+5.  **API 基础 URL**: 输入代理服务器的地址，例如 `http://localhost:2048/v1` (注意包含 `/v1`)。
+6.  **API 密钥**: 留空或输入任意字符 (服务器不验证)。
+7.  保存设置。
+8.  现在，你应该可以在 Open WebUI 中选择 `aistudio-gemini-cjs` 模型并开始聊天了。
+
+### 5. 使用测试脚本 (可选)
+
+本目录下提供了一个 `test.js` 脚本，用于在命令行中直接与代理进行交互式聊天。
+
+1.  **安装额外依赖**: `test.js` 使用了 OpenAI 的官方 Node.js SDK。
+    ```bash
+    npm install openai
+    # 或 yarn add openai / pnpm add openai
+    ```
+2.  **检查配置**: 打开 `test.js`，确认 `LOCAL_PROXY_URL` 指向你的代理服务器地址 (`http://127.0.0.1:2048/v1/`)。`DUMMY_API_KEY` 可以保持不变。
+3.  **运行测试**: 在 `deprecated_javascript_version` 目录下运行：
+    ```bash
+    node test.js
+    ```
+    之后就可以在命令行输入问题进行测试了。输入 `exit` 退出。
+
+## 💻 多平台指南 (Javascript 版本)
+
+*   **macOS**:
+    *   `auto_connect_aistudio.cjs` 通常能自动找到 Chrome。
+    *   防火墙可能会提示是否允许 Node.js 接受网络连接，请允许。
+*   **Linux**:
+    *   确保已安装 `google-chrome-stable` 或 `chromium-browser`。
+    *   如果脚本找不到 Chrome，你可能需要修改 `auto_connect_aistudio.cjs` 中的 `getChromePath` 函数，手动指定路径，或者创建一个符号链接 (`/usr/bin/google-chrome`) 指向实际的 Chrome 可执行文件。
+    *   某些 Linux 发行版可能需要安装额外的 Playwright 依赖库，参考 [Playwright Linux 文档](https://playwright.dev/docs/intro#system-requirements)。运行 `npx playwright install-deps` 可能有助于安装。
+*   **Windows**:
+    *   **强烈建议使用 WSL (Windows Subsystem for Linux)**。在 WSL 中按照 Linux 指南操作通常更顺畅。
+    *   **直接在 Windows 上运行 (不推荐)**:
+        *   `auto_connect_aistudio.cjs` 可能需要手动修改 `getChromePath` 函数来指定 Chrome 的完整路径 (例如 `C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe`)。注意路径中的反斜杠需要转义 (`\\`)。
+        *   防火墙设置需要允许 Node.js 和 Chrome 监听和连接端口 (`8848` 和 `2048`)。
+        *   由于文件系统和权限差异，可能会遇到未知问题，例如端口检查或进程结束操作 (`taskkill`) 失败。
+
+## 🔧 故障排除 (Javascript 版本)
+
+*   **`auto_connect_aistudio.cjs` 启动失败或报错**:
+    *   **依赖未找到**: 确认运行了 `npm install` 等命令。
+    *   **Chrome 路径找不到**: 确认 Chrome/Chromium 已安装，并按需修改 `getChromePath` 函数或创建符号链接 (Linux)。
+    *   **端口 (`8848`) 被占用且无法自动清理**: 根据脚本提示，使用系统工具（如 `lsof -i :8848` / `tasklist | findstr "8848"`）手动查找并结束占用端口的进程。
+    *   **连接 Playwright 超时**: 确认 Chrome 是否已成功启动并监听 `8848` 端口，防火墙是否阻止本地连接 `127.0.0.1:8848`。查看 `auto_connect_aistudio.cjs` 中的 `CONNECT_TIMEOUT_MS` 是否足够。
+    *   **打开/导航 AI Studio 页面失败**: 检查网络连接，尝试手动在浏览器中打开 `https://aistudio.google.com/prompts/new_chat` 并完成登录。查看 `NAVIGATION_TIMEOUT_MS` 是否足够。
+    *   **窗口大小问题**: 如果 460px 宽度导致问题，可以尝试修改 `auto_connect_aistudio.cjs` 中的 `--window-size` 参数，但这可能影响自动清空功能。
+*   **`server.cjs` 启动时提示端口被占用 (`EADDRINUSE`)**:
+    *   检查是否有其他程序 (包括旧的服务器实例) 正在使用 `2048` 端口。关闭冲突程序或修改 `server.cjs` 中的 `SERVER_PORT`。
+*   **服务器日志显示 Playwright 未就绪或连接失败 (在 `server.cjs` 启动后)**:
+    *   通常意味着 `auto_connect_aistudio.cjs` 启动的 Chrome 实例意外关闭或无响应。检查 Chrome 窗口是否还在，AI Studio 页面是否崩溃。
+    *   尝试关闭所有相关进程（`node` 和 `chrome`），然后重新运行 `node auto_connect_aistudio.cjs`。
+    *   检查根目录下的 `errors/` 目录是否有截图和 HTML 文件，它们可能包含 AI Studio 页面的错误信息或状态。
+*   **客户端 (如 Open WebUI) 无法连接或请求失败**: 
+    *   确认 API 基础 URL 配置正确 (`http://localhost:2048/v1`)。
+    *   检查 `server.cjs` 运行的终端是否有错误输出。
+    *   确保客户端和服务器在同一网络中，且防火墙没有阻止从客户端到服务器 `2048` 端口的连接。
+*   **API 请求返回 5xx 错误**: 
+    *   **503 Service Unavailable / Playwright not ready**: `server.cjs` 无法连接到 Chrome。
+    *   **504 Gateway Timeout**: 请求处理时间超过了 `RESPONSE_COMPLETION_TIMEOUT`。可能是 AI Studio 响应慢或卡住了。
+    *   **502 Bad Gateway / AI Studio Error**: `server.cjs` 在 AI Studio 页面上检测到了错误提示 (`toast` 消息)，或无法正确解析 AI 的响应。检查 `errors/` 快照。
+    *   **500 Internal Server Error**: `server.cjs` 内部发生未捕获的错误。检查服务器日志和 `errors/` 快照。
+*   **AI 回复不完整、格式错误或包含 `<<<START_RESPONSE>>>` 标记**: 
+    *   AI Studio 的 Web UI 输出不稳定。服务器尽力解析，但可能失败。
+    *   非流式请求：如果返回的 JSON 中缺少 `response` 字段或无法解析，服务器可能返回空内容或原始 JSON 字符串。检查 `errors/` 快照确认 AI Studio 页面的实际输出。
+    *   流式请求：如果 AI 未按预期输出 Markdown 代码块或起始标记，流式传输可能提前中断或包含非预期内容。
+    *   尝试调整 Prompt 或稍后重试。
+*   **自动清空上下文失败**:
+    *   服务器日志出现 "清空聊天记录或验证时出错" 或 "验证超时" 的警告。
+    *   **原因**: AI Studio 网页更新导致 `server.cjs` 中的 `CLEAR_CHAT_BUTTON_SELECTOR` 或 `CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR` 失效。
+    *   **解决**: 检查 `errors/` 快照，使用浏览器开发者工具检查实际页面元素，并更新 `server.cjs` 文件顶部的选择器常量。
+    *   **原因**: 清空操作本身耗时超过了 `CLEAR_CHAT_VERIFY_TIMEOUT_MS`。
+    *   **解决**: 如果网络或机器较慢，可以尝试在 `server.cjs` 中适当增加这个超时时间。 

deprecated_javascript_version/auto_connect_aistudio.cjs

@@ -0,0 +1,595 @@
+#!/usr/bin/env node
+
+// auto_connect_aistudio.js (v2.9 - Refined Launch & Page Handling + Beautified Output)
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const readline = require('readline');
+
+// --- Configuration ---
+const DEBUGGING_PORT = 8848;
+const TARGET_URL = 'https://aistudio.google.com/prompts/new_chat'; // Target page
+const SERVER_SCRIPT_FILENAME = 'server.cjs'; // Corrected script name
+const CONNECTION_RETRIES = 5;
+const RETRY_DELAY_MS = 4000;
+const CONNECT_TIMEOUT_MS = 20000; // Timeout for connecting to CDP
+const NAVIGATION_TIMEOUT_MS = 35000; // Increased timeout for page navigation
+const CDP_ADDRESS = `http://127.0.0.1:${DEBUGGING_PORT}`;
+
+// --- ANSI Colors ---
+const RESET = '\x1b[0m';
+const BRIGHT = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const BLUE = '\x1b[34m';
+const MAGENTA = '\x1b[35m';
+const CYAN = '\x1b[36m';
+
+// --- Globals ---
+const SERVER_SCRIPT_PATH = path.join(__dirname, SERVER_SCRIPT_FILENAME);
+let playwright; // Loaded in checkDependencies
+
+// --- Platform-Specific Chrome Path ---
+function getChromePath() {
+    switch (process.platform) {
+        case 'darwin':
+            return '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+        case 'win32':
+            // 尝试 Program Files 和 Program Files (x86)
+            const winPaths = [
+                path.join(process.env.ProgramFiles || '', 'Google\Chrome\Application\chrome.exe'),
+                path.join(process.env['ProgramFiles(x86)'] || '', 'Google\Chrome\Application\chrome.exe')
+            ];
+            return winPaths.find(p => fs.existsSync(p));
+        case 'linux':
+            // 尝试常见的 Linux 路径
+            const linuxPaths = [
+                '/usr/bin/google-chrome',
+                '/usr/bin/google-chrome-stable',
+                '/opt/google/chrome/chrome',
+                // Add path for Flatpak installation if needed
+                // '/var/lib/flatpak/exports/bin/com.google.Chrome'
+            ];
+            return linuxPaths.find(p => fs.existsSync(p));
+        default:
+            return null; // 不支持的平台
+    }
+}
+
+const chromeExecutablePath = getChromePath();
+
+// --- 端口检查函数 ---
+function isPortInUse(port) {
+    const platform = process.platform;
+    let command;
+    // console.log(`${DIM}   检查端口 ${port}...${RESET}`); // Optional: Verbose check
+    try {
+        if (platform === 'win32') {
+            // 在 Windows 上，查找监听状态的 TCP 端口
+            command = `netstat -ano | findstr LISTENING | findstr :${port}`;
+            execSync(command); // 如果找到，不会抛出错误
+            return true;
+        } else if (platform === 'darwin' || platform === 'linux') {
+            // 在 macOS 或 Linux 上，查找监听该端口的进程
+            command = `lsof -i tcp:${port} -sTCP:LISTEN`;
+            execSync(command); // 如果找到，不会抛出错误
+            return true;
+        }
+    } catch (error) {
+        // 如果命令执行失败（通常意味着找不到匹配的进程），则端口未被占用
+        // console.log(`端口 ${port} 检查命令执行失败或未找到进程:`, error.message.split('\n')[0]); // 可选的调试信息
+        return false;
+    }
+    // 对于不支持的平台，保守地假设端口未被占用
+    return false;
+}
+
+// --- 查找占用端口的 PID --- (新增)
+function findPidsUsingPort(port) {
+    const platform = process.platform;
+    const pids = [];
+    let command;
+    try {
+        console.log(`${DIM}   正在查找占用端口 ${port} 的进程...${RESET}`);
+        if (platform === 'win32') {
+            command = `netstat -ano | findstr LISTENING | findstr :${port}`;
+            const output = execSync(command).toString();
+            const lines = output.trim().split('\n');
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                const pid = parts[parts.length - 1]; // PID is the last column
+                if (pid && !isNaN(pid)) {
+                    pids.push(pid);
+                }
+            }
+        } else { // macOS or Linux
+            command = `lsof -t -i tcp:${port} -sTCP:LISTEN`;
+            const output = execSync(command).toString();
+            const lines = output.trim().split('\n');
+            for (const line of lines) {
+                const pid = line.trim();
+                if (pid && !isNaN(pid)) {
+                    pids.push(pid);
+                }
+            }
+        }
+        if (pids.length > 0) {
+             console.log(`   ${YELLOW}找到占用端口 ${port} 的 PID: ${pids.join(', ')}${RESET}`);
+        } else {
+             console.log(`   ${GREEN}未找到明确监听端口 ${port} 的进程。${RESET}`);
+        }
+    } catch (error) {
+        // 命令失败通常意味着没有找到进程
+        console.log(`   ${GREEN}查找端口 ${port} 进程的命令执行失败或无结果。${RESET}`);
+    }
+    return [...new Set(pids)]; // 返回去重后的 PID 列表
+}
+
+// --- 结束进程 --- (新增)
+function killProcesses(pids) {
+    if (pids.length === 0) return true; // 没有进程需要结束
+
+    const platform = process.platform;
+    let success = true;
+    console.log(`${YELLOW}   正在尝试结束 PID: ${pids.join(', ')}...${RESET}`);
+
+    for (const pid of pids) {
+        try {
+            if (platform === 'win32') {
+                execSync(`taskkill /F /PID ${pid}`);
+                console.log(`   ${GREEN}✅ 成功结束 PID ${pid} (Windows)${RESET}`);
+            } else { // macOS or Linux
+                execSync(`kill -9 ${pid}`);
+                console.log(`   ${GREEN}✅ 成功结束 PID ${pid} (macOS/Linux)${RESET}`);
+            }
+        } catch (error) {
+            console.warn(`   ${RED}⚠️ 结束 PID ${pid} 时出错: ${error.message.split('\n')[0]}${RESET}`);
+            // 可能原因：进程已不存在、权限不足等
+            success = false; // 标记至少有一个失败了
+        }
+    }
+    return success;
+}
+
+// --- 创建 Readline Interface ---
+function askQuestion(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+
+    return new Promise(resolve => rl.question(query, ans => {
+        rl.close();
+        resolve(ans);
+    }))
+}
+
+// --- 步骤 1: 检查 Playwright 依赖 ---
+async function checkDependencies() {
+    console.log(`${CYAN}-------------------------------------------------${RESET}`);
+    console.log(`${CYAN}--- 步骤 1: 检查依赖项 ---${RESET}`);
+    console.log('将检查以下模块是否已安装:');
+    const requiredModules = ['express', 'playwright', '@playwright/test', 'cors'];
+    const missingModules = [];
+    let allFound = true;
+
+    for (const moduleName of requiredModules) {
+        process.stdout.write(`   - ${moduleName} ... `);
+        try {
+            require.resolve(moduleName); // Use require.resolve for checking existence without loading
+            console.log(`${GREEN}✓ 已找到${RESET}`); // Green checkmark
+        } catch (error) {
+            if (error.code === 'MODULE_NOT_FOUND') {
+                console.log(`${RED}❌ 未找到${RESET}`); // Red X
+                missingModules.push(moduleName);
+                allFound = false;
+            } else {
+                console.log(`${RED}❌ 检查时出错: ${error.message}${RESET}`);
+                allFound = false;
+                // Consider exiting if it's not MODULE_NOT_FOUND?
+                // return false;
+            }
+        }
+    }
+
+    process.stdout.write(`   - 服务器脚本 (${SERVER_SCRIPT_FILENAME}) ... `);
+    if (!fs.existsSync(SERVER_SCRIPT_PATH)) {
+        console.log(`${RED}❌ 未找到${RESET}`); // Red X
+        console.error(`     ${RED}错误: 未在预期路径找到 '${SERVER_SCRIPT_FILENAME}' 文件。${RESET}`);
+        console.error(`     预期路径: ${SERVER_SCRIPT_PATH}`);
+        console.error(`     请确保 '${SERVER_SCRIPT_FILENAME}' 与此脚本位于同一目录。`);
+        allFound = false;
+    } else {
+        console.log(`${GREEN}✓ 已找到${RESET}`); // Green checkmark
+    }
+
+    if (!allFound) {
+        console.log(`\n${RED}-------------------------------------------------${RESET}`);
+        console.error(`${RED}❌ 错误: 依赖项检查未通过！${RESET}`);
+        if (missingModules.length > 0) {
+            console.error(`   ${RED}缺少以下 Node.js 模块: ${missingModules.join(', ')}${RESET}`);
+            console.log('   请根据您使用的包管理器运行以下命令安装依赖：');
+            console.log(`      ${MAGENTA}npm install ${missingModules.join(' ')}${RESET}`);
+            console.log('      或');
+            console.log(`      ${MAGENTA}yarn add ${missingModules.join(' ')}${RESET}`);
+            console.log('      或');
+            console.log(`      ${MAGENTA}pnpm install ${missingModules.join(' ')}${RESET}`);
+            console.log('   (如果已安装但仍提示未找到，请尝试删除 node_modules 目录和 package-lock.json/yarn.lock 文件后重新安装)');
+        }
+        if (!fs.existsSync(SERVER_SCRIPT_PATH)) {
+             console.error(`   ${RED}缺少必要的服务器脚本文件: ${SERVER_SCRIPT_FILENAME}${RESET}`);
+             console.error(`   请确保它和 auto_connect_aistudio.cjs 在同一个文件夹内。`);
+        }
+        console.log(`${RED}-------------------------------------------------${RESET}`);
+        return false;
+    }
+
+    console.log(`\n${GREEN}✅ 所有依赖检查通过。${RESET}`);
+    playwright = require('playwright'); // Load playwright only after checks
+    return true;
+}
+
+// --- 步骤 2: 检查并启动 Chrome ---
+async function launchChrome() {
+    console.log(`${CYAN}-------------------------------------------------${RESET}`);
+    console.log(`${CYAN}--- 步骤 2: 启动或连接 Chrome (调试端口 ${DEBUGGING_PORT}) ---${RESET}`);
+
+    // 首先检查端口是否被占用
+    if (isPortInUse(DEBUGGING_PORT)) {
+        console.log(`${YELLOW}⚠️ 警告: 端口 ${DEBUGGING_PORT} 已被占用。${RESET}`);
+        console.log('   这通常意味着已经有一个 Chrome 实例在监听此端口。');
+        const question = `选择操作: [Y/n]
+  ${GREEN}Y (默认): 尝试连接现有 Chrome 实例并启动 API 服务器。${RESET}
+  ${YELLOW}n:        自动强行结束占用端口 ${DEBUGGING_PORT} 的进程，然后启动新的 Chrome 实例。${RESET}
+请输入选项 [Y/n]: `;
+        const answer = await askQuestion(question);
+
+        if (answer.toLowerCase() === 'n') {
+            console.log(`\n好的，您选择了启动新实例。将尝试自动清理端口...`);
+            const pids = findPidsUsingPort(DEBUGGING_PORT);
+            if (pids.length > 0) {
+                const killSuccess = killProcesses(pids);
+                if (killSuccess) {
+                    console.log(`   ${GREEN}✅ 尝试结束进程完成。等待 1 秒检查端口...${RESET}`);
+                    await new Promise(resolve => setTimeout(resolve, 1000)); // 短暂等待
+                    if (isPortInUse(DEBUGGING_PORT)) {
+                        console.error(`${RED}❌ 错误: 尝试结束后，端口 ${DEBUGGING_PORT} 仍然被占用。${RESET}`);
+                        console.error('   可能原因：权限不足，或进程未能正常终止。请尝试手动结束进程。' );
+                         // 提供手动清理提示
+                         console.log(`${YELLOW}提示: 您可以使用以下命令查找进程 ID (PID):${RESET}`);
+                         if (process.platform === 'win32') {
+                             console.log(`  - 在 CMD 或 PowerShell 中: netstat -ano | findstr :${DEBUGGING_PORT}`);
+                             console.log('  - 找到 PID 后，使用: taskkill /F /PID <PID>');
+                         } else { // macOS or Linux
+                             console.log(`  - 在终端中: lsof -t -i:${DEBUGGING_PORT}`);
+                             console.log('  - 找到 PID 后，使用: kill -9 <PID>');
+                         }
+                         await askQuestion('请在手动结束进程后，按 Enter 键重试脚本...');
+                         process.exit(1); // 退出，让用户处理后重跑
+                    } else {
+                        console.log(`   ${GREEN}✅ 端口 ${DEBUGGING_PORT} 现在空闲。${RESET}`);
+                        // 端口已清理，继续执行下面的 Chrome 启动流程
+                    }
+                } else {
+                    console.error(`${RED}❌ 错误: 尝试结束部分或全部占用端口的进程失败。${RESET}`);
+                    console.error('   请检查日志中的具体错误信息，可能需要手动结束进程。');
+                    await askQuestion('请在手动结束进程后，按 Enter 键重试脚本...');
+                    process.exit(1); // 退出，让用户处理后重跑
+                }
+            } else {
+                console.log(`${YELLOW}   虽然端口被占用，但未能找到具体监听的进程 PID。可能情况复杂，建议手动检查。${RESET}` );
+                 await askQuestion('请手动检查并确保端口空闲后，按 Enter 键重试脚本...');
+                 process.exit(1); // 退出
+            }
+            // 如果代码执行到这里，意味着端口清理成功，将继续启动 Chrome
+            console.log(`\n准备启动新的 Chrome 实例...`);
+
+        } else {
+            console.log(`\n好的，将尝试连接到现有的 Chrome 实例...`);
+            return 'use_existing'; // 特殊返回值，告知主流程跳过启动，直接连接
+        }
+    }
+
+    // --- 如果端口未被占用，或者用户选择 'n' 且自动清理成功 ---
+
+    if (!chromeExecutablePath) {
+        console.error(`${RED}❌ 错误: 未能在当前操作系统 (${process.platform}) 的常见路径找到 Chrome 可执行文件。${RESET}`);
+        console.error('   请确保已安装 Google Chrome，或修改脚本中的 getChromePath 函数以指向正确的路径。');
+        if (process.platform === 'win32') {
+             console.error('   (已尝试查找 %ProgramFiles% 和 %ProgramFiles(x86)% 下的路径)');
+        } else if (process.platform === 'linux') {
+             console.error('   (已尝试查找 /usr/bin/google-chrome, /usr/bin/google-chrome-stable, /opt/google/chrome/chrome)');
+        }
+        return false;
+    }
+
+    console.log(`   ${GREEN}找到 Chrome 路径:${RESET} ${chromeExecutablePath}`);
+
+    // 只有在明确需要启动新实例时才提示关闭其他实例
+    // (如果上面选择了 'n' 并清理成功，这里 isPortInUse 应该返回 false)
+    if (!isPortInUse(DEBUGGING_PORT)) {
+         console.log(`${YELLOW}⚠️ 重要提示：为了确保新的调试端口生效，建议先手动完全退出所有*其他*可能干扰的 Google Chrome 实例。${RESET}`);
+         console.log('   (在 macOS 上通常是 Cmd+Q，Windows/Linux 上是关闭所有窗口)');
+         await askQuestion('请确认已处理好其他 Chrome 实例，然后按 Enter 键继续启动...');
+    } else {
+         // 理论上不应该到这里，因为端口已被清理或选择了 use_existing
+         console.warn(`   ${YELLOW}警告：端口 ${DEBUGGING_PORT} 意外地仍被占用。继续尝试启动，但这极有可能失败。${RESET}`);
+         await askQuestion('请按 Enter 键继续尝试启动...');
+    }
+
+
+    console.log(`正在尝试启动 Chrome...`);
+    console.log(`  路径: "${chromeExecutablePath}"`);
+    // --- 修改：添加启动参数 ---
+    const chromeArgs = [
+        `--remote-debugging-port=${DEBUGGING_PORT}`,
+        `--window-size=460,800` // 指定宽度为 460px，高度暂定为 800px (可以根据需要调整)
+        // 你可以在这里添加其他需要的 Chrome 启动参数
+    ];
+    console.log(`  参数: ${chromeArgs.join(' ')}`); // 打印所有参数
+
+    try {
+        const chromeProcess = spawn(
+            chromeExecutablePath,
+            chromeArgs, // 使用包含窗口大小的参数数组
+            { detached: true, stdio: 'ignore' } // Detach to allow script to exit independently if needed
+        );
+        chromeProcess.unref(); // Allow parent process to exit independently
+
+        console.log(`${GREEN}✅ Chrome 启动命令已发送 (指定窗口大小)。稍后将尝试连接...${RESET}`);
+        console.log(`${DIM}⏳ 等待 3 秒让 Chrome 进程启动...${RESET}`);
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        return true; // 表示启动流程已尝试
+
+    } catch (error) {
+        console.error(`${RED}❌ 启动 Chrome 时出错: ${error.message}${RESET}`);
+        console.error(`   请检查路径 "${chromeExecutablePath}" 是否正确，以及是否有权限执行。`);
+        return false;
+    }
+}
+
+// --- 步骤 3: 连接 Playwright 并管理页面 (带重试) ---
+async function connectAndManagePage() {
+    console.log(`${CYAN}-------------------------------------------------${RESET}`);
+    console.log(`${CYAN}--- 步骤 3: 连接 Playwright 到 ${CDP_ADDRESS} (最多尝试 ${CONNECTION_RETRIES} 次) ---${RESET}`);
+    let browser = null;
+    let context = null;
+
+    for (let i = 0; i < CONNECTION_RETRIES; i++) {
+        try {
+            console.log(`\n${DIM}尝试连接 Playwright (第 ${i + 1}/${CONNECTION_RETRIES} 次)...${RESET}`);
+            browser = await playwright.chromium.connectOverCDP(CDP_ADDRESS, { timeout: CONNECT_TIMEOUT_MS });
+            console.log(`${GREEN}✅ 成功连接到 Chrome！${RESET}`);
+
+             // Simplified context fetching
+             await new Promise(resolve => setTimeout(resolve, 500)); // Short delay after connect
+             const contexts = browser.contexts();
+             if (contexts && contexts.length > 0) {
+                 context = contexts[0];
+                 console.log(`-> 获取到浏览器默认上下文。`);
+                 break; // Connection and context successful
+             } else {
+                 // This case should be rare if connectOverCDP succeeded with a responsive Chrome
+                 throw new Error('连接成功，但无法获取浏览器上下文。Chrome 可能没有响应或未完全初始化。');
+             }
+
+        } catch (error) {
+            console.warn(`   ${YELLOW}连接尝试 ${i + 1} 失败: ${error.message.split('\n')[0]}${RESET}`);
+             if (browser && browser.isConnected()) {
+                 // Should not happen if connectOverCDP failed, but good practice
+                 await browser.close().catch(e => console.error("尝试关闭连接失败的浏览器时出错:", e));
+             }
+             browser = null;
+             context = null;
+
+            if (i < CONNECTION_RETRIES - 1) {
+                console.log(`   ${YELLOW}可能原因: Chrome 未完全启动 / 端口 ${DEBUGGING_PORT} 未监听 / 端口被占用。${RESET}`);
+                console.log(`${DIM}   等待 ${RETRY_DELAY_MS / 1000} 秒后重试...${RESET}`);
+                await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
+            } else {
+                console.error(`\n${RED}❌ 在 ${CONNECTION_RETRIES} 次尝试后仍然无法连接。${RESET}`);
+                console.error('   请再次检查：');
+                console.error('   1. Chrome 是否真的已经通过脚本成功启动，并且窗口可见、已加载？(可能需要登录Google)');
+                console.error(`   2. 是否有其他程序占用了端口 ${DEBUGGING_PORT}？(检查命令: macOS/Linux: lsof -i :${DEBUGGING_PORT} | Windows: netstat -ano | findstr ${DEBUGGING_PORT})`);
+                console.error('   3. 启动 Chrome 时终端或系统是否有报错信息？');
+                console.error('   4. 防火墙或安全软件是否阻止了本地回环地址(127.0.0.1)的连接？');
+                return false;
+            }
+        }
+    }
+
+    if (!browser || !context) {
+         console.error(`${RED}-> 未能成功连接到浏览器或获取上下文。${RESET}`);
+         return false;
+    }
+
+    // --- 连接成功后的页面管理逻辑 ---
+    console.log(`\n${CYAN}--- 页面管理 ---${RESET}`);
+    try {
+        let targetPage = null;
+        let pages = [];
+        try {
+            pages = context.pages();
+        } catch (err) {
+             console.error(`${RED}❌ 获取现有页面列表时出错:${RESET}`, err);
+             console.log("   将尝试打开新页面...");
+        }
+
+        console.log(`${DIM}-> 检查 ${pages.length} 个已存在的页面...${RESET}`);
+        const aiStudioUrlPattern = 'aistudio.google.com/';
+        const loginUrlPattern = 'accounts.google.com/';
+
+        for (const page of pages) {
+            try {
+                if (!page.isClosed()) {
+                    const pageUrl = page.url();
+                    console.log(`${DIM}   检查页面: ${pageUrl}${RESET}`);
+                    // Prioritize AI Studio pages, then login pages
+                    if (pageUrl.includes(aiStudioUrlPattern)) {
+                         console.log(`-> ${GREEN}找到 AI Studio 页面:${RESET} ${pageUrl}`);
+                         targetPage = page;
+                         // Ensure it's the target URL if possible
+                         if (!pageUrl.includes('/prompts/new_chat')) {
+                              console.log(`${YELLOW}   非目标页面，尝试导航到 ${TARGET_URL}...${RESET}`);
+                              try {
+                                   await targetPage.goto(TARGET_URL, { waitUntil: 'domcontentloaded', timeout: NAVIGATION_TIMEOUT_MS });
+                                   console.log(`   ${GREEN}导航成功:${RESET} ${targetPage.url()}`);
+                              } catch (navError) {
+                                   console.warn(`   ${YELLOW}警告：导航到 ${TARGET_URL} 失败: ${navError.message.split('\n')[0]}${RESET}`);
+                                   console.warn(`   ${YELLOW}将使用当前页面 (${pageUrl})，请稍后手动确认。${RESET}`);
+                              }
+                         } else {
+                              console.log(`   ${GREEN}页面已在目标路径或子路径。${RESET}`);
+                         }
+                         break; // Found a good AI Studio page
+                    } else if (pageUrl.includes(loginUrlPattern) && !targetPage) {
+                        // Keep track of a login page if no AI studio page is found yet
+                        console.log(`-> ${YELLOW}发现 Google 登录页面，暂存。${RESET}`);
+                        targetPage = page;
+                        // Don't break here, keep looking for a direct AI Studio page
+                    }
+                 }
+             } catch (pageError) {
+                  if (!page.isClosed()) {
+                      console.warn(`   ${YELLOW}警告：评估或导航页面时出错: ${pageError.message.split('\n')[0]}${RESET}`);
+                  }
+                  // Avoid using a page that caused an error
+                  if (targetPage === page) {
+                      targetPage = null;
+                  }
+             }
+        }
+
+        // If after checking all pages, the best we found was a login page
+        if (targetPage && targetPage.url().includes(loginUrlPattern)) {
+            console.log(`-> ${YELLOW}未找到直接的 AI Studio 页面，将使用之前找到的登录页面。${RESET}`);
+            console.log(`   ${YELLOW}请确保在该页面手动完成登录。${RESET}`);
+        }
+
+        // If no suitable page was found at all
+        if (!targetPage) {
+            console.log(`-> ${YELLOW}未找到合适的现有页面。正在打开新页面并导航到 ${TARGET_URL}...${RESET}`);
+            try {
+                targetPage = await context.newPage();
+                console.log(`${DIM}   正在导航...${RESET}`);
+                await targetPage.goto(TARGET_URL, { waitUntil: 'domcontentloaded', timeout: NAVIGATION_TIMEOUT_MS });
+                console.log(`-> ${GREEN}新页面已打开并导航到:${RESET} ${targetPage.url()}`);
+            } catch (newPageError) {
+                 console.error(`${RED}❌ 打开或导航新页面到 ${TARGET_URL} 失败: ${newPageError.message}${RESET}`);
+                 console.error("   请检查网络连接，以及 Chrome 是否能正常访问该网址。可能需要手动登录。" );
+                 await browser.close().catch(e => {});
+                 return false;
+            }
+        }
+
+        try {
+            await targetPage.bringToFront();
+            console.log('-> 已尝试将目标页面置于前台。');
+        } catch (bringToFrontError) {
+            console.warn(`   ${YELLOW}警告：将页面置于前台失败: ${bringToFrontError.message.split('\n')[0]}${RESET}`);
+            console.warn(`   (这可能发生在窗口最小化或位于不同虚拟桌面上时，通常不影响连接)`);
+        }
+        await new Promise(resolve => setTimeout(resolve, 500)); // Small delay after bringToFront
+
+
+        console.log(`\n${BRIGHT}${GREEN}🎉 --- AI Studio 连接准备完成 --- 🎉${RESET}`);
+        console.log(`${GREEN}Chrome 已启动，Playwright 已连接，相关页面已找到或创建。${RESET}`);
+        console.log(`${YELLOW}请确保在 Chrome 窗口中 AI Studio 页面处于可交互状态 (例如，已登录Google, 无弹窗)。${RESET}`);
+
+        return true;
+
+    } catch (error) {
+        console.error(`\n${RED}❌ --- 步骤 3 页面管理失败 ---${RESET}`);
+        console.error('   在连接成功后，处理页面时发生错误:', error);
+        if (browser && browser.isConnected()) {
+             await browser.close().catch(e => console.error("关闭浏览器时出错:", e));
+        }
+        return false;
+    } finally {
+         // 这里不再打印即将退出的日志，因为脚本会继续运行 server.js
+         // console.log("-> auto_connect_aistudio.js 步骤3结束。");
+         // 不需要手动断开 browser 连接，因为是 connectOverCDP
+    }
+}
+
+
+// --- 步骤 4: 启动 API 服务器 ---
+function startApiServer() {
+    console.log(`${CYAN}-------------------------------------------------${RESET}`);
+    console.log(`${CYAN}--- 步骤 4: 启动 API 服务器 ('node ${SERVER_SCRIPT_FILENAME}') ---${RESET}`);
+    console.log(`${DIM}   脚本路径: ${SERVER_SCRIPT_PATH}${RESET}`);
+
+    if (!fs.existsSync(SERVER_SCRIPT_PATH)) {
+        console.error(`${RED}❌ 错误: 无法启动服务器，文件不存在: ${SERVER_SCRIPT_PATH}${RESET}`);
+        process.exit(1);
+    }
+
+    console.log(`${DIM}正在启动: node ${SERVER_SCRIPT_PATH}${RESET}`);
+
+    try {
+        const serverProcess = spawn('node', [SERVER_SCRIPT_PATH], {
+            stdio: 'inherit',
+            cwd: __dirname
+        });
+
+        serverProcess.on('error', (err) => {
+            console.error(`${RED}❌ 启动 '${SERVER_SCRIPT_FILENAME}' 失败: ${err.message}${RESET}`);
+            console.error(`请检查 Node.js 是否已安装并配置在系统 PATH 中，以及 '${SERVER_SCRIPT_FILENAME}' 文件是否有效。`);
+            process.exit(1);
+        });
+
+        serverProcess.on('exit', (code, signal) => {
+            console.log(`\n${MAGENTA}👋 '${SERVER_SCRIPT_FILENAME}' 进程已退出 (代码: ${code}, 信号: ${signal})。${RESET}`);
+            console.log("自动连接脚本执行结束。");
+            process.exit(code ?? 0);
+        });
+        // Don't print the success message here, let server.cjs print its own ready message
+        // console.log("✅ '${SERVER_SCRIPT_FILENAME}' 已启动。脚本将保持运行，直到服务器进程结束或被手动中断。");
+
+    } catch (error) {
+        console.error(`${RED}❌ 启动 '${SERVER_SCRIPT_FILENAME}' 时发生意外错误: ${error.message}${RESET}`);
+        process.exit(1);
+    }
+}
+
+
+// --- 主执行流程 ---
+(async () => {
+    console.log(`${MAGENTA}🚀 欢迎使用 AI Studio 自动连接与启动脚本 (跨平台优化, v2.9 自动端口清理) 🚀${RESET}`);
+    console.log(`${MAGENTA}=================================================${RESET}`);
+
+    if (!await checkDependencies()) {
+        process.exit(1);
+    }
+
+    console.log(`${MAGENTA}=================================================${RESET}`);
+
+    const launchResult = await launchChrome();
+
+    if (launchResult === false) {
+        console.log(`${RED}❌ 启动 Chrome 失败，脚本终止。${RESET}`);
+        process.exit(1);
+    }
+
+    // 如果 launchResult 是 'use_existing' 或 true, 都需要连接
+    console.log(`${MAGENTA}=================================================${RESET}`);
+    if (!await connectAndManagePage()) {
+         // 如果连接失败，并且我们是尝试连接到现有实例，给出更具体的提示
+         if (launchResult === 'use_existing') {
+             console.error(`${RED}❌ 连接到现有 Chrome 实例 (端口 ${DEBUGGING_PORT}) 失败。${RESET}`);
+             console.error('   请确认：');
+             console.error('   1. 占用该端口的确实是您想连接的 Chrome 实例。');
+             console.error('   2. 该 Chrome 实例是以 --remote-debugging-port 参数启动的。');
+             console.error('   3. Chrome 实例本身运行正常，没有崩溃或无响应。');
+         }
+         process.exit(1);
+    }
+
+    // 无论 Chrome 是新启动的还是已存在的，只要连接成功，就启动 API 服务器
+    console.log(`${MAGENTA}=================================================${RESET}`);
+    startApiServer();
+
+})(); 

deprecated_javascript_version/package.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.19.2",
+    "playwright": "^1.44.1",
+    "@playwright/test": "^1.44.1"
+  }
+}

deprecated_javascript_version/server.cjs

@@ -0,0 +1,1520 @@
+// server.cjs (优化版 v2.17 - 增加日志ID & 常量)
+
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const cors = require('cors');
+
+// --- 依赖检查 ---
+let playwright, expect;
+const requiredModules = ['express', 'playwright', '@playwright/test', 'cors'];
+const missingModules = [];
+
+for (const modName of requiredModules) {
+    try {
+        if (modName === 'playwright') {
+            playwright = require(modName);
+        } else if (modName === '@playwright/test') {
+            expect = require(modName).expect;
+        } else {
+            require(modName);
+        }
+        // console.log(`✅ 模块 ${modName} 已加载。`); // Optional: Log success
+    } catch (e) {
+        console.error(`❌ 模块 ${modName} 未找到。`);
+        missingModules.push(modName);
+    }
+}
+
+if (missingModules.length > 0) {
+    console.error("-------------------------------------------------------------");
+    console.error("❌ 错误：缺少必要的依赖模块！");
+    console.error("请根据您使用的包管理器运行以下命令安装依赖：");
+    console.error("-------------------------------------------------------------");
+    console.error(`   npm install ${missingModules.join(' ')}`);
+    console.error("   或");
+    console.error(`   yarn add ${missingModules.join(' ')}`);
+    console.error("   或");
+    console.error(`   pnpm install ${missingModules.join(' ')}`);
+    console.error("-------------------------------------------------------------");
+    process.exit(1);
+}
+
+// --- 配置 ---
+const SERVER_PORT = process.env.PORT || 2048;
+const CHROME_DEBUGGING_PORT = 8848;
+const CDP_ADDRESS = `http://127.0.0.1:${CHROME_DEBUGGING_PORT}`;
+const AI_STUDIO_URL_PATTERN = 'aistudio.google.com/';
+const RESPONSE_COMPLETION_TIMEOUT = 300000; // 5分钟总超时
+const POLLING_INTERVAL = 300; // 非流式/通用检查间隔
+const POLLING_INTERVAL_STREAM = 200; // 流式检查轮询间隔 (ms)
+// v2.12: Timeout for secondary checks *after* spinner disappears
+const POST_SPINNER_CHECK_DELAY_MS = 500; // Spinner消失后稍作等待再检查其他状态
+const FINAL_STATE_CHECK_TIMEOUT_MS = 1500; // 检查按钮和输入框最终状态的超时
+const SPINNER_CHECK_TIMEOUT_MS = 1000; // 检查Spinner状态的超时
+const POST_COMPLETION_BUFFER = 1000; // JSON模式下可以缩短检查后等待时间
+const SILENCE_TIMEOUT_MS = 1500; // 文本静默多久后认为稳定 (Spinner消失后)
+
+// --- 常量 ---
+const MODEL_NAME = 'google-ai-studio-via-playwright-cdp-json';
+const CHAT_COMPLETION_ID_PREFIX = 'chatcmpl-';
+
+// --- 选择器常量 ---
+const INPUT_SELECTOR = 'ms-prompt-input-wrapper textarea';
+const SUBMIT_BUTTON_SELECTOR = 'button[aria-label="Run"]';
+const RESPONSE_CONTAINER_SELECTOR = 'ms-chat-turn .chat-turn-container.model'; // 选择器指向 AI 模型回复的容器
+const RESPONSE_TEXT_SELECTOR = 'ms-cmark-node.cmark-node';
+const LOADING_SPINNER_SELECTOR = 'button[aria-label="Run"] svg .stoppable-spinner';
+const ERROR_TOAST_SELECTOR = 'div.toast.warning, div.toast.error';
+// !! 新增：清空聊天记录相关选择器 !!
+const CLEAR_CHAT_BUTTON_SELECTOR = 'button[aria-label="Clear chat"][data-test-clear="outside"]:has(span.material-symbols-outlined:has-text("refresh"))'; // 清空按钮 (带图标确认)
+const CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR = 'button.mdc-button:has-text("Continue")'; // 确认对话框中的 "Continue" 按钮
+// !! 新增：清空验证相关常量 !!
+const CLEAR_CHAT_VERIFY_TIMEOUT_MS = 5000; // 等待清空生效的总超时时间 (ms)
+const CLEAR_CHAT_VERIFY_INTERVAL_MS = 300; // 检查清空状态的轮询间隔 (ms)
+
+// v2.16: JSON Structure Prompt (Restored for non-streaming)
+const prepareAIStudioPrompt = (userPrompt, systemPrompt = null) => {
+    let fullPrompt = `
+IMPORTANT: Your entire response MUST be a single JSON object. Do not include any text outside of this JSON object.
+The JSON object must have a single key named "response".
+Inside the value of the "response" key (which is a string), you MUST put the exact marker "<<<START_RESPONSE>>>"" at the very beginning of your actual answer. There should be NO text before this marker within the response string.
+`;
+
+    if (systemPrompt && systemPrompt.trim() !== '') {
+        fullPrompt += `\nSystem Instruction: ${systemPrompt}\n`;
+    }
+
+    fullPrompt += `
+Example 1:
+User asks: "What is the capital of France?"
+Your response MUST be:
+{
+  "response": "<<<START_RESPONSE>>>The capital of France is Paris."
+}
+
+Example 2:
+User asks: "Write a python function to add two numbers"
+Your response MUST be:
+{
+  "response": "<<<START_RESPONSE>>>\\\`\\\`\\\`python\\\\ndef add(a, b):\\\\n  return a + b\\\\n\\\`\\\`\\\`"
+}
+
+Now, answer the following user prompt, ensuring your output strictly adheres to the JSON format AND the start marker requirement described above:
+
+User Prompt: "${userPrompt}"
+
+Your JSON Response:
+`;
+    return fullPrompt;
+};
+
+// v2.26: Use JSON prompt for streaming as well -> vNEXT: Use Markdown Code Block for streaming
+// vNEXT: Instruct AI to output *incomplete* JSON for streaming -> vNEXT: Instruct AI to output Markdown Code Block
+const prepareAIStudioPromptStream = (userPrompt, systemPrompt = null) => {
+    let fullPrompt = `
+IMPORTANT: For this streaming request, your entire response MUST be enclosed in a single markdown code block (like \`\`\` block \`\`\`).
+Inside this code block, your actual answer text MUST start immediately after the exact marker "<<<START_RESPONSE>>>".
+Start your response exactly with "\`\`\`\n<<<START_RESPONSE>>>" followed by your answer content.
+Continue outputting your answer content. You SHOULD include the final closing "\`\`\`" at the very end of your full response stream.
+`;
+
+    if (systemPrompt && systemPrompt.trim() !== '') {
+        fullPrompt += `\nSystem Instruction: ${systemPrompt}\n`;
+    }
+
+    fullPrompt += `
+Example 1 (Streaming):
+User asks: "What is the capital of France?"
+Your streamed response MUST look like this over time:
+Stream part 1: \`\`\`\n<<<START_RESPONSE>>>The capital
+Stream part 2:  of France is
+Stream part 3:  Paris.\n\`\`\`
+
+Example 2 (Streaming):
+User asks: "Write a python function to add two numbers"
+Your streamed response MUST look like this over time:
+Stream part 1: \`\`\`\n<<<START_RESPONSE>>>\`\`\`python\ndef add(a, b):
+Stream part 2: \n  return a + b\n
+Stream part 3: \`\`\`\n\`\`\`
+
+Now, answer the following user prompt, ensuring your output strictly adheres to the markdown code block, start marker, and streaming requirements described above:
+
+User Prompt: "${userPrompt}"
+
+Your Response (Streaming, within a markdown code block):
+`;
+    return fullPrompt;
+};
+
+const app = express();
+
+// --- 全局变量 ---
+let browser = null;
+let page = null;
+let isPlaywrightReady = false;
+let isInitializing = false;
+// v2.18: 请求队列和处理状态
+let requestQueue = [];
+let isProcessing = false;
+
+
+// --- Playwright 初始化函数 ---
+async function initializePlaywright() {
+    if (isPlaywrightReady || isInitializing) return;
+    isInitializing = true;
+    console.log(`--- 初始化 Playwright: 连接到 ${CDP_ADDRESS} ---`);
+
+    try {
+        browser = await playwright.chromium.connectOverCDP(CDP_ADDRESS, { timeout: 20000, ignoreHTTPSErrors: true });
+        console.log('✅ 成功连接到正在运行的 Chrome 实例！');
+
+        browser.once('disconnected', () => {
+            console.error('❌ Playwright 与 Chrome 的连接已断开！');
+            isPlaywrightReady = false;
+            browser = null;
+            page = null;
+            // v2.18: Clear queue on disconnect? Maybe not, let requests fail naturally.
+        });
+
+        await new Promise(resolve => setTimeout(resolve, 500));
+
+        const contexts = browser.contexts();
+        let context;
+        if (!contexts || contexts.length === 0) {
+             await new Promise(resolve => setTimeout(resolve, 1500));
+             const retryContexts = browser.contexts();
+             if (!retryContexts || retryContexts.length === 0) {
+                 throw new Error('无法获取浏览器上下文。请检查 Chrome 是否已正确启动并响应。');
+             }
+             context = retryContexts[0];
+        } else {
+             context = contexts[0];
+        }
+
+        let foundPage = null;
+        const pages = context.pages();
+        console.log(`-> 发现 ${pages.length} 个页面。正在搜索 AI Studio (匹配 "${AI_STUDIO_URL_PATTERN}")...`);
+        for (const p of pages) {
+            try {
+                 if (p.isClosed()) continue;
+                const url = p.url();
+                if (url.includes(AI_STUDIO_URL_PATTERN) && url.includes('/prompts/')) {
+                    console.log(`-> 找到 AI Studio 页面: ${url}`);
+                    foundPage = p;
+                    break;
+                }
+            } catch (pageError) {
+                 if (!p.isClosed()) {
+                     console.warn(`   警告：评估页面 URL 时出错: ${pageError.message.split('\\n')[0]}`);
+                 }
+            }
+        }
+
+        if (!foundPage) {
+            throw new Error(`未在已连接的 Chrome 中找到包含 "${AI_STUDIO_URL_PATTERN}" 和 "/prompts/" 的页面。请确保 auto_connect_aistudio.js 已成功运行，并且 AI Studio 页面 (例如 prompts/new_chat) 已打开。`);
+        }
+
+        page = foundPage;
+        console.log('-> 已定位到 AI Studio 页面。');
+        await page.bringToFront();
+        console.log('-> 尝试将页面置于前台。检查加载状态...');
+        await page.waitForLoadState('domcontentloaded', { timeout: 15000 });
+        console.log('-> 页面 DOM 已加载。');
+
+        try {
+            console.log("-> 尝试定位核心输入区域以确��页面就绪...");
+            await page.locator('ms-prompt-input-wrapper').waitFor({ state: 'visible', timeout: 15000 });
+             console.log("-> 核心输入区域容器已找到。");
+        } catch(initCheckError) {
+            console.warn(`⚠️ 初始化检查警告：未能快速定位到核心输入区域容器。页面可能仍在加载或结构有变: ${initCheckError.message.split('\\n')[0]}`);
+            await saveErrorSnapshot('init_check_fail');
+        }
+
+        isPlaywrightReady = true;
+        console.log('✅ Playwright 已准备就绪。');
+        // v2.18: Start processing queue if playwright just became ready and queue has items
+        if (requestQueue.length > 0 && !isProcessing) {
+             console.log(`[Queue] Playwright 就绪，队列中有 ${requestQueue.length} 个请求，开始处理...`);
+             processQueue();
+        }
+
+    } catch (error) {
+        console.error(`❌ 初始化 Playwright 失败: ${error.message}`);
+        await saveErrorSnapshot('init_fail');
+        isPlaywrightReady = false;
+        browser = null;
+        page = null;
+    } finally {
+        isInitializing = false;
+    }
+}
+
+// --- 中间件 ---
+app.use(cors());
+app.use(express.json({ limit: '20mb' }));
+app.use(express.urlencoded({ limit: '20mb', extended: true })); // Also for urlencoded
+
+// --- Web UI Route ---
+app.get('/', (req, res) => {
+    const htmlPath = path.join(__dirname, 'index.html');
+    if (fs.existsSync(htmlPath)) {
+        res.sendFile(htmlPath);
+    } else {
+        res.status(404).send('Error: index.html not found.');
+    }
+});
+
+// --- 健康检查 ---
+app.get('/health', (req, res) => {
+    const isConnected = browser?.isConnected() ?? false;
+    const isPageValid = page && !page.isClosed();
+    const queueLength = requestQueue.length;
+    const status = {
+        status: 'Unknown',
+        message: '',
+        playwrightReady: isPlaywrightReady,
+        browserConnected: isConnected,
+        pageValid: isPageValid,
+        initializing: isInitializing,
+        processing: isProcessing,
+        queueLength: queueLength
+    };
+
+    if (isPlaywrightReady && isPageValid && isConnected) {
+        status.status = 'OK';
+        status.message = `Server running, Playwright connected, page valid. Currently ${isProcessing ? 'processing' : 'idle'} with ${queueLength} item(s) in queue.`;
+        res.status(200).json(status);
+    } else {
+        status.status = 'Error';
+        const reasons = [];
+        if (!isPlaywrightReady) reasons.push("Playwright not initialized or ready");
+        if (!isPageValid) reasons.push("Target page not found or closed");
+        if (!isConnected) reasons.push("Browser disconnected");
+        if (isInitializing) reasons.push("Playwright is currently initializing");
+        status.message = `Service Unavailable. Issues: ${reasons.join(', ')}. Currently ${isProcessing ? 'processing' : 'idle'} with ${queueLength} item(s) in queue.`;
+        res.status(503).json(status);
+    }
+});
+
+// --- 新增：API 辅助函数 ---
+
+// 验证聊天请求
+// v2.19: Updated validation to handle array content (text parts only)
+function validateChatRequest(messages) {
+    const reqId = messages?.[0]?.reqId || 'validation'; // Get reqId if passed, fallback
+    if (!messages || !Array.isArray(messages) || messages.length === 0) {
+        throw new Error(`[${reqId}] Invalid request: "messages" array is missing or empty.`);
+    }
+    const lastUserMessage = messages.filter(msg => msg.role === 'user').pop();
+    if (!lastUserMessage) {
+        throw new Error(`[${reqId}] Invalid request: No user message found in the "messages" array.`);
+    }
+
+    let userPromptContentInput = lastUserMessage.content;
+    let processedUserPrompt = ""; // Initialize as empty string
+
+    // 1. Handle null/undefined content
+    if (userPromptContentInput === null || userPromptContentInput === undefined) {
+        console.warn(`[${reqId}] (Validation) Warning: Last user message content is null or undefined. Treating as empty string.`);
+        processedUserPrompt = "";
+    }
+    // 2. Handle string content (most common case)
+    else if (typeof userPromptContentInput === 'string') {
+        processedUserPrompt = userPromptContentInput;
+    }
+    // 3. Handle array content (attempt compatibility with OpenAI vision format)
+    else if (Array.isArray(userPromptContentInput)) {
+        console.log(`[${reqId}] (Validation) Info: Last user message content is an array. Processing text parts...`);
+        let textParts = [];
+        let unsupportedParts = false;
+        for (const item of userPromptContentInput) {
+            if (typeof item === 'object' && item !== null && item.type === 'text' && typeof item.text === 'string') {
+                textParts.push(item.text);
+            } else if (typeof item === 'object' && item !== null && item.type === 'image_url') {
+                console.warn(`[${reqId}] (Validation) Warning: Found 'image_url' content part. This proxy cannot process images via AI Studio web UI. Ignoring image.`);
+                unsupportedParts = true;
+                // Optionally, include the URL as text, but it might confuse the AI:
+                // textParts.push(`[Image URL (Unsupported): ${item.image_url?.url || 'N/A'}]`);
+            } else {
+                // Handle other unexpected items in the array - stringify them?
+                 console.warn(`[${reqId}] (Validation) Warning: Found unexpected item in content array (Type: ${typeof item}). Converting to JSON string.`);
+                 try {
+                      textParts.push(JSON.stringify(item));
+                      unsupportedParts = true;
+                 } catch (e) {
+                      console.error(`[${reqId}] (Validation) Error stringifying array item: ${e}. Skipping item.`);
+                 }
+            }
+        }
+        processedUserPrompt = textParts.join('\\n'); // Join text parts with newline
+        if (unsupportedParts) {
+             console.warn(`[${reqId}] (Validation) Warning: Some parts of the array content were unsupported or ignored (e.g., images). Only text parts were included in the final prompt.`);
+        }
+        if (!processedUserPrompt) {
+             console.warn(`[${reqId}] (Validation) Warning: Processed array content resulted in an empty prompt.`);
+        }
+    }
+    // 4. Handle other object types (fallback to JSON stringify)
+    else if (typeof userPromptContentInput === 'object' && userPromptContentInput !== null) {
+        console.warn(`[${reqId}] (Validation) Warning: Last user message content is an object but not a recognized array format. Converting to JSON string.`);
+        try {
+            processedUserPrompt = JSON.stringify(userPromptContentInput);
+        } catch (stringifyError) {
+            console.error(`[${reqId}] (Validation) Error stringifying object user content: ${stringifyError}. Falling back to empty string.`);
+            processedUserPrompt = "";
+        }
+    }
+    // 5. Handle other primitive types (e.g., number, boolean) - convert to string
+    else {
+        console.warn(`[${reqId}] (Validation) Warning: Last user message content is an unexpected primitive type (${typeof userPromptContentInput}). Converting to string.`);
+        processedUserPrompt = String(userPromptContentInput);
+    }
+
+    // Final check - should always be a string here
+    if (typeof processedUserPrompt !== 'string') {
+         console.error(`[${reqId}] (Validation) CRITICAL ERROR: Failed to process user prompt content into a string. Type after processing: ${typeof processedUserPrompt}. Using empty string.`);
+         processedUserPrompt = ""; // Safeguard
+    }
+
+
+    // Extract system prompt (remains the same logic)
+    const systemPromptContent = messages.find(msg => msg.role === 'system')?.content;
+    // Basic validation for system prompt (ensure it's a string if provided)
+    let processedSystemPrompt = null;
+    if (systemPromptContent !== null && systemPromptContent !== undefined) {
+        if (typeof systemPromptContent === 'string') {
+            processedSystemPrompt = systemPromptContent;
+        } else {
+            console.warn(`[${reqId}] (Validation) Warning: System prompt content is not a string (Type: ${typeof systemPromptContent}). Ignoring system prompt.`);
+            // Optionally stringify it: processedSystemPrompt = JSON.stringify(systemPromptContent);
+        }
+    }
+
+
+    return {
+        userPrompt: processedUserPrompt, // Ensure this is always a string
+        systemPrompt: processedSystemPrompt // Ensure this is null or a string
+    };
+}
+
+// 与页面交互并提交 Prompt
+async function interactAndSubmitPrompt(page, prompt, reqId) {
+    console.log(`[${reqId}] 开始页面交互...`);
+    const inputField = page.locator(INPUT_SELECTOR);
+    const submitButton = page.locator(SUBMIT_BUTTON_SELECTOR);
+    const loadingSpinner = page.locator(LOADING_SPINNER_SELECTOR); // Keep spinner locator here for later use
+
+    console.log(`[${reqId}]  - 等待输入框可用...`);
+        try {
+            await inputField.waitFor({ state: 'visible', timeout: 10000 });
+        } catch (e) {
+         console.error(`[${reqId}] ❌ 查找输入框失败！`);
+         await saveErrorSnapshot(`input_field_not_visible_${reqId}`);
+         throw new Error(`[${reqId}] Failed to find visible input field. Error: ${e.message}`);
+    }
+
+    console.log(`[${reqId}]  - 清空并填充输入框...`);
+        await inputField.fill(prompt, { timeout: 60000 });
+
+    console.log(`[${reqId}]  - 等待运行按钮可用...`);
+        try {
+            await expect(submitButton).toBeEnabled({ timeout: 10000 });
+        } catch (e) {
+        console.error(`[${reqId}] ❌ 等待运行按钮变为可用状态超时！`);
+        await saveErrorSnapshot(`submit_button_not_enabled_before_click_${reqId}`);
+        throw new Error(`[${reqId}] Submit button not enabled before click. Error: ${e.message}`);
+    }
+
+    console.log(`[${reqId}]  - 点击运行按钮...`);
+    await submitButton.click({ timeout: 10000 });
+
+    return { inputField, submitButton, loadingSpinner }; // Return locators
+}
+
+// 定位最新的回复元素
+async function locateResponseElements(page, { inputField, submitButton, loadingSpinner }, reqId) {
+    console.log(`[${reqId}] 定位 AI 回复元素...`);
+        let lastResponseContainer;
+    let responseElement;
+        let locatedResponseElements = false;
+
+        for (let i = 0; i < 3 && !locatedResponseElements; i++) {
+             try {
+             console.log(`[${reqId}]    尝试定位最新回复容器及文本元素 (第 ${i + 1} 次)`);
+                 await page.waitForTimeout(500 + i * 500); // 固有延迟
+
+             const isEndState = await checkEndConditionQuickly(page, loadingSpinner, inputField, submitButton, 250, reqId);
+             const locateTimeout = isEndState ? 3000 : 60000;
+                 if (isEndState) {
+                console.log(`[${reqId}]     -> 检测到结束条件已满足，使用 ${locateTimeout / 1000}s 超时进行定位。`);
+                 }
+
+             lastResponseContainer = page.locator(RESPONSE_CONTAINER_SELECTOR).last();
+                 await lastResponseContainer.waitFor({ state: 'attached', timeout: locateTimeout });
+
+             responseElement = lastResponseContainer.locator(RESPONSE_TEXT_SELECTOR);
+                 await responseElement.waitFor({ state: 'attached', timeout: locateTimeout });
+
+             console.log(`[${reqId}]    回复容器和文本元素定位成功。`);
+                 locatedResponseElements = true;
+             } catch (locateError) {
+             console.warn(`[${reqId}]    第 ${i + 1} 次定位回复元素失败: ${locateError.message.split('\n')[0]}`);
+                 if (i === 2) {
+                  await saveErrorSnapshot(`response_locate_fail_${reqId}`);
+                  throw new Error(`[${reqId}] Failed to locate response elements after multiple attempts.`);
+             }
+         }
+    }
+    if (!locatedResponseElements) throw new Error(`[${reqId}] Could not locate response elements.`);
+    return { responseElement, lastResponseContainer }; // Return located elements
+}
+
+// --- 新增：处理流式响应 (vNEXT: 标记优先，静默结束，无JSON处理) ---
+async function handleStreamingResponse(res, responseElement, page, { inputField, submitButton, loadingSpinner }, operationTimer, reqId, isRequestCancelled) {
+    console.log(`[${reqId}]   - 流式传输开始 (vNEXT: Marker priority, silence end, no JSON handling)...`); // TODO: Update version
+    let lastRawText = "";
+    let lastSentResponseContent = ""; // Tracks content *after* the marker that has been SENT
+    let responseStarted = false; // Tracks if <<<START_RESPONSE>>> has been seen
+    const startTime = Date.now();
+    let spinnerHasDisappeared = false;
+    let lastTextChangeTimestamp = Date.now();
+    const startMarker = '<<<START_RESPONSE>>>';
+    let streamFinishedNaturally = false;
+
+    while (Date.now() - startTime < RESPONSE_COMPLETION_TIMEOUT && !streamFinishedNaturally) {
+        // --- 添加检查：请求是否已取消 ---
+        const cancelled = isRequestCancelled(); // 调用检查函数
+        // 添加日志记录检查结果
+        // console.log(`[${reqId}]   (Streaming Loop Check) isRequestCancelled() returned: ${cancelled}`); // 可选：过于频繁，暂时注释掉
+        if (cancelled) {
+             console.log(`[${reqId}]   (Streaming) 检测到请求已取消 (isRequestCancelled() is true)，停止处理。`); // 修改日志
+             clearTimeout(operationTimer); // 确保定时器清除
+             if (!res.writableEnded) res.end(); // 确保响应结束
+             return; // 退出函数
+        }
+        // --- 结束检查 ---
+
+        const loopStartTime = Date.now();
+
+        // 1. Get current raw text
+        const currentRawText = await getRawTextContent(responseElement, lastRawText, reqId);
+
+        if (currentRawText !== lastRawText) {
+            lastTextChangeTimestamp = Date.now();
+            let potentialNewDelta = "";
+            let currentContentAfterMarker = "";
+
+            // 2. Marker Check & Delta Calculation
+            const markerIndex = currentRawText.indexOf(startMarker);
+            if (markerIndex !== -1) {
+                if (!responseStarted) {
+                    console.log(`[${reqId}]    (流式 Simple) 检测到 ${startMarker}，开始传输...`);
+                    responseStarted = true;
+                }
+                // Content after marker in the current raw text
+                currentContentAfterMarker = currentRawText.substring(markerIndex + startMarker.length);
+                // Calculate new content since last *sent* content
+                potentialNewDelta = currentContentAfterMarker.substring(lastSentResponseContent.length);
+            } else if(responseStarted) {
+                 // If marker was seen before, but now disappears (e.g., AI cleared output?), treat as no new delta.
+                 potentialNewDelta = "";
+                 console.warn(`[${reqId}] Marker disappeared after being seen. Raw: ${currentRawText.substring(0,100)}`);
+            }
+
+            // 3. Send Delta if found
+            if (potentialNewDelta) {
+                 // console.log(`[${reqId}]    (Send Stream Simple) Sending Delta (len: ${potentialNewDelta.length})`);
+                 sendStreamChunk(res, potentialNewDelta, reqId);
+                 lastSentResponseContent += potentialNewDelta; // Update tracking
+            }
+
+            // Update last raw text
+            lastRawText = currentRawText;
+
+        } // End if(currentRawText !== lastRawText)
+
+        // 4. Check Spinner status
+        if (!spinnerHasDisappeared) {
+            try {
+                await expect(loadingSpinner).toBeHidden({ timeout: 50 });
+                spinnerHasDisappeared = true;
+                lastTextChangeTimestamp = Date.now(); // Reset silence timer when spinner disappears
+                console.log(`[${reqId}]    Spinner 已消失，进入静默期检测...`);
+            } catch (e) { /* Spinner still visible */ }
+        }
+
+        // 5. Silence Check (Standard)
+        const isSilent = spinnerHasDisappeared && (Date.now() - lastTextChangeTimestamp > SILENCE_TIMEOUT_MS);
+
+        if (isSilent) {
+            console.log(`[${reqId}] Silence detected. Finishing stream.`);
+            streamFinishedNaturally = true;
+            break; // Exit loop
+        }
+
+        // 6. Control polling interval
+        const loopEndTime = Date.now();
+        const loopDuration = loopEndTime - loopStartTime;
+        const waitTime = Math.max(0, POLLING_INTERVAL_STREAM - loopDuration);
+        await page.waitForTimeout(waitTime);
+
+    } // --- End main loop ---
+
+    // --- Cleanup and End --- (如果循环是因取消而退出，下面的代码不会执行)
+    clearTimeout(operationTimer); // Clear the specific timer for THIS request
+
+    if (!streamFinishedNaturally && Date.now() - startTime >= RESPONSE_COMPLETION_TIMEOUT) {
+        // Timeout case
+        console.warn(`[${reqId}]   - 流式传输(Simple模式)因总超时 (${RESPONSE_COMPLETION_TIMEOUT / 1000}s) 结束。`);
+        await saveErrorSnapshot(`streaming_simple_timeout_${reqId}`);
+        if (!res.writableEnded) {
+            sendStreamError(res, "Stream processing timed out on server (Simple mode).", reqId);
+        }
+    } else if (streamFinishedNaturally && !res.writableEnded) {
+        // Natural end (Silence detected)
+        // --- Final Sync (Simple Mode) ---
+        // Check one last time for any content received after the last delta was sent but before silence was declared.
+        console.log(`[${reqId}]    (Simple Stream) Loop ended naturally, performing final sync check...`);
+        const finalRawText = await getRawTextContent(responseElement, lastRawText, reqId);
+        console.log(`[${reqId}]    (Simple Stream) Performing final marker check and delta calculation...`);
+        try {
+             let finalExtractedContent = ""; // Content after marker
+             const finalMarkerIndex = finalRawText.indexOf(startMarker);
+             if (finalMarkerIndex !== -1) {
+                  finalExtractedContent = finalRawText.substring(finalMarkerIndex + startMarker.length);
+             }
+
+             const finalDelta = finalExtractedContent.substring(lastSentResponseContent.length);
+
+            if (finalDelta){
+                 console.log(`[${reqId}]    (Final Sync Simple) Sending final delta (len: ${finalDelta.length})`);
+                 sendStreamChunk(res, finalDelta, reqId);
+            } else {
+                 console.log(`[${reqId}]    (Final Sync Simple) No final delta to send based on lastSent comparison.`);
+            }
+        } catch (e) { console.warn(`[${reqId}] (Simple Stream) Final sync error during marker/delta calc: ${e.message}`); }
+        // --- End Final Sync ---
+
+        res.write('data: [DONE]\n\n');
+        res.end();
+        console.log(`[${reqId}] ✅ 流式(Simple模式)响应 [DONE] 已发送。`);
+    } else if (res.writableEnded) {
+        console.log(`[${reqId}] 流(Simple模式)已提前结束 (writableEnded=true)，不再发送 [DONE]。`);
+    } else {
+         console.log(`[${reqId}] 流(Simple模式)结束时状态异常 (finishedNaturally=${streamFinishedNaturally}, writableEnded=${res.writableEnded})，不再发送 [DONE]。`);
+    }
+}
+
+// --- 新增：处理非流式响应 --- vNEXT: Restore JSON Parsing
+async function handleNonStreamingResponse(res, page, locators, operationTimer, reqId, isRequestCancelled) {
+    console.log(`[${reqId}]   - 等待 AI 处理完成 (检查 Spinner 消失 + 输入框空 + 按钮禁用)...`);
+            let processComplete = false;
+            const nonStreamStartTime = Date.now();
+    let finalStateCheckInitiated = false;
+    const { inputField, submitButton, loadingSpinner } = locators;
+
+    // Completion check logic
+            while (!processComplete && Date.now() - nonStreamStartTime < RESPONSE_COMPLETION_TIMEOUT) {
+                // --- 添加检查：请求是否已取消 ---
+                if (isRequestCancelled()) {
+                    console.log(`[${reqId}]   (Non-Streaming) 检测到请求已取消，停止等待完成状态。`);
+                    clearTimeout(operationTimer); // 确保定时器清除
+                    if (!res.headersSent) {
+                         // 如果头还没发送，可以发送一个取消错误
+                         res.status(499).json({ error: { message: `[${reqId}] Client closed request`, type: 'client_error' } });
+                    } else if (!res.writableEnded) {
+                         res.end(); // 否则只结束响应
+                    }
+                    return; // 退出函数
+                }
+                // --- 结束检查 ---
+
+                  let isSpinnerHidden = false;
+                  let isInputEmpty = false;
+                  let isButtonDisabled = false;
+
+                  try {
+                      await expect(loadingSpinner).toBeHidden({ timeout: SPINNER_CHECK_TIMEOUT_MS });
+                      isSpinnerHidden = true;
+                  } catch { /* Spinner still visible */ }
+
+                  if (isSpinnerHidden) {
+                      try {
+                          await expect(inputField).toHaveValue('', { timeout: FINAL_STATE_CHECK_TIMEOUT_MS });
+                          isInputEmpty = true;
+                      } catch { /* Input not empty */ }
+
+                      if (isInputEmpty) {
+                          try {
+                              await expect(submitButton).toBeDisabled({ timeout: FINAL_STATE_CHECK_TIMEOUT_MS });
+                              isButtonDisabled = true;
+                          } catch { /* Button not disabled */ }
+                      }
+                  }
+
+                  if (isSpinnerHidden && isInputEmpty && isButtonDisabled) {
+                      if (!finalStateCheckInitiated) {
+                          finalStateCheckInitiated = true;
+                console.log(`[${reqId}]    检测到潜在最终状态。等待 ${POST_COMPLETION_BUFFER}ms 进行确认...`); // Use constant
+                await page.waitForTimeout(POST_COMPLETION_BUFFER); // Wait a bit first
+                console.log(`[${reqId}]    ${POST_COMPLETION_BUFFER}ms 等待结束，重新检查状态...`);
+                try {
+                    await expect(loadingSpinner).toBeHidden({ timeout: 500 });
+                    await expect(inputField).toHaveValue('', { timeout: 500 });
+                    await expect(submitButton).toBeDisabled({ timeout: 500 });
+                    console.log(`[${reqId}]    状态确认成功。开始文本静默检查...`);
+
+                    // --- NEW: Text Silence Check ---
+                    let lastCheckText = '';
+                    let currentCheckText = '';
+                    let textStable = false;
+                    const silenceCheckStartTime = Date.now();
+                    // Re-locate response element here for the check
+                    const { responseElement: checkResponseElement } = await locateResponseElements(page, locators, reqId);
+
+                    while (Date.now() - silenceCheckStartTime < SILENCE_TIMEOUT_MS * 2) { // Check for up to 2*silence duration
+                        lastCheckText = currentCheckText;
+                        currentCheckText = await getRawTextContent(checkResponseElement, lastCheckText, reqId);
+                        if (currentCheckText === lastCheckText) {
+                             // Text hasn't changed since last check in this loop
+                             if (Date.now() - silenceCheckStartTime >= SILENCE_TIMEOUT_MS) {
+                                  // And enough time has passed
+                                  console.log(`[${reqId}]    文本内容静默 ${SILENCE_TIMEOUT_MS}ms，确认处理完成。`);
+                                  textStable = true;
+                                  break;
+                             }
+                        } else {
+                            // Text changed, reset silence timer within this check
+                            // silenceCheckStartTime = Date.now(); // Option: Reset timer on any change
+                            console.log(`[${reqId}]    (静默检查) 文本仍在变化...`);
+                        }
+                        await page.waitForTimeout(POLLING_INTERVAL); // Use standard poll interval for checks
+                    }
+
+                    if (textStable) {
+                         processComplete = true; // Mark process as complete
+                    } else {
+                         console.warn(`[${reqId}]    警告: 文本静默检查超时，可能仍在输出。将继续尝试解析。`);
+                         processComplete = true; // Proceed anyway after timeout, but log warning
+                    }
+                    // --- END NEW: Text Silence Check ---
+
+                } catch (recheckError) {
+                    console.log(`[${reqId}]    状态在确认期间发生变化 (${recheckError.message.split('\\n')[0]})。继续轮询...`);
+                    finalStateCheckInitiated = false;
+                }
+            }
+        } else {
+             if (finalStateCheckInitiated) {
+                 console.log(`[${reqId}]    最终状态不再满足，重置确认标志。`);
+                 finalStateCheckInitiated = false;
+             }
+             await page.waitForTimeout(POLLING_INTERVAL * 2); // Longer wait if not in final state check
+        }
+    } // --- End Completion check logic loop ---
+
+    // --- 添加检查：如果在循环结束后发现请求已取消 ---
+    if (isRequestCancelled()) {
+        console.log(`[${reqId}]   (Non-Streaming) 请求在等待完成后被取消，不再继续处理。`);
+        // 定时器和响应应该已经被上面的检查处理了，这里只退出
+        return;
+    }
+    // --- 结束检查 ---
+
+    // Check for Page Errors BEFORE attempting to parse JSON
+    console.log(`[${reqId}]   - 检查页面上是否存在错误提示...`);
+    const pageError = await detectAndExtractPageError(page, reqId);
+              if (pageError) {
+        console.error(`[${reqId}] ❌ 检测到 AI Studio 页面错误: ${pageError}`);
+        await saveErrorSnapshot(`page_error_detected_${reqId}`);
+        throw new Error(`[${reqId}] AI Studio Error: ${pageError}`);
+              }
+
+              if (!processComplete) {
+         console.warn(`[${reqId}]    警告：等待最终完成状态超时或未能稳定确认 (${(Date.now() - nonStreamStartTime) / 1000}s)。将直接尝试获取并解析JSON。`);
+          await saveErrorSnapshot(`nonstream_final_state_timeout_${reqId}`);
+               } else {
+         console.log(`[${reqId}]   - 开始获取并解析最终 JSON...`);
+               }
+
+    // Get and Parse JSON
+             let aiResponseText = null;
+             const maxRetries = 3;
+             let attempts = 0;
+
+             while (attempts < maxRetries && aiResponseText === null) {
+                  attempts++;
+         console.log(`[${reqId}]     - 尝试获取原始文本并解析 JSON (第 ${attempts} 次)...`);
+         try {
+             // Re-locate response element within the retry loop for robustness
+             const { responseElement: currentResponseElement } = await locateResponseElements(page, locators, reqId);
+
+             const rawText = await getRawTextContent(currentResponseElement, '', reqId);
+
+                      if (!rawText || rawText.trim() === '') {
+                 console.warn(`[${reqId}]     - 第 ${attempts} 次获取的原始文本为空。`);
+                          throw new Error("Raw text content is empty.");
+                      }
+              console.log(`[${reqId}]     - 获取到原始文本 (长度: ${rawText.length}): \"${rawText.substring(0,100)}...\"`);
+
+             const parsedJson = tryParseJson(rawText, reqId);
+
+                      if (parsedJson) {
+                          if (typeof parsedJson.response === 'string') {
+                              aiResponseText = parsedJson.response;
+                              console.log(`[${reqId}]     - 成功解析 JSON 并提取 'response' 字段。`);
+                          } else {
+                              // JSON 有效但无 response 字段
+                              try {
+                                  aiResponseText = JSON.stringify(parsedJson);
+                                  console.log(`[${reqId}]     - 警告: 未找到 'response' 字段，但解析到有效 JSON。将整个 JSON 字符串化作为回复。`);
+                              } catch (stringifyError) {
+                                  console.error(`[${reqId}]     - 错误：无法将解析出的 JSON 字符串化: ${stringifyError.message}`);
+                                  aiResponseText = null;
+                                  throw new Error("Failed to stringify the parsed JSON object.");
+                              }
+                          }
+                      } else {
+                          // JSON 解析失败
+                          console.warn(`[${reqId}]     - 第 ${attempts} 次未能解析 JSON。`);
+                          aiResponseText = null;
+                          if (attempts >= maxRetries) {
+                              await saveErrorSnapshot(`json_parse_fail_final_attempt_${reqId}`);
+                          }
+                          throw new Error("Failed to parse JSON from raw text.");
+                      }
+
+                 break;
+
+                  } catch (e) {
+             console.warn(`[${reqId}]     - 第 ${attempts} 次获取或解析失败: ${e.message.split('\n')[0]}`);
+             aiResponseText = null;
+                      if (attempts >= maxRetries) {
+                 console.error(`[${reqId}]     - 多次尝试获取并解析 JSON 失败。`);
+                 if (!e.message?.includes('snapshot')) await saveErrorSnapshot(`get_parse_json_failed_final_${reqId}`);
+                          aiResponseText = ""; // Fallback to empty string
+                      } else {
+                  await new Promise(resolve => setTimeout(resolve, 1500 + attempts * 500));
+                      }
+                  }
+             }
+
+            if (aiResponseText === null) {
+         console.log(`[${reqId}]     - JSON 解析失败，再次检查页面错误...`);
+         const finalCheckError = await detectAndExtractPageError(page, reqId);
+                 if (finalCheckError) {
+              console.error(`[${reqId}] ❌ 检测到 AI Studio 页面错误 (在 JSON 解析失败后): ${finalCheckError}`);
+              await saveErrorSnapshot(`page_error_post_json_fail_${reqId}`);
+              throw new Error(`[${reqId}] AI Studio Error after JSON parse failed: ${finalCheckError}`);
+         }
+          console.warn(`[${reqId}] 警告：所有尝试均未能获取并解析出有效的 JSON 回复。返回空回复。`);
+                  aiResponseText = "";
+              }
+
+    // Handle potential nested JSON
+            let cleanedResponse = aiResponseText;
+            try {
+                 // Attempt to parse the potential stringified JSON again for nested 'response' check
+                 // Only attempt if aiResponseText is likely a stringified JSON object/array
+                 if (aiResponseText && aiResponseText.startsWith('{') || aiResponseText.startsWith('[')) {
+                      const outerParsed = JSON.parse(aiResponseText); // Use JSON.parse directly here
+                      const innerParsed = tryParseJson(outerParsed.response, reqId); // Try parsing the inner 'response' field if it exists
+                      if (innerParsed && typeof innerParsed.response === 'string') {
+                          console.log(`[${reqId}]    (非流式) 检测到嵌套 JSON，使用内层 response 内容。`);
+                          cleanedResponse = innerParsed.response;
+                      } else if (typeof outerParsed.response === 'string') {
+                          // If the *outer* 'response' was already a string (not nested JSON), use it directly
+                          console.log(`[${reqId}]    (非流式) 使用外层 'response' 字段内容。`);
+                          cleanedResponse = outerParsed.response;
+                      }
+                      // If neither inner nor outer 'response' fields are relevant strings, keep the stringified JSON as cleanedResponse
+                 }
+            } catch (e) {
+                 // If parsing aiResponseText fails, it means it wasn't a stringified JSON in the first place,
+                 // or it was malformed. Keep the original aiResponseText.
+                 // console.warn(`[${reqId}] (Info) Post-processing check: aiResponseText ('${aiResponseText.substring(0,50)}...') is not a parseable JSON or lacks 'response'. Keeping original value. Error: ${e.message}`);
+                 cleanedResponse = aiResponseText; // Keep original if parsing fails
+            }
+
+    console.log(`[${reqId}] ✅ 获取到解析后的 AI 回复 (来自JSON, 长度: ${cleanedResponse?.length ?? 0}): \"${cleanedResponse?.substring(0, 100)}...\"`);
+
+               // --- 新增步骤：在非流式响应中移除标记 ---
+               const startMarker = '<<<START_RESPONSE>>>';
+
+               let finalContentForUser = cleanedResponse; // 默认使用清理后的响应
+
+               // Check for and remove the starting marker if present
+               if (finalContentForUser?.startsWith(startMarker)) {
+                    finalContentForUser = finalContentForUser.substring(startMarker.length);
+                    console.log(`[${reqId}]    (非流式 JSON) 移除前缀 ${startMarker}，最终内容长度: ${finalContentForUser.length}`);
+               } else if (aiResponseText !== null && aiResponseText !== "") { // 仅在获取到非空文本但无标记时警告
+                    console.warn(`[${reqId}]    (非流式 JSON) 警告: 未在 response 字段中找到预期的 ${startMarker} 前缀。内容: \"${aiResponseText.substring(0,50)}...\"`);
+               }
+               // --- 结束新增步骤 ---
+
+
+               // 使用移除标记后的内容构建最终响应
+               const responsePayload = {
+                  id: `${CHAT_COMPLETION_ID_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 15)}`,
+                  object: 'chat.completion',
+                  created: Math.floor(Date.now() / 1000),
+                  model: MODEL_NAME,
+                  choices: [{
+                      index: 0,
+                      message: { role: 'assistant', content: finalContentForUser }, // Use cleaned content
+                      finish_reason: 'stop',
+                  }],
+                  usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+              };
+              console.log(`[${reqId}] ✅ 返回 JSON 响应 (来自解析后的JSON)。`);
+              clearTimeout(operationTimer); // Clear the specific timer for THIS request
+              res.json(responsePayload);
+          }
+
+// --- 新增：处理 /v1/models 请求以满足 Open WebUI 验证 ---
+app.get('/v1/models', (req, res) => {
+    const modelId = 'aistudio-proxy'; // 您计划在 Open WebUI 中使用的模型名称
+    // 使用简短的日志ID或时间戳
+    const logPrefix = `[${Date.now().toString(36).slice(-5)}]`;
+    console.log(`${logPrefix} --- 收到 /v1/models 请求，返回模拟模型列表 ---`);
+    res.json({
+        object: "list",
+        data: [
+            {
+                id: modelId, // 返回您要用的那个名字
+                object: "model",
+                created: Math.floor(Date.now() / 1000),
+                owned_by: "openai-proxy", // 可以随便写
+                permission: [],
+                root: modelId,
+                parent: null
+            }
+            // 如果需要添加更多名称指向同一个代理，可以在此添加
+            // ,{
+            //    id: "gemini-pro-proxy",
+            //    object: "model",
+            //    created: Math.floor(Date.now() / 1000),
+            //    owned_by: "openai-proxy",
+            //    permission: [],
+            //    root: "gemini-pro-proxy",
+            //    parent: null
+            // }
+        ]
+    });
+});
+
+
+// --- v2.18: 新增队列处理函数 ---
+async function processQueue() {
+     if (isProcessing || requestQueue.length === 0) {
+          return;
+     }
+
+     isProcessing = true;
+     // 从队列头部取出包含状态的请求项
+     const queueItem = requestQueue.shift();
+     // 解构所需变量，包括取消标记和临时处理器
+     const { req, res, reqId, isCancelledByClient, preliminaryCloseHandler } = queueItem;
+
+     // --- 重要：立即移除临时监听器（如果存在且未被触发移除）---
+     // 因为我们要么跳过处理，要么添加新的主监听器
+     if (preliminaryCloseHandler) {
+          // 使用 removeListener 以防万一它已被触发并自我移除
+          res.removeListener('close', preliminaryCloseHandler);
+     }
+     // --- 结束移除临时监听器 ---
+
+     // --- 新增：检查请求是否在处理前已被取消 ---
+     if (isCancelledByClient) {
+          console.log(`[${reqId}] Request was cancelled by client before processing began. Skipping.`);
+          // 清理可能由其他地方（如主 close 事件处理器）设置的定时器，以防万一
+          if (operationTimer) clearTimeout(operationTimer);
+          // 标记处理结束（跳过），然后处理下一个
+          isProcessing = false;
+          processQueue(); // 尝试处理下一个请求
+          return; // 退出当前 processQueue 调用
+     }
+     // --- 结束新增检查 ---
+
+     console.log(`\n[${reqId}] ---开始处理队列中的请求 (剩余 ${requestQueue.length} 个)---`);
+
+     let operationTimer; // 主操作定时器
+     // *** 修改：将 isCancelledByClient 的状态传递给处理期间的 isCancelled 标志 ***
+     let isCancelled = isCancelledByClient; 
+     // 如果在开始处理时就已经被取消，添加一条日志
+     if (isCancelled) {
+          console.log(`[${reqId}] Warning: Request was cancelled very shortly before processing logic started.`);
+          // 虽然上面的检查理论上会处理，但这里多一层保险
+     }
+     // *** 结束修改 ***
+     let closeEventHandler = null; // 主 close 事件处理器引用
+
+     try {
+          // 1. 检查 Playwright 状态 (现在可以安全地继续，因为请求未被提前取消)
+          // *** 新增：如果此时 isCancelled 已经是 true，则直接跳到 finally ***
+          if (isCancelled) {
+               console.log(`[${reqId}] Skipping Playwright interaction as request is already marked cancelled.`);
+               throw new Error(`[${reqId}] Request pre-cancelled`); // 抛出错误以跳到 catch/finally
+          }
+          // *** 结束新增检查 ***
+          
+          if (!isPlaywrightReady && !isInitializing) {
+               console.warn(`[${reqId}] Playwright 未就绪，尝试重新初始化...`);
+               await initializePlaywright();
+          }
+          if (!isPlaywrightReady || !page || page.isClosed() || !browser?.isConnected()) {
+               console.error(`[${reqId}] API 请求失败：Playwright 未就绪、页面关闭或连接断开。`);
+               let detail = 'Unknown issue.';
+               if (!browser?.isConnected()) detail = "Browser connection lost.";
+               else if (!page || page.isClosed()) detail = "Target AI Studio page is not available or closed.";
+               else if (!isPlaywrightReady) detail = "Playwright initialization failed or incomplete.";
+               console.error(`[${reqId}] Playwright 连接不可用详情: ${detail}`);
+               // 直接为当前请求返回错误，不需要抛出，因为要继续处理队列
+               if (!res.headersSent) {
+                    res.status(503).json({
+                         error: { message: `[${reqId}] Playwright connection is not active. ${detail} Please ensure Chrome is running correctly, the AI Studio tab is open, and potentially restart the server.`, type: 'server_error' }
+                    });
+               }
+               throw new Error("Playwright not ready for this request."); // Throw to skip further processing in try block
+          }
+
+          const { messages, stream, ...otherParams } = req.body;
+          const isStreaming = stream === true;
+
+          // --- 修改：基于消息数量启发式判断并执行清空操作 + 验证 ---
+          const isLikelyNewChat = Array.isArray(messages) && (messages.length === 1 || (messages.length === 2 && messages.some(m => m.role === 'system')));
+
+          if (isLikelyNewChat && CLEAR_CHAT_BUTTON_SELECTOR && CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR) {
+              console.log(`[${reqId}] 检测到可能是新对话 (消息数: ${messages.length})，尝试清空聊天记录...`);
+              try {
+                  const clearButton = page.locator(CLEAR_CHAT_BUTTON_SELECTOR);
+                  console.log(`[${reqId}]   - 查找并点击"Clear chat"按钮...`);
+                  await clearButton.waitFor({ state: 'visible', timeout: 7000 });
+                  await clearButton.click({ timeout: 5000 });
+                  console.log(`[${reqId}]   - "Clear chat"按钮已点击。`);
+
+                  console.log(`[${reqId}]   - 等待确认对话框及"Continue"按钮出现...`);
+                  const confirmButton = page.locator(CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR);
+                  await confirmButton.waitFor({ state: 'visible', timeout: 5000 });
+
+                  console.log(`[${reqId}]   - 点击"Continue"按钮...`);
+                  await confirmButton.click({ timeout: 5000 });
+                  console.log(`[${reqId}]   - "Continue"按钮已点击。开始验证清空效果...`);
+
+                  // --- 新增：验证清空效果 ---
+                  const checkStartTime = Date.now();
+                  let cleared = false;
+                  while (Date.now() - checkStartTime < CLEAR_CHAT_VERIFY_TIMEOUT_MS) {
+                      // 定位所有 AI 回复容器
+                      const modelTurns = page.locator(RESPONSE_CONTAINER_SELECTOR);
+                      const count = await modelTurns.count();
+                      if (count === 0) {
+                          console.log(`[${reqId}]   ✅ 验证成功: 页面上未找到之前的 AI 回复元素 (耗时 ${Date.now() - checkStartTime}ms)。`);
+                          cleared = true;
+                          break; // 验证成功，退出循环
+                      }
+                      // 稍微等待后再次检查
+                      await page.waitForTimeout(CLEAR_CHAT_VERIFY_INTERVAL_MS);
+                  }
+
+                  if (!cleared) {
+                      // 如果超时后仍然找到 AI 回复元素
+                      console.warn(`[${reqId}]   ⚠️ 验证超时: 在 ${CLEAR_CHAT_VERIFY_TIMEOUT_MS}ms 内仍能检测到之前的 AI 回复元素。上下文可能未完全清空。`);
+                      // 保存快照以供调试
+                      await saveErrorSnapshot(`clear_chat_verify_fail_${reqId}`);
+                  }
+                  // --- 结束：验证清空效果 ---
+
+              } catch (clearChatError) {
+                  console.warn(`[${reqId}] ⚠️ 清空聊天记录或验证时出错: ${clearChatError.message.split('\n')[0]}. 将继续执行请求，但上下文可能未被清除。`);
+                  if (clearChatError.message.includes('selector')) {
+                       console.warn(`   (请仔细检查选择器是否仍然有效: CLEAR_CHAT_BUTTON_SELECTOR='${CLEAR_CHAT_BUTTON_SELECTOR}', CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR='${CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR}')`);
+                  }
+                  await saveErrorSnapshot(`clear_chat_fail_or_verify_${reqId}`);
+              }
+          } else if (isLikelyNewChat && (!CLEAR_CHAT_BUTTON_SELECTOR || !CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR)) {
+              console.warn(`[${reqId}] 检测到可能是新对话，但未完整配置清空聊天相关的选择器常量，无法自动重置上下文。`);
+          }
+          // --- 结束：启发式新对话处理 ---
+
+          console.log(`[${reqId}] 请求模式: ${isStreaming ? '流式 (SSE)' : '非流式 (JSON)'}`);
+
+          // 2. 设置此请求的总操作超时
+          operationTimer = setTimeout(async () => {
+               await saveErrorSnapshot(`operation_timeout_${reqId}`);
+               console.error(`[${reqId}] Operation timed out after ${RESPONSE_COMPLETION_TIMEOUT / 1000} seconds.`);
+               if (!res.headersSent) {
+                    res.status(504).json({ error: { message: `[${reqId}] Operation timed out`, type: 'timeout_error' } });
+               } else if (isStreaming && !res.writableEnded) {
+                    sendStreamError(res, "Operation timed out on server.", reqId);
+               }
+               // Note: Timeout error now managed within processQueue, allowing next item to proceed
+          }, RESPONSE_COMPLETION_TIMEOUT);
+
+          // 3. 验证请求 (使用更新后的函数)
+          // Pass reqId to validation for better logging context
+          const validationMessages = messages.map(m => ({ ...m, reqId })); // Add reqId temporarily
+          const { userPrompt, systemPrompt: extractedSystemPrompt } = validateChatRequest(validationMessages);
+          // Combine system prompts if provided in multiple ways
+          const systemPrompt = extractedSystemPrompt || otherParams?.system_prompt;
+
+          // --- Logging (Now userPrompt is guaranteed to be a string) ---
+          const userPromptPreview = userPrompt.substring(0, 80);
+          console.log(`[${reqId}]   处理后的 User Prompt (用于提交, start): \"${userPromptPreview}...\" (Total length: ${userPrompt.length})`);
+
+          if (systemPrompt) {
+               // systemPrompt from validateChatRequest is also guaranteed string or null
+               const systemPromptPreview = systemPrompt.substring(0, 80);
+               console.log(`[${reqId}]   处理后的 System Prompt (用于提交, start): \"${systemPromptPreview}...\"`);
+          } else {
+               console.log(`[${reqId}]   无 System Prompt。`);
+          }
+          if (Object.keys(otherParams).length > 0) {
+                console.log(`[${reqId}]   记录到的额外参数: ${JSON.stringify(otherParams)}`);
+          }
+          // --- End Logging ---
+
+          // 4. 准备 Prompt (使用处理后的 userPrompt 和 systemPrompt)
+          let prompt;
+          if (isStreaming) {
+               prompt = prepareAIStudioPromptStream(userPrompt, systemPrompt); // Assumes prepare functions handle null systemPrompt
+               console.log(`[${reqId}] 构建的流式 Prompt (Raw): \"${prompt.substring(0, 200)}...\"`);
+          } else {
+               prompt = prepareAIStudioPrompt(userPrompt, systemPrompt); // Assumes prepare functions handle null systemPrompt
+               console.log(`[${reqId}] 构建的非流式 Prompt (JSON): \"${prompt.substring(0, 200)}...\"`);
+          }
+
+          // 5. 与页面交互并提交
+          const locators = await interactAndSubmitPrompt(page, prompt, reqId);
+
+          // --- 添加 'close' 事件监听器 ---
+          closeEventHandler = async () => {
+               console.log(`[${reqId}] 'close' event handler triggered.`); // <-- 新增日志
+               if (isCancelled) {
+                    console.log(`[${reqId}] 'close' event handler: Already cancelled, doing nothing.`); // <-- 新增日志
+                    return; // 防止重复执行
+               }
+               isCancelled = true;
+               console.log(`[${reqId}] Client disconnected ('close' event). Attempting to stop generation by clicking the run/stop button.`);
+               clearTimeout(operationTimer); // 清除主超时定时器
+
+               // 尝试点击运行/停止按钮 (因为它是同一个按钮)
+               try {
+                    // 确保 locators, submitButton, inputField 存在
+                    if (!locators || !locators.submitButton || !locators.inputField) {
+                         console.warn(`[${reqId}]   closeEventHandler: Cannot attempt to click stop button: locators (button or input) not available.`); // <-- 修改日志
+                         return;
+                    }
+                    // 检查按钮是否仍然可用 (增加超时)
+                    console.log(`[${reqId}]   closeEventHandler: Checking button state (timeout: 2000ms)...`); // <-- 修改日志
+                    const isEnabled = await locators.submitButton.isEnabled({ timeout: 2000 }); // <-- 增加超时
+                    console.log(`[${reqId}]   closeEventHandler: Button isEnabled result: ${isEnabled}`); // <-- 新增日志
+
+                    if (isEnabled) {
+                         // *** 新增：检查输入框是否为空 (增加超时) ***
+                         console.log(`[${reqId}]   closeEventHandler: Button enabled, checking input value (timeout: 2000ms)...`); // <-- 修改日志
+                         const inputValue = await locators.inputField.inputValue({ timeout: 2000 }); // <-- 增加超时
+                         console.log(`[${reqId}]   closeEventHandler: Input value: "${inputValue}"`); // <-- 新增日志
+                         if (inputValue === '') {
+                              console.log(`[${reqId}]   closeEventHandler: Run/Stop button is enabled AND input is empty. Clicking it to stop generation...`); // <-- 修改日志
+                              // 使用 click({ force: true }) 可能更可靠
+                              await locators.submitButton.click({ timeout: 5000, force: true });
+                              console.log(`[${reqId}]   closeEventHandler: Run/Stop button click attempted.`); // <-- 修改日志
+                         } else {
+                              console.log(`[${reqId}]   closeEventHandler: Run/Stop button is enabled BUT input is NOT empty. Assuming user typed new input, not clicking stop.`); // <-- 修改日志
+                         }
+                         // *** 结束新增检查 ***
+                    } else {
+                         console.log(`[${reqId}]   closeEventHandler: Run/Stop button is already disabled (generation likely finished or close event was late). No click needed.`); // <-- 修改日志
+                    }
+               } catch (clickError) {
+                    // 捕获检查或点击过程中的错误
+                    console.warn(`[${reqId}]   closeEventHandler: Error during stop button check/click: ${clickError.message.split('\n')[0]}`); // <-- 修改日志
+                    // 添加更详细日志并尝试保存快照
+                    console.error(`[${reqId}]   closeEventHandler: Detailed error during check/click:`, clickError); 
+                    await saveErrorSnapshot(`close_handler_click_error_${reqId}`); 
+               }
+          };
+          res.on('close', closeEventHandler);
+          // --- 结束添加监听器 ---
+
+          // 6. 定位响应元素
+          const { responseElement } = await locateResponseElements(page, locators, reqId);
+
+          // 7. 处理响应 (流式或非流式)
+          console.log(`[${reqId}] 处理 AI 回复...`);
+          if (isStreaming) {
+               // --- 设置流式响应头 ---
+               res.setHeader('Content-Type', 'text/event-stream');
+               res.setHeader('Cache-Control', 'no-cache');
+               res.setHeader('Connection', 'keep-alive');
+               res.flushHeaders();
+
+               // 调用流式处理函数
+               // 传递检查函数 () => isCancelled
+               await handleStreamingResponse(res, responseElement, page, locators, operationTimer, reqId, () => isCancelled);
+
+          } else {
+               // 调用非流式处理函数
+               // 传递检查函数 () => isCancelled
+               await handleNonStreamingResponse(res, page, locators, operationTimer, reqId, () => isCancelled);
+          }
+
+          // --- 修改：仅在未被取消时记录成功 --- 
+          if (!isCancelled) {
+               console.log(`[${reqId}] ✅ 请求处理成功完成。`);
+               clearTimeout(operationTimer); // 只有真正成功完成才清除计时器
+          } else {
+               console.log(`[${reqId}] ℹ️ 请求处理因客户端断开连接而被中止。`);
+               // operationTimer 应该已经在 closeEventHandler 中被清除了
+          }
+          // --- 结束修改 ---
+
+     } catch (error) {
+          // 确保在任何错误情况下都清除此请求的定时器 (如果 close 事件未触发)
+          if (!isCancelled) {
+               clearTimeout(operationTimer);
+          }
+          console.error(`[${reqId}] ❌ 处理队列中的请求时出错: ${error.message}\n${error.stack}`);
+
+          // --- 恢复：添加条件判断是否需要保存快照 ---
+          const shouldSaveSnapshot = !(
+              error.message?.includes('Invalid request') || // 跳过请求验证错误
+              error.message?.includes('Playwright not ready') // 跳过 Playwright 初始化/连接错误
+              // 未来可以根据需要添加其他不需要快照的错误类型
+          );
+
+          if (shouldSaveSnapshot && !error.message?.includes('snapshot') && !error.stack?.includes('saveErrorSnapshot')) {
+              // 避免在保存快照本身失败或已知Playwright问题时再次尝试保存
+              await saveErrorSnapshot(`general_api_error_${reqId}`);
+          } else if (!shouldSaveSnapshot) {
+              console.log(`[${reqId}] (Info) Skipping error snapshot for this type of error: ${error.message.split('\n')[0]}`);
+          }
+          // --- 结束恢复 ---
+
+          // 发送错误响应，如果尚未发送
+          if (!res.headersSent) {
+                let statusCode = 500;
+                let errorType = 'server_error';
+                if (error.message?.includes('timed out') || error.message?.includes('timeout')) {
+                    statusCode = 504; // Gateway Timeout
+                    errorType = 'timeout_error';
+                } else if (error.message?.includes('AI Studio Error')) {
+                    statusCode = 502; // Bad Gateway (error from upstream)
+                    errorType = 'upstream_error';
+                } else if (error.message?.includes('Invalid request')) {
+                    statusCode = 400; // Bad Request
+                    errorType = 'invalid_request_error';
+                } else if (error.message?.includes('Playwright not ready')) { // Specific handling for PW not ready here
+                    statusCode = 503;
+                    errorType = 'server_error';
+                }
+               res.status(statusCode).json({ error: { message: `[${reqId}] ${error.message}`, type: errorType } });
+          } else if (req.body.stream === true && !res.writableEnded) { // Check if it WAS a streaming request
+                // 如果是流式响应且头部已发送，则发送流式错误
+                sendStreamError(res, error.message, reqId);
+          }
+          else if (!res.writableEnded) {
+                // 对于非流式但已发送部分内容的罕见情况，或流式错误发送后的清理
+                res.end();
+          }
+     } finally {
+          // --- 添加清理逻辑 ---
+          if (closeEventHandler) {
+               res.removeListener('close', closeEventHandler);
+               // console.log(`[${reqId}] Removed 'close' event listener.`); // Optional debug log
+          }
+          // --- 结束清理逻辑 ---
+          isProcessing = false; // 标记处理已结束
+          console.log(`[${reqId}] ---结束处理队列中的请求---`);
+          // 触发处理下一个请求（如果队列中有）
+          processQueue();
+     }
+}
+
+// --- API 端点 (v2.18: 使用队列) ---
+app.post('/v1/chat/completions', async (req, res) => {
+    const reqId = Math.random().toString(36).substring(2, 9); // 生成简短的请求 ID
+    console.log(`\n[${reqId}] === 收到 /v1/chat/completions 请求 ===`);
+
+    // 创建请求队列项，并添加取消标记和临时监听器引用
+    const queueItem = {
+         req,
+         res,
+         reqId,
+         isCancelledByClient: false,
+         preliminaryCloseHandler: null
+    };
+
+    // --- 添加临时的 'close' 事件监听器 ---
+    queueItem.preliminaryCloseHandler = () => {
+         if (!queueItem.isCancelledByClient) { // 避免重复标记
+              console.log(`[${reqId}] Client disconnected before processing started.`);
+              queueItem.isCancelledByClient = true;
+              // 从 res 对象移除自身，防止后续冲突
+              res.removeListener('close', queueItem.preliminaryCloseHandler);
+         }
+    };
+    res.once('close', queueItem.preliminaryCloseHandler); // 使用 once 确保最多触发一次
+    // --- 结束添加临时监听器 ---
+
+    // 将请求加入队列
+    requestQueue.push(queueItem); // <-- 推入包含标记的对象
+    console.log(`[${reqId}] 请求已加入队列 (当前队列长度: ${requestQueue.length})`);
+
+    // 尝试处理队列 (如果当前未在处理)
+    if (!isProcessing) {
+        console.log(`[Queue] 触发队列处理 (收到新请求 ${reqId} 时处于空闲状态)`);
+        processQueue();
+    } else {
+         console.log(`[Queue] 当前正在处理其他请求，请求 ${reqId} 已排队等待。`);
+    }
+});
+
+
+// --- Helper: 获取当前文本 (v2.14 - 获取原始文本) -> vNEXT: Try innerText
+async function getRawTextContent(responseElement, previousText, reqId) {
+    try {
+         await responseElement.waitFor({ state: 'attached', timeout: 1500 });
+         const preElement = responseElement.locator('pre').last();
+         let rawText = null;
+         try {
+              await preElement.waitFor({ state: 'attached', timeout: 500 });
+              // 尝试使用 innerText 获取渲染后的文本，可能更好地保留换行
+              rawText = await preElement.innerText({ timeout: 1000 });
+         } catch {
+              // 如果 pre 元素获取失败，回退到 responseElement 的 innerText
+              console.warn(`[${reqId}] (Warn) Failed to get innerText from <pre>, falling back to parent.`);
+              rawText = await responseElement.innerText({ timeout: 2000 });
+         }
+         // 移除 trim()，直接返回获取到的文本
+         return rawText !== null ? rawText : previousText;
+    } catch (e) {
+         console.warn(`[${reqId}] (Warn) getRawTextContent (innerText) failed: ${e.message.split('\n')[0]}. Returning previous.`);
+         return previousText;
+    }
+}
+
+// --- Helper: 发送流式块 ---
+function sendStreamChunk(res, delta, reqId) {
+    if (delta && !res.writableEnded) {
+        const chunk = {
+            id: `${CHAT_COMPLETION_ID_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 15)}`,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: MODEL_NAME,
+            choices: [{ index: 0, delta: { content: delta }, finish_reason: null }]
+        };
+         try {
+             res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+         } catch (writeError) {
+              console.error(`[${reqId}] Error writing stream chunk:`, writeError.message);
+              if (!res.writableEnded) res.end(); // End stream on write error
+         }
+    }
+}
+
+// --- Helper: 发送流式错误块 ---
+function sendStreamError(res, errorMessage, reqId) {
+     if (!res.writableEnded) {
+         const errorPayload = { error: { message: `[${reqId}] Server error during streaming: ${errorMessage}`, type: 'server_error' } };
+         try {
+              // Avoid writing multiple DONE messages if error occurs after normal DONE
+              if (!res.writableEnded) res.write(`data: ${JSON.stringify(errorPayload)}\n\n`);
+              if (!res.writableEnded) res.write('data: [DONE]\n\n');
+         } catch (e) {
+             console.error(`[${reqId}] Error writing stream error chunk:`, e.message);
+         } finally {
+             if (!res.writableEnded) res.end(); // Ensure stream ends
+         }
+     }
+}
+
+// --- Helper: 保存错误快照 ---
+async function saveErrorSnapshot(errorName = 'error') {
+     // Extract reqId if present in the name
+     const nameParts = errorName.split('_');
+     const reqId = nameParts[nameParts.length - 1].length === 7 ? nameParts.pop() : null; // Simple check for likely reqId
+     const baseErrorName = nameParts.join('_');
+     const logPrefix = reqId ? `[${reqId}]` : '[No ReqId]';
+
+     if (!browser?.isConnected() || !page || page.isClosed()) {
+         console.log(`${logPrefix} 无法保存错误快照 (${baseErrorName})，浏览器或页面不可用。`);
+         return;
+     }
+     console.log(`${logPrefix} 尝试保存错误快照 (${baseErrorName})...`);
+     const timestamp = Date.now();
+     const errorDir = path.join(__dirname, 'errors');
+     try {
+          if (!fs.existsSync(errorDir)) fs.mkdirSync(errorDir, { recursive: true });
+          // Include reqId in filename if available
+          const filenameSuffix = reqId ? `${reqId}_${timestamp}` : `${timestamp}`;
+          const screenshotPath = path.join(errorDir, `${baseErrorName}_screenshot_${filenameSuffix}.png`);
+          const htmlPath = path.join(errorDir, `${baseErrorName}_page_${filenameSuffix}.html`);
+
+          try {
+               await page.screenshot({ path: screenshotPath, fullPage: true, timeout: 15000 });
+               console.log(`${logPrefix}    错误快照已保存到: ${screenshotPath}`);
+          } catch (screenshotError) {
+               console.error(`${logPrefix}    保存屏幕截图失败 (${baseErrorName}): ${screenshotError.message}`);
+          }
+          try {
+               const content = await page.content({timeout: 15000});
+               fs.writeFileSync(htmlPath, content);
+               console.log(`${logPrefix}    错误页面HTML已保存到: ${htmlPath}`);
+          } catch (htmlError) {
+                console.error(`${logPrefix}    保存页面HTML失败 (${baseErrorName}): ${htmlError.message}`);
+          }
+     } catch (dirError) {
+          console.error(`${logPrefix}    创建错误目录或保存快照时出错: ${dirError.message}`);
+     }
+}
+
+// v2.14: Helper to safely parse JSON, attempting to find the outermost object/array
+function tryParseJson(text, reqId) {
+    if (!text || typeof text !== 'string') return null;
+    text = text.trim();
+
+    let startIndex = -1;
+    let endIndex = -1;
+
+    const firstBrace = text.indexOf('{');
+    const firstBracket = text.indexOf('[');
+
+    if (firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket)) {
+        startIndex = firstBrace;
+        endIndex = text.lastIndexOf('}');
+    } else if (firstBracket !== -1) {
+        startIndex = firstBracket;
+        endIndex = text.lastIndexOf(']');
+    }
+
+    if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+        // console.warn(`[${reqId}] (Warn) Could not find valid start/end braces/brackets for JSON parsing.`);
+        return null;
+    }
+
+    const jsonText = text.substring(startIndex, endIndex + 1);
+
+    try {
+        return JSON.parse(jsonText);
+    } catch (e) {
+         // console.warn(`[${reqId}] (Warn) JSON parse failed for extracted text: ${e.message}`);
+        return null;
+    }
+}
+
+// --- Helper: 检测并提取页面错误提示 ---
+async function detectAndExtractPageError(page, reqId) {
+    const errorToastLocator = page.locator(ERROR_TOAST_SELECTOR).last();
+    try {
+        const isVisible = await errorToastLocator.isVisible({ timeout: 1000 });
+        if (isVisible) {
+            console.log(`[${reqId}]    检测到错误 Toast 元素。`);
+            const messageLocator = errorToastLocator.locator('span.content-text');
+            const errorMessage = await messageLocator.textContent({ timeout: 500 });
+            return errorMessage || "Detected error toast, but couldn't extract specific message.";
+        } else {
+             return null;
+        }
+    } catch (e) {
+        // console.warn(`[${reqId}] (Warn) Checking for error toast failed or timed out: ${e.message.split('\n')[0]}`);
+        return null;
+    }
+}
+
+// --- Helper: 快速检查结束条件 ---
+async function checkEndConditionQuickly(page, spinnerLocator, inputLocator, buttonLocator, timeoutMs = 250, reqId) {
+    try {
+        const results = await Promise.allSettled([
+            expect(spinnerLocator).toBeHidden({ timeout: timeoutMs }),
+            expect(inputLocator).toHaveValue('', { timeout: timeoutMs }),
+            expect(buttonLocator).toBeDisabled({ timeout: timeoutMs })
+        ]);
+        const allMet = results.every(result => result.status === 'fulfilled');
+        // console.log(`[${reqId}] (Quick Check) All met: ${allMet}`);
+        return allMet;
+    } catch (error) {
+        // console.warn(`[${reqId}] (Quick Check) Error during checkEndConditionQuickly: ${error.message}`);
+        return false;
+    }
+}
+
+// --- 启动服务器 ---
+let serverInstance = null;
+(async () => {
+    await initializePlaywright();
+
+    serverInstance = app.listen(SERVER_PORT, () => {
+        console.log("\n=============================================================");
+        // v2.18: Updated version marker
+        console.log("          🚀 AI Studio Proxy Server (v2.18 - Queue) 🚀");
+        console.log("=============================================================");
+        console.log(`🔗 监听地址: http://localhost:${SERVER_PORT}`);
+        console.log(`   - Web UI (测试): http://localhost:${SERVER_PORT}/`);
+        console.log(`   - API 端点:   http://localhost:${SERVER_PORT}/v1/chat/completions`);
+        console.log(`   - 模型接口:   http://localhost:${SERVER_PORT}/v1/models`);
+        console.log(`   - 健康检查:   http://localhost:${SERVER_PORT}/health`);
+        console.log("-------------------------------------------------------------");
+        if (isPlaywrightReady) {
+            console.log('✅ Playwright 连接成功，服务已准备就绪！');
+        } else {
+            console.warn('⚠️ Playwright 未就绪。请检查下方日志并确保 Chrome/AI Studio 正常运行。');
+            console.warn('   API 请求将失败，直到 Playwright 连接成功。');
+        }
+        console.log("-------------------------------------------------------------");
+        console.log(`⏳ 等待 Chrome 实例 (调试端口: ${CHROME_DEBUGGING_PORT})...`);
+        console.log("   请确保已运行 auto_connect_aistudio.js 脚本，");
+        console.log("   并且 Google AI Studio 页面已在浏览器中打开。 ");
+        console.log("=============================================================\n");
+    });
+
+    serverInstance.on('error', (error) => {
+        if (error.code === 'EADDRINUSE') {
+            console.error("\n=============================================================");
+            console.error(`❌ 致命错误：端口 ${SERVER_PORT} 已被占用！`);
+            console.error("   请关闭占用该端口的其他程序，或在 server.cjs 中修改 SERVER_PORT。 ");
+            console.error("=============================================================\n");
+        } else {
+            console.error('❌ 服务器启动失败:', error);
+        }
+        process.exit(1);
+    });
+
+})();
+
+// --- 优雅关闭处理 ---
+let isShuttingDown = false;
+async function shutdown(signal) {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    console.log(`\n收到 ${signal} 信号，正在关闭服务器...`);
+    console.log(`当前队列中有 ${requestQueue.length} 个请求等待处理。将不再接受新请求。`);
+    // Option: Wait for the current request to finish?
+    // For now, we'll just close the server, potentially interrupting the current request.
+
+    if (serverInstance) {
+        serverInstance.close(async (err) => {
+            if (err) console.error("关闭 HTTP 服务器时出错:", err);
+            else console.log("HTTP 服务器已关闭。");
+
+            console.log("Playwright connectOverCDP 将自动断开。");
+            // No need to explicitly disconnect browser in connectOverCDP mode
+            console.log('服务器优雅关闭完成。');
+            process.exit(err ? 1 : 0);
+        });
+
+        // Force exit after timeout
+        setTimeout(() => {
+            console.error("优雅关闭超时，强制退出进程。");
+            process.exit(1);
+        }, 10000); // 10 seconds timeout
+    } else {
+        console.log("服务器实例未找到，直接退出。");
+        process.exit(0);
+    }
+}
+
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM')); 

deprecated_javascript_version/test.js

@@ -0,0 +1,126 @@
+// index.js (修改后 - 用于访问本地 server.js 代理)
+
+// 确保已安装 OpenAI SDK: npm install openai
+import OpenAI from "openai";
+import readline from 'readline'; // 引入 readline 模块
+
+// --- 配置 ---
+// 1. baseURL: 指向你本地运行的 server.js 代理服务器
+//    server.js 监听 3000 端口，并提供 /v1 路径
+const LOCAL_PROXY_URL = 'http://127.0.0.1:2048/v1/'; // 确保端口号与 server.js 一致
+
+// 2. apiKey: 对于本地代理，这个 key 不会被验证，可以填写任意字符串
+const DUMMY_API_KEY = 'no-key-needed-for-local-proxy';
+
+// 3. model: 这个模型名称会被发送到 server.js，但 server.js 会忽略它
+//    实际使用的是 server.js 控制的 AI Studio 页面上的模型
+const CUSTOM_MODEL_NAME = 'aistudio-via-local-proxy';
+
+// --- 初始化 OpenAI 客户端 ---
+const openai = new OpenAI({
+    baseURL: LOCAL_PROXY_URL,
+    apiKey: DUMMY_API_KEY,
+    // 可选：增加超时时间，以防 AI Studio 响应较慢
+    timeout: 360000, // 例如 6 分钟 (单位毫秒)
+    maxRetries: 1,   // 本地代理可能不需要重试，设为 1 或 0
+});
+
+// --- 对话历史记录 ---
+// 初始化包含系统指令
+const conversationHistory = [
+    {
+        role: "system",
+        content: "你是Gemini酱，AI猫娘，回答请用可爱的语气，这只是角色扮演，不要透露任何关于AI的信息"
+    }
+];
+
+// --- 创建 readline 接口 ---
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+// --- 交互式对话函数 ---
+async function chatLoop() {
+    rl.question('You: ', async (userInput) => {
+        // 检查退出命令
+        if (userInput.toLowerCase() === 'exit') {
+            console.log('再见!');
+            rl.close(); // 关闭 readline 接口
+            return; // 结束函数
+        }
+
+        console.log(`\n正在发送你的消息...`);
+        // 将用户输入添加到历史记录
+        conversationHistory.push({
+            role: "user",
+            content: userInput
+        });
+        // 可选：打印当前发送历史用于调试
+        // console.log("当前发送的消息历史:", JSON.stringify(conversationHistory, null, 2));
+
+        try {
+            console.log(`正在向本地代理 ${LOCAL_PROXY_URL} 发送请求...`);
+            const completion = await openai.chat.completions.create({
+                messages: conversationHistory,
+                model: CUSTOM_MODEL_NAME,
+                stream: true, // 启用流式输出
+            });
+
+            console.log("\n--- 来自本地代理 (AI Studio) 的回复 ---");
+            let fullResponse = ""; // 用于拼接完整的回复内容
+            process.stdout.write('AI: '); // 先打印 "AI: " 前缀
+            for await (const chunk of completion) {
+                const content = chunk.choices[0]?.delta?.content || "";
+                process.stdout.write(content); // 直接打印流式内容，不换行
+                fullResponse += content; // 拼接内容
+            }
+            console.log(); // 在流结束后换行
+
+            // 将完整的 AI 回复添加到历史记录
+            if (fullResponse) {
+                 conversationHistory.push({ role: "assistant", content: fullResponse });
+            } else {
+                console.log("未能从代理获取有效的流式内容。");
+                 // 如果回复无效，可以选择从历史中移除刚才的用户输入
+                conversationHistory.pop();
+            }
+            console.log("----------------------------------------------\n");
+
+        } catch (error) {
+            console.error("\n--- 请求出错 ---");
+            // 保持之前的错误处理逻辑
+            if (error instanceof OpenAI.APIError) {
+                console.error(`   错误类型: OpenAI APIError (可能是代理返回的错误)`);
+                console.error(`   状态码: ${error.status}`);
+                console.error(`   错误消息: ${error.message}`);
+                console.error(`   错误代码: ${error.code}`);
+                console.error(`   错误参数: ${error.param}`);
+            } else if (error.code === 'ECONNREFUSED') {
+                console.error(`   错误类型: 连接被拒绝 (ECONNREFUSED)`);
+                console.error(`   无法连接到服务器 ${LOCAL_PROXY_URL}。请检查 server.js 是否运行。`);
+            } else if (error.name === 'TimeoutError' || (error.cause && error.cause.code === 'UND_ERR_CONNECT_TIMEOUT')) {
+                 console.error(`   错误类型: 连接超时`);
+                 console.error(`   连接到 ${LOCAL_PROXY_URL} 超时。请检查 server.js 或 AI Studio 响应。`);
+            } else {
+                console.error('   发生了未知错误:', error.message);
+            }
+            console.error("----------------------------------------------\n");
+             // 出错时，从历史中移除刚才的用户输入，避免影响下次对话
+            conversationHistory.pop();
+        }
+
+        // 不论成功或失败，都继续下一次循环
+        chatLoop();
+    });
+}
+
+// --- 启动交互式对话 ---
+console.log('你好! 我是Gemini酱。有什么事可以帮你哒，输入 "exit" 退出。');
+console.log('   (请确保 server.js 和 auto_connect_aistudio.js 正在运行)');
+chatLoop(); // 开始第一次提问
+
+// --- 不再需要文件末尾的 main 调用和 setTimeout 示例 ---
+// // 运行第一次对话
+// main("你好！简单介绍一下你自己以及你的能力。");
+// ... (移除 setTimeout 示例)