init

AGENTS.md

@@ -0,0 +1,22 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+Snap-Solver is a Flask web app served from `app.py`, which wires Socket.IO streaming, screenshot capture, and model dispatch. Model adapters live in `models/`, with `factory.py` loading provider metadata from `config/models.json` and creating the appropriate client (OpenAI, Anthropic, DeepSeek, Qwen, etc.). User-facing templates live under `templates/`, with shared assets in `static/`. Runtime configuration and secrets are JSON files in `config/`; treat these as local-only overrides even if sample values exist in the repo. Python dependencies are listed in `requirements.txt` (lockfile: `uv.lock`).
+
+## Build, Test, and Development Commands
+- `python -m venv .venv && source .venv/bin/activate` sets up an isolated environment.
+- `pip install -r requirements.txt` or `uv sync` installs Flask, provider SDKs, and Socket.IO.
+- `python app.py` boots the development server at `http://localhost:5000` with verbose engine logs.
+- `FLASK_ENV=development python app.py` enables auto-reload during active development.
+
+## Coding Style & Naming Conventions
+Follow PEP 8: 4-space indentation, `snake_case` for Python functions, and descriptive class names that match provider roles (see `models/openai.py`). JSON configs use lowerCamelCase keys so the web client can consume them directly; keep that convention when adding settings. Client scripts in `static/js/` should stay modular and avoid sprawling event handlers.
+
+## Testing Guidelines
+There is no automated test suite yet; whenever you add features, verify end-to-end by launching `python app.py`, triggering a screenshot from the UI, and confirming Socket.IO events stream without tracebacks. When integrating a new model, seed a temporary key in `config/api_keys.json`, exercise one request, and capture console logs before reverting secrets. If you introduce automated tests, place them in `tests/` and gate external calls behind mocks so the suite can run offline.
+
+## Commit & Pull Request Guidelines
+The history favors concise, imperative commit subjects in Chinese (e.g., `修复发送按钮保存裁剪框数据`). Keep messages under 70 characters, enumerate multi-part changes in the body, and reference related issues with `#123` when applicable. Pull requests should outline the user-visible impact, note any config updates or new dependencies, attach UI screenshots for front-end tweaks, and list manual verification steps so reviewers can reproduce them quickly.
+
+## Configuration & Security Tips
+Never commit real API keys—`.gitignore` already excludes `config/api_keys.json` and other volatile files, so create local copies (`config/api_keys.local.json`) for experimentation. When sharing deployment instructions, direct operators to set API credentials via environment variables or secure vaults and only populate JSON stubs during runtime startup logic.

Dockerfile

@@ -1,13 +1,13 @@
-FROM python:3.12
+FROM python:3.10-slim
 
-WORKDIR /code
+WORKDIR /app
 
-COPY ./requirements.txt /code/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+# 安装依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
+# 复制项目所有文件
 COPY . .
 
-EXPOSE 7860
-
-CMD ["shiny", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]
+# 启动命令
+CMD ["python", "app.py"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2025] [Zippland]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,20 +1,224 @@
----
-title: Snap Solver
-emoji: 🌍
-colorFrom: yellow
-colorTo: indigo
-sdk: docker
-pinned: false
-license: mit
----
+<h1 align="center">Snap-Solver <img src="https://img.shields.io/badge/版本-1.5.1-blue" alt="版本"></h1>
 
-This is a templated Space for [Shiny for Python](https://shiny.rstudio.com/py/). 
 
+<p align="center">
+  <b>🔍 一键截屏，自动解题 - 线上考试，从未如此简单</b>
+</p>
 
-To get started with a new app do the following:
+<p align="center">
+  <img src="https://img.shields.io/badge/Python-3.x-blue?logo=python" alt="Python">
+  <img src="https://img.shields.io/badge/Framework-Flask-green?logo=flask" alt="Flask">
+  <img src="https://img.shields.io/badge/AI-Multi--Model-orange" alt="AI">
+  <img src="https://img.shields.io/badge/License-Apache%202.0-lightgrey" alt="License">
+</p>
 
-1) Install Shiny with `pip install shiny`
-2) Create a new app with `shiny create`
-3) Then run the app with `shiny run --reload`
 
-To learn more about this framework please see the [Documentation](https://shiny.rstudio.com/py/docs/overview.html).
+<p align="center">
+  <a href="#-核心特性">核心特性</a> •
+  <a href="#-快速开始">快速开始</a> •
+  <a href="#-新手教程">新手教程</a> •
+  <a href="#-使用指南">使用指南</a> •
+  <a href="#-技术架构">技术架构</a> •
+  <a href="#-高级配置">高级配置</a> •
+  <a href="#-常见问题">常见问题</a> •
+  <a href="#-获取帮助">获取帮助</a>
+</p>
+
+<div align="center">
+  <a href="https://github.com/Zippland/Snap-Solver/releases">
+    <img src="https://img.shields.io/badge/⚡%20快速开始-下载最新版本-0366D6?style=for-the-badge&logo=github&logoColor=white" alt="获取Release" width="240" />
+  </a>
+  &nbsp;&nbsp;&nbsp;&nbsp;
+  <a href="docs/beginner-tutorial.md">
+    <img src="https://img.shields.io/badge/📘%20零基础入门-阅读新手教程-FF9800?style=for-the-badge&logo=bookstack&logoColor=white" alt="阅读新手教程" width="240" />
+  </a>
+  &nbsp;&nbsp;&nbsp;&nbsp;
+  <a href="mailto:zylanjian@outlook.com">
+    <img src="https://img.shields.io/badge/📞%20代部署支持-联系我们-28a745?style=for-the-badge&logo=mail.ru&logoColor=white" alt="联系我们" width="220" />
+  </a>
+</div>
+<!-- <p align="center">
+  <img src="pic.jpg" alt="Snap-Solver 截图" width="300" />
+</p> -->
+
+## 💫 项目简介
+
+**Snap-Solver** 是一个革命性的AI笔试测评工具，专为学生、考生和自学者设计。只需**按下快捷键**，即可自动截取屏幕上的任何题目，通过AI进行分析并提供详细解答。
+
+无论是复杂的数学公式、物理难题、编程问题，还是其他学科的挑战，Snap-Solver都能提供清晰、准确、有条理的解决方案，帮助您更好地理解和掌握知识点。
+
+## 📚 新手教程
+
+第一次使用？按照我们的 [《新手教程》](docs/beginner-tutorial.md) 完成环境准备、模型配置和首次解题演练，全程图文指引，几分钟即可上手。
+
+## 🔧 技术架构
+
+```mermaid
+graph TD
+    A[用户界面] --> B[Flask Web服务]
+    B --> C{API路由}
+    C --> D[截图服务]
+    C --> E[OCR识别]
+    C --> F[AI分析]
+    E --> |Mathpix API| G[文本提取]
+    F --> |模型选择| H1[OpenAI]
+    F --> |模型选择| H2[Anthropic]
+    F --> |模型选择| H3[DeepSeek]
+    F --> |模型选择| H4[Alibaba]
+    F --> |模型选择| H5[Google]
+    F --> |模型选择| H6[Doubao]
+    D --> I[Socket.IO实时通信]
+    I --> A
+```
+
+## ✨ 核心特性
+
+<table>
+  <tr>
+    <td width="50%">
+      <h3>📱 跨设备协同</h3>
+      <ul>
+        <li><b>一键截图</b>：按下快捷键，即可在移动设备上查看和分析电脑屏幕</li>
+        <li><b>局域网共享</b>：一处部署，多设备访问，提升学习效率</li>
+      </ul>
+    </td>
+    <td width="50%">
+      <h3>🧠 多模型AI支持</h3>
+      <ul>
+        <li><b>GPT 家族</b>：OpenAI强大的推理能力</li>
+        <li><b>Claude 家族</b>：Anthropic的高级理解与解释</li>
+        <li><b>DeepSeek 家族</b>：专为中文场景优化的模型</li>
+        <li><b>QVQ 和 Qwen 家族</b>：以视觉推理闻名的国产AI</li>
+        <li><b>Gemini 家族</b>：智商130的非推理AI</li>
+      </ul>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <h3>🔍 精准识别</h3>
+      <ul>
+        <li><b>OCR文字识别</b>：准确捕捉图片中的文本</li>
+        <li><b>数学公式支持</b>：通过Mathpix精确识别复杂数学符号</li>
+      </ul>
+    </td>
+    <td>
+      <h3>🌐 全球无障碍</h3>
+      <ul>
+        <li><b>VPN代理支持</b>：自定义代理设置，解决网络访问限制</li>
+        <li><b>多语言响应</b>：支持定制AI回复语言</li>
+      </ul>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <h3>💻 全平台兼容</h3>
+      <ul>
+        <li><b>桌面支持</b>：Windows、MacOS、Linux</li>
+        <li><b>移动访问</b>：手机、平板通过浏览器直接使用</li>
+      </ul>
+    </td>
+    <td>
+      <h3>⚙️ 高度可定制</h3>
+      <ul>
+        <li><b>思考深度控制</b>：调整AI的分析深度</li>
+        <li><b>自定义提示词</b>：针对特定学科优化提示</li>
+      </ul>
+    </td>
+  </tr>
+</table>
+
+## 🚀 快速开始
+
+### 📋 前置要求
+
+- Python 3.x
+- 至少以下一个API Key:
+  - OpenAI API Key
+  - Anthropic API Key (推荐✅)
+  - DeepSeek API Key
+  - Alibaba API Key （国内用户首选）
+  - Google API Key
+  - Mathpix API Key (推荐OCR识别✅)
+
+### 📥 开始使用
+
+```bash
+# 启动应用
+python app.py
+```
+
+### 📱 访问方式
+
+- **本机访问**：打开浏览器，访问 http://localhost:5000
+- **局域网设备访问**：在同一网络的任何设备上访问 `http://[电脑IP]:5000`
+
+### 🎯 使用场景示例
+
+- **课后习题**：截取教材或作业中的难题，获取步骤详解
+- **编程调试**：截取代码错误信息，获取修复建议
+- **考试复习**：分析错题并理解解题思路
+- **文献研究**：截取复杂论文段落，获取简化解释
+
+### 🧩 组件详情
+
+- **前端**：响应式HTML/CSS/JS界面，支持移动设备
+- **后端**：Flask + SocketIO，提供RESTful API和WebSocket
+- **AI接口**：多模型支持，统一接口标准
+- **图像处理**：高效的截图和裁剪功能
+
+## ⚙️ 高级可调参数
+
+- **温度**：调整回答的创造性与确定性（0.1-1.0）
+- **最大输出Token**：控制回答长度
+- **推理深度**：标准模式（快速）或深度思考（详细）
+- **思考预算占比**：平衡思考过程与最终答案的详细程度
+- **系统提示词**：自定义AI的基础行为与专业领域
+
+## ❓ 常见问题
+
+<details>
+<summary><b>如何获得最佳识别效果？</b></summary>
+<p>
+确保截图清晰，包含完整题目和必要上下文。对于数学公式，建议使用Mathpix OCR以获得更准确的识别结果。
+</p>
+</details>
+
+<details>
+<summary><b>无法连接到服务怎么办？</b></summary>
+<p>
+1. 检查防火墙设置是否允许5000端口<br>
+2. 确认设备在同一局域网内<br>
+3. 尝试重启应用程序<br>
+4. 查看控制台日志获取错误信息
+</p>
+</details>
+
+<details>
+<summary><b>API调用失败的原因？</b></summary>
+<p>
+1. API密钥可能无效或余额不足<br>
+2. 网络连接问题，特别是国际API<br>
+3. 代理设置不正确<br>
+4. API服务可能临时不可用
+</p>
+</details>
+
+<details>
+<summary><b>如何优化AI回答质量？</b></summary>
+<p>
+1. 调整系统提示词，添加特定学科的指导<br>
+2. 根据问题复杂度选择合适的模型<br>
+3. 对于复杂题目，使用"深度思考"模式<br>
+4. 确保截取的题目包含完整信息
+</p>
+</details>
+
+## 🤝 获取帮助
+
+- **代部署服务**：如果您不擅长编程，需要代部署服务，请联系 [zylanjian@outlook.com](mailto:zylanjian@outlook.com)
+- **问题报告**：在GitHub仓库提交Issue
+- **功能建议**：欢迎通过Issue或邮件提供改进建议
+
+## 📜 开源协议
+
+本项目采用 [Apache 2.0](LICENSE) 协议。

app.py

@@ -1,162 +1,1119 @@
-import faicons as fa
-import plotly.express as px
+from flask import Flask, jsonify, render_template, request, send_from_directory
+from flask_socketio import SocketIO
+import pyautogui
+import base64
+from io import BytesIO
+import socket
+from threading import Thread, Event
+import threading
+from PIL import Image
+import pyperclip
+from models import ModelFactory
+import time
+import os
+import json
+import traceback
+import requests
+from datetime import datetime
+import sys
 
-# Load data and compute static values
-from shared import app_dir, tips
-from shinywidgets import render_plotly
+app = Flask(__name__)
+socketio = SocketIO(
+    app, 
+    cors_allowed_origins="*", 
+    ping_timeout=30, 
+    ping_interval=5, 
+    max_http_buffer_size=50 * 1024 * 1024,
+    async_mode='threading',  # 使用threading模式提高兼容性
+    engineio_logger=True,    # 启用引擎日志，便于调试
+    logger=True              # 启用Socket.IO日志
+)
 
-from shiny import reactive, render
-from shiny.express import input, ui
+# 常量定义
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+CONFIG_DIR = os.path.join(CURRENT_DIR, 'config')
+STATIC_DIR = os.path.join(CURRENT_DIR, 'static')
+# 确保配置目录存在
+os.makedirs(CONFIG_DIR, exist_ok=True)
 
-bill_rng = (min(tips.total_bill), max(tips.total_bill))
+# 密钥和其他配置文件路径
+API_KEYS_FILE = os.path.join(CONFIG_DIR, 'api_keys.json')
+API_BASE_URLS_FILE = os.path.join(CONFIG_DIR, 'api_base_urls.json')
+VERSION_FILE = os.path.join(CONFIG_DIR, 'version.json')
+UPDATE_INFO_FILE = os.path.join(CONFIG_DIR, 'update_info.json')
+PROMPT_FILE = os.path.join(CONFIG_DIR, 'prompts.json')  # 新增提示词配置文件路径
+PROXY_API_FILE = os.path.join(CONFIG_DIR, 'proxy_api.json')  # 新增中转API配置文件路径
 
-# Add page title and sidebar
-ui.page_opts(title="Restaurant tipping", fillable=True)
+DEFAULT_API_BASE_URLS = {
+    "AnthropicApiBaseUrl": "",
+    "OpenaiApiBaseUrl": "",
+    "DeepseekApiBaseUrl": "",
+    "AlibabaApiBaseUrl": "",
+    "GoogleApiBaseUrl": "",
+    "DoubaoApiBaseUrl": ""
+}
 
-with ui.sidebar(open="desktop"):
-    ui.input_slider(
-        "total_bill",
-        "Bill amount",
-        min=bill_rng[0],
-        max=bill_rng[1],
-        value=bill_rng,
-        pre="$",
-    )
-    ui.input_checkbox_group(
-        "time",
-        "Food service",
-        ["Lunch", "Dinner"],
-        selected=["Lunch", "Dinner"],
-        inline=True,
+def ensure_api_base_urls_file():
+    """确保 API 基础 URL 配置文件存在并包含所有占位符"""
+    try:
+        file_exists = os.path.exists(API_BASE_URLS_FILE)
+        base_urls = {}
+        if file_exists:
+            try:
+                with open(API_BASE_URLS_FILE, 'r', encoding='utf-8') as f:
+                    loaded = json.load(f)
+                if isinstance(loaded, dict):
+                    base_urls = loaded
+                else:
+                    file_exists = False
+            except json.JSONDecodeError:
+                file_exists = False
+
+        missing_key_added = False
+        for key, default_value in DEFAULT_API_BASE_URLS.items():
+            if key not in base_urls:
+                base_urls[key] = default_value
+                missing_key_added = True
+
+        if not file_exists or missing_key_added or not base_urls:
+            with open(API_BASE_URLS_FILE, 'w', encoding='utf-8') as f:
+                json.dump(base_urls or DEFAULT_API_BASE_URLS, f, ensure_ascii=False, indent=2)
+    except Exception as e:
+        print(f"初始化API基础URL配置失败: {e}")
+
+# 确保API基础URL文件已经生成
+ensure_api_base_urls_file()
+
+# 跟踪用户生成任务的字典
+generation_tasks = {}
+
+# 初始化模型工厂
+ModelFactory.initialize()
+
+def get_local_ip():
+    try:
+        # Get local IP address
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except Exception:
+        return "127.0.0.1"
+
+@app.route('/')
+def index():
+    local_ip = get_local_ip()
+    
+    # 检查更新
+    try:
+        update_info = check_for_updates()
+    except:
+        update_info = {'has_update': False}
+        
+    return render_template('index.html', local_ip=local_ip, update_info=update_info)
+
+@socketio.on('connect')
+def handle_connect():
+    print('Client connected')
+
+@socketio.on('disconnect')
+def handle_disconnect():
+    print('Client disconnected')
+
+def create_model_instance(model_id, settings, is_reasoning=False):
+    """创建模型实例"""
+    # 提取API密钥
+    api_keys = settings.get('apiKeys', {})
+    
+    # 确定需要哪个API密钥
+    api_key_id = None
+    # 特殊情况：o3-mini使用OpenAI API密钥
+    if model_id.lower() == "o3-mini":
+        api_key_id = "OpenaiApiKey"
+    # 其他Anthropic/Claude模型
+    elif "claude" in model_id.lower() or "anthropic" in model_id.lower():
+        api_key_id = "AnthropicApiKey"
+    elif any(keyword in model_id.lower() for keyword in ["gpt", "openai"]):
+        api_key_id = "OpenaiApiKey"
+    elif "deepseek" in model_id.lower():
+        api_key_id = "DeepseekApiKey"
+    elif "qvq" in model_id.lower() or "alibaba" in model_id.lower() or "qwen" in model_id.lower():
+        api_key_id = "AlibabaApiKey"
+    elif "gemini" in model_id.lower() or "google" in model_id.lower():
+        api_key_id = "GoogleApiKey"
+    elif "doubao" in model_id.lower():
+        api_key_id = "DoubaoApiKey"
+    
+    # 首先尝试从本地配置获取API密钥
+    api_key = get_api_key(api_key_id)
+    
+    # 如果本地没有配置，尝试使用前端传递的密钥（向后兼容）
+    if not api_key:
+        api_key = api_keys.get(api_key_id)
+    
+    if not api_key:
+        raise ValueError(f"API key is required for the selected model (keyId: {api_key_id})")
+    
+    # 获取maxTokens参数，默认为8192
+    max_tokens = int(settings.get('maxTokens', 8192))
+    
+    # 检查是否启用中转API
+    proxy_api_config = load_proxy_api()
+    base_url = None
+    
+    if proxy_api_config.get('enabled', False):
+        # 根据模型类型选择对应的中转API
+        if "claude" in model_id.lower() or "anthropic" in model_id.lower():
+            base_url = proxy_api_config.get('apis', {}).get('anthropic', '')
+        elif any(keyword in model_id.lower() for keyword in ["gpt", "openai"]):
+            base_url = proxy_api_config.get('apis', {}).get('openai', '')
+        elif "deepseek" in model_id.lower():
+            base_url = proxy_api_config.get('apis', {}).get('deepseek', '')
+        elif "qvq" in model_id.lower() or "alibaba" in model_id.lower() or "qwen" in model_id.lower():
+            base_url = proxy_api_config.get('apis', {}).get('alibaba', '')
+        elif "gemini" in model_id.lower() or "google" in model_id.lower():
+            base_url = proxy_api_config.get('apis', {}).get('google', '')
+    
+    # 从前端设置获取自定义API基础URL (apiBaseUrls)
+    api_base_urls = settings.get('apiBaseUrls', {})
+    if api_base_urls:
+        # 根据模型类型选择对应的自定义API基础URL
+        if "claude" in model_id.lower() or "anthropic" in model_id.lower():
+            custom_base_url = api_base_urls.get('anthropic')
+            if custom_base_url:
+                base_url = custom_base_url
+        elif any(keyword in model_id.lower() for keyword in ["gpt", "openai"]):
+            custom_base_url = api_base_urls.get('openai')
+            if custom_base_url:
+                base_url = custom_base_url
+        elif "deepseek" in model_id.lower():
+            custom_base_url = api_base_urls.get('deepseek')
+            if custom_base_url:
+                base_url = custom_base_url
+        elif "qvq" in model_id.lower() or "alibaba" in model_id.lower() or "qwen" in model_id.lower():
+            custom_base_url = api_base_urls.get('alibaba')
+            if custom_base_url:
+                base_url = custom_base_url
+        elif "gemini" in model_id.lower() or "google" in model_id.lower():
+            custom_base_url = api_base_urls.get('google')
+            if custom_base_url:
+                base_url = custom_base_url
+        elif "doubao" in model_id.lower():
+            custom_base_url = api_base_urls.get('doubao')
+            if custom_base_url:
+                base_url = custom_base_url
+    
+    # 创建模型实例
+    model_instance = ModelFactory.create_model(
+        model_name=model_id,
+        api_key=api_key,
+        temperature=None if is_reasoning else float(settings.get('temperature', 0.7)),
+        system_prompt=settings.get('systemPrompt'),
+        language=settings.get('language', '中文'),
+        api_base_url=base_url  # 现在BaseModel支持api_base_url参数
     )
-    ui.input_action_button("reset", "Reset filter")
-
-# Add main content
-ICONS = {
-    "user": fa.icon_svg("user", "regular"),
-    "wallet": fa.icon_svg("wallet"),
-    "currency-dollar": fa.icon_svg("dollar-sign"),
-    "ellipsis": fa.icon_svg("ellipsis"),
-}
+    
+    # 设置最大输出Token，但不为阿里巴巴模型设置（它们有自己内部的处理逻辑）
+    is_alibaba_model = "qvq" in model_id.lower() or "alibaba" in model_id.lower() or "qwen" in model_id.lower()
+    if not is_alibaba_model:
+        model_instance.max_tokens = max_tokens
+    
+    return model_instance
+
+def stream_model_response(response_generator, sid, model_name=None):
+    """Stream model responses to the client"""
+    try:
+        print("Starting response streaming...")
+        
+        # 判断模型是否为推理模型
+        is_reasoning = model_name and ModelFactory.is_reasoning(model_name)
+        if is_reasoning:
+            print(f"使用推理模型 {model_name}，将显示思考过程")
+        
+        # 初始化：发送开始状态
+        socketio.emit('ai_response', {
+            'status': 'started',
+            'content': '',
+            'is_reasoning': is_reasoning
+        }, room=sid)
+        print("Sent initial status to client")
+
+        # 维护服务端缓冲区以累积完整内容
+        response_buffer = ""
+        thinking_buffer = ""
+        
+        # 上次发送的时间戳，用于控制发送频率
+        last_emit_time = time.time()
+        
+        # 流式处理响应
+        for response in response_generator:
+            # 处理Mathpix响应
+            if isinstance(response.get('content', ''), str) and 'mathpix' in response.get('model', ''):
+                    if current_time - last_emit_time >= 0.3:
+                        socketio.emit('ai_response', {
+                            'status': 'thinking',
+                            'content': thinking_buffer,
+                            'is_reasoning': True
+                        }, room=sid)
+                        last_emit_time = current_time
+                
+            elif status == 'thinking_complete':
+                # 仅对推理模型处理思考过程
+                if is_reasoning:
+                    # 直接使用完整的思考内容
+                    thinking_buffer = content
+                    
+                    print(f"Thinking complete, total length: {len(thinking_buffer)} chars")
+                    socketio.emit('ai_response', {
+                        'status': 'thinking_complete',
+                        'content': thinking_buffer,
+                        'is_reasoning': True
+                    }, room=sid)
+                    
+            elif status == 'streaming':
+                # 直接使用模型提供的完整内容
+                response_buffer = content
+                
+                # 控制发送频率，至少间隔0.3秒
+                current_time = time.time()
+                if current_time - last_emit_time >= 0.3:
+                    socketio.emit('ai_response', {
+                        'status': 'streaming',
+                        'content': response_buffer,
+                        'is_reasoning': is_reasoning
+                    }, room=sid)
+                    last_emit_time = current_time
+                    
+            elif status == 'completed':
+                # 确保发送最终完整内容
+                socketio.emit('ai_response', {
+                    'status': 'completed',
+                    'content': content or response_buffer,
+                    'is_reasoning': is_reasoning
+                }, room=sid)
+                print("Response completed")
+                
+            elif status == 'error':
+                # 错误状态直接转发
+                response['is_reasoning'] = is_reasoning
+                socketio.emit('ai_response', response, room=sid)
+                print(f"Error: {response.get('error', 'Unknown error')}")
+                
+            # 其他状态直接转发
+            else:
+                response['is_reasoning'] = is_reasoning
+                socketio.emit('ai_response', response, room=sid)
+
+    except Exception as e:
+        error_msg = f"Streaming error: {str(e)}"
+        print(error_msg)
+        socketio.emit('ai_response', {
+            'status': 'error',
+            'error': error_msg,
+            'is_reasoning': model_name and ModelFactory.is_reasoning(model_name)
+        }, room=sid)
+
+@socketio.on('request_screenshot')
+def handle_screenshot_request():
+    try:
+        # 添加调试信息
+        print("DEBUG: 执行request_screenshot截图")
+        
+        # Capture the screen
+        screenshot = pyautogui.screenshot()
+        
+        # Convert the image to base64 string
+        buffered = BytesIO()
+        screenshot.save(buffered, format="PNG")
+        img_str = base64.b64encode(buffered.getvalue()).decode()
+        
+        # Emit the screenshot back to the client，不打印base64数据
+        print("DEBUG: 完成request_screenshot截图，图片大小: {} KB".format(len(img_str) // 1024))
+        socketio.emit('screenshot_response', {
+            'success': True,
+            'image': img_str
+        })
+    except Exception as e:
+        socketio.emit('screenshot_response', {
+            'success': False,
+            'error': str(e)
+        })
+
+@socketio.on('extract_text')
+def handle_text_extraction(data):
+    try:
+        print("Starting text extraction...")
+        
+        # Validate input data
+        if not data or not isinstance(data, dict):
+            raise ValueError("Invalid request data")
+            
+        if 'image' not in data:
+            raise ValueError("No image data provided")
+            
+        image_data = data['image']
+        if not isinstance(image_data, str):
+            raise ValueError("Invalid image data format")
+        
+        # 检查图像大小，避免处理过大的图像导致断开连接
+        image_size_bytes = len(image_data) * 3 / 4  # 估算base64的实际大小
+        if image_size_bytes > 10 * 1024 * 1024:  # 10MB
+            raise ValueError("Image too large, please crop to a smaller area")
+            
+        settings = data.get('settings', {})
+        if not isinstance(settings, dict):
+            raise ValueError("Invalid settings format")
+        
+        # 优先使用百度OCR，如果没有配置则使用Mathpix
+        # 首先尝试获取百度OCR API密钥
+        baidu_api_key = get_api_key('BaiduApiKey')
+        baidu_secret_key = get_api_key('BaiduSecretKey')
+        
+        # 构建百度OCR API密钥（格式：api_key:secret_key）
+        ocr_key = None
+        ocr_model = None
+        
+        if baidu_api_key and baidu_secret_key:
+            ocr_key = f"{baidu_api_key}:{baidu_secret_key}"
+            ocr_model = 'baidu-ocr'
+            print("Using Baidu OCR for text extraction...")
+        else:
+            # 回退到Mathpix
+            mathpix_app_id = get_api_key('MathpixAppId')
+            mathpix_app_key = get_api_key('MathpixAppKey')
+            
+            # 构建完整的Mathpix API密钥（格式：app_id:app_key）
+            mathpix_key = f"{mathpix_app_id}:{mathpix_app_key}" if mathpix_app_id and mathpix_app_key else None
+            
+            # 如果本地没有配置，尝试使用前端传递的密钥（向后兼容）
+            if not mathpix_key:
+                mathpix_key = settings.get('mathpixApiKey')
+            
+            if mathpix_key:
+                ocr_key = mathpix_key
+                ocr_model = 'mathpix'
+                print("Using Mathpix OCR for text extraction...")
+        
+        if not ocr_key:
+            raise ValueError("OCR API key is required. Please configure Baidu OCR (API Key + Secret Key) or Mathpix (App ID + App Key)")
+        
+        # 先回复客户端，确认已收到请求，防止超时断开
+        # 注意：这里不能使用return，否则后续代码不会执行
+        socketio.emit('request_acknowledged', {
+            'status': 'received', 
+            'message': f'Image received, text extraction in progress using {ocr_model}'
+        }, room=request.sid)
+        
+        try:
+            if ocr_model == 'baidu-ocr':
+                api_key, secret_key = ocr_key.split(':')
+                if not api_key.strip() or not secret_key.strip():
+                    raise ValueError()
+            elif ocr_model == 'mathpix':
+                app_id, app_key = ocr_key.split(':')
+                if not app_id.strip() or not app_key.strip():
+                    raise ValueError()
+        except ValueError:
+            if ocr_model == 'baidu-ocr':
+                raise ValueError("Invalid Baidu OCR API key format. Expected format: 'API_KEY:SECRET_KEY'")
+            else:
+                raise ValueError("Invalid Mathpix API key format. Expected format: 'app_id:app_key'")
+
+        print(f"Creating {ocr_model} model instance...")
+        # ModelFactory.create_model会处理不同模型类型
+        model = ModelFactory.create_model(
+            model_name=ocr_model,
+            api_key=ocr_key
+        )
+
+        print("Starting text extraction...")
+        # 使用新的extract_full_text方法直接提取完整文本
+        extracted_text = model.extract_full_text(image_data)
+        
+        # 直接返回文本结果
+        socketio.emit('text_extracted', {
+            'content': extracted_text
+        }, room=request.sid)
+
+    except ValueError as e:
+        error_msg = str(e)
+        print(f"Validation error: {error_msg}")
+        socketio.emit('text_extracted', {
+            'error': error_msg
+        }, room=request.sid)
+    except Exception as e:
+        error_msg = f"Text extraction error: {str(e)}"
+        print(f"Unexpected error: {error_msg}")
+        print(f"Error details: {type(e).__name__}")
+        socketio.emit('text_extracted', {
+            'error': error_msg
+        }, room=request.sid)
+
+@socketio.on('stop_generation')
+def handle_stop_generation():
+    """处理停止生成请求"""
+    sid = request.sid
+    print(f"接收到停止生成请求: {sid}")
+    
+    if sid in generation_tasks:
+        # 设置停止标志
+        stop_event = generation_tasks[sid]
+        stop_event.set()
+        
+        # 发送已停止状态
+        socketio.emit('ai_response', {
+            'status': 'stopped',
+            'content': '生成已停止'
+        }, room=sid)
+        
+        print(f"已停止用户 {sid} 的生成任务")
+    else:
+        print(f"未找到用户 {sid} 的生成任务")
+
+@socketio.on('analyze_text')
+def handle_analyze_text(data):
+    try:
+        text = data.get('text', '')
+        settings = data.get('settings', {})
+        
+        # 获取推理配置
+        reasoning_config = settings.get('reasoningConfig', {})
+        
+        # 获取maxTokens
+        max_tokens = int(settings.get('maxTokens', 8192))
+        
+        print(f"Debug - 文本分析请求: {text[:50]}...")
+        print(f"Debug - 最大Token: {max_tokens}, 推理配置: {reasoning_config}")
+        
+        # 获取模型和API密钥
+        model_id = settings.get('model', 'claude-3-7-sonnet-20250219')
+        
+        if not text:
+            socketio.emit('error', {'message': '文本内容不能为空'})
+            return
+
+        # 获取模型信息，判断是否为推理模型
+        model_info = settings.get('modelInfo', {})
+        is_reasoning = model_info.get('isReasoning', False)
+        
+        model_instance = create_model_instance(model_id, settings, is_reasoning)
+        
+        # 将推理配置传递给模型
+        if reasoning_config:
+            model_instance.reasoning_config = reasoning_config
+        
+        # 如果启用代理，配置代理设置
+        proxies = None
+        if settings.get('proxyEnabled'):
+            proxies = {
+                'http': f"http://{settings.get('proxyHost')}:{settings.get('proxyPort')}",
+                'https': f"http://{settings.get('proxyHost')}:{settings.get('proxyPort')}"
+            }
+
+        # 创建用于停止生成的事件
+        sid = request.sid
+        stop_event = Event()
+        generation_tasks[sid] = stop_event
+        
+        try:
+            for response in model_instance.analyze_text(text, proxies=proxies):
+                # 检查是否收到停止信号
+                if stop_event.is_set():
+                    print(f"分析文本生成被用户 {sid} 停止")
+                    break
+                    
+                socketio.emit('ai_response', response, room=sid)
+        finally:
+            # 清理任务
+            if sid in generation_tasks:
+                del generation_tasks[sid]
+            
+    except Exception as e:
+        print(f"Error in analyze_text: {str(e)}")
+        traceback.print_exc()
+        socketio.emit('error', {'message': f'分析文本时出错: {str(e)}'})
+
+@socketio.on('analyze_image')
+def handle_analyze_image(data):
+    try:
+        image_data = data.get('image')
+        settings = data.get('settings', {})
+        
+        # 获取推理配置
+        reasoning_config = settings.get('reasoningConfig', {})
+        
+        # 获取maxTokens
+        max_tokens = int(settings.get('maxTokens', 8192))
+        
+        print(f"Debug - 图像分析请求")
+        print(f"Debug - 最大Token: {max_tokens}, 推理配置: {reasoning_config}")
+        
+        # 获取模型和API密钥
+        model_id = settings.get('model', 'claude-3-7-sonnet-20250219')
+        
+        if not image_data:
+            socketio.emit('error', {'message': '图像数据不能为空'})
+            return
+
+        # 获取模型信息，判断是否为推理模型
+        model_info = settings.get('modelInfo', {})
+        is_reasoning = model_info.get('isReasoning', False)
+        
+        model_instance = create_model_instance(model_id, settings, is_reasoning)
+        
+        # 将推理配置传递给模型
+        if reasoning_config:
+            model_instance.reasoning_config = reasoning_config
+            
+        # 如果启用代理，配置代理设置
+        proxies = None
+        if settings.get('proxyEnabled'):
+            proxies = {
+                'http': f"http://{settings.get('proxyHost')}:{settings.get('proxyPort')}",
+                'https': f"http://{settings.get('proxyHost')}:{settings.get('proxyPort')}"
+            }
+
+        # 创建用于停止生成的事件
+        sid = request.sid
+        stop_event = Event()
+        generation_tasks[sid] = stop_event
+        
+        try:
+            for response in model_instance.analyze_image(image_data, proxies=proxies):
+                # 检查是否收到停止信号
+                if stop_event.is_set():
+                    print(f"分析图像生成被用户 {sid} 停止")
+                    break
+                    
+                socketio.emit('ai_response', response, room=sid)
+        finally:
+            # 清理任务
+            if sid in generation_tasks:
+                del generation_tasks[sid]
+            
+    except Exception as e:
+        print(f"Error in analyze_image: {str(e)}")
+        traceback.print_exc()
+        socketio.emit('error', {'message': f'分析图像时出错: {str(e)}'})
+
+@socketio.on('capture_screenshot')
+def handle_capture_screenshot(data):
+    try:
+        # 添加调试信息
+        print("DEBUG: 执行capture_screenshot截图")
+        
+        # Capture the screen
+        screenshot = pyautogui.screenshot()
+        
+        # Convert the image to base64 string
+        buffered = BytesIO()
+        screenshot.save(buffered, format="PNG")
+        img_str = base64.b64encode(buffered.getvalue()).decode()
+        
+        # Emit the screenshot back to the client，不打印base64数据
+        print("DEBUG: 完成capture_screenshot截图，图片大小: {} KB".format(len(img_str) // 1024))
+        socketio.emit('screenshot_complete', {
+            'success': True,
+            'image': img_str
+        }, room=request.sid)
+    except Exception as e:
+        error_msg = f"Screenshot error: {str(e)}"
+        print(f"Error capturing screenshot: {error_msg}")
+        socketio.emit('screenshot_complete', {
+            'success': False,
+            'error': error_msg
+        }, room=request.sid)
+
+def load_model_config():
+    """加载模型配置信息"""
+    try:
+        config_path = os.path.join(CONFIG_DIR, 'models.json')
+        with open(config_path, 'r', encoding='utf-8') as f:
+            config = json.load(f)
+        return config
+    except Exception as e:
+        print(f"加载模型配置失败: {e}")
+        return {
+            "providers": {},
+            "models": {}
+        }
+
+def load_prompts():
+    """加载系统提示词配置"""
+    try:
+        if os.path.exists(PROMPT_FILE):
+            with open(PROMPT_FILE, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        else:
+            # 如果文件不存在，创建默认提示词配置
+            default_prompts = {
+                "default": {
+                    "name": "默认提示词",
+                    "content": "您是一位专业的问题解决专家。请逐步分析问题，找出问题所在，并提供详细的解决方案。始终使用用户偏好的语言回答。",
+                    "description": "通用问题解决提示词"
+                }
+            }
+            with open(PROMPT_FILE, 'w', encoding='utf-8') as f:
+                json.dump(default_prompts, f, ensure_ascii=False, indent=4)
+            return default_prompts
+    except Exception as e:
+        print(f"加载提示词配置失败: {e}")
+        return {
+            "default": {
+                "name": "默认提示词",
+                "content": "您是一位专业的问题解决专家。请逐步分析问题，找出问题所在，并提供详细的解决方案。始终使用用户偏好的语言回答。",
+                "description": "通用问题解决提示词"
+            }
+        }
+
+def save_prompt(prompt_id, prompt_data):
+    """保存单个提示词到配置文件"""
+    try:
+        prompts = load_prompts()
+        prompts[prompt_id] = prompt_data
+        with open(PROMPT_FILE, 'w', encoding='utf-8') as f:
+            json.dump(prompts, f, ensure_ascii=False, indent=4)
+        return True
+    except Exception as e:
+        print(f"保存提示词配置失败: {e}")
+        return False
+
+def delete_prompt(prompt_id):
+    """从配置文件中删除一个提示词"""
+    try:
+        prompts = load_prompts()
+        if prompt_id in prompts:
+            del prompts[prompt_id]
+            with open(PROMPT_FILE, 'w', encoding='utf-8') as f:
+                json.dump(prompts, f, ensure_ascii=False, indent=4)
+            return True
+        return False
+    except Exception as e:
+        print(f"删除提示词配置失败: {e}")
+        return False
+
+# 替换 before_first_request 装饰器
+def init_model_config():
+    """初始化模型配置"""
+    try:
+        model_config = load_model_config()
+        # 更新ModelFactory的模型信息
+        if hasattr(ModelFactory, 'update_model_capabilities'):
+            ModelFactory.update_model_capabilities(model_config)
+        print("已加载模型配置")
+    except Exception as e:
+        print(f"初始化模型配置失败: {e}")
+
+# 在请求处理前注册初始化函数
+@app.before_request
+def before_request_handler():
+    # 使用全局变量跟踪是否已初始化
+    if not getattr(app, '_model_config_initialized', False):
+        init_model_config()
+        app._model_config_initialized = True
+
+# 版本检查函数
+def check_for_updates():
+    """检查GitHub上是否有新版本"""
+    try:
+        # 读取当前版本信息
+        version_file = os.path.join(CONFIG_DIR, 'version.json')
+        with open(version_file, 'r', encoding='utf-8') as f:
+            version_info = json.load(f)
+            
+        current_version = version_info.get('version', '0.0.0')
+        repo = version_info.get('github_repo', 'Zippland/Snap-Solver')
+        
+        # 请求GitHub API获取最新发布版本
+        api_url = f"https://api.github.com/repos/{repo}/releases/latest"
+        
+        # 添加User-Agent以符合GitHub API要求
+        headers = {'User-Agent': 'Snap-Solver-Update-Checker'}
+        
+        response = requests.get(api_url, headers=headers, timeout=5)
+        if response.status_code == 200:
+            latest_release = response.json()
+            latest_version = latest_release.get('tag_name', '').lstrip('v')
+            
+            # 如果版本号为空，尝试从名称中提取
+            if not latest_version and 'name' in latest_release:
+                import re
+                version_match = re.search(r'v?(\d+\.\d+\.\d+)', latest_release['name'])
+                if version_match:
+                    latest_version = version_match.group(1)
+            
+            # 比较版本号（简单比较，可以改进为更复杂的语义版本比较）
+            has_update = compare_versions(latest_version, current_version)
+            
+            update_info = {
+                'has_update': has_update,
+                'current_version': current_version,
+                'latest_version': latest_version,
+                'release_url': latest_release.get('html_url', f"https://github.com/{repo}/releases/latest"),
+                'release_date': latest_release.get('published_at', ''),
+                'release_notes': latest_release.get('body', ''),
+            }
+            
+            # 缓存更新信息
+            update_info_file = os.path.join(CONFIG_DIR, 'update_info.json')
+            with open(update_info_file, 'w', encoding='utf-8') as f:
+                json.dump(update_info, f, ensure_ascii=False, indent=2)
+                
+            return update_info
+        
+        # 如果无法连接GitHub，尝试读取缓存的更新信息
+        update_info_file = os.path.join(CONFIG_DIR, 'update_info.json')
+        if os.path.exists(update_info_file):
+            with open(update_info_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        
+        return {'has_update': False, 'current_version': current_version}
+            
+    except Exception as e:
+        print(f"检查更新失败: {str(e)}")
+        # 出错时返回一个默认的值
+        return {'has_update': False, 'error': str(e)}
+
+def compare_versions(version1, version2):
+    """比较两个版本号，如果version1比version2更新，则返回True"""
+    try:
+        v1_parts = [int(x) for x in version1.split('.')]
+        v2_parts = [int(x) for x in version2.split('.')]
+        
+        # 确保两个版本号的组成部分长度相同
+        while len(v1_parts) < len(v2_parts):
+            v1_parts.append(0)
+        while len(v2_parts) < len(v1_parts):
+            v2_parts.append(0)
+            
+        # 逐部分比较
+        for i in range(len(v1_parts)):
+            if v1_parts[i] > v2_parts[i]:
+                return True
+            elif v1_parts[i] < v2_parts[i]:
+                return False
+                
+        # 完全相同的版本
+        return False
+    except:
+        # 如果解析出错，默认不更新
+        return False
+
+@app.route('/api/check-update', methods=['GET'])
+def api_check_update():
+    """检查更新的API端点"""
+    update_info = check_for_updates()
+    return jsonify(update_info)
+
+# 添加配置文件路由
+@app.route('/config/<path:filename>')
+def serve_config(filename):
+    return send_from_directory(CONFIG_DIR, filename)
+
+# 添加用于获取所有模型信息的API
+@app.route('/api/models', methods=['GET'])
+def get_models():
+    """返回可用的模型列表"""
+    models = ModelFactory.get_available_models()
+    return jsonify(models)
+
+# 获取所有API密钥
+@app.route('/api/keys', methods=['GET'])
+def get_api_keys():
+    """获取所有API密钥"""
+    api_keys = load_api_keys()
+    return jsonify(api_keys)
+
+# 保存API密钥
+@app.route('/api/keys', methods=['POST'])
+def update_api_keys():
+    """更新API密钥配置"""
+    try:
+        new_keys = request.json
+        if not isinstance(new_keys, dict):
+            return jsonify({"success": False, "message": "无效的API密钥格式"}), 400
+        
+        # 加载当前密钥
+        current_keys = load_api_keys()
+        
+        # 更新密钥
+        for key, value in new_keys.items():
+            current_keys[key] = value
+        
+        # 保存回文件
+        if save_api_keys(current_keys):
+            return jsonify({"success": True, "message": "API密钥已保存"})
+        else:
+            return jsonify({"success": False, "message": "保存API密钥失败"}), 500
+    
+    except Exception as e:
+        return jsonify({"success": False, "message": f"更新API密钥错误: {str(e)}"}), 500
+
+# 加载API密钥配置
+def load_api_keys():
+    """从配置文件加载API密钥"""
+    try:
+        default_keys = {
+            "AnthropicApiKey": "",
+            "OpenaiApiKey": "",
+            "DeepseekApiKey": "",
+            "AlibabaApiKey": "",
+            "MathpixAppId": "",
+            "MathpixAppKey": "",
+            "GoogleApiKey": "",
+            "DoubaoApiKey": "",
+            "BaiduApiKey": "",
+            "BaiduSecretKey": ""
+        }
+        if os.path.exists(API_KEYS_FILE):
+            with open(API_KEYS_FILE, 'r', encoding='utf-8') as f:
+                api_keys = json.load(f)
+
+            # 确保新增的密钥占位符能自动补充
+            missing_key_added = False
+            for key, default_value in default_keys.items():
+                if key not in api_keys:
+                    api_keys[key] = default_value
+                    missing_key_added = True
+
+            if missing_key_added:
+                save_api_keys(api_keys)
+
+            return api_keys
+        else:
+            # 如果文件不存在，创建默认配置
+            save_api_keys(default_keys)
+            return default_keys
+    except Exception as e:
+        print(f"加载API密钥配置失败: {e}")
+        return {}
+
+# 加载中转API配置
+def load_proxy_api():
+    """从配置文件加载中转API配置"""
+    try:
+        if os.path.exists(PROXY_API_FILE):
+            with open(PROXY_API_FILE, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        else:
+            # 如果文件不存在，创建默认配置
+            default_proxy_apis = {
+                "enabled": False,
+                "apis": {
+                    "anthropic": "",
+                    "openai": "",
+                    "deepseek": "",
+                    "alibaba": "",
+                    "google": ""
+                }
+            }
+            save_proxy_api(default_proxy_apis)
+            return default_proxy_apis
+    except Exception as e:
+        print(f"加载中转API配置失败: {e}")
+        return {"enabled": False, "apis": {}}
+
+# 保存中转API配置
+def save_proxy_api(proxy_api_config):
+    """保存中转API配置到文件"""
+    try:
+        # 确保配置目录存在
+        os.makedirs(os.path.dirname(PROXY_API_FILE), exist_ok=True)
+        
+        with open(PROXY_API_FILE, 'w', encoding='utf-8') as f:
+            json.dump(proxy_api_config, f, ensure_ascii=False, indent=2)
+        return True
+    except Exception as e:
+        print(f"保存中转API配置失败: {e}")
+        return False
+
+# 保存API密钥配置
+def save_api_keys(api_keys):
+    try:
+        # 确保配置目录存在
+        os.makedirs(os.path.dirname(API_KEYS_FILE), exist_ok=True)
+        
+        with open(API_KEYS_FILE, 'w', encoding='utf-8') as f:
+            json.dump(api_keys, f, ensure_ascii=False, indent=2)
+        return True
+    except Exception as e:
+        print(f"保存API密钥配置失败: {e}")
+        return False
+
+# 获取特定API密钥
+def get_api_key(key_name):
+    """获取指定的API密钥"""
+    api_keys = load_api_keys()
+    return api_keys.get(key_name, "")
+
+@app.route('/api/models')
+def api_models():
+    """API端点：获取可用模型列表"""
+    try:
+        # 加载模型配置
+        config = load_model_config()
+        
+        # 转换为前端需要的格式
+        models = []
+        for model_id, model_info in config['models'].items():
+            models.append({
+                'id': model_id,
+                'display_name': model_info.get('name', model_id),
+                'is_multimodal': model_info.get('supportsMultimodal', False),
+                'is_reasoning': model_info.get('isReasoning', False),
+                'description': model_info.get('description', ''),
+                'version': model_info.get('version', 'latest')
+            })
+        
+        # 返回模型列表
+        return jsonify(models)
+    except Exception as e:
+        print(f"获取模型列表时出错: {e}")
+        return jsonify([]), 500
+
+@app.route('/api/prompts', methods=['GET'])
+def get_prompts():
+    """API端点：获取所有系统提示词"""
+    try:
+        prompts = load_prompts()
+        return jsonify(prompts)
+    except Exception as e:
+        print(f"获取提示词列表时出错: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/prompts/<prompt_id>', methods=['GET'])
+def get_prompt(prompt_id):
+    """API端点：获取单个系统提示词"""
+    try:
+        prompts = load_prompts()
+        if prompt_id in prompts:
+            return jsonify(prompts[prompt_id])
+        else:
+            return jsonify({"error": "提示词不存在"}), 404
+    except Exception as e:
+        print(f"获取提示词时出错: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/prompts', methods=['POST'])
+def add_prompt():
+    """API端点：添加或更新系统提示词"""
+    try:
+        data = request.json
+        if not data or not isinstance(data, dict):
+            return jsonify({"error": "无效的请求数据"}), 400
+            
+        prompt_id = data.get('id')
+        if not prompt_id:
+            return jsonify({"error": "提示词ID不能为空"}), 400
+            
+        prompt_data = {
+            "name": data.get('name', f"提示词{prompt_id}"),
+            "content": data.get('content', ""),
+            "description": data.get('description', "")
+        }
+        
+        save_prompt(prompt_id, prompt_data)
+        return jsonify({"success": True, "id": prompt_id})
+    except Exception as e:
+        print(f"保存提示词时出错: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/prompts/<prompt_id>', methods=['DELETE'])
+def remove_prompt(prompt_id):
+    """API端点：删除系统提示词"""
+    try:
+        success = delete_prompt(prompt_id)
+        if success:
+            return jsonify({"success": True})
+        else:
+            return jsonify({"error": "提示词不存在或删除失败"}), 404
+    except Exception as e:
+        print(f"删除提示词时出错: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/proxy-api', methods=['GET'])
+def get_proxy_api():
+    """API端点：获取中转API配置"""
+    try:
+        proxy_api_config = load_proxy_api()
+        return jsonify(proxy_api_config)
+    except Exception as e:
+        print(f"获��中转API配置时出错: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/proxy-api', methods=['POST'])
+def update_proxy_api():
+    """API端点：更新中转API配置"""
+    try:
+        new_config = request.json
+        if not isinstance(new_config, dict):
+            return jsonify({"success": False, "message": "无效的中转API配置格式"}), 400
+        
+        # 保存回文件
+        if save_proxy_api(new_config):
+            return jsonify({"success": True, "message": "中转API配置已保存"})
+        else:
+            return jsonify({"success": False, "message": "保存中转API配置失败"}), 500
+    
+    except Exception as e:
+        return jsonify({"success": False, "message": f"更新中转API配置错误: {str(e)}"}), 500
+
+@app.route('/api/clipboard', methods=['POST'])
+def update_clipboard():
+    """将文本复制到服务器剪贴板"""
+    try:
+        data = request.get_json(silent=True) or {}
+        text = data.get('text', '')
+
+        if not isinstance(text, str) or not text.strip():
+            return jsonify({"success": False, "message": "剪贴板内容不能为空"}), 400
+
+        # 直接尝试复制，不使用is_available()检查
+        try:
+            pyperclip.copy(text)
+            return jsonify({"success": True})
+        except Exception as e:
+            return jsonify({"success": False, "message": f"复制到剪贴板失败: {str(e)}"}), 500
+    except Exception as e:
+        app.logger.exception("更新剪贴板时发生异常")
+        return jsonify({"success": False, "message": f"服务器内部错误: {str(e)}"}), 500
+
+@app.route('/api/clipboard', methods=['GET'])
+def get_clipboard():
+    """从服务器剪贴板读取文本"""
+    try:
+        # 直接尝试读取，不使用is_available()检查
+        try:
+            text = pyperclip.paste()
+            if text is None:
+                text = ""
+                
+            return jsonify({
+                "success": True, 
+                "text": text,
+                "message": "成功读取剪贴板内容"
+            })
+        except Exception as e:
+            return jsonify({"success": False, "message": f"读取剪贴板失败: {str(e)}"}), 500
+    except Exception as e:
+        app.logger.exception("读取剪贴板时发生异常")
+        return jsonify({"success": False, "message": f"服务器内部错误: {str(e)}"}), 500
+
+if __name__ == '__main__':
+    # 从环境变量获取PORT，如果没有则默认为5000（本地调试用）
+    import os
+    port = int(os.environ.get('PORT', 5000))
+
+    local_ip = get_local_ip()
+    print(f"Local IP Address: {local_ip}")
+    print(f"Connect from your mobile device using: {local_ip}:{port}")
+
+    # 加载模型配置 (保持不变)
+    model_config = load_model_config()
+    if hasattr(ModelFactory, 'update_model_capabilities'):
+        ModelFactory.update_model_capabilities(model_config)
+        print("已加载模型配置信息")
 
-with ui.layout_columns(fill=False):
-    with ui.value_box(showcase=ICONS["user"]):
-        "Total tippers"
-
-        @render.express
-        def total_tippers():
-            tips_data().shape[0]
-
-    with ui.value_box(showcase=ICONS["wallet"]):
-        "Average tip"
-
-        @render.express
-        def average_tip():
-            d = tips_data()
-            if d.shape[0] > 0:
-                perc = d.tip / d.total_bill
-                f"{perc.mean():.1%}"
-
-    with ui.value_box(showcase=ICONS["currency-dollar"]):
-        "Average bill"
-
-        @render.express
-        def average_bill():
-            d = tips_data()
-            if d.shape[0] > 0:
-                bill = d.total_bill.mean()
-                f"${bill:.2f}"
-
-
-with ui.layout_columns(col_widths=[6, 6, 12]):
-    with ui.card(full_screen=True):
-        ui.card_header("Tips data")
-
-        @render.data_frame
-        def table():
-            return render.DataGrid(tips_data())
-
-    with ui.card(full_screen=True):
-        with ui.card_header(class_="d-flex justify-content-between align-items-center"):
-            "Total bill vs tip"
-            with ui.popover(title="Add a color variable", placement="top"):
-                ICONS["ellipsis"]
-                ui.input_radio_buttons(
-                    "scatter_color",
-                    None,
-                    ["none", "sex", "smoker", "day", "time"],
-                    inline=True,
-                )
-
-        @render_plotly
-        def scatterplot():
-            color = input.scatter_color()
-            return px.scatter(
-                tips_data(),
-                x="total_bill",
-                y="tip",
-                color=None if color == "none" else color,
-                trendline="lowess",
-            )
-
-    with ui.card(full_screen=True):
-        with ui.card_header(class_="d-flex justify-content-between align-items-center"):
-            "Tip percentages"
-            with ui.popover(title="Add a color variable"):
-                ICONS["ellipsis"]
-                ui.input_radio_buttons(
-                    "tip_perc_y",
-                    "Split by:",
-                    ["sex", "smoker", "day", "time"],
-                    selected="day",
-                    inline=True,
-                )
-
-        @render_plotly
-        def tip_perc():
-            from ridgeplot import ridgeplot
-
-            dat = tips_data()
-            dat["percent"] = dat.tip / dat.total_bill
-            yvar = input.tip_perc_y()
-            uvals = dat[yvar].unique()
-
-            samples = [[dat.percent[dat[yvar] == val]] for val in uvals]
-
-            plt = ridgeplot(
-                samples=samples,
-                labels=uvals,
-                bandwidth=0.01,
-                colorscale="viridis",
-                colormode="row-index",
-            )
-
-            plt.update_layout(
-                legend=dict(
-                    orientation="h", yanchor="bottom", y=1.02, xanchor="center", x=0.5
-                )
-            )
-
-            return plt
-
-
-ui.include_css(app_dir / "styles.css")
-
-# --------------------------------------------------------
-# Reactive calculations and effects
-# --------------------------------------------------------
-
-
-@reactive.calc
-def tips_data():
-    bill = input.total_bill()
-    idx1 = tips.total_bill.between(bill[0], bill[1])
-    idx2 = tips.time.isin(input.time())
-    return tips[idx1 & idx2]
-
-
-@reactive.effect
-@reactive.event(input.reset)
-def _():
-    ui.update_slider("total_bill", value=bill_rng)
-    ui.update_checkbox_group("time", selected=["Lunch", "Dinner"])
+    # 运行应用，并绑定到 0.0.0.0 和动态端口
+    socketio.run(app, host='0.0.0.0', port=port, allow_unsafe_werkzeug=True)

config/api_base_urls.json

@@ -0,0 +1,8 @@
+{
+  "AnthropicApiBaseUrl": "",
+  "OpenaiApiBaseUrl": "",
+  "DeepseekApiBaseUrl": "",
+  "AlibabaApiBaseUrl": "",
+  "GoogleApiBaseUrl": "",
+  "DoubaoApiBaseUrl": ""
+}

config/api_keys.json

@@ -0,0 +1,12 @@
+{
+  "AnthropicApiKey": "",
+  "OpenaiApiKey": "",
+  "DeepseekApiKey": "",
+  "AlibabaApiKey": "",
+  "MathpixAppId": "",
+  "MathpixAppKey": "",
+  "GoogleApiKey": "AIzaSyCoK-0ku5mFHjoOADjamOiZdqMp4zOezkQ",
+  "DoubaoApiKey": "",
+  "BaiduApiKey": "",
+  "BaiduSecretKey": ""
+}

config/models.json

@@ -0,0 +1,188 @@
+{
+    "providers": {
+        "anthropic": {
+            "name": "Anthropic",
+            "api_key_id": "AnthropicApiKey",
+            "class_name": "AnthropicModel"
+        },
+        "openai": {
+            "name": "OpenAI",
+            "api_key_id": "OpenaiApiKey",
+            "class_name": "OpenAIModel"
+        },
+        "deepseek": {
+            "name": "DeepSeek",
+            "api_key_id": "DeepseekApiKey",
+            "class_name": "DeepSeekModel"
+        },
+        "alibaba": {
+            "name": "Alibaba",
+            "api_key_id": "AlibabaApiKey",
+            "class_name": "AlibabaModel"
+        },
+        "google": {
+            "name": "Google",
+            "api_key_id": "GoogleApiKey",
+            "class_name": "GoogleModel"
+        },
+        "doubao": {
+            "name": "Doubao",
+            "api_key_id": "DoubaoApiKey",
+            "class_name": "DoubaoModel"
+        }
+    },
+    "models": {
+        "claude-opus-4-20250514": {
+            "name": "Claude 4 Opus",
+            "provider": "anthropic",
+            "supportsMultimodal": true,
+            "isReasoning": true,
+            "version": "20250514",
+            "description": "最强大的Claude 4 Opus模型，支持图像理解和深度思考过程"
+        },
+        "claude-opus-4-1-20250805": {
+            "name": "Claude 4.1 Opus",
+            "provider": "anthropic",
+            "supportsMultimodal": true,
+            "isReasoning": false,
+            "version": "20250805",
+            "description": "Claude Opus 4.1 最新标准模式，快速响应并支持多模态输入"
+        },
+        "claude-opus-4-1-20250805-thinking": {
+            "name": "Claude 4.1 Opus (Thinking)",
+            "provider": "anthropic",
+            "supportsMultimodal": true,
+            "isReasoning": true,
+            "version": "20250805",
+            "description": "Claude Opus 4.1 思考模式，启用更长思考过程以提升推理质量"
+        },
+        "claude-sonnet-4-20250514": {
+            "name": "Claude 4 Sonnet",
+            "provider": "anthropic",
+            "supportsMultimodal": true,
+            "isReasoning": true,
+            "version": "20250514",
+            "description": "高性能的Claude 4 Sonnet模型，支持图像理解和思考过程"
+        },
+        "claude-sonnet-4-5-20250929": {
+            "name": "Claude 4.5 Sonnet",
+            "provider": "anthropic",
+            "supportsMultimodal": true,
+            "isReasoning": true,
+            "version": "20250929",
+            "description": "Claude Sonnet 4.5 版，兼具多模态理解与最新推理能力"
+        },
+        "gpt-4o-2024-11-20": {
+            "name": "GPT-4o",
+            "provider": "openai",
+            "supportsMultimodal": true,
+            "isReasoning": false,
+            "version": "2024-11-20",
+            "description": "OpenAI的GPT-4o模型，支持图像理解"
+        },
+        "gpt-5-2025-08-07": {
+            "name": "GPT-5",
+            "provider": "openai",
+            "supportsMultimodal": true,
+            "isReasoning": true,
+            "version": "2025-08-07",
+            "description": "OpenAI旗舰级GPT-5模型，支持多模态输入与高级推理"
+        },
+        "gpt-5-1": {
+            "name": "GPT-5.1",
+            "provider": "openai",
+            "supportsMultimodal": true,
+            "isReasoning": true,
+            "version": "latest",
+            "description": "GPT-5.1 新版旗舰模型，强化长上下文与推理表现"
+        },
+        "gpt-5-codex-high": {
+            "name": "GPT Codex High",
+            "provider": "openai",
+            "supportsMultimodal": false,
+            "isReasoning": true,
+            "version": "latest",
+            "description": "OpenAI高性能代码模型Codex High，侧重复杂代码生成与重构"
+        },
+        "o3-mini": {
+            "name": "o3-mini",
+            "provider": "openai",
+            "supportsMultimodal": false,
+            "isReasoning": true,
+            "version": "latest",
+            "description": "OpenAI的o3-mini模型，支持图像理解和思考过程"
+        },
+        "deepseek-chat": {
+            "name": "DeepSeek-V3",
+            "provider": "deepseek",
+            "supportsMultimodal": false,
+            "isReasoning": false,
+            "version": "latest",
+            "description": "DeepSeek最新大模型，671B MoE模型，支持60 tokens/秒的高速生成"
+        },
+        "deepseek-reasoner": {
+            "name": "DeepSeek-R1",
+            "provider": "deepseek",
+            "supportsMultimodal": false,
+            "isReasoning": true,
+            "version": "latest",
+            "description": "DeepSeek推理模型，提供详细思考过程（仅支持文本）"
+        },
+        "QVQ-Max-2025-03-25": {
+            "name": "QVQ-Max",
+            "provider": "alibaba",
+            "supportsMultimodal": true,
+            "isReasoning": true,
+            "version": "2025-03-25",
+            "description": "阿里巴巴通义千问-QVQ-Max版本，支持图像理解和思考过程"
+        },
+        "qwen-vl-max-latest": {
+            "name": "Qwen-VL-MAX",
+            "provider": "alibaba",
+            "supportsMultimodal": true,
+            "isReasoning": false,
+            "version": "latest",
+            "description": "阿里通义千问VL-MAX模型，视觉理解能力最强，支持图像理解和复杂任务"
+        },
+        "gemini-2.5-pro": {
+            "name": "Gemini 2.5 Pro",
+            "provider": "google",
+            "supportsMultimodal": true,
+            "isReasoning": true,
+            "version": "latest",
+            "description": "Google最强大的Gemini 2.5 Pro模型，支持图像理解（需要付费API密钥）"
+        },
+        "gemini-2.5-flash": {
+            "name": "Gemini 2.5 Flash",
+            "provider": "google",
+            "supportsMultimodal": true,
+            "isReasoning": false,
+            "version": "latest",
+            "description": "Google最新的Gemini 2.5 Flash模型，支持图像理解，速度更快，性能更好"
+        },
+        "gemini-2.0-flash": {
+            "name": "Gemini 2.0 Flash",
+            "provider": "google",
+            "supportsMultimodal": true,
+            "isReasoning": false,
+            "version": "latest",
+            "description": "Google更快速的Gemini 2.0 Flash模型，支持图像理解，有免费配额"
+        },
+        "gemini-3-pro": {
+            "name": "Gemini 3 Pro",
+            "provider": "google",
+            "supportsMultimodal": true,
+            "isReasoning": true,
+            "version": "latest",
+            "description": "Google Gemini 3 Pro 顶级推理模型，面向复杂多模态任务"
+        },
+        "doubao-seed-1-6-250615": {
+            "name": "Doubao-Seed-1.6",
+            "provider": "doubao",
+            "supportsMultimodal": true,
+            "isReasoning": true,
+            "version": "latest",
+            "description": "支持auto/thinking/non-thinking三种思考模式、支持多模态、256K长上下文"
+        }
+    }
+}

config/prompts.json

@@ -0,0 +1,36 @@
+{   "ACM_hard": {
+        "name": "ACM编程题（困难）",
+        "content":"你是一个顶尖的算法竞赛选手 + 程序员。你的任务是接收一道 ACM / 编程题目（包含题目描述、输入输出格式、约束）并输出一份完整可运行的解法。请严格按照以下步骤：\n1. 题目复述；\n2. 复杂度与限制分析；\n3. 思路与算法设计；\n4. 伪代码 / 算法框架；\n5. 最终可运行python代码（带注释）；\n6. 时间复杂度 / 空间复杂度总结 + 边界 / 特殊输入测试。输出格式必须包含这些部分，不得省略分析或直接跳到代码。",
+        "description": "专为ACM编程竞赛题设计的提示词"
+    },
+    "a_default": {
+        "name": "默认提示词",
+        "content": "如果给的是图片，请先识别图片上面的题目，并输出完整题干；如果给的不是图片，直接诠释一下题目。然后解决该问题，如果是编程题，请输出最终可运行代码（带注释）。",
+        "description": "通用问题解决提示词"
+    },
+    "single_choice": {
+        "name": "单选题提示词",
+        "content": "您是一位专业的单选题解析专家。当看到一个单选题时，请：\n1. 仔细阅读题目要求和选项\n2. 分析每个选项的正确性\n3. 明确指出正确选项\n4. 解释为什么该选项正确\n5. 简要说明其他选项错误的原因\n6. 总结相关知识点",
+        "description": "专为单选题分析设计的提示词"
+    },
+    "multiple_choice": {
+        "name": "多选题提示词",
+        "content": "您是一位专业的多选题解析专家。当看到一个多选题时，请：\n1. 仔细阅读题目要求和所有选项\n2. 逐一分析每个选项的正确性\n3. 明确列出所有正确选项\n4. 详细解释每个正确选项的理由\n5. 说明错误选项的问题所在\n6. 归纳总结相关知识点",
+        "description": "专为多选题分析设计的提示词"
+    },
+    "programming": {
+        "name": "ACM编程题提示词",
+        "content": "您是一位专业的ACM编程竞赛解题专家。当看到一个编程题时，请：\n1. 分析题目要求、输入输出格式和约束条件\n2. 确定解题思路和算法策略\n3. 分析算法复杂度\n4. 提供完整、可运行的代码实现\n5. 解释代码中的关键部分\n6. 提供一些测试用例及其输出\n7. 讨论可能的优化方向",
+        "description": "专为ACM编程竞赛题设计的提示词"
+    },
+    "pattern_reasoning": {
+        "name": "图形推理题提示词",
+        "content": "您是一位专业的图形推理题解析专家。当看到一个图形推理题时，请：\n1. 观察并描述题目给出的图形序列\n2. 分析图形之间的变化规律\n3. 归纳可能的变化模式（如旋转、翻转、数量变化等）\n4. 应用发现的规律预测下一个图形\n5. 在多个选项中确定符合规律的答案\n6. 详细解释推理过程",
+        "description": "专为图形推理题设计的提示词"
+    },
+    "chart_calculation": {
+        "name": "图表计算题提示词",
+        "content": "您是一位专业的图表数据分析专家。当看到一个包含图表的计算题时，请：\n1. 仔细阅读并描述图表包含的信息（表格、柱状图、折线图等）\n2. 确定题目要求计算的具体内容\n3. 从图表中提取相关数据\n4. 设计合适的计算方法\n5. 进行准确的计算过程\n6. 清晰呈现计算结果\n7. 必要时解释数据的含义和趋势",
+        "description": "专为图表数据分析和计算题设计的提示词"
+    }
+}

config/proxy_api.json

@@ -0,0 +1,11 @@
+{
+  "apis": {
+    "alibaba": "",
+    "anthropic": "",
+    "deepseek": "",
+    "doubao": "",
+    "google": "",
+    "openai": ""
+  },
+  "enabled": true
+}

config/update_info.json

@@ -0,0 +1,8 @@
+{
+  "has_update": false,
+  "current_version": "1.5.1",
+  "latest_version": "1.5.1",
+  "release_url": "https://github.com/Zippland/Snap-Solver/releases/tag/v1.5.1",
+  "release_date": "2025-11-19T12:45:59Z",
+  "release_notes": "**Full Changelog**: https://github.com/Zippland/Snap-Solver/compare/v1.5.0...v1.5.1"
+}

config/version.json

@@ -0,0 +1,5 @@
+{
+    "version": "1.5.1",
+    "build_date": "2025-04-11",
+    "github_repo": "Zippland/Snap-Solver"
+} 

docs/beginner-tutorial.md

@@ -0,0 +1,310 @@
+# Snap-Solver 零基础上手教程
+
+这篇教程面向第一次接触编程或 Python 的朋友，手把手带你从安装环境开始，直到在电脑和手机上顺利使用 Snap-Solver 完成题目分析。如果你在任何步骤遇到困难，建议按章节逐步检查，或对照文末的常见问题排查。
+
+---
+
+## 1. Snap-Solver 是什么？
+
+Snap-Solver 是一个本地运行的截屏解题工具，主要功能包括：
+- 一键截取电脑屏幕的题目图片；
+- 自动调用 OCR（文字识别）和多种大模型，给出详细解析；
+- 支持在手机、平板等局域网设备上实时查看结果；
+- 可以按需配置代理、中转 API、自定义提示词等高级选项。
+
+整个应用基于 Python + Flask，只要能启动一个 Python 程序，就可以完全离线地掌握它的运行方式。
+
+---
+
+## 2. 准备清单
+
+- 一台可以联网的 Windows、macOS 或 Linux 电脑；
+- 至少一个可用的模型 API Key（推荐准备 2~3 个，方便切换）：
+  - OpenAI、Anthropic、DeepSeek、阿里灵积（Qwen）、Google、Mathpix 等任一即可；
+- 约 2 GB 可用硬盘空间；
+- 基本的文本编辑器（Windows 自带记事本即可，推荐使用 VS Code / Notepad++ 等更易读的工具）。
+
+> **提示**：Snap-Solver 不依赖显卡或 GPU，普通轻薄本即可顺利运行。
+
+---
+
+## 3. 第一次打开命令行
+
+Snap-Solver 需要在命令行里执行几条简单的指令。命令行是一个黑色（或白色）窗口，通过输入文字来让电脑完成任务。不同系统打开方式略有区别：
+
+### 3.1 Windows
+1. 同时按下键盘 `Win` 键（左下角带 Windows 徽标的键）+ `S`，输入 `cmd` 或 `terminal`。
+2. 选择 **命令提示符（Command Prompt）** 或 **Windows Terminal**，回车打开。
+3. 复制命令时，可在窗口上点击右键 → 「粘贴」，或使用快捷键 `Ctrl + V`。
+4. 想切换到某个文件夹（例如 `D:\Snap-Solver`），输入：
+   ```powershell
+   cd /d D:\Snap-Solver
+   ```
+5. 查看当前文件夹内的内容：
+   ```powershell
+   dir
+   ```
+
+### 3.2 macOS
+1. 同时按下 `Command + Space` 呼出 Spotlight，输入 `Terminal` 并回车。
+2. 在终端中，复制粘贴使用常规快捷键 `Command + C` / `Command + V`。
+3. 切换到下载好的项目目录（例如在「下载」文件夹内）：
+   ```bash
+   cd ~/Downloads/Snap-Solver
+   ```
+4. 查看当前文件夹内容：
+   ```bash
+   ls
+   ```
+
+### 3.3 Linux（Ubuntu 示例）
+1. 同时按 `Ctrl + Alt + T` 打开终端。
+2. 切换到项目目录：
+   ```bash
+   cd ~/Snap-Solver
+   ```
+3. 查看内容：
+   ```bash
+   ls
+   ```
+
+> **常用命令速记**
+> - `cd 路径`：进入某个文件夹（路径中有空格请用双引号包住，例如 `cd "C:\My Folder"`）。
+> - `dir`（Windows）/`ls`（macOS、Linux）：查看当前文件夹下的文件。
+> - 键盘方向键 ↑ 可以快速调出上一条命令，避免重复输入。
+
+---
+
+## 4. 安装 Python 3
+
+Snap-Solver 基于 Python 3.9+，推荐使用 3.10 或 3.11 版本。
+
+### 4.1 Windows
+1. 打开浏览器访问：https://www.python.org/downloads/
+2. 点击最新的稳定版（例如 `Python 3.11.x`）的 **Download Windows installer (64-bit)**。
+3. 双击下载的安装包，记得在第一步勾选 **Add Python to PATH**。
+4. 按提示完成安装。
+5. 打开命令行窗口，输入：
+   ```powershell
+   python --version
+   pip --version
+   ```
+   若能看到版本号（如 `Python 3.11.7`），说明安装成功。
+
+### 4.2 macOS
+1. 访问 https://www.python.org/downloads/mac-osx/ 下载 `macOS 64-bit universal2 installer`。
+2. 双击 `.pkg` 文件按提示安装。
+3. 打开终端输入：
+   ```bash
+   python3 --version
+   pip3 --version
+   ```
+   如果输出版本号，表示安装完成。后续命令中的 `python`、`pip` 均可替换为 `python3`、`pip3`。
+
+### 4.3 Linux（Ubuntu 示例）
+```bash
+sudo apt update
+sudo apt install python3 python3-venv python3-pip -y
+python3 --version
+pip3 --version
+```
+
+---
+
+## 5. （可选）安装 Git
+
+Git 方便后续更新项目，也可以用来下载代码。
+- Windows：https://git-scm.com/download/win
+- macOS：在终端输入 `xcode-select --install` 或从 https://git-scm.com/download/mac 获取
+- Linux：`sudo apt install git -y`
+
+如果暂时不想安装 Git，也可以稍后直接下载压缩包。
+
+---
+
+## 6. 获取 Snap-Solver 项目代码
+
+任选其一：
+1. **使用 Git 克隆（推荐）**
+   ```bash
+   git clone https://github.com/Zippland/Snap-Solver.git
+   cd Snap-Solver
+   ```
+2. **下载压缩包**
+   - 打开项目主页：https://github.com/Zippland/Snap-Solver
+   - 点击右侧 `Release` → `Source code (zip)`
+   - 解压缩后，将文件夹重命名为 `Snap-Solver` 并记住路径
+
+后续步骤默认你已经位于项目根目录（包含 `app.py`、`requirements.txt` 的那个文件夹）。如果忘记位置，可再次查看文件夹并使用 `cd` 进入��
+
+---
+
+## 7. 创建虚拟环境并安装依赖
+
+虚拟环境可以把项目依赖和系统环境隔离，避免冲突。
+
+### 7.1 创建虚拟环境
+
+- **Windows PowerShell**
+  ```powershell
+  python -m venv .venv
+  .\.venv\Scripts\Activate
+  ```
+- **macOS / Linux**
+  ```bash
+  python3 -m venv .venv
+  source .venv/bin/activate
+  ```
+
+激活成功后，命令行前面会出现 `(.venv)` 前缀。若你关闭了命令行窗口，需要重新进入项目目录并再次执行激活命令。
+
+### 7.2 安装依赖
+
+```bash
+pip install --upgrade pip
+pip install -r requirements.txt
+```
+
+常见依赖（Flask、PyAutoGUI、Pillow 等）都会自动安装。首次安装可能用时 1~5 分钟，请耐心等待。
+
+> **如果安装失败**：请检查网络、切换镜像源或参考文末常见问题。
+
+---
+
+## 8. 首次启动与访问
+
+1. 保证虚拟环境处于激活状态。
+2. 在项目根目录执行：
+   ```bash
+    python3 -m venv .venv
+    source .venv/bin/activate
+    python app.py
+   ```
+3. 终端中会看到 Flask/SocketIO 的日志，最后出现 `Running on http://127.0.0.1:5000` 表示启动成功。
+4. 若需要在手机/平板访问，请在**同一局域网下**输入 `http://<电脑IP>:5000`。电脑 IP 可在终端日志中看到，例如 `http://192.168.1.8:5000`（可能是别的，每次打开都会刷新）。
+
+> **暂停服务**：在终端按 `Ctrl + C` 即可停止运行。再次启动时，只需重新激活虚拟环境并执行 `python app.py`。
+   ```bash
+    python3 -m venv .venv
+    source .venv/bin/activate
+    python app.py
+   ```
+---
+
+## 9. 配置 API 密钥与基础设置
+
+启动网页后，点击右上角的齿轮图标进入「设置」面板，建议先完成以下几项：
+
+### 9.1 填写模型 API Key
+
+- 根据你手上的 Key，将对应值填入设置页面的输入框中；
+- 常用字段：
+  - `OpenaiApiKey`：OpenAI 模型（如 GPT-4o、o3-mini）
+  - `AnthropicApiKey`：Claude 系列
+  - `DeepseekApiKey`：DeepSeek
+  - `AlibabaApiKey`：通义千问 / Qwen / QVQ
+  - `GoogleApiKey`：Gemini 系列
+  - `MathpixAppId` & `MathpixAppKey`：用于高精度公式识别
+- 点击保存后，信息会写入 `config/api_keys.json` 方便下次启动直接读取。
+
+### 9.2  设置代理与中转（可选）
+
+- 若你需要走代理或企业中转通道，可在设置面板中开启代理选项；
+- 对应的 JSON 文件是 `config/proxy_api.json`，可直接编辑来指定各模型的自定义 `base_url`；
+- 修改后需重启应用才能生效。
+
+### 9.3 如何确认 VPN/代理端口
+
+很多加速器或 VPN 客户端会在本地启动一个「系统代理」服务（常见端口如 `7890`、`1080` 等）。具体端口位置通常可以通过以下途径找到：
+- 打开 VPN 客户端的设置页面，寻找「本地监听端口」「HTTP(S) 代理」「SOCKS 代理」等字样；
+- Windows 用户也可以在「设置 → 网络和 Internet → 代理」里查看「使用代理服务器」的地址和端口；
+- macOS 用户可在「系统设置 → 网络 → Wi-Fi（或以太网）→ 详情 → 代理」里查看勾选的服务和端口；
+- 高级用户可以在命令行里运行 `netstat -ano | findstr 127.0.0.1`（Windows）或 `lsof -iTCP -sTCP:LISTEN | grep 127.0.0.1`（macOS/Linux）确认本地监听端口。
+
+拿到端口后，在 Snap-Solver 的代理设置中填入对应的地址（通常是 `127.0.0.1:<端口>`），就能让模型请求走 VPN。不同工具的界面名称可能略有差异，重点是找出「本地监听地址 + 端口号」这一对信息。
+
+---
+
+## 10. 获取常用 API Key（详细教程）
+
+API Key 相当于你在各大模型平台上的「门票」。不同平台的获取流程不同，以下列出了最常用的几个来源。申请过程中务必保护好个人隐私与账号安全，切勿向他人泄露密钥。
+
+### 10.1 OpenAI（GPT-4o / o3-mini 等）
+1. 打开 https://platform.openai.com/ 并使用邮箱或第三方账号注册 / 登录。
+2. 首次使用需完成实名和支付方式绑定（可选择信用卡或预付费余额）。
+3. 登录后点击右上角头像 → `View API keys`。
+4. 点击 `Create new secret key`，复制生成的密钥（形如 `sk-...`）。
+5. 将该密钥粘贴到 Snap-Solver 的 `OpenaiApiKey` 输入框，并妥善保存。
+
+### 10.2 Anthropic（Claude 系列）
+1. 打开 https://console.anthropic.com/ 并注册账号。
+2. 按提示完成手机号验证和支付方式绑定（部分国家需排队开通）。
+3. 登录后进入 `API Keys` 页面，点击 `Create Key`。
+4. 复制生成的密钥（形如 `sk-ant-...`），粘贴到 Snap-Solver 的 `AnthropicApiKey`。
+
+### 10.3 DeepSeek
+1. 访问 https://platform.deepseek.com/ 并注册登录。
+2. 如果需要人民币支付，可在「账号设置」绑定支付宝；海外用户可使用信用卡。
+3. 进入 `API Keys`，点击 `新建密钥`。
+4. 复制生成的密钥（形如 `sk-xxx`），填入 `DeepseekApiKey`。
+
+### 10.4 阿里云通义千问 / Qwen / QVQ
+1. 打开 https://dashscope.console.aliyun.com/ 并使用阿里云账号登录。
+2. 进入「API Key 管理」页面，点击 `创建 API Key`。
+3. 复制密钥（形如 `sk-yourkey`）填入 `AlibabaApiKey`。
+4. 如需开通收费模型，请在「计费与配额」中先完成实名认证并开通付费策略。
+
+### 10.5 Google Gemini
+1. 前往 https://ai.google.dev/ 并登录 Google 账号。
+2. 点击右上角 `Get API key`。
+3. 选择或创建项目，生成新的 API Key。
+4. 将密钥填入 `GoogleApiKey`。
+
+### 10.6 Mathpix（高精度公式识别）
+1. 访问 https://dashboard.mathpix.com/ 注册账号。
+2. 完成邮箱验证后，在侧边栏找到 `API Keys`。
+3. 创建新的 App，复制 `App ID` 和 `App Key`。
+4. 分别填入 Snap-Solver 的 `MathpixAppId` 与 `MathpixAppKey` 字段。
+
+> **安全小贴士**
+> - API Key 和密码一样重要，泄露后他人可能代你调用接口、消耗额度。
+> - 建议为不同用途创建多个密钥，定期检查和撤销不用的密钥。
+> - 如果平台支持额度上限、IP 白名单等功能，可以酌情启用以降低风险。
+
+---
+
+## 11. 完成第一次题目解析
+
+1. 确认右上角的「连接状态」显示为绿色的「已连接」。
+2. 点击顶部的「开始截图」，按提示框拖拽需要识别的题目区域。
+3. 截图完成后，预览区会显示图片，并出现「发送至 AI」或「提取文本」按钮：
+   - **发送至 AI**：直接让所选模型解析图像；
+   - **提取文本**：先做 OCR，把文字复制出来，再发送给模型。
+4. 在右侧的「分析结果」面板可以查看：
+   - AI 的思考过程（可折叠）；
+   - 最终解答、代码或步骤；
+   - 中间日志与计时。
+5. 若需要改用其他模型，重新打开设置面板即可实时切换。
+
+> **小技巧**：长按或双击分析结果中的文本，可快速复制粘贴；终端会实时输出请求日志，方便排查问题。
+
+---
+
+## 12. 常见问题速查
+
+- **`python` 命令找不到**：在 Windows 上打开新的终端后请重启电脑，或使用 `py` 命令；macOS/Linux 请尝试 `python3`。
+- **`pip install` 超时**：可以临时使用清华源 `pip install -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt`。
+- **启动后网页打不开**：确认终端没有报错；检查防火墙、端口占用，或尝试 `http://127.0.0.1:5000`。
+- **截图没反应**：Windows/macOS 需要授权「辅助功能 / 截屏」权限给 Python；macOS 在「系统设置 - 隐私与安全」中勾选 `python` 或终端应用。
+- **模型报 401/403**：检查 API Key 是否正确、账号余额是否充足，必要时在设置里更换模型或填入自定义域名。
+- **手机访问失败**：确保手机和电脑在同一个 Wi-Fi 下，且电脑未开启 VPN 导致局域网隔离。
+
+---
+
+## 13. 进一步探索
+
+- `config/models.json`：自定义展示在下拉框的模型列表，包含模型名称、供应商、能力标签等，可按需添加。
+- `config/prompts.json`：定义默认 prompt，可根据学科优化。
+- 更新项目：如果是 Git 克隆，执行 `git pull`；压缩包用户可重新下载覆盖。
+
+完成以上步骤后，你已经具备运行和日常使用 Snap-Solver 的全部基础。如果你有新的需求或遇到无法解决的问题，可以先查看 README 或在 Issues 中搜索 / 提问。祝你学习顺利，刷题提效！

models/__init__.py

@@ -0,0 +1,19 @@
+from .base import BaseModel
+from .anthropic import AnthropicModel
+from .openai import OpenAIModel
+from .deepseek import DeepSeekModel
+from .alibaba import AlibabaModel
+from .google import GoogleModel
+from .doubao import DoubaoModel
+from .factory import ModelFactory
+
+__all__ = [
+    'BaseModel',
+    'AnthropicModel',
+    'OpenAIModel',
+    'DeepSeekModel',
+    'AlibabaModel',
+    'GoogleModel',
+    'DoubaoModel',
+    'ModelFactory'
+]

models/alibaba.py

@@ -0,0 +1,321 @@
+import os
+from typing import Generator, Dict, Optional, Any
+from openai import OpenAI
+from .base import BaseModel
+
+class AlibabaModel(BaseModel):
+    def __init__(self, api_key: str, temperature: float = 0.7, system_prompt: str = None, language: str = None, model_name: str = None, api_base_url: str = None):
+        # 如果没有提供模型名称，才使用默认值
+        self.model_name = model_name if model_name else "QVQ-Max-2025-03-25"
+        print(f"初始化阿里巴巴模型: {self.model_name}")
+        # 在super().__init__之前设置model_name，这样get_default_system_prompt能使用它
+        super().__init__(api_key, temperature, system_prompt, language)
+        self.api_base_url = api_base_url  # 存储API基础URL
+    
+    def get_default_system_prompt(self) -> str:
+        """根据模型名称返回不同的默认系统提示词"""
+        # 检查是否是通义千问VL模型
+        if self.model_name and "qwen-vl" in self.model_name:
+            return """你是通义千问VL视觉语言助手，擅长图像理解、文字识别、内容分析和创作。请根据用户提供的图像：
+                1. 仔细阅读并理解问题
+                2. 分析问题的关键组成部分
+                3. 提供清晰的、逐步的解决方案
+                4. 如果相关，解释涉及的概念或理论
+                5. 如果有多种解决方法，先解释最高效的方法"""
+        else:
+            # QVQ模型使用原先的提示词
+            return """你是一位专业的问题分析与解答助手。当看到一个问题图片时，请：
+                1. 仔细阅读并理解问题
+                2. 分析问题的关键组成部分
+                3. 提供清晰的、逐步的解决方案
+                4. 如果相关，解释涉及的概念或理论
+                5. 如果有多种解决方法，先解释最高效的方法"""
+
+    def get_model_identifier(self) -> str:
+        """根据模型名称返回对应的模型标识符"""
+        # 直接映射模型ID到DashScope API使用的标识符
+        model_mapping = {
+            "QVQ-Max-2025-03-25": "qvq-max",
+            "qwen-vl-max-latest": "qwen-vl-max",  # 修正为正确的API标识符
+        }
+        
+        print(f"模型名称: {self.model_name}")
+        
+        # 从模型映射表中获取模型标识符，如果不存在则使用默认值
+        model_id = model_mapping.get(self.model_name)
+        if model_id:
+            print(f"从映射表中获取到模型标识符: {model_id}")
+            return model_id
+            
+        # 如果没有精确匹配，检查是否包含特定前缀
+        if self.model_name and "qwen-vl" in self.model_name.lower():
+            if "max" in self.model_name.lower():
+                print(f"识别为qwen-vl-max模型")
+                return "qwen-vl-max"
+            elif "plus" in self.model_name.lower():
+                print(f"识别为qwen-vl-plus模型")
+                return "qwen-vl-plus"
+            elif "lite" in self.model_name.lower():
+                print(f"识别为qwen-vl-lite模型")
+                return "qwen-vl-lite"
+            print(f"默认使用qwen-vl-max模型")
+            return "qwen-vl-max"  # 默认使用最强版本
+        
+        # 如果包含QVQ或alibaba关键词，默认使用qvq-max
+        if self.model_name and ("qvq" in self.model_name.lower() or "alibaba" in self.model_name.lower()):
+            print(f"识别为QVQ模型，使用qvq-max")
+            return "qvq-max"
+            
+        # 最后的默认值
+        print(f"警告：无法识别的模型名称 {self.model_name}，默认使用qvq-max")
+        return "qvq-max"
+
+    def analyze_text(self, text: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """Stream QVQ-Max's response for text analysis"""
+        try:
+            # Initial status
+            yield {"status": "started", "content": ""}
+
+            # Save original environment state
+            original_env = {
+                'http_proxy': os.environ.get('http_proxy'),
+                'https_proxy': os.environ.get('https_proxy')
+            }
+
+            try:
+                # Set proxy environment variables if provided
+                if proxies:
+                    if 'http' in proxies:
+                        os.environ['http_proxy'] = proxies['http']
+                    if 'https' in proxies:
+                        os.environ['https_proxy'] = proxies['https']
+
+                # Initialize OpenAI compatible client for DashScope
+                client = OpenAI(
+                    api_key=self.api_key,
+                    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
+                )
+
+                # Prepare messages
+                messages = [
+                    {
+                        "role": "system",
+                        "content": [{"type": "text", "text": self.system_prompt}]
+                    },
+                    {
+                        "role": "user",
+                        "content": [{"type": "text", "text": text}]
+                    }
+                ]
+
+                # 创建聊天完成请求
+                response = client.chat.completions.create(
+                    model=self.get_model_identifier(),
+                    messages=messages,
+                    temperature=self.temperature,
+                    stream=True,
+                    max_tokens=self._get_max_tokens()
+                )
+
+                # 记录思考过程和回答
+                reasoning_content = ""
+                answer_content = ""
+                is_answering = False
+                
+                # 检查是否为通义千问VL模型（不支持reasoning_content）
+                is_qwen_vl = "qwen-vl" in self.get_model_identifier().lower()
+                print(f"分析文本使用模型标识符: {self.get_model_identifier()}, 是否为千问VL模型: {is_qwen_vl}")
+                
+                for chunk in response:
+                    if not chunk.choices:
+                        continue
+                        
+                    delta = chunk.choices[0].delta
+                    
+                    # 处理思考过程（仅适用于QVQ模型）
+                    if not is_qwen_vl and hasattr(delta, 'reasoning_content') and delta.reasoning_content is not None:
+                        reasoning_content += delta.reasoning_content
+                        # 思考过程作为一个独立的内容发送
+                        yield {
+                            "status": "reasoning",
+                            "content": reasoning_content,
+                            "is_reasoning": True
+                        }
+                    elif delta.content != "":
+                        # 判断是否开始回答（从思考过程切换到回答）
+                        if not is_answering and not is_qwen_vl:
+                            is_answering = True
+                            # 发送完整的思考过程
+                            if reasoning_content:
+                                yield {
+                                    "status": "reasoning_complete",
+                                    "content": reasoning_content,
+                                    "is_reasoning": True
+                                }
+                        
+                        # 累积回答内容
+                        answer_content += delta.content
+                        
+                        # 发送回答内容
+                        yield {
+                            "status": "streaming",
+                            "content": answer_content
+                        }
+
+                # 确保发送最终完整内容
+                if answer_content:
+                    yield {
+                        "status": "completed",
+                        "content": answer_content
+                    }
+
+            finally:
+                # Restore original environment state
+                for key, value in original_env.items():
+                    if value is None:
+                        if key in os.environ:
+                            del os.environ[key]
+                    else:
+                        os.environ[key] = value
+
+        except Exception as e:
+            yield {
+                "status": "error",
+                "error": str(e)
+            }
+
+    def analyze_image(self, image_data: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """Stream model's response for image analysis"""
+        try:
+            # Initial status
+            yield {"status": "started", "content": ""}
+
+            # Save original environment state
+            original_env = {
+                'http_proxy': os.environ.get('http_proxy'),
+                'https_proxy': os.environ.get('https_proxy')
+            }
+
+            try:
+                # Set proxy environment variables if provided
+                if proxies:
+                    if 'http' in proxies:
+                        os.environ['http_proxy'] = proxies['http']
+                    if 'https' in proxies:
+                        os.environ['https_proxy'] = proxies['https']
+
+                # Initialize OpenAI compatible client for DashScope
+                client = OpenAI(
+                    api_key=self.api_key,
+                    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
+                )
+
+                # 使用系统提供的系统提示词，不再自动添加语言指令
+                system_prompt = self.system_prompt
+
+                # Prepare messages with image
+                messages = [
+                    {
+                        "role": "system",
+                        "content": [{"type": "text", "text": system_prompt}]
+                    },
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/jpeg;base64,{image_data}"
+                                }
+                            },
+                            {
+                                "type": "text",
+                                "text": "请分析这个图片并提供详细的解答。"
+                            }
+                        ]
+                    }
+                ]
+
+                # 创建聊天完成请求
+                response = client.chat.completions.create(
+                    model=self.get_model_identifier(),
+                    messages=messages,
+                    temperature=self.temperature,
+                    stream=True,
+                    max_tokens=self._get_max_tokens()
+                )
+
+                # 记录思考过程和回答
+                reasoning_content = ""
+                answer_content = ""
+                is_answering = False
+                
+                # 检查是否为通义千问VL模型（不支持reasoning_content）
+                is_qwen_vl = "qwen-vl" in self.get_model_identifier().lower()
+                print(f"分析图像使用模型标识符: {self.get_model_identifier()}, 是否为千问VL模型: {is_qwen_vl}")
+                
+                for chunk in response:
+                    if not chunk.choices:
+                        continue
+                        
+                    delta = chunk.choices[0].delta
+                    
+                    # 处理思考过程（仅适用于QVQ模型）
+                    if not is_qwen_vl and hasattr(delta, 'reasoning_content') and delta.reasoning_content is not None:
+                        reasoning_content += delta.reasoning_content
+                        # 思考过程作为一个独立的内容发送
+                        yield {
+                            "status": "reasoning",
+                            "content": reasoning_content,
+                            "is_reasoning": True
+                        }
+                    elif delta.content != "":
+                        # 判断是否开始回答（从思考过程切换到回答）
+                        if not is_answering and not is_qwen_vl:
+                            is_answering = True
+                            # 发送完整的思考过程
+                            if reasoning_content:
+                                yield {
+                                    "status": "reasoning_complete",
+                                    "content": reasoning_content,
+                                    "is_reasoning": True
+                                }
+                        
+                        # 累积回答内容
+                        answer_content += delta.content
+                        
+                        # 发送回答内容
+                        yield {
+                            "status": "streaming",
+                            "content": answer_content
+                        }
+
+                # 确保发送最终完整内容
+                if answer_content:
+                    yield {
+                        "status": "completed",
+                        "content": answer_content
+                    }
+
+            finally:
+                # Restore original environment state
+                for key, value in original_env.items():
+                    if value is None:
+                        if key in os.environ:
+                            del os.environ[key]
+                    else:
+                        os.environ[key] = value
+
+        except Exception as e:
+            yield {
+                "status": "error",
+                "error": str(e)
+            } 
+
+    def _get_max_tokens(self) -> int:
+        """根据模型类型返回合适的max_tokens值"""
+        # 检查是否为通义千问VL模型
+        if "qwen-vl" in self.get_model_identifier():
+            return 2000  # 通义千问VL模型最大支持2048，留一些余量
+        # QVQ模型或其他模型
+        return self.max_tokens if hasattr(self, 'max_tokens') and self.max_tokens else 4000 

models/anthropic.py

@@ -0,0 +1,371 @@
+import json
+import requests
+from typing import Generator, Optional
+from .base import BaseModel
+
+class AnthropicModel(BaseModel):
+    def __init__(self, api_key, temperature=0.7, system_prompt=None, language=None, api_base_url=None, model_identifier=None):
+        super().__init__(api_key, temperature, system_prompt or self.get_default_system_prompt(), language or "en")
+        # 设置API基础URL，默认为Anthropic官方API
+        self.api_base_url = api_base_url or "https://api.anthropic.com/v1"
+        # 设置模型标识符，支持动态选择
+        self.model_identifier = model_identifier or "claude-3-7-sonnet-20250219"
+        # 初始化推理配置
+        self.reasoning_config = None
+        # 初始化最大Token数
+        self.max_tokens = None
+        
+    def get_default_system_prompt(self) -> str:
+        return """You are an expert at analyzing questions and providing detailed solutions. When presented with an image of a question:
+1. First read and understand the question carefully
+2. Break down the key components of the question
+3. Provide a clear, step-by-step solution
+4. If relevant, explain any concepts or theories involved
+5. If there are multiple approaches, explain the most efficient one first"""
+
+    def get_model_identifier(self) -> str:
+        return self.model_identifier
+
+    def analyze_text(self, text: str, proxies: Optional[dict] = None) -> Generator[dict, None, None]:
+        """Stream Claude's response for text analysis"""
+        try:
+            yield {"status": "started"}
+            
+            api_key = self.api_key
+            if api_key.startswith('Bearer '):
+                api_key = api_key[7:]
+                
+            headers = {
+                'x-api-key': api_key,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+                'accept': 'application/json',
+            }
+
+            # 获取最大输出Token设置
+            max_tokens = 8192  # 默认值
+            if hasattr(self, 'max_tokens') and self.max_tokens:
+                max_tokens = self.max_tokens
+
+            payload = {
+                'model': self.get_model_identifier(),
+                'stream': True,
+                'max_tokens': max_tokens,
+                'temperature': 1,
+                'system': self.system_prompt,
+                'messages': [{
+                    'role': 'user',
+                    'content': [
+                        {
+                            'type': 'text',
+                            'text': text
+                        }
+                    ]
+                }]
+            }
+            
+            # 处理推理配置
+            if hasattr(self, 'reasoning_config') and self.reasoning_config:
+                # 如果设置了extended reasoning
+                if self.reasoning_config.get('reasoning_depth') == 'extended':  
+                    think_budget = self.reasoning_config.get('think_budget', max_tokens // 2)
+                    payload['thinking'] = {
+                        'type': 'enabled',
+                        'budget_tokens': think_budget
+                    }
+                # 如果设置了instant模式
+                elif self.reasoning_config.get('speed_mode') == 'instant':
+                    # 确保当使用speed_mode时不包含thinking参数
+                    if 'thinking' in payload:
+                        del payload['thinking']
+                # 默认启用思考但使用较小的预算
+                else:
+                    payload['thinking'] = {
+                        'type': 'enabled',
+                        'budget_tokens': min(4096, max_tokens // 4)
+                    }
+            # 默认设置
+            else:
+                payload['thinking'] = {
+                    'type': 'enabled',
+                    'budget_tokens': min(4096, max_tokens // 4)
+                }
+                
+            print(f"Debug - 推理配置: max_tokens={max_tokens}, thinking={payload.get('thinking', payload.get('speed_mode', 'default'))}")
+
+            # 使用配置的API基础URL
+            api_endpoint = f"{self.api_base_url}/messages"
+            
+            response = requests.post(
+                api_endpoint,
+                headers=headers,
+                json=payload,
+                stream=True,
+                proxies=proxies,
+                timeout=60
+            )
+
+            if response.status_code != 200:
+                error_msg = f'API error: {response.status_code}'
+                try:
+                    error_data = response.json()
+                    if 'error' in error_data:
+                        error_msg += f" - {error_data['error']['message']}"
+                except:
+                    error_msg += f" - {response.text}"
+                yield {"status": "error", "error": error_msg}
+                return
+
+            thinking_content = ""
+            response_buffer = ""
+            
+            for chunk in response.iter_lines():
+                if not chunk:
+                    continue
+
+                try:
+                    chunk_str = chunk.decode('utf-8')
+                    if not chunk_str.startswith('data: '):
+                        continue
+
+                    chunk_str = chunk_str[6:]
+                    data = json.loads(chunk_str)
+
+                    if data.get('type') == 'content_block_delta':
+                        if 'delta' in data:
+                            if 'text' in data['delta']:
+                                text_chunk = data['delta']['text']
+                                response_buffer += text_chunk
+                                # 只在每累积一定数量的字符后才发送，减少UI跳变
+                                if len(text_chunk) >= 10 or text_chunk.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                    yield {
+                                        "status": "streaming",
+                                        "content": response_buffer
+                                    }
+                                
+                            elif 'thinking' in data['delta']:
+                                thinking_chunk = data['delta']['thinking']
+                                thinking_content += thinking_chunk
+                                # 只在每累积一定数量的字符后才发送，减少UI跳变
+                                if len(thinking_chunk) >= 20 or thinking_chunk.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                    yield {
+                                        "status": "thinking",
+                                        "content": thinking_content
+                                    }
+                    
+                    # 处理新的extended_thinking格式
+                    elif data.get('type') == 'extended_thinking_delta':
+                        if 'delta' in data and 'text' in data['delta']:
+                            thinking_chunk = data['delta']['text']
+                            thinking_content += thinking_chunk
+                            # 只在每累积一定数量的字符后才发送，减少UI跳变
+                            if len(thinking_chunk) >= 20 or thinking_chunk.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                yield {
+                                    "status": "thinking",
+                                    "content": thinking_content
+                                }
+
+                    elif data.get('type') == 'message_stop':
+                        # 确保发送完整的思考内容
+                        if thinking_content:
+                            yield {
+                                "status": "thinking_complete",
+                                "content": thinking_content
+                            }
+                        # 确保发送完整的响应内容
+                        yield {
+                            "status": "completed",
+                            "content": response_buffer
+                        }
+
+                    elif data.get('type') == 'error':
+                        error_msg = data.get('error', {}).get('message', 'Unknown error')
+                        yield {
+                            "status": "error",
+                            "error": error_msg
+                        }
+                        break
+
+                except json.JSONDecodeError as e:
+                    print(f"JSON decode error: {str(e)}")
+                    continue
+
+        except Exception as e:
+            yield {
+                "status": "error",
+                "error": f"Streaming error: {str(e)}"
+            }
+
+    def analyze_image(self, image_data, proxies: Optional[dict] = None):
+        yield {"status": "started"}
+        
+        api_key = self.api_key
+        if api_key.startswith('Bearer '):
+            api_key = api_key[7:]
+            
+        headers = {
+            'x-api-key': api_key,
+            'anthropic-version': '2023-06-01',
+            'content-type': 'application/json'
+        }
+        
+        # 使用系统提供的系统提示词，不再自动添加语言指令
+        system_prompt = self.system_prompt
+        
+        # 获取最大输出Token设置
+        max_tokens = 8192  # 默认值
+        if hasattr(self, 'max_tokens') and self.max_tokens:
+            max_tokens = self.max_tokens
+            
+        payload = {
+            'model': self.get_model_identifier(),
+            'stream': True,
+            'max_tokens': max_tokens,
+            'temperature': 1,
+            'system': system_prompt,
+            'messages': [{
+                'role': 'user',
+                'content': [
+                    {
+                        'type': 'image',
+                        'source': {
+                            'type': 'base64',
+                            'media_type': 'image/png',
+                            'data': image_data
+                        }
+                    },
+                    {
+                        'type': 'text',
+                        'text': "请分析这个问题并提供详细的解决方案。如果你看到多个问题，请逐一解决。"
+                    }
+                ]
+            }]
+        }
+        
+        # 处理推理配置
+        if hasattr(self, 'reasoning_config') and self.reasoning_config:
+            # 如果设置了extended reasoning
+            if self.reasoning_config.get('reasoning_depth') == 'extended':
+                think_budget = self.reasoning_config.get('think_budget', max_tokens // 2)
+                payload['thinking'] = {
+                    'type': 'enabled',
+                    'budget_tokens': think_budget
+                }
+            # 如果设置了instant模式
+            elif self.reasoning_config.get('speed_mode') == 'instant':
+                # 只需确保不包含thinking参数，不添加speed_mode参数
+                if 'thinking' in payload:
+                    del payload['thinking']
+            # 默认启用思考但使用较小的预算
+            else:
+                payload['thinking'] = {
+                    'type': 'enabled',
+                    'budget_tokens': min(4096, max_tokens // 4)
+                }
+        # 默认设置
+        else:
+            payload['thinking'] = {
+                'type': 'enabled',
+                'budget_tokens': min(4096, max_tokens // 4)
+            }
+            
+        print(f"Debug - 图像分析推理配置: max_tokens={max_tokens}, thinking={payload.get('thinking', payload.get('speed_mode', 'default'))}")
+
+        # 使用配置的API基础URL
+        api_endpoint = f"{self.api_base_url}/messages"
+        
+        response = requests.post(
+            api_endpoint,
+            headers=headers,
+            json=payload,
+            stream=True,
+            proxies=proxies,
+            timeout=60
+        )
+
+        if response.status_code != 200:
+            error_msg = f'API error: {response.status_code}'
+            try:
+                error_data = response.json()
+                if 'error' in error_data:
+                    error_msg += f" - {error_data['error']['message']}"
+            except:
+                error_msg += f" - {response.text}"
+            yield {"status": "error", "error": error_msg}
+            return
+
+        thinking_content = ""
+        response_buffer = ""
+        
+        for chunk in response.iter_lines():
+            if not chunk:
+                continue
+
+            try:
+                chunk_str = chunk.decode('utf-8')
+                if not chunk_str.startswith('data: '):
+                    continue
+
+                chunk_str = chunk_str[6:]
+                data = json.loads(chunk_str)
+
+                if data.get('type') == 'content_block_delta':
+                    if 'delta' in data:
+                        if 'text' in data['delta']:
+                            text_chunk = data['delta']['text']
+                            response_buffer += text_chunk
+                            # 只在每累积一定数量的字符后才发送，减少UI跳变
+                            if len(text_chunk) >= 10 or text_chunk.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                yield {
+                                    "status": "streaming",
+                                    "content": response_buffer
+                                }
+                            
+                        elif 'thinking' in data['delta']:
+                            thinking_chunk = data['delta']['thinking']
+                            thinking_content += thinking_chunk
+                            # 只在每累积一定数量的字符后才发送，减少UI跳变
+                            if len(thinking_chunk) >= 20 or thinking_chunk.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                yield {
+                                    "status": "thinking",
+                                    "content": thinking_content
+                                }
+                
+                # 处理新的extended_thinking格式
+                elif data.get('type') == 'extended_thinking_delta':
+                    if 'delta' in data and 'text' in data['delta']:
+                        thinking_chunk = data['delta']['text']
+                        thinking_content += thinking_chunk
+                        # 只在每累积一定数量的字符后才发送，减少UI跳变
+                        if len(thinking_chunk) >= 20 or thinking_chunk.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                            yield {
+                                "status": "thinking",
+                                "content": thinking_content
+                            }
+
+                elif data.get('type') == 'message_stop':
+                    # 确保发送完整的思考内容
+                    if thinking_content:
+                        yield {
+                            "status": "thinking_complete",
+                            "content": thinking_content
+                        }
+                    # 确保发送完整的响应内容
+                    yield {
+                        "status": "completed",
+                        "content": response_buffer
+                    }
+                    
+                elif data.get('type') == 'error':
+                    error_message = data.get('error', {}).get('message', 'Unknown error')
+                    yield {
+                        "status": "error",
+                        "error": error_message
+                    }
+                    
+            except Exception as e:
+                yield {
+                    "status": "error",
+                    "error": f"Error processing response: {str(e)}"
+                }
+                break

models/baidu_ocr.py

@@ -0,0 +1,177 @@
+import base64
+import json
+import time
+import urllib.request
+import urllib.parse
+from typing import Generator, Dict, Any
+from .base import BaseModel
+
+class BaiduOCRModel(BaseModel):
+    """
+    百度OCR模型，用于图像文字识别
+    """
+    
+    def __init__(self, api_key: str, secret_key: str = None, temperature: float = 0.7, system_prompt: str = None):
+        """
+        初始化百度OCR模型
+        
+        Args:
+            api_key: 百度API Key
+            secret_key: 百度Secret Key（可以在api_key中用冒号分隔传入）
+            temperature: 不用于OCR但保持BaseModel兼容性
+            system_prompt: 不用于OCR但保持BaseModel兼容性
+            
+        Raises:
+            ValueError: 如果API密钥格式无效
+        """
+        super().__init__(api_key, temperature, system_prompt)
+        
+        # 支持两种格式：单独传递或在api_key中用冒号分隔
+        if secret_key:
+            self.api_key = api_key
+            self.secret_key = secret_key
+        else:
+            try:
+                self.api_key, self.secret_key = api_key.split(':')
+            except ValueError:
+                raise ValueError("百度OCR API密钥必须是 'API_KEY:SECRET_KEY' 格式或单独传递secret_key参数")
+        
+        # 百度API URLs
+        self.token_url = "https://aip.baidubce.com/oauth/2.0/token"
+        self.ocr_url = "https://aip.baidubce.com/rest/2.0/ocr/v1/accurate_basic"
+        
+        # 缓存access_token
+        self._access_token = None
+        self._token_expires = 0
+    
+    def get_access_token(self) -> str:
+        """获取百度API的access_token"""
+        # 检查是否需要刷新token（提前5分钟刷新）
+        if self._access_token and time.time() < self._token_expires - 300:
+            return self._access_token
+        
+        # 请求新的access_token
+        params = {
+            'grant_type': 'client_credentials',
+            'client_id': self.api_key,
+            'client_secret': self.secret_key
+        }
+        
+        data = urllib.parse.urlencode(params).encode('utf-8')
+        request = urllib.request.Request(self.token_url, data=data)
+        request.add_header('Content-Type', 'application/x-www-form-urlencoded')
+        
+        try:
+            with urllib.request.urlopen(request) as response:
+                result = json.loads(response.read().decode('utf-8'))
+                
+            if 'access_token' in result:
+                self._access_token = result['access_token']
+                # 设置过期时间（默认30天，但我们提前刷新）
+                self._token_expires = time.time() + result.get('expires_in', 2592000)
+                return self._access_token
+            else:
+                raise Exception(f"获取access_token失败: {result.get('error_description', '未知错误')}")
+                
+        except Exception as e:
+            raise Exception(f"请求access_token失败: {str(e)}")
+    
+    def ocr_image(self, image_data: str) -> str:
+        """
+        对图像进行OCR识别
+        
+        Args:
+            image_data: Base64编码的图像数据
+            
+        Returns:
+            str: 识别出的文字内容
+        """
+        access_token = self.get_access_token()
+        
+        # 准备请求数据
+        params = {
+            'image': image_data,
+            'language_type': 'auto_detect',  # 自动检测语言
+            'detect_direction': 'true',      # 检测图像朝向
+            'probability': 'false'           # 不返回置信度（减少响应大小）
+        }
+        
+        data = urllib.parse.urlencode(params).encode('utf-8')
+        url = f"{self.ocr_url}?access_token={access_token}"
+        
+        request = urllib.request.Request(url, data=data)
+        request.add_header('Content-Type', 'application/x-www-form-urlencoded')
+        
+        try:
+            with urllib.request.urlopen(request) as response:
+                result = json.loads(response.read().decode('utf-8'))
+                
+            if 'error_code' in result:
+                raise Exception(f"百度OCR API错误: {result.get('error_msg', '未知错误')}")
+            
+            # 提取识别的文字
+            words_result = result.get('words_result', [])
+            text_lines = [item['words'] for item in words_result]
+            
+            return '\n'.join(text_lines)
+            
+        except Exception as e:
+            raise Exception(f"OCR识别失败: {str(e)}")
+    
+    def extract_full_text(self, image_data: str) -> str:
+        """
+        提取图像中的完整文本（与Mathpix兼容的接口）
+        
+        Args:
+            image_data: Base64编码的图像数据
+            
+        Returns:
+            str: 提取的文本内容
+        """
+        return self.ocr_image(image_data)
+    
+    def analyze_image(self, image_data: str, proxies: dict = None) -> Generator[Dict[str, Any], None, None]:
+        """
+        分析图像并返回OCR结果（流式输出以保持接口一致性）
+        
+        Args:
+            image_data: Base64编码的图像数据
+            proxies: 代理配置（未使用）
+            
+        Yields:
+            dict: 包含OCR结果的响应
+        """
+        try:
+            text = self.ocr_image(image_data)
+            yield {
+                'status': 'completed',
+                'content': text,
+                'model': 'baidu-ocr'
+            }
+        except Exception as e:
+            yield {
+                'status': 'error',
+                'content': f'OCR识别失败: {str(e)}',
+                'model': 'baidu-ocr'
+            }
+    
+    def analyze_text(self, text: str, proxies: dict = None) -> Generator[Dict[str, Any], None, None]:
+        """
+        分析文本（OCR模型不支持文本分析）
+        
+        Args:
+            text: 输入文本
+            proxies: 代理配置（未使用）
+            
+        Yields:
+            dict: 错误响应
+        """
+        yield {
+            'status': 'error',
+            'content': 'OCR模型不支持文本分析功能',
+            'model': 'baidu-ocr'
+        }
+    
+    def get_model_identifier(self) -> str:
+        """返回模型标识符"""
+        return "baidu-ocr"

models/base.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+from typing import Generator, Any
+
+class BaseModel(ABC):
+    def __init__(self, api_key: str, temperature: float = 0.7, system_prompt: str = None, language: str = None, api_base_url: str = None):
+        self.api_key = api_key
+        self.temperature = temperature
+        self.language = language
+        self.system_prompt = system_prompt or self.get_default_system_prompt()
+        self.api_base_url = api_base_url
+
+    @abstractmethod
+    def analyze_image(self, image_data: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """
+        Analyze the given image and yield response chunks.
+        
+        Args:
+            image_data: Base64 encoded image data
+            proxies: Optional proxy configuration
+            
+        Yields:
+            dict: Response chunks with status and content
+        """
+        pass
+
+    @abstractmethod
+    def analyze_text(self, text: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """
+        Analyze the given text and yield response chunks.
+        
+        Args:
+            text: Text to analyze
+            proxies: Optional proxy configuration
+            
+        Yields:
+            dict: Response chunks with status and content
+        """
+        pass
+
+    def get_default_system_prompt(self) -> str:
+        """返回默认的系统提示词，子类可覆盖但不再是必须实现的方法"""
+        return "您是一位专业的问题解决专家。请逐步分析问题，找出问题所在，并提供详细的解决方案。始终使用用户偏好的语言回答。"
+
+    @abstractmethod
+    def get_model_identifier(self) -> str:
+        """Return the model identifier used in API calls"""
+        pass

models/deepseek.py

@@ -0,0 +1,364 @@
+import json
+import requests
+import os
+from typing import Generator
+from openai import OpenAI
+from .base import BaseModel
+
+class DeepSeekModel(BaseModel):
+    def __init__(self, api_key: str, temperature: float = 0.7, system_prompt: str = None, language: str = None, model_name: str = "deepseek-reasoner", api_base_url: str = None):
+        super().__init__(api_key, temperature, system_prompt, language)
+        self.model_name = model_name
+        self.api_base_url = api_base_url  # 存储API基础URL
+
+    def get_default_system_prompt(self) -> str:
+        return """You are an expert at analyzing questions and providing detailed solutions. When presented with an image of a question:
+1. First read and understand the question carefully
+2. Break down the key components of the question
+3. Provide a clear, step-by-step solution
+4. If relevant, explain any concepts or theories involved
+5. If there are multiple approaches, explain the most efficient one first"""
+
+    def get_model_identifier(self) -> str:
+        """根据模型名称返回正确的API标识符"""
+        # 通过模型名称来确定实际的API调用标识符
+        if self.model_name == "deepseek-chat":
+            return "deepseek-chat"
+        # 如果是deepseek-reasoner或包含reasoner的模型名称，返回推理模型标识符
+        if "reasoner" in self.model_name.lower():
+            return "deepseek-reasoner"
+        # 对于deepseek-chat也返回对应的模型名称
+        if "chat" in self.model_name.lower() or self.model_name == "deepseek-chat":
+            return "deepseek-chat"
+        
+        # 根据配置中的模型ID来确定实际的模型类型
+        if self.model_name == "deepseek-reasoner":
+            return "deepseek-reasoner"
+        elif self.model_name == "deepseek-chat":
+            return "deepseek-chat"
+            
+        # 默认使用deepseek-chat作为API标识符
+        print(f"未知的DeepSeek模型名称: {self.model_name}，使用deepseek-chat作为默认值")
+        return "deepseek-chat"
+
+    def analyze_text(self, text: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """Stream DeepSeek's response for text analysis"""
+        try:
+            # Initial status
+            yield {"status": "started", "content": ""}
+
+            # 保存原始环境变量
+            original_env = {
+                'http_proxy': os.environ.get('http_proxy'),
+                'https_proxy': os.environ.get('https_proxy')
+            }
+
+            try:
+                # 如果提供了代理设置，通过环境变量设置
+                if proxies:
+                    if 'http' in proxies:
+                        os.environ['http_proxy'] = proxies['http']
+                    if 'https' in proxies:
+                        os.environ['https_proxy'] = proxies['https']
+
+                # 初始化DeepSeek客户端，不再使用session对象
+                client = OpenAI(
+                    api_key=self.api_key,
+                    base_url="https://api.deepseek.com"
+                )
+
+                # 使用系统提供的系统提示词，不再自动添加语言指令
+                system_prompt = self.system_prompt
+
+                # 构建请求参数
+                params = {
+                    "model": self.get_model_identifier(),
+                    "messages": [
+                        {
+                            'role': 'system',
+                            'content': system_prompt
+                        }, 
+                        {
+                            'role': 'user',
+                            'content': text
+                        }
+                    ],
+                    "stream": True
+                }
+                
+                # 只有非推理模型才设置temperature参数
+                if not self.get_model_identifier().endswith('reasoner') and self.temperature is not None:
+                    params["temperature"] = self.temperature
+                    
+                print(f"调用DeepSeek API: {self.get_model_identifier()}, 是否设置温度: {not self.get_model_identifier().endswith('reasoner')}, 温度值: {self.temperature if not self.get_model_identifier().endswith('reasoner') else 'N/A'}")
+
+                response = client.chat.completions.create(**params)
+                
+                # 使用两个缓冲区，分别用于常规内容和思考内容
+                response_buffer = ""
+                thinking_buffer = ""
+                
+                for chunk in response:
+                    # 打印chunk以调试
+                    try:
+                        print(f"DeepSeek API返回chunk: {chunk}")
+                    except:
+                        print("无法打印chunk")
+                        
+                    try:
+                        # 同时处理两种不同的内容，确保正确区分思考内容和最终内容
+                        delta = chunk.choices[0].delta
+                        
+                        # 处理推理模型的思考内容
+                        if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
+                            content = delta.reasoning_content
+                            thinking_buffer += content
+                            
+                            # 发送思考内容更新
+                            if len(content) >= 20 or content.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                yield {
+                                    "status": "thinking",
+                                    "content": thinking_buffer
+                                }
+                        
+                        # 处理最终结果内容 - 即使在推理模型中也会有content字段
+                        if hasattr(delta, 'content') and delta.content:
+                            content = delta.content
+                            response_buffer += content
+                            print(f"累积响应内容: '{content}', 当前buffer: '{response_buffer}'")
+                            
+                            # 发送结果内容更新
+                            if len(content) >= 10 or content.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                yield {
+                                    "status": "streaming",
+                                    "content": response_buffer
+                                }
+                        
+                        # 处理消息结束
+                        if hasattr(chunk.choices[0], 'finish_reason') and chunk.choices[0].finish_reason:
+                            print(f"生成结束，原因: {chunk.choices[0].finish_reason}")
+                            # 注意：不要在这里把思考内容作为正文，因为这可能导致重复内容
+                    except Exception as e:
+                        print(f"解析响应chunk时出错: {str(e)}")
+                        continue
+
+                # 确保发送最终的缓冲内容
+                if thinking_buffer:
+                    yield {
+                        "status": "thinking_complete",
+                        "content": thinking_buffer
+                    }
+                
+                # 发送最终响应内容
+                if response_buffer:
+                    yield {
+                        "status": "completed",
+                        "content": response_buffer
+                    }
+                
+                # 如果没有正常的响应内容，但有思考内容，则将思考内容作为最终结果
+                elif thinking_buffer:
+                    yield {
+                        "status": "completed",
+                        "content": thinking_buffer
+                    }
+                else:
+                    # 如果两者都没有，返回一个空结果
+                    yield {
+                        "status": "completed",
+                        "content": "没有获取到内容"
+                    }
+
+            except Exception as e:
+                error_msg = str(e)
+                print(f"DeepSeek API调用出错: {error_msg}")
+                
+                # 提供具体的错误信息
+                if "invalid_api_key" in error_msg.lower():
+                    error_msg = "DeepSeek API密钥无效，请检查您的API密钥"
+                elif "rate_limit" in error_msg.lower():
+                    error_msg = "DeepSeek API请求频率超限，请稍后再试"
+                elif "quota_exceeded" in error_msg.lower():
+                    error_msg = "DeepSeek API配额已用完，请续费或等待下个计费周期"
+                
+                yield {
+                    "status": "error",
+                    "error": f"DeepSeek API错误: {error_msg}"
+                }
+            finally:
+                # 恢复原始环境变量
+                for key, value in original_env.items():
+                    if value is None:
+                        if key in os.environ:
+                            del os.environ[key]
+                    else:
+                        os.environ[key] = value
+
+        except Exception as e:
+            error_msg = str(e)
+            print(f"调用DeepSeek模型时发生错误: {error_msg}")
+            
+            if "invalid_api_key" in error_msg.lower():
+                error_msg = "API密钥无效，请检查设置"
+            elif "rate_limit" in error_msg.lower():
+                error_msg = "API请求频率超限，请稍后再试"
+            
+            yield {
+                "status": "error",
+                "error": f"DeepSeek API错误: {error_msg}"
+            }
+
+    def analyze_image(self, image_data: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """Stream DeepSeek's response for image analysis"""
+        try:
+            # 检查我们是否有支持图像的模型
+            if self.model_name == "deepseek-chat" or self.model_name == "deepseek-reasoner":
+                yield {
+                    "status": "error",
+                    "error": "当前DeepSeek模型不支持图像分析，请使用Anthropic或OpenAI的多模态模型"
+                }
+                return
+                
+            # Initial status
+            yield {"status": "started", "content": ""}
+
+            # 保存原始环境变量
+            original_env = {
+                'http_proxy': os.environ.get('http_proxy'),
+                'https_proxy': os.environ.get('https_proxy')
+            }
+
+            try:
+                # 如果提供了代理设置，通过环境变量设置
+                if proxies:
+                    if 'http' in proxies:
+                        os.environ['http_proxy'] = proxies['http']
+                    if 'https' in proxies:
+                        os.environ['https_proxy'] = proxies['https']
+
+                # 初始化DeepSeek客户端，不再使用session对象
+                client = OpenAI(
+                    api_key=self.api_key,
+                    base_url="https://api.deepseek.com"
+                )
+
+                # 使用系统提供的系统提示词，不再自动添加语言指令
+                system_prompt = self.system_prompt
+
+                # 构建请求参数
+                params = {
+                    "model": self.get_model_identifier(),
+                    "messages": [
+                        {
+                            'role': 'system',
+                            'content': system_prompt
+                        }, 
+                        {
+                            'role': 'user',
+                            'content': f"Here's an image of a question to analyze: data:image/png;base64,{image_data}"
+                        }
+                    ],
+                    "stream": True
+                }
+                
+                # 只有非推理模型才设置temperature参数
+                if not self.get_model_identifier().endswith('reasoner') and self.temperature is not None:
+                    params["temperature"] = self.temperature
+
+                response = client.chat.completions.create(**params)
+                
+                # 使用两个缓冲区，分别用于常规内容和思考内容
+                response_buffer = ""
+                thinking_buffer = ""
+                
+                for chunk in response:
+                    # 打印chunk以调试
+                    try:
+                        print(f"DeepSeek图像API返回chunk: {chunk}")
+                    except:
+                        print("无法打印chunk")
+                
+                    try:
+                        # 同时处理两种不同的内容，确保正确区分思考内容和最终内容
+                        delta = chunk.choices[0].delta
+                        
+                        # 处理推理模型的思考内容
+                        if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
+                            content = delta.reasoning_content
+                            thinking_buffer += content
+                            
+                            # 发送思考内容更新
+                            if len(content) >= 20 or content.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                yield {
+                                    "status": "thinking",
+                                    "content": thinking_buffer
+                                }
+                        
+                        # 处理最终结果内容 - 即使在推理模型中也会有content字段
+                        if hasattr(delta, 'content') and delta.content:
+                            content = delta.content
+                            response_buffer += content
+                            print(f"累积图像响应内容: '{content}', 当前buffer: '{response_buffer}'")
+                            
+                            # 发送结果内容更新
+                            if len(content) >= 10 or content.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                yield {
+                                    "status": "streaming",
+                                    "content": response_buffer
+                                }
+                        
+                        # 处理消息结束
+                        if hasattr(chunk.choices[0], 'finish_reason') and chunk.choices[0].finish_reason:
+                            print(f"图像生成结束，原因: {chunk.choices[0].finish_reason}")
+                    except Exception as e:
+                        print(f"解析图像响应chunk时出错: {str(e)}")
+                        continue
+
+                # 确保发送最终的缓冲内容
+                if thinking_buffer:
+                    yield {
+                        "status": "thinking_complete",
+                        "content": thinking_buffer
+                    }
+                
+                # 发送最终响应内容
+                if response_buffer:
+                    yield {
+                        "status": "completed",
+                        "content": response_buffer
+                    }
+                
+            except Exception as e:
+                error_msg = str(e)
+                print(f"DeepSeek API调用出错: {error_msg}")
+                
+                # 提供具体的错误信息
+                if "invalid_api_key" in error_msg.lower():
+                    error_msg = "DeepSeek API密钥无效，请检查您的API密钥"
+                elif "rate_limit" in error_msg.lower():
+                    error_msg = "DeepSeek API请求频率超限，请稍后再试"
+                
+                yield {
+                    "status": "error",
+                    "error": f"DeepSeek API错误: {error_msg}"
+                }
+            finally:
+                # 恢复原始环境变量
+                for key, value in original_env.items():
+                    if value is None:
+                        if key in os.environ:
+                            del os.environ[key]
+                    else:
+                        os.environ[key] = value
+
+        except Exception as e:
+            error_msg = str(e)
+            if "invalid_api_key" in error_msg.lower():
+                error_msg = "API密钥无效，请检查设置"
+            elif "rate_limit" in error_msg.lower():
+                error_msg = "API请求频率超限，请稍后再试"
+            
+            yield {
+                "status": "error",
+                "error": f"DeepSeek API错误: {error_msg}"
+            }

models/doubao.py

@@ -0,0 +1,354 @@
+import json
+import os
+import base64
+from typing import Generator, Dict, Any, Optional
+import requests
+from .base import BaseModel
+
+class DoubaoModel(BaseModel):
+    """
+    豆包API模型实现类
+    支持字节跳动的豆包AI模型，可处理文本和图像输入
+    """
+    
+    def __init__(self, api_key: str, temperature: float = 0.7, system_prompt: str = None, language: str = None, model_name: str = None, api_base_url: str = None):
+        """
+        初始化豆包模型
+        
+        Args:
+            api_key: 豆包API密钥
+            temperature: 生成温度
+            system_prompt: 系统提示词
+            language: 首选语言
+            model_name: 指定具体模型名称，如不指定则使用默认值
+            api_base_url: API基础URL，用于设置自定义API端点
+        """
+        super().__init__(api_key, temperature, system_prompt, language)
+        self.model_name = model_name or self.get_model_identifier()
+        self.base_url = api_base_url or "https://ark.cn-beijing.volces.com/api/v3"
+        self.max_tokens = 4096  # 默认最大输出token数
+        self.reasoning_config = None  # 推理配置，类似于AnthropicModel
+    
+    def get_default_system_prompt(self) -> str:
+        return """你是一个专业的问题分析专家。当看到问题图片时：
+1. 仔细阅读并理解问题
+2. 分解问题的关键组成部分
+3. 提供清晰的分步解决方案
+4. 如果相关，解释涉及的概念或理论
+5. 如果有多种方法，优先解释最有效的方法"""
+
+    def get_model_identifier(self) -> str:
+        """返回默认的模型标识符"""
+        return "doubao-seed-1-6-250615"  # Doubao-Seed-1.6
+    
+    def get_actual_model_name(self) -> str:
+        """根据配置的模型名称返回实际的API调用标识符"""
+        # 豆包API的实际模型名称映射
+        model_mapping = {
+            "doubao-seed-1-6-250615": "doubao-seed-1-6-250615"
+        }
+        
+        return model_mapping.get(self.model_name, "doubao-seed-1-6-250615")
+    
+    def analyze_text(self, text: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """流式生成文本响应"""
+        try:
+            yield {"status": "started"}
+            
+            # 设置环境变量代理（如果提供）
+            original_proxies = None
+            if proxies:
+                original_proxies = {
+                    'http_proxy': os.environ.get('http_proxy'),
+                    'https_proxy': os.environ.get('https_proxy')
+                }
+                if 'http' in proxies:
+                    os.environ['http_proxy'] = proxies['http']
+                if 'https' in proxies:
+                    os.environ['https_proxy'] = proxies['https']
+            
+            try:
+                # 构建请求头
+                headers = {
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json"
+                }
+                
+                # 构建消息 - 添加系统提示词
+                messages = []
+                
+                # 添加系统提示词
+                if self.system_prompt:
+                    messages.append({
+                        "role": "system",
+                        "content": self.system_prompt
+                    })
+                
+                # 添加用户查询
+                user_content = text
+                if self.language and self.language != 'auto':
+                    user_content = f"请使用{self.language}回答以下问题: {text}"
+                
+                messages.append({
+                    "role": "user",
+                    "content": user_content
+                })
+
+                # 处理推理配置
+                thinking = {
+                    "type": "auto"  # 默认值
+                }
+                
+                if hasattr(self, 'reasoning_config') and self.reasoning_config:
+                    # 从reasoning_config中获取thinking_mode
+                    thinking_mode = self.reasoning_config.get('thinking_mode', "auto")
+                    thinking = {
+                        "type": thinking_mode
+                    }
+
+                # 构建请求数据
+                data = {
+                    "model": self.get_actual_model_name(),
+                    "messages": messages,
+                    "thinking": thinking,
+                    "temperature": self.temperature,
+                    "max_tokens": self.max_tokens,
+                    "stream": True
+                }
+                
+                # 发送流式请求
+                response = requests.post(
+                    f"{self.base_url}/chat/completions",
+                    headers=headers,
+                    json=data,
+                    stream=True,
+                    proxies=proxies if proxies else None,
+                    timeout=60
+                )
+                
+                if response.status_code != 200:
+                    error_text = response.text
+                    raise Exception(f"HTTP {response.status_code}: {error_text}")
+                
+                response.raise_for_status()
+                
+                # 初始化响应缓冲区
+                response_buffer = ""
+                
+                # 处理流式响应
+                for line in response.iter_lines():
+                    if not line:
+                        continue
+                    
+                    line = line.decode('utf-8')
+                    if not line.startswith('data: '):
+                        continue
+                    
+                    line = line[6:]  # 移除 'data: ' 前缀
+                    
+                    if line == '[DONE]':
+                        break
+                    
+                    try:
+                        chunk_data = json.loads(line)
+                        choices = chunk_data.get('choices', [])
+                        
+                        if choices and len(choices) > 0:
+                            delta = choices[0].get('delta', {})
+                            content = delta.get('content', '')
+                            
+                            if content:
+                                response_buffer += content
+                                
+                                # 发送响应进度
+                                yield {
+                                    "status": "streaming",
+                                    "content": response_buffer
+                                }
+                    
+                    except json.JSONDecodeError:
+                        continue
+                
+                # 确保发送完整的最终内容
+                yield {
+                    "status": "completed",
+                    "content": response_buffer
+                }
+            
+            finally:
+                # 恢复原始代理设置
+                if original_proxies:
+                    for key, value in original_proxies.items():
+                        if value is None:
+                            if key in os.environ:
+                                del os.environ[key]
+                        else:
+                            os.environ[key] = value
+                
+        except Exception as e:
+            yield {
+                "status": "error",
+                "error": f"豆包API错误: {str(e)}"
+            }
+    
+    def analyze_image(self, image_data: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """分析图像并流式生成响应"""
+        try:
+            yield {"status": "started"}
+            
+            # 设置环境变量代理（如果提供）
+            original_proxies = None
+            if proxies:
+                original_proxies = {
+                    'http_proxy': os.environ.get('http_proxy'),
+                    'https_proxy': os.environ.get('https_proxy')
+                }
+                if 'http' in proxies:
+                    os.environ['http_proxy'] = proxies['http']
+                if 'https' in proxies:
+                    os.environ['https_proxy'] = proxies['https']
+            
+            try:
+                # 构建请求头
+                headers = {
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json"
+                }
+                
+                # 处理图像数据
+                if image_data.startswith('data:image'):
+                    # 如果是data URI，提取base64部分
+                    image_data = image_data.split(',', 1)[1]
+                
+                # 构建用户消息 - 使用豆包API官方示例格式
+                # 首先检查图像数据的格式，确保是有效的图像
+                image_format = "jpeg"  # 默认使用jpeg
+                if image_data.startswith('/9j/'):  # JPEG magic number in base64
+                    image_format = "jpeg"
+                elif image_data.startswith('iVBORw0KGgo'):  # PNG magic number in base64
+                    image_format = "png"
+                
+                # 构建消息
+                messages = []
+                
+                # 添加系统提示词
+                if self.system_prompt:
+                    messages.append({
+                        "role": "system",
+                        "content": self.system_prompt
+                    })
+                
+                user_content = [
+                    {
+                        "type": "text",
+                        "text": f"请使用{self.language}分析这张图片并提供详细解答。" if self.language and self.language != 'auto' else "请分析这张图片并提供详细解答?"
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/{image_format};base64,{image_data}"
+                        }
+                    }
+                ]
+                
+                messages.append({
+                    "role": "user",
+                    "content": user_content
+                })
+
+                # 处理推理配置
+                thinking = {
+                    "type": "auto"  # 默认值
+                }
+                
+                if hasattr(self, 'reasoning_config') and self.reasoning_config:
+                    # 从reasoning_config中获取thinking_mode
+                    thinking_mode = self.reasoning_config.get('thinking_mode', "auto")
+                    thinking = {
+                        "type": thinking_mode
+                    }
+                
+                # 构建请求数据
+                data = {
+                    "model": self.get_actual_model_name(),
+                    "messages": messages,
+                    "thinking": thinking,
+                    "temperature": self.temperature,
+                    "max_tokens": self.max_tokens,
+                    "stream": True
+                }
+                
+                # 发送流式请求
+                response = requests.post(
+                    f"{self.base_url}/chat/completions",
+                    headers=headers,
+                    json=data,
+                    stream=True,
+                    proxies=proxies if proxies else None,
+                    timeout=60
+                )
+                
+                if response.status_code != 200:
+                    error_text = response.text
+                    raise Exception(f"HTTP {response.status_code}: {error_text}")
+                
+                response.raise_for_status()
+                
+                # 初始化响应缓冲区
+                response_buffer = ""
+                
+                # 处理流式响应
+                for line in response.iter_lines():
+                    if not line:
+                        continue
+                    
+                    line = line.decode('utf-8')
+                    if not line.startswith('data: '):
+                        continue
+                    
+                    line = line[6:]  # 移除 'data: ' 前缀
+                    
+                    if line == '[DONE]':
+                        break
+                    
+                    try:
+                        chunk_data = json.loads(line)
+                        choices = chunk_data.get('choices', [])
+                        
+                        if choices and len(choices) > 0:
+                            delta = choices[0].get('delta', {})
+                            content = delta.get('content', '')
+                            
+                            if content:
+                                response_buffer += content
+                                
+                                # 发送响应进度
+                                yield {
+                                    "status": "streaming",
+                                    "content": response_buffer
+                                }
+                    
+                    except json.JSONDecodeError:
+                        continue
+                
+                # 确保发送完整的最终内容
+                yield {
+                    "status": "completed",
+                    "content": response_buffer
+                }
+            
+            finally:
+                # 恢复原始代理设置
+                if original_proxies:
+                    for key, value in original_proxies.items():
+                        if value is None:
+                            if key in os.environ:
+                                del os.environ[key]
+                        else:
+                            os.environ[key] = value
+                
+        except Exception as e:
+            yield {
+                "status": "error",
+                "error": f"豆包图像分析错误: {str(e)}"
+            }

models/factory.py

@@ -0,0 +1,277 @@
+from typing import Dict, Type, Any, Optional
+import json
+import os
+import importlib
+from .base import BaseModel
+from .mathpix import MathpixModel  # MathpixModel需要直接导入，因为它是特殊OCR工具
+from .baidu_ocr import BaiduOCRModel  # 百度OCR也是特殊OCR工具，直接导入
+
+class ModelFactory:
+    # 模型基本信息，包含类型和特性
+    _models: Dict[str, Dict[str, Any]] = {}
+    _class_map: Dict[str, Type[BaseModel]] = {}
+    
+    @classmethod
+    def initialize(cls):
+        """从配置文件加载模型信息"""
+        try:
+            config_path = os.path.join(os.path.dirname(__file__), '..', 'config', 'models.json')
+            with open(config_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+            
+            # 加载提供商信息和类映射
+            providers = config.get('providers', {})
+            for provider_id, provider_info in providers.items():
+                class_name = provider_info.get('class_name')
+                if class_name:
+                    # 从当前包动态导入模型类
+                    module = importlib.import_module(f'.{provider_id.lower()}', package=__package__)
+                    cls._class_map[provider_id] = getattr(module, class_name)
+            
+            # 加载模型信息
+            for model_id, model_info in config.get('models', {}).items():
+                provider_id = model_info.get('provider')
+                if provider_id and provider_id in cls._class_map:
+                    cls._models[model_id] = {
+                        'class': cls._class_map[provider_id],
+                        'provider_id': provider_id,
+                        'is_multimodal': model_info.get('supportsMultimodal', False),
+                        'is_reasoning': model_info.get('isReasoning', False),
+                        'display_name': model_info.get('name', model_id),
+                        'description': model_info.get('description', '')
+                    }
+            
+            # 添加特殊OCR工具模型（不在配置文件中定义）
+            
+            # 添加Mathpix OCR工具
+            cls._models['mathpix'] = {
+                'class': MathpixModel,
+                'is_multimodal': True,
+                'is_reasoning': False,
+                'display_name': 'Mathpix OCR',
+                'description': '数学公式识别工具，适用于复杂数学内容',
+                'is_ocr_only': True
+            }
+            
+            # 添加百度OCR工具
+            cls._models['baidu-ocr'] = {
+                'class': BaiduOCRModel,
+                'is_multimodal': True,
+                'is_reasoning': False,
+                'display_name': '百度OCR',
+                'description': '通用文字识别工具，支持中文识别',
+                'is_ocr_only': True
+            }
+            
+            print(f"已从配置加载 {len(cls._models)} 个模型")
+        except Exception as e:
+            print(f"加载模型配置失败: {str(e)}")
+            cls._initialize_defaults()
+    
+    @classmethod
+    def _initialize_defaults(cls):
+        """初始化默认模型（当配置加载失败时）"""
+        print("配置加载失败，使用空模型列表")
+        
+        # 不再硬编码模型定义，而是使用空字典
+        cls._models = {}
+        
+        # 添加特殊OCR工具（当配置加载失败时的备用）
+        try:
+            # 导入并添加Mathpix OCR工具
+            from .mathpix import MathpixModel
+            
+            cls._models['mathpix'] = {
+                'class': MathpixModel,
+                'is_multimodal': True,
+                'is_reasoning': False,
+                'display_name': 'Mathpix OCR',
+                'description': '数学公式识别工具，适用于复杂数学内容',
+                'is_ocr_only': True
+            }
+        except Exception as e:
+            print(f"无法加载Mathpix OCR工具: {str(e)}")
+            
+        # 添加百度OCR工具
+        try:
+            from .baidu_ocr import BaiduOCRModel
+            
+            cls._models['baidu-ocr'] = {
+                'class': BaiduOCRModel,
+                'is_multimodal': True,
+                'is_reasoning': False,
+                'display_name': '百度OCR',
+                'description': '通用文字识别工具，支持中文识别',
+                'is_ocr_only': True
+            }
+        except Exception as e:
+            print(f"无法加载百度OCR工具: {str(e)}")
+
+    @classmethod
+    def create_model(cls, model_name: str, api_key: str, temperature: float = 0.7, 
+                     system_prompt: Optional[str] = None, language: Optional[str] = None, api_base_url: Optional[str] = None) -> BaseModel:
+        """
+        Create a model instance based on the model name.
+        
+        Args:
+            model_name: The identifier for the model
+            api_key: The API key for the model service
+            temperature: The temperature to use for generation
+            system_prompt: The system prompt to use
+            language: The preferred language for responses
+            api_base_url: The base URL for API requests
+            
+        Returns:
+            A model instance
+        """
+        if model_name not in cls._models:
+            raise ValueError(f"Unknown model: {model_name}")
+            
+        model_info = cls._models[model_name]
+        model_class = model_info['class']
+        provider_id = model_info.get('provider_id')
+        
+        if provider_id == 'openai':
+            return model_class(
+                api_key=api_key,
+                temperature=temperature,
+                system_prompt=system_prompt,
+                language=language,
+                api_base_url=api_base_url,
+                model_identifier=model_name
+            )
+        
+        # 对于DeepSeek模型，需要传递正确的模型名称
+        if 'deepseek' in model_name.lower():
+            return model_class(
+                api_key=api_key,
+                temperature=temperature,
+                system_prompt=system_prompt,
+                language=language,
+                model_name=model_name,
+                api_base_url=api_base_url
+            )
+        # 对于阿里巴巴模型，也需要传递正确的模型名称
+        elif 'qwen' in model_name.lower() or 'qvq' in model_name.lower() or 'alibaba' in model_name.lower():
+            return model_class(
+                api_key=api_key,
+                temperature=temperature,
+                system_prompt=system_prompt,
+                language=language,
+                model_name=model_name
+            )
+        # 对于Google模型，也需要传递正确的模型名称
+        elif 'gemini' in model_name.lower() or 'google' in model_name.lower():
+            return model_class(
+                api_key=api_key,
+                temperature=temperature,
+                system_prompt=system_prompt,
+                language=language,
+                model_name=model_name,
+                api_base_url=api_base_url
+            )
+        # 对于豆包模型，也需要传递正确的模型名称
+        elif 'doubao' in model_name.lower():
+            return model_class(
+                api_key=api_key,
+                temperature=temperature,
+                system_prompt=system_prompt,
+                language=language,
+                model_name=model_name,
+                api_base_url=api_base_url
+            )
+        # 对于Mathpix模型，不传递language参数
+        elif model_name == 'mathpix':
+            return model_class(
+                api_key=api_key,
+                temperature=temperature,
+                system_prompt=system_prompt
+            )
+        # 对于百度OCR模型，传递api_key（支持API_KEY:SECRET_KEY格式）
+        elif model_name == 'baidu-ocr':
+            return model_class(
+                api_key=api_key,
+                temperature=temperature,
+                system_prompt=system_prompt
+            )
+        # 对于Anthropic模型，需要传递model_identifier参数
+        elif 'claude' in model_name.lower() or 'anthropic' in model_name.lower():
+            return model_class(
+                api_key=api_key,
+                temperature=temperature,
+                system_prompt=system_prompt,
+                language=language,
+                api_base_url=api_base_url,
+                model_identifier=model_name
+            )
+        else:
+            # 其他模型仅传递标准参数
+            return model_class(
+                api_key=api_key,
+                temperature=temperature,
+                system_prompt=system_prompt,
+                language=language,
+                api_base_url=api_base_url
+            )
+
+    @classmethod
+    def get_available_models(cls) -> list[Dict[str, Any]]:
+        """Return a list of available models with their information"""
+        models_info = []
+        for model_id, info in cls._models.items():
+            # 跳过仅OCR工具模型
+            if info.get('is_ocr_only', False):
+                continue
+                
+            models_info.append({
+                'id': model_id,
+                'display_name': info.get('display_name', model_id),
+                'description': info.get('description', ''),
+                'is_multimodal': info.get('is_multimodal', False),
+                'is_reasoning': info.get('is_reasoning', False)
+            })
+        return models_info
+    
+    @classmethod
+    def get_model_ids(cls) -> list[str]:
+        """Return a list of available model identifiers"""
+        return [model_id for model_id in cls._models.keys() 
+                if not cls._models[model_id].get('is_ocr_only', False)]
+
+    @classmethod
+    def is_multimodal(cls, model_name: str) -> bool:
+        """判断模型是否支持多模态输入"""
+        return cls._models.get(model_name, {}).get('is_multimodal', False)
+    
+    @classmethod
+    def is_reasoning(cls, model_name: str) -> bool:
+        """判断模型是否为推理模型"""
+        return cls._models.get(model_name, {}).get('is_reasoning', False)
+    
+    @classmethod
+    def get_model_display_name(cls, model_name: str) -> str:
+        """获取模型的显示名称"""
+        return cls._models.get(model_name, {}).get('display_name', model_name)
+
+    @classmethod
+    def register_model(cls, model_name: str, model_class: Type[BaseModel], 
+                      is_multimodal: bool = False, is_reasoning: bool = False,
+                      display_name: Optional[str] = None, description: Optional[str] = None) -> None:
+        """
+        Register a new model type with the factory.
+        
+        Args:
+            model_name: The identifier for the model
+            model_class: The model class to register
+            is_multimodal: Whether the model supports image input
+            is_reasoning: Whether the model provides reasoning process
+            display_name: Human-readable name for the model
+            description: Description of the model
+        """
+        cls._models[model_name] = {
+            'class': model_class,
+            'is_multimodal': is_multimodal,
+            'is_reasoning': is_reasoning,
+            'display_name': display_name or model_name,
+            'description': description or ''
+        }

models/google.py

@@ -0,0 +1,250 @@
+import json
+import os
+import base64
+from typing import Generator, Dict, Any, Optional, List
+import google.generativeai as genai
+from .base import BaseModel
+
+class GoogleModel(BaseModel):
+    """
+    Google Gemini API模型实现类
+    支持Gemini 2.5 Pro等模型，可处理文本和图像输入
+    """
+    
+    def __init__(self, api_key: str, temperature: float = 0.7, system_prompt: str = None, language: str = None, model_name: str = None, api_base_url: str = None):
+        """
+        初始化Google模型
+        
+        Args:
+            api_key: Google API密钥
+            temperature: 生成温度
+            system_prompt: 系统提示词
+            language: 首选语言
+            model_name: 指定具体模型名称，如不指定则使用默认值
+            api_base_url: API基础URL，用于设置自定义API端点
+        """
+        super().__init__(api_key, temperature, system_prompt, language)
+        self.model_name = model_name or self.get_model_identifier()
+        self.max_tokens = 8192  # 默认最大输出token数
+        self.api_base_url = api_base_url
+        
+        # 配置Google API
+        if api_base_url:
+            # 配置中转API - 使用环境变量方式
+            # 移除末尾的斜杠以避免重复路径问题
+            clean_base_url = api_base_url.rstrip('/')
+            # 设置环境变量来指定API端点
+            os.environ['GOOGLE_AI_API_ENDPOINT'] = clean_base_url
+            genai.configure(api_key=api_key)
+        else:
+            # 使用默认API端点
+            # 清除可能存在的自定义端点环境变量
+            if 'GOOGLE_AI_API_ENDPOINT' in os.environ:
+                del os.environ['GOOGLE_AI_API_ENDPOINT']
+            genai.configure(api_key=api_key)
+    
+    def get_default_system_prompt(self) -> str:
+        return """You are an expert at analyzing questions and providing detailed solutions. When presented with an image of a question:
+1. First read and understand the question carefully
+2. Break down the key components of the question
+3. Provide a clear, step-by-step solution
+4. If relevant, explain any concepts or theories involved
+5. If there are multiple approaches, explain the most efficient one first"""
+
+    def get_model_identifier(self) -> str:
+        """返回默认的模型标识符"""
+        return "gemini-2.0-flash"  # 使用有免费配额的模型作为默认值
+    
+    def analyze_text(self, text: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """流式生成文本响应"""
+        try:
+            yield {"status": "started"}
+            
+            # 设置环境变量代理（如果提供）
+            original_proxies = None
+            if proxies:
+                original_proxies = {
+                    'http_proxy': os.environ.get('http_proxy'),
+                    'https_proxy': os.environ.get('https_proxy')
+                }
+                if 'http' in proxies:
+                    os.environ['http_proxy'] = proxies['http']
+                if 'https' in proxies:
+                    os.environ['https_proxy'] = proxies['https']
+            
+            try:
+                # 初始化模型
+                model = genai.GenerativeModel(self.model_name)
+                
+                # 获取最大输出Token设置
+                max_tokens = self.max_tokens if hasattr(self, 'max_tokens') else 8192
+                
+                # 创建配置参数
+                generation_config = {
+                    'temperature': self.temperature,
+                    'max_output_tokens': max_tokens,
+                    'top_p': 0.95,
+                    'top_k': 64,
+                }
+                
+                # 构建提示
+                prompt_parts = []
+                
+                # 添加系统提示词
+                if self.system_prompt:
+                    prompt_parts.append(self.system_prompt)
+                
+                # 添加用户查询
+                if self.language and self.language != 'auto':
+                    prompt_parts.append(f"请使用{self.language}回答以下问题: {text}")
+                else:
+                    prompt_parts.append(text)
+                
+                # 初始化响应缓冲区
+                response_buffer = ""
+                
+                # 流式生成响应
+                response = model.generate_content(
+                    prompt_parts,
+                    generation_config=generation_config,
+                    stream=True
+                )
+                
+                for chunk in response:
+                    if not chunk.text:
+                        continue
+                    
+                    # 累积响应文本
+                    response_buffer += chunk.text
+                    
+                    # 发送响应进度
+                    if len(chunk.text) >= 10 or chunk.text.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                        yield {
+                            "status": "streaming",
+                            "content": response_buffer
+                        }
+                
+                # 确保发送完整的最终内容
+                yield {
+                    "status": "completed",
+                    "content": response_buffer
+                }
+            
+            finally:
+                # 恢复原始代理设置
+                if original_proxies:
+                    for key, value in original_proxies.items():
+                        if value is None:
+                            if key in os.environ:
+                                del os.environ[key]
+                        else:
+                            os.environ[key] = value
+                
+        except Exception as e:
+            yield {
+                "status": "error",
+                "error": f"Gemini API错误: {str(e)}"
+            }
+    
+    def analyze_image(self, image_data: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """分析图像并流式生成响应"""
+        try:
+            yield {"status": "started"}
+            
+            # 设置环境变量代理（如果提供）
+            original_proxies = None
+            if proxies:
+                original_proxies = {
+                    'http_proxy': os.environ.get('http_proxy'),
+                    'https_proxy': os.environ.get('https_proxy')
+                }
+                if 'http' in proxies:
+                    os.environ['http_proxy'] = proxies['http']
+                if 'https' in proxies:
+                    os.environ['https_proxy'] = proxies['https']
+            
+            try:
+                # 初始化模型
+                model = genai.GenerativeModel(self.model_name)
+                
+                # 获取最大输出Token设置
+                max_tokens = self.max_tokens if hasattr(self, 'max_tokens') else 8192
+                
+                # 创建配置参数
+                generation_config = {
+                    'temperature': self.temperature,
+                    'max_output_tokens': max_tokens,
+                    'top_p': 0.95,
+                    'top_k': 64,
+                }
+                
+                # 构建提示词
+                prompt_parts = []
+                
+                # 添加系统提示词
+                if self.system_prompt:
+                    prompt_parts.append(self.system_prompt)
+                
+                # 添加默认图像分析指令
+                if self.language and self.language != 'auto':
+                    prompt_parts.append(f"请使用{self.language}分析这张图片并提供详细解答。")
+                else:
+                    prompt_parts.append("请分析这张图片并提供详细解答。")
+                
+                # 处理图像数据
+                if image_data.startswith('data:image'):
+                    # 如果是data URI，提取base64部分
+                    image_data = image_data.split(',', 1)[1]
+                
+                # 使用genai的特定方法处理图像
+                image_part = {
+                    "mime_type": "image/jpeg",
+                    "data": base64.b64decode(image_data)
+                }
+                prompt_parts.append(image_part)
+                
+                # 初始化响应缓冲区
+                response_buffer = ""
+                
+                # 流式生成响应
+                response = model.generate_content(
+                    prompt_parts,
+                    generation_config=generation_config,
+                    stream=True
+                )
+                
+                for chunk in response:
+                    if not chunk.text:
+                        continue
+                    
+                    # 累积响应文本
+                    response_buffer += chunk.text
+                    
+                    # 发送响应进度
+                    if len(chunk.text) >= 10 or chunk.text.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                        yield {
+                            "status": "streaming",
+                            "content": response_buffer
+                        }
+                
+                # 确保发送完整的最终内容
+                yield {
+                    "status": "completed",
+                    "content": response_buffer
+                }
+            
+            finally:
+                # 恢复原始代理设置
+                if original_proxies:
+                    for key, value in original_proxies.items():
+                        if value is None:
+                            if key in os.environ:
+                                del os.environ[key]
+                        else:
+                            os.environ[key] = value
+                
+        except Exception as e:
+            yield {
+                "status": "error",
+                "error": f"Gemini图像分析错误: {str(e)}"
+            } 

models/mathpix.py

@@ -0,0 +1,362 @@
+from typing import Generator, Dict, Any
+import json
+import requests
+from .base import BaseModel
+
+class MathpixModel(BaseModel):
+    """
+    Mathpix OCR model for processing images containing mathematical formulas,
+    text, and tables.
+    """
+    
+    def __init__(self, api_key: str, temperature: float = 0.7, system_prompt: str = None):
+        """
+        Initialize the Mathpix model.
+        
+        Args:
+            api_key: Mathpix API key in format "app_id:app_key"
+            temperature: Not used for Mathpix but kept for BaseModel compatibility
+            system_prompt: Not used for Mathpix but kept for BaseModel compatibility
+            
+        Raises:
+            ValueError: If the API key format is invalid
+        """
+        # 只传递必需的参数，不传递language参数
+        super().__init__(api_key, temperature, system_prompt)
+        try:
+            self.app_id, self.app_key = api_key.split(':')
+        except ValueError:
+            raise ValueError("Mathpix API key must be in format 'app_id:app_key'")
+        
+        self.api_url = "https://api.mathpix.com/v3/text"
+        self.headers = {
+            "app_id": self.app_id,
+            "app_key": self.app_key,
+            "Content-Type": "application/json"
+        }
+        
+        # Content type presets
+        self.presets = {
+            "math": {
+                "formats": ["latex_normal", "latex_styled", "asciimath"],
+                "data_options": {
+                    "include_asciimath": True,
+                    "include_latex": True,
+                    "include_mathml": True
+                },
+                "ocr_options": {
+                    "detect_formulas": True,
+                    "enable_math_ocr": True,
+                    "enable_handwritten": True,
+                    "rm_spaces": True
+                }
+            },
+            "text": {
+                "formats": ["text"],
+                "data_options": {
+                    "include_latex": False,
+                    "include_asciimath": False
+                },
+                "ocr_options": {
+                    "enable_spell_check": True,
+                    "enable_handwritten": True,
+                    "rm_spaces": False
+                }
+            },
+            "table": {
+                "formats": ["text", "data"],
+                "data_options": {
+                    "include_latex": True
+                },
+                "ocr_options": {
+                    "detect_tables": True,
+                    "enable_spell_check": True,
+                    "rm_spaces": True
+                }
+            },
+            "full_text": {
+                "formats": ["text"],
+                "data_options": {
+                    "include_latex": False,
+                    "include_asciimath": False
+                },
+                "ocr_options": {
+                    "enable_spell_check": True,
+                    "enable_handwritten": True,
+                    "rm_spaces": False,
+                    "detect_paragraphs": True,
+                    "enable_tables": False,
+                    "enable_math_ocr": False
+                }
+            }
+        }
+        
+        # Default to math preset
+        self.current_preset = "math"
+
+    def analyze_image(self, image_data: str, proxies: dict = None, content_type: str = None, 
+                     confidence_threshold: float = 0.8, max_retries: int = 3) -> Generator[dict, None, None]:
+        """
+        Analyze an image using Mathpix OCR API.
+        
+        Args:
+            image_data: Base64 encoded image data
+            proxies: Optional proxy configuration
+            content_type: Type of content to analyze ('math', 'text', or 'table')
+            confidence_threshold: Minimum confidence score to accept (0.0 to 1.0)
+            max_retries: Maximum number of retry attempts for failed requests
+            
+        Yields:
+            dict: Response chunks with status and content
+        """
+        if content_type and content_type in self.presets:
+            self.current_preset = content_type
+
+        preset = self.presets[self.current_preset]
+        
+        try:
+            # Prepare request payload
+            payload = {
+                "src": f"data:image/jpeg;base64,{image_data}",
+                "formats": preset["formats"],
+                "data_options": preset["data_options"],
+                "ocr_options": preset["ocr_options"]
+            }
+            
+            # Initialize retry counter
+            retry_count = 0
+            
+            while retry_count < max_retries:
+                try:
+                    # Send request to Mathpix API with timeout
+                    response = requests.post(
+                        self.api_url,
+                        headers=self.headers,
+                        json=payload,
+                        proxies=proxies,
+                        timeout=25  # 25 second timeout
+                    )
+                    
+                    # Handle specific API error codes
+                    if response.status_code == 429:  # Rate limit exceeded
+                        if retry_count < max_retries - 1:
+                            retry_count += 1
+                            continue
+                        else:
+                            raise requests.exceptions.RequestException("Rate limit exceeded")
+                    
+                    response.raise_for_status()
+                    result = response.json()
+                    
+                    # Check confidence threshold
+                    if 'confidence' in result and result['confidence'] < confidence_threshold:
+                        yield {
+                            "status": "warning",
+                            "content": f"Low confidence score: {result['confidence']:.2%}"
+                        }
+                    
+                    break  # Success, exit retry loop
+                    
+                except (requests.exceptions.Timeout, requests.exceptions.ConnectionError):
+                    if retry_count < max_retries - 1:
+                        retry_count += 1
+                        continue
+                    raise
+            
+            # Format the response
+            formatted_response = self._format_response(result)
+            
+            # Yield initial status
+            yield {
+                "status": "started",
+                "content": ""
+            }
+            
+            # Yield the formatted response
+            yield {
+                "status": "completed",
+                "content": formatted_response,
+                "model": self.get_model_identifier()
+            }
+            
+        except requests.exceptions.RequestException as e:
+            yield {
+                "status": "error",
+                "error": f"Mathpix API error: {str(e)}"
+            }
+        except Exception as e:
+            yield {
+                "status": "error",
+                "error": f"Error processing image: {str(e)}"
+            }
+
+    def analyze_text(self, text: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """
+        Not implemented for Mathpix model as it only processes images.
+        """
+        yield {
+            "status": "error",
+            "error": "Text analysis is not supported by Mathpix model"
+        }
+
+    def get_default_system_prompt(self) -> str:
+        """
+        Not used for Mathpix model.
+        """
+        return ""
+
+    def get_model_identifier(self) -> str:
+        """
+        Return the model identifier.
+        """
+        return "mathpix"
+
+    def _format_response(self, result: Dict[str, Any]) -> str:
+        """
+        Format the Mathpix API response into a readable string.
+        
+        Args:
+            result: Raw API response from Mathpix
+            
+        Returns:
+            str: Formatted response string with all available formats
+        """
+        formatted_parts = []
+        
+        # Add confidence score if available
+        if 'confidence' in result:
+            formatted_parts.append(f"Confidence: {result['confidence']:.2%}\n")
+        
+        # Add text content
+        if 'text' in result:
+            formatted_parts.append("Text Content:")
+            formatted_parts.append(result['text'])
+            formatted_parts.append("")
+        
+        # Add LaTeX content
+        if 'latex_normal' in result:
+            formatted_parts.append("LaTeX (Normal):")
+            formatted_parts.append(result['latex_normal'])
+            formatted_parts.append("")
+            
+        if 'latex_styled' in result:
+            formatted_parts.append("LaTeX (Styled):")
+            formatted_parts.append(result['latex_styled'])
+            formatted_parts.append("")
+        
+        # Add data formats (ASCII math, MathML)
+        if 'data' in result and isinstance(result['data'], list):
+            for item in result['data']:
+                item_type = item.get('type', '')
+                if item_type and 'value' in item:
+                    formatted_parts.append(f"{item_type.upper()}:")
+                    formatted_parts.append(item['value'])
+                    formatted_parts.append("")
+        
+        # Add table data if present
+        if 'tables' in result and result['tables']:
+            formatted_parts.append("Tables Detected:")
+            for i, table in enumerate(result['tables'], 1):
+                formatted_parts.append(f"Table {i}:")
+                if 'cells' in table:
+                    # Format table as a grid
+                    cells = table['cells']
+                    if cells:
+                        max_col = max(cell.get('col', 0) for cell in cells) + 1
+                        max_row = max(cell.get('row', 0) for cell in cells) + 1
+                        grid = [['' for _ in range(max_col)] for _ in range(max_row)]
+                        
+                        for cell in cells:
+                            row = cell.get('row', 0)
+                            col = cell.get('col', 0)
+                            text = cell.get('text', '')
+                            grid[row][col] = text
+                        
+                        # Format grid as table
+                        col_widths = [max(len(str(grid[r][c])) for r in range(max_row)) for c in range(max_col)]
+                        for row in grid:
+                            row_str = ' | '.join(f"{str(cell):<{width}}" for cell, width in zip(row, col_widths))
+                            formatted_parts.append(f"| {row_str} |")
+                formatted_parts.append("")
+        
+        # Add error message if present
+        if 'error' in result:
+            error_msg = result['error']
+            if isinstance(error_msg, dict):
+                error_msg = error_msg.get('message', str(error_msg))
+            formatted_parts.append(f"Error: {error_msg}")
+        
+        return "\n".join(formatted_parts).strip()
+
+    def extract_full_text(self, image_data: str, proxies: dict = None, max_retries: int = 3) -> str:
+        """
+        专门用于提取图像中的全部文本内容，忽略数学公式和表格等其他元素。
+        
+        Args:
+            image_data: Base64编码的图像数据
+            proxies: 可选的代理配置
+            max_retries: 请求失败时的最大重试次数
+            
+        Returns:
+            str: 图像中提取的完整文本内容
+        """
+        try:
+            # 准备请求负载，使用专为全文提取配置的参数
+            payload = {
+                "src": f"data:image/jpeg;base64,{image_data}",
+                "formats": ["text"],
+                "data_options": {
+                    "include_latex": False,
+                    "include_asciimath": False
+                },
+                "ocr_options": {
+                    "enable_spell_check": True,
+                    "enable_handwritten": True,
+                    "rm_spaces": False,
+                    "detect_paragraphs": True,
+                    "enable_tables": False,
+                    "enable_math_ocr": False
+                }
+            }
+            
+            # 初始化重试计数器
+            retry_count = 0
+            
+            while retry_count < max_retries:
+                try:
+                    # 发送请求到Mathpix API
+                    response = requests.post(
+                        self.api_url,
+                        headers=self.headers,
+                        json=payload,
+                        proxies=proxies,
+                        timeout=30  # 30秒超时
+                    )
+                    
+                    # 处理特定API错误代码
+                    if response.status_code == 429:  # 超出速率限制
+                        if retry_count < max_retries - 1:
+                            retry_count += 1
+                            continue
+                        else:
+                            raise requests.exceptions.RequestException("超出API速率限制")
+                    
+                    response.raise_for_status()
+                    result = response.json()
+                    
+                    # 直接返回文本内容
+                    if 'text' in result:
+                        return result['text']
+                    else:
+                        return "未能提取到文本内容"
+                    
+                except (requests.exceptions.Timeout, requests.exceptions.ConnectionError):
+                    if retry_count < max_retries - 1:
+                        retry_count += 1
+                        continue
+                    raise
+            
+        except requests.exceptions.RequestException as e:
+            return f"Mathpix API错误: {str(e)}"
+        except Exception as e:
+            return f"处理图像时出错: {str(e)}"

models/openai.py

@@ -0,0 +1,219 @@
+import os
+from typing import Generator, Dict, Optional
+from openai import OpenAI
+from .base import BaseModel
+
+class OpenAIModel(BaseModel):
+    def __init__(self, api_key, temperature=0.7, system_prompt=None, language=None, api_base_url=None, model_identifier=None):
+        super().__init__(api_key, temperature, system_prompt, language)
+        # 设置API基础URL，默认为OpenAI官方API
+        self.api_base_url = api_base_url
+        # 允许从外部配置显式指定模型标识符
+        self.model_identifier = model_identifier or "gpt-4o-2024-11-20"
+        
+    def get_default_system_prompt(self) -> str:
+        return """You are an expert at analyzing questions and providing detailed solutions. When presented with an image of a question:
+1. First read and understand the question carefully
+2. Break down the key components of the question
+3. Provide a clear, step-by-step solution
+4. If relevant, explain any concepts or theories involved
+5. If there are multiple approaches, explain the most efficient one first"""
+
+    def get_model_identifier(self) -> str:
+        return self.model_identifier
+
+    def analyze_text(self, text: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """Stream GPT-4o's response for text analysis"""
+        try:
+            # Initial status
+            yield {"status": "started", "content": ""}
+
+            # Save original environment state
+            original_env = {
+                'http_proxy': os.environ.get('http_proxy'),
+                'https_proxy': os.environ.get('https_proxy')
+            }
+
+            try:
+                # Set proxy environment variables if provided
+                if proxies:
+                    if 'http' in proxies:
+                        os.environ['http_proxy'] = proxies['http']
+                    if 'https' in proxies:
+                        os.environ['https_proxy'] = proxies['https']
+
+                # Initialize OpenAI client with base_url if provided
+                if self.api_base_url:
+                    client = OpenAI(api_key=self.api_key, base_url=self.api_base_url)
+                else:
+                    client = OpenAI(api_key=self.api_key)
+
+                # Prepare messages
+                messages = [
+                    {
+                        "role": "system",
+                        "content": self.system_prompt
+                    },
+                    {
+                        "role": "user",
+                        "content": text
+                    }
+                ]
+
+                response = client.chat.completions.create(
+                    model=self.get_model_identifier(),
+                    messages=messages,
+                    temperature=self.temperature,
+                    stream=True,
+                    max_tokens=4000
+                )
+
+                # 使用累积缓冲区
+                response_buffer = ""
+                
+                for chunk in response:
+                    if hasattr(chunk.choices[0].delta, 'content'):
+                        content = chunk.choices[0].delta.content
+                        if content:
+                            # 累积内容
+                            response_buffer += content
+                            
+                            # 只在累积一定数量的字符或遇到句子结束标记时才发送
+                            if len(content) >= 10 or content.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                yield {
+                                    "status": "streaming",
+                                    "content": response_buffer
+                                }
+
+                # 确保发送最终完整内容
+                if response_buffer:
+                    yield {
+                        "status": "streaming",
+                        "content": response_buffer
+                    }
+
+                # Send completion status
+                yield {
+                    "status": "completed",
+                    "content": response_buffer
+                }
+
+            finally:
+                # Restore original environment state
+                for key, value in original_env.items():
+                    if value is None:
+                        if key in os.environ:
+                            del os.environ[key]
+                    else:
+                        os.environ[key] = value
+
+        except Exception as e:
+            yield {
+                "status": "error",
+                "error": str(e)
+            }
+
+    def analyze_image(self, image_data: str, proxies: dict = None) -> Generator[dict, None, None]:
+        """Stream GPT-4o's response for image analysis"""
+        try:
+            # Initial status
+            yield {"status": "started", "content": ""}
+
+            # Save original environment state
+            original_env = {
+                'http_proxy': os.environ.get('http_proxy'),
+                'https_proxy': os.environ.get('https_proxy')
+            }
+
+            try:
+                # Set proxy environment variables if provided
+                if proxies:
+                    if 'http' in proxies:
+                        os.environ['http_proxy'] = proxies['http']
+                    if 'https' in proxies:
+                        os.environ['https_proxy'] = proxies['https']
+
+                # Initialize OpenAI client with base_url if provided
+                if self.api_base_url:
+                    client = OpenAI(api_key=self.api_key, base_url=self.api_base_url)
+                else:
+                    client = OpenAI(api_key=self.api_key)
+
+                # 使用系统提供的系统提示词，不再自动添加语言指令
+                system_prompt = self.system_prompt
+
+                # Prepare messages with image
+                messages = [
+                    {
+                        "role": "system",
+                        "content": system_prompt
+                    },
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/jpeg;base64,{image_data}"
+                                }
+                            },
+                            {
+                                "type": "text",
+                                "text": "Please analyze this image and provide a detailed solution."
+                            }
+                        ]
+                    }
+                ]
+
+                response = client.chat.completions.create(
+                    model=self.get_model_identifier(),
+                    messages=messages,
+                    temperature=self.temperature,
+                    stream=True,
+                    max_tokens=4000
+                )
+
+                # 使用累积缓冲区
+                response_buffer = ""
+                
+                for chunk in response:
+                    if hasattr(chunk.choices[0].delta, 'content'):
+                        content = chunk.choices[0].delta.content
+                        if content:
+                            # 累积内容
+                            response_buffer += content
+                            
+                            # 只在累积一定数量的字符或遇到句子结束标记时才发送
+                            if len(content) >= 10 or content.endswith(('.', '!', '?', '。', '！', '？', '\n')):
+                                yield {
+                                    "status": "streaming",
+                                    "content": response_buffer
+                                }
+
+                # 确保发送最终完整内容
+                if response_buffer:
+                    yield {
+                        "status": "streaming",
+                        "content": response_buffer
+                    }
+
+                # Send completion status
+                yield {
+                    "status": "completed",
+                    "content": response_buffer
+                }
+
+            finally:
+                # Restore original environment state
+                for key, value in original_env.items():
+                    if value is None:
+                        if key in os.environ:
+                            del os.environ[key]
+                    else:
+                        os.environ[key] = value
+
+        except Exception as e:
+            yield {
+                "status": "error",
+                "error": str(e)
+            }

requirements.txt

@@ -1,6 +1,10 @@
-faicons
-shiny
-shinywidgets
-plotly
-pandas
-ridgeplot
+flask==3.1.0
+pyautogui==0.9.54
+pyperclip==1.8.2
+Pillow==11.1.0
+flask-socketio==5.5.1
+python-engineio==4.11.2
+python-socketio==5.12.1
+requests==2.32.3
+openai==1.61.0
+google-generativeai==0.7.0

shared.py

@@ -1,6 +0,0 @@
-from pathlib import Path
-
-import pandas as pd
-
-app_dir = Path(__file__).parent
-tips = pd.read_csv(app_dir / "tips.csv")

static/js/main.js

@@ -0,0 +1,2247 @@
+class SnapSolver {
+    constructor() {
+        console.log('Creating SnapSolver instance...');
+        
+        // 初始化属性
+        this.socket = null;
+        this.socketId = null;
+        this.isProcessing = false;
+        this.cropper = null;
+        this.autoScrollInterval = null;
+        this.capturedImage = null; // 存储截图的base64数据
+        this.userThinkingExpanded = false; // 用户思考过程展开状态偏好
+        this.originalImage = null;
+        this.croppedImage = null;
+        this.extractedContent = '';
+        this.eventsSetup = false;
+        
+        // Cache DOM elements
+        this.captureBtn = document.getElementById('captureBtn');
+        // 移除裁剪按钮引用
+        this.screenshotImg = document.getElementById('screenshotImg');
+        this.imagePreview = document.getElementById('imagePreview');
+        this.emptyState = document.getElementById('emptyState');
+        this.extractedText = document.getElementById('extractedText');
+        this.cropContainer = document.getElementById('cropContainer');
+        this.sendToClaudeBtn = document.getElementById('sendToClaude');
+        this.extractTextBtn = document.getElementById('extractText');
+        this.sendExtractedTextBtn = document.getElementById('sendExtractedText');
+        this.claudePanel = document.getElementById('claudePanel');
+        this.responseContent = document.getElementById('responseContent');
+        this.thinkingContent = document.getElementById('thinkingContent');
+        this.thinkingSection = document.getElementById('thinkingSection');
+        this.thinkingToggle = document.getElementById('thinkingToggle');
+        this.connectionStatus = document.getElementById('connectionStatus');
+        this.statusLight = document.querySelector('.status-light');
+        this.progressLine = document.querySelector('.progress-line');
+        this.statusText = document.querySelector('.status-text');
+        this.analysisIndicator = document.querySelector('.analysis-indicator');
+        this.clipboardTextarea = document.getElementById('clipboardText');
+        this.clipboardSendButton = document.getElementById('clipboardSend');
+        this.clipboardReadButton = document.getElementById('clipboardRead');
+        this.clipboardStatus = document.getElementById('clipboardStatus');
+        
+        // Crop elements
+        this.cropCancel = document.getElementById('cropCancel');
+        this.cropConfirm = document.getElementById('cropConfirm');
+        this.cropSendToAI = document.getElementById('cropSendToAI');
+        
+        // 初始化应用
+        this.initialize();
+    }
+
+    initializeElements() {
+        // 查找主要UI元素
+        this.connectionStatus = document.getElementById('connectionStatus');
+        this.captureBtn = document.getElementById('captureBtn');
+        this.emptyState = document.getElementById('emptyState');
+        this.imagePreview = document.getElementById('imagePreview');
+        this.screenshotImg = document.getElementById('screenshotImg');
+        this.sendToClaudeBtn = document.getElementById('sendToClaude');
+        this.extractTextBtn = document.getElementById('extractText');
+        this.extractedText = document.getElementById('extractedText');
+        this.sendExtractedTextBtn = document.getElementById('sendExtractedText');
+        this.claudePanel = document.getElementById('claudePanel');
+        this.closeClaudePanel = document.getElementById('closeClaudePanel');
+        this.thinkingSection = document.getElementById('thinkingSection');
+        this.thinkingToggle = document.getElementById('thinkingToggle');
+        this.thinkingContent = document.getElementById('thinkingContent');
+        this.responseContent = document.getElementById('responseContent');
+        this.cropContainer = document.getElementById('cropContainer');
+        this.cropCancel = document.getElementById('cropCancel');
+        this.cropConfirm = document.getElementById('cropConfirm');
+        this.cropSendToAI = document.getElementById('cropSendToAI');
+        this.stopGenerationBtn = document.getElementById('stopGenerationBtn');
+        this.clipboardTextarea = document.getElementById('clipboardText');
+        this.clipboardSendButton = document.getElementById('clipboardSend');
+        this.clipboardReadButton = document.getElementById('clipboardRead');
+        this.clipboardStatus = document.getElementById('clipboardStatus');
+        
+        // 处理按钮事件
+        if (this.closeClaudePanel) {
+            this.closeClaudePanel.addEventListener('click', () => {
+                this.claudePanel.classList.add('hidden');
+            });
+        }
+        
+        // 处理停止生成按钮点击事件
+        if (this.stopGenerationBtn) {
+            this.stopGenerationBtn.addEventListener('click', () => {
+                this.stopGeneration();
+            });
+        }
+    }
+
+    initializeState() {
+        this.socket = null;
+        this.cropper = null;
+        this.croppedImage = null;
+        this.extractedContent = '';
+        
+        // 确保裁剪容器和其他面板初始为隐藏状态
+        if (this.cropContainer) {
+            this.cropContainer.classList.add('hidden');
+        }
+        if (this.claudePanel) {
+            this.claudePanel.classList.add('hidden');
+        }
+        if (this.thinkingSection) {
+            this.thinkingSection.classList.add('hidden');
+        }
+    }
+
+    setupAutoScroll() {
+        // Create MutationObserver to watch for content changes
+        const observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === 'characterData' || mutation.type === 'childList') {
+                    this.responseContent.scrollTo({
+                        top: this.responseContent.scrollHeight,
+                        behavior: 'smooth'
+                    });
+                }
+            });
+        });
+
+        // Start observing the response content
+        observer.observe(this.responseContent, {
+            childList: true,
+            characterData: true,
+            subtree: true
+        });
+    }
+
+    updateConnectionStatus(status, isConnected) {
+        if (this.connectionStatus) {
+            this.connectionStatus.textContent = status;
+            
+            if (isConnected) {
+                this.connectionStatus.classList.remove('disconnected');
+                this.connectionStatus.classList.add('connected');
+            } else {
+                this.connectionStatus.classList.remove('connected');
+                this.connectionStatus.classList.add('disconnected');
+            }
+        }
+    }
+
+    updateStatusLight(status) {
+        // 获取进度指示器元素
+        const progressLine = document.querySelector('.progress-line');
+        const statusText = document.querySelector('.status-text');
+        const analysisIndicator = document.querySelector('.analysis-indicator');
+        
+        if (!progressLine || !statusText || !analysisIndicator) {
+            console.error('状态指示器元素未找到:', {
+                progressLine: !!progressLine,
+                statusText: !!statusText,
+                analysisIndicator: !!analysisIndicator
+            });
+            return;
+        }
+        
+        // 确保指示器可见
+        analysisIndicator.style.display = 'flex';
+        
+        // 先移除所有可能的状态类
+        analysisIndicator.classList.remove('processing', 'completed', 'error');
+        progressLine.classList.remove('processing', 'completed', 'error');
+        
+        switch (status) {
+            case 'started':
+            case 'thinking':
+            case 'reasoning':
+            case 'streaming':
+                // 添加处理中状态类
+                analysisIndicator.classList.add('processing');
+                progressLine.classList.add('processing');
+                statusText.textContent = '生成中';
+                break;
+                
+            case 'completed':
+                // 添加完成状态类
+                analysisIndicator.classList.add('completed');
+                progressLine.classList.add('completed');
+                statusText.textContent = '完成';
+                break;
+                
+            case 'error':
+                // 添加错误状态类
+                analysisIndicator.classList.add('error');
+                progressLine.classList.add('error');
+                statusText.textContent = '出错';
+                break;
+                
+            case 'stopped':
+                // 添加错误状态类（用于停止状态）
+                analysisIndicator.classList.add('error');
+                progressLine.classList.add('error');
+                statusText.textContent = '已停止';
+                break;
+                
+            default:
+                // 对于未知状态，显示准备中
+                statusText.textContent = '准备中';
+                break;
+        }
+    }
+
+    initializeConnection() {
+        try {
+            // 添加日志以便调试
+            console.log('尝试连接WebSocket服务器...');
+            
+            // 确保在Safari上使用完整的URL
+            const socketUrl = window.location.protocol === 'https:' 
+                ? `${window.location.origin}` 
+                : window.location.origin;
+                
+            console.log('WebSocket连接URL:', socketUrl);
+            
+            this.socket = io(socketUrl, {
+                reconnection: true,
+                reconnectionAttempts: 5,
+                reconnectionDelay: 1000,
+                reconnectionDelayMax: 5000,
+                timeout: 20000,
+                autoConnect: true,
+                transports: ['websocket', 'polling'] // 明确指定传输方式，增加兼容性
+            });
+
+            this.socket.on('connect', () => {
+                console.log('Connected to server');
+                this.updateConnectionStatus('已连接', true);
+                this.captureBtn.disabled = false;
+            });
+
+            this.socket.on('disconnect', () => {
+                console.log('Disconnected from server');
+                this.updateConnectionStatus('已断开', false);
+            });
+
+            this.socket.on('connect_error', (error) => {
+                console.error('Connection error:', error);
+                this.updateConnectionStatus('连接错误', false);
+            });
+
+            this.socket.on('reconnect', (attemptNumber) => {
+                console.log(`Reconnected after ${attemptNumber} attempts`);
+                this.updateConnectionStatus('已重连', true);
+            });
+
+            this.socket.on('reconnect_attempt', (attemptNumber) => {
+                console.log(`Reconnection attempt: ${attemptNumber}`);
+            });
+
+            this.socket.on('reconnect_error', (error) => {
+                console.error('Reconnection error:', error);
+            });
+
+            this.socket.on('reconnect_failed', () => {
+                console.error('Failed to reconnect');
+                window.uiManager.showToast('Connection to server failed, please refresh the page and try again', 'error');
+            });
+
+            this.setupSocketEventHandlers();
+
+        } catch (error) {
+            console.error('Connection error:', error);
+            this.updateConnectionStatus('重连失败', false);
+            // 移除setTimeout，让用户手动刷新页面重连
+            window.uiManager.showToast('连接服务器失败，请刷新页面重试', 'error');
+        }
+    }
+
+    setupSocketEventHandlers() {
+        // 如果已经设置过事件处理器，先移除它们
+        if (this.hasOwnProperty('eventsSetup') && this.eventsSetup) {
+            this.socket.off('screenshot_response');
+            this.socket.off('screenshot_complete');
+            this.socket.off('request_acknowledged');
+            this.socket.off('text_extracted');
+            this.socket.off('ai_response');
+        }
+        
+        // 标记事件处理器已设置
+        this.eventsSetup = true;
+        
+        // 添加响应计数器
+        if (!window.responseCounter) {
+            window.responseCounter = 0;
+        }
+        
+        // 旧版截图响应处理器 (保留兼容性)
+        this.socket.on('screenshot_response', (data) => {
+            // 增加计数并记录
+            window.responseCounter++;
+            console.log(`DEBUG: 接收到screenshot_response响应，计数 = ${window.responseCounter}`);
+            
+            if (data.success) {
+                this.screenshotImg.src = `data:image/png;base64,${data.image}`;
+                this.originalImage = `data:image/png;base64,${data.image}`;
+                this.imagePreview.classList.remove('hidden');
+                this.emptyState.classList.add('hidden');
+                
+                // 根据模型类型显示适当的按钮
+                this.updateImageActionButtons();
+                
+                // 恢复按钮状态
+                this.captureBtn.disabled = false;
+                this.captureBtn.innerHTML = '<i class="fas fa-camera"></i>';
+                
+                // 初始化裁剪器
+                this.initializeCropper();
+                
+                window.uiManager.showToast('截图成功', 'success');
+            } else {
+                this.captureBtn.disabled = false;
+                this.captureBtn.innerHTML = '<i class="fas fa-camera"></i>';
+                console.error('截图失败:', data.error);
+                window.uiManager.showToast('截图失败: ' + data.error, 'error');
+            }
+        });
+        
+        // 新版截图响应处理器
+        this.socket.on('screenshot_complete', (data) => {
+            // 增加计数并记录
+            window.responseCounter++;
+            console.log(`DEBUG: 接收到screenshot_complete响应，计数 = ${window.responseCounter}`);
+            
+            this.captureBtn.disabled = false;
+            this.captureBtn.innerHTML = '<i class="fas fa-camera"></i>';
+            
+            if (data.success) {
+                // 显示截图预览
+                this.screenshotImg.src = 'data:image/png;base64,' + data.image;
+                this.originalImage = 'data:image/png;base64,' + data.image;
+                this.imagePreview.classList.remove('hidden');
+                this.emptyState.classList.add('hidden');
+                
+                // 根据模型类型显示适当的按钮
+                this.updateImageActionButtons();
+                
+                // 初始化裁剪工具
+                this.initializeCropper();
+                
+                // 显示成功消息
+                window.uiManager.showToast('截图成功', 'success');
+            } else {
+                // 显示错误消息
+                window.uiManager.showToast('截图失败: ' + (data.error || '未知错误'), 'error');
+            }
+        });
+
+        // 确认请求处理
+        this.socket.on('request_acknowledged', (data) => {
+            console.log('服务器确认收到请求:', data);
+        });
+
+        // Text extraction response
+        this.socket.on('text_extracted', (data) => {
+            // 重新启用按钮
+            this.extractTextBtn.disabled = false;
+            this.extractTextBtn.innerHTML = '<i class="fas fa-font"></i><span>提取文本</span>';
+            
+            if (this.extractedText) {
+                this.extractedText.disabled = false;
+            }
+            
+            // 检查是否有内容数据
+            if (data.content) {
+                this.extractedText.value = data.content;
+                this.extractedContent = data.content;
+                this.extractedText.classList.remove('hidden');
+                this.sendExtractedTextBtn.classList.remove('hidden');
+                this.sendExtractedTextBtn.disabled = false;
+                
+                window.uiManager.showToast('文本提取成功', 'success');
+            } else if (data.error) {
+                console.error('文本提取失败:', data.error);
+                window.uiManager.showToast('文本提取失败: ' + data.error, 'error');
+                
+                // 启用发送按钮以便用户可以手动输入文本
+                this.sendExtractedTextBtn.disabled = false;
+            } else {
+                // 未知响应格式
+                console.error('未知的文本提取响应格式:', data);
+                window.uiManager.showToast('文本提取返回未知格式', 'error');
+                this.sendExtractedTextBtn.disabled = false;
+            }
+        });
+
+        this.socket.on('ai_response', (data) => {
+            console.log('Received ai_response:', data);
+            this.updateStatusLight(data.status);
+            
+            // 确保Claude面板可见
+            if (this.claudePanel && this.claudePanel.classList.contains('hidden')) {
+                this.claudePanel.classList.remove('hidden');
+            }
+            
+            switch (data.status) {
+                case 'started':
+                    console.log('Analysis started');
+                    // 清空显示内容
+                    if (this.responseContent) this.responseContent.innerHTML = '';
+                    if (this.thinkingContent) this.thinkingContent.innerHTML = '';
+                    if (this.thinkingSection) this.thinkingSection.classList.add('hidden');
+                    
+                    // 禁用按钮防止重复点击
+                    if (this.sendToClaudeBtn) this.sendToClaudeBtn.disabled = true;
+                    if (this.sendExtractedTextBtn) this.sendExtractedTextBtn.disabled = true;
+                    
+                    // 显示进行中状态
+                    if (this.responseContent) {
+                        this.responseContent.innerHTML = '<div class="loading-message">分析进行中，请稍候...</div>';
+                        this.responseContent.style.display = 'block';
+                    }
+                    
+                    // 显示停止生成按钮
+                    this.showStopGenerationButton();
+                    break;
+                    
+                case 'thinking':
+                    // 处理思考内容
+                    if (data.content && this.thinkingContent && this.thinkingSection) {
+                        console.log('Received thinking content');
+                        this.thinkingSection.classList.remove('hidden');
+                        
+                        // 显示动态省略号
+                        this.showThinkingAnimation(true);
+                        
+                        // 直接设置完整内容
+                        this.setElementContent(this.thinkingContent, data.content);
+                        
+                        // 添加打字动画效果
+                        this.thinkingContent.classList.add('thinking-typing');
+                        
+                        // 根据用户偏好设置展开/折叠状态
+                        this.thinkingContent.classList.remove('expanded');
+                        this.thinkingContent.classList.remove('collapsed');
+                        
+                        if (this.userThinkingExpanded) {
+                            this.thinkingContent.classList.add('expanded');
+                        } else {
+                            this.thinkingContent.classList.add('collapsed');
+                        }
+                        
+                        // 更新切换按钮图标
+                        const toggleIcon = document.querySelector('#thinkingToggle .toggle-btn i');
+                        if (toggleIcon) {
+                            toggleIcon.className = this.userThinkingExpanded ? 
+                                'fas fa-chevron-up' : 'fas fa-chevron-down';
+                        }
+                    }
+                    
+                    // 确保停止按钮可见
+                    this.showStopGenerationButton();
+                    break;
+                
+                case 'reasoning':
+                    // 处理推理内容 (QVQ-Max模型使用)
+                    if (data.content && this.thinkingContent && this.thinkingSection) {
+                        console.log('Received reasoning content');
+                        this.thinkingSection.classList.remove('hidden');
+                        
+                        // 显示动态省略号
+                        this.showThinkingAnimation(true);
+                        
+                        // 直接设置完整内容
+                        this.setElementContent(this.thinkingContent, data.content);
+                        
+                        // 添加打字动画效果
+                        this.thinkingContent.classList.add('thinking-typing');
+                        
+                        // 根据用户偏好设置展开/折叠状态
+                        this.thinkingContent.classList.remove('expanded');
+                        this.thinkingContent.classList.remove('collapsed');
+                        
+                        if (this.userThinkingExpanded) {
+                            this.thinkingContent.classList.add('expanded');
+                        } else {
+                            this.thinkingContent.classList.add('collapsed');
+                        }
+                        
+                        // 更新切换按钮图标
+                        const toggleIcon = document.querySelector('#thinkingToggle .toggle-btn i');
+                        if (toggleIcon) {
+                            toggleIcon.className = this.userThinkingExpanded ? 
+                                'fas fa-chevron-up' : 'fas fa-chevron-down';
+                        }
+                    }
+                    
+                    // 确保停止按钮可见
+                    this.showStopGenerationButton();
+                    break;
+                
+                case 'thinking_complete':
+                    // 完整的思考内容
+                    if (data.content && this.thinkingContent && this.thinkingSection) {
+                        console.log('思考过程完成');
+                        this.thinkingSection.classList.remove('hidden');
+                        
+                        // 停止动态省略号
+                        this.showThinkingAnimation(false);
+                        
+                        // 设置完整内容
+                        this.setElementContent(this.thinkingContent, data.content);
+                        
+                        // 移除打字动画
+                        this.thinkingContent.classList.remove('thinking-typing');
+                        
+                        // 根据用户偏好设置展开/折叠状态
+                        this.thinkingContent.classList.remove('expanded');
+                        this.thinkingContent.classList.remove('collapsed');
+                        
+                        if (this.userThinkingExpanded) {
+                            this.thinkingContent.classList.add('expanded');
+                        } else {
+                            this.thinkingContent.classList.add('collapsed');
+                        }
+                        
+                        // 确保图标正确显示
+                        const toggleIcon = this.thinkingToggle.querySelector('.toggle-btn i');
+                        if (toggleIcon) {
+                            toggleIcon.className = this.userThinkingExpanded ? 
+                                'fas fa-chevron-up' : 'fas fa-chevron-down';
+                        }
+                    }
+                    break;
+                    
+                case 'reasoning_complete':
+                    // 完整的推理内容 (QVQ-Max模型使用)
+                    if (data.content && this.thinkingContent && this.thinkingSection) {
+                        console.log('Reasoning complete');
+                        this.thinkingSection.classList.remove('hidden');
+                        
+                        // 停止动态省略号
+                        this.showThinkingAnimation(false);
+                        
+                        // 设置完整内容
+                        this.setElementContent(this.thinkingContent, data.content);
+                        
+                        // 移除打字动画
+                        this.thinkingContent.classList.remove('thinking-typing');
+                        
+                        // 根据用户偏好设置展开/折叠状态
+                        this.thinkingContent.classList.remove('expanded');
+                        this.thinkingContent.classList.remove('collapsed');
+                        
+                        if (this.userThinkingExpanded) {
+                            this.thinkingContent.classList.add('expanded');
+                        } else {
+                            this.thinkingContent.classList.add('collapsed');
+                        }
+                        
+                        // 确保图标正确显示
+                        const toggleIcon = this.thinkingToggle.querySelector('.toggle-btn i');
+                        if (toggleIcon) {
+                            toggleIcon.className = this.userThinkingExpanded ? 
+                                'fas fa-chevron-up' : 'fas fa-chevron-down';
+                        }
+                    }
+                    break;
+                    
+                case 'streaming':
+                    if (data.content && this.responseContent) {
+                        console.log('Received content chunk');
+                        
+                        // 使用更安全的方式设置内容，避免HTML解析问题
+                        this.setElementContent(this.responseContent, data.content);
+                        this.responseContent.style.display = 'block';
+                        
+                        // 停止省略号动画
+                        this.showThinkingAnimation(false);
+                        
+                        // 移除思考部分的打字动画
+                        if (this.thinkingContent) {
+                            this.thinkingContent.classList.remove('thinking-typing');
+                        }
+                        
+                        // 平滑滚动到最新内容
+                        this.scrollToBottom();
+                    }
+                    
+                    // 确保停止按钮可见
+                    this.showStopGenerationButton();
+                    break;
+                    
+                case 'completed':
+                    console.log('Analysis completed');
+                    
+                    // 重新启用按钮
+                    if (this.sendToClaudeBtn) this.sendToClaudeBtn.disabled = false;
+                    if (this.sendExtractedTextBtn) this.sendExtractedTextBtn.disabled = false;
+                    
+                    // 恢复界面
+                    this.updateStatusLight('completed');
+                    
+                    // 只有在有思考内容时才显示思考组件
+                    if (this.thinkingSection && this.thinkingContent) {
+                        // 检查思考内容是否为空
+                        const hasThinkingContent = this.thinkingContent.textContent && this.thinkingContent.textContent.trim() !== '';
+                        
+                        if (hasThinkingContent) {
+                            // 有思考内容，显示思考组件
+                            this.thinkingSection.classList.remove('hidden');
+                            
+                            // 根据用户偏好设置展开/折叠状态
+                            this.thinkingContent.classList.remove('expanded');
+                            this.thinkingContent.classList.remove('collapsed');
+                            
+                            if (this.userThinkingExpanded) {
+                                this.thinkingContent.classList.add('expanded');
+                            } else {
+                                this.thinkingContent.classList.add('collapsed');
+                            }
+                            
+                            const toggleBtn = document.querySelector('#thinkingToggle .toggle-btn i');
+                            if (toggleBtn) {
+                                toggleBtn.className = this.userThinkingExpanded ? 
+                                    'fas fa-chevron-up' : 'fas fa-chevron-down';
+                            }
+                            
+                            // 简化提示信息
+                            window.uiManager.showToast('分析完成', 'success');
+                        } else {
+                            // 没有思考内容，隐藏思考组件
+                            this.thinkingSection.classList.add('hidden');
+                            window.uiManager.showToast('分析完成', 'success');
+                        }
+                    }
+                    
+                    // 确保响应内容完整显示
+                    if (data.content && data.content.trim() !== '' && this.responseContent) {
+                        this.setElementContent(this.responseContent, data.content);
+                    }
+                    
+                    // 确保结果内容可见
+                    if (this.responseContent) {
+                        this.responseContent.style.display = 'block';
+                        
+                        // 滚动到结果内容底部
+                        this.scrollToBottom();
+                    }
+                    
+                    // 隐藏停止生成按钮
+                    this.hideStopGenerationButton();
+                    break;
+                    
+                case 'stopped':
+                    // 处理停止生成的响应
+                    console.log('Generation stopped');
+                    
+                    // 重新启用按钮
+                    if (this.sendToClaudeBtn) this.sendToClaudeBtn.disabled = false;
+                    if (this.sendExtractedTextBtn) this.sendExtractedTextBtn.disabled = false;
+                    
+                    // 恢复界面
+                    this.updateStatusLight('stopped');
+                    
+                    // 隐藏停止生成按钮
+                    this.hideStopGenerationButton();
+                    
+                    // 显示提示信息
+                    window.uiManager.showToast('已停止生成', 'info');
+                    break;
+                    
+                case 'error':
+                    console.error('Analysis error:', data.error);
+                    
+                    // 安全处理错误消息，确保它是字符串
+                    let errorMessage = 'Unknown error occurred';
+                    if (data.error) {
+                        if (typeof data.error === 'string') {
+                            errorMessage = data.error;
+                        } else if (typeof data.error === 'object') {
+                            // 如果是对象，尝试获取消息字段或转换为JSON
+                            errorMessage = data.error.message || data.error.error || JSON.stringify(data.error);
+                        } else {
+                            errorMessage = String(data.error);
+                        }
+                    }
+                    
+                    // 显示错误信息
+                    if (this.responseContent) {
+                        // 不要尝试获取现有内容，直接显示错误信息
+                        this.setElementContent(this.responseContent, 'Error: ' + errorMessage);
+                    }
+                    
+                    // 重新启用按钮
+                    if (this.sendToClaudeBtn) this.sendToClaudeBtn.disabled = false;
+                    if (this.sendExtractedTextBtn) this.sendExtractedTextBtn.disabled = false;
+                    
+                    window.uiManager.showToast('Analysis failed: ' + errorMessage, 'error');
+                    
+                    // 隐藏停止生成按钮
+                    this.hideStopGenerationButton();
+                    break;
+                    
+                default:
+                    console.warn('Unknown response status:', data.status);
+                    
+                    // 对于未知状态，尝试显示内容（如果有）
+                    if (data.content && this.responseContent) {
+                        this.setElementContent(this.responseContent, data.content);
+                        this.responseContent.style.display = 'block';
+                    }
+                    
+                    // 确保按钮可用
+                    if (this.sendToClaudeBtn) this.sendToClaudeBtn.disabled = false;
+                    if (this.sendExtractedTextBtn) this.sendExtractedTextBtn.disabled = false;
+                    
+                    window.uiManager.showToast('Unknown error occurred', 'error');
+                    
+                    // 隐藏停止生成按钮
+                    this.hideStopGenerationButton();
+                    break;
+            }
+        });
+        
+        // 接收到thinking数据时
+        this.socket.on('thinking', (data) => {
+            console.log('收到思考过程数据');
+
+            // 显示思考区域
+            this.thinkingSection.classList.remove('hidden');
+            
+            // 显示动态省略号
+            this.showThinkingAnimation(true);
+            
+            // 使用setElementContent方法处理Markdown
+            this.setElementContent(this.thinkingContent, data.thinking);
+            
+            // 根据用户偏好设置展开/折叠状态
+            this.thinkingContent.classList.remove('expanded');
+            this.thinkingContent.classList.remove('collapsed');
+            
+            if (this.userThinkingExpanded) {
+                this.thinkingContent.classList.add('expanded');
+            } else {
+                this.thinkingContent.classList.add('collapsed');
+            }
+            
+            const toggleIcon = this.thinkingToggle.querySelector('.toggle-btn i');
+            if (toggleIcon) {
+                toggleIcon.className = this.userThinkingExpanded ? 
+                    'fas fa-chevron-up' : 'fas fa-chevron-down';
+            }
+        });
+
+        // 思考过程完成 - Socket事件处理
+        this.socket.on('thinking_complete', (data) => {
+            console.log('Socket接收到思考过程完成');
+            this.thinkingSection.classList.remove('hidden');
+            
+            // 停止动态省略号动画
+            this.showThinkingAnimation(false);
+            
+            // 使用setElementContent方法处理Markdown
+            this.setElementContent(this.thinkingContent, data.thinking);
+            
+            // ��据用户偏好设置展开/折叠状态
+            this.thinkingContent.classList.remove('expanded');
+            this.thinkingContent.classList.remove('collapsed');
+            
+            if (this.userThinkingExpanded) {
+                this.thinkingContent.classList.add('expanded');
+            } else {
+                this.thinkingContent.classList.add('collapsed');
+            }
+            
+            // 确保图标正确显示
+            const toggleIcon = this.thinkingToggle.querySelector('.toggle-btn i');
+            if (toggleIcon) {
+                toggleIcon.className = this.userThinkingExpanded ? 
+                    'fas fa-chevron-up' : 'fas fa-chevron-down';
+            }
+        });
+
+        // 分析完成
+        this.socket.on('analysis_complete', (data) => {
+            console.log('分析完成，接收到结果');
+            this.updateStatusLight('completed');
+            this.enableInterface();
+            
+            // 显示分析结果
+            if (this.responseContent) {
+                // 使用setElementContent方法处理Markdown
+                this.setElementContent(this.responseContent, data.response);
+                this.responseContent.style.display = 'block';
+                
+                // 直接滚动到结果区域，不使用setTimeout
+                this.responseContent.scrollIntoView({ behavior: 'smooth' });
+            }
+            
+            // 确保思考部分完全显示（如果有的话）
+            if (data.thinking && this.thinkingSection && this.thinkingContent) {
+                this.thinkingSection.classList.remove('hidden');
+                // 使用setElementContent方法处理Markdown
+                this.setElementContent(this.thinkingContent, data.thinking);
+                
+                // 根据用户偏好设置展开/折叠状态
+                this.thinkingContent.classList.remove('expanded');
+                this.thinkingContent.classList.remove('collapsed');
+                
+                if (this.userThinkingExpanded) {
+                    this.thinkingContent.classList.add('expanded');
+                } else {
+                    this.thinkingContent.classList.add('collapsed');
+                }
+                
+                const toggleIcon = this.thinkingToggle.querySelector('.toggle-btn i');
+                if (toggleIcon) {
+                    toggleIcon.className = this.userThinkingExpanded ? 
+                        'fas fa-chevron-up' : 'fas fa-chevron-down';
+                }
+                
+                // 弹出提示
+                window.uiManager.showToast('分析完成', 'success');
+            }
+        });
+    }
+
+    // 新方法：安全设置DOM内容的方法（替代updateElementContent）
+    setElementContent(element, content) {
+        if (!element) return;
+        
+        // 首先确保content是字符串
+        if (typeof content !== 'string') {
+            if (content === null || content === undefined) {
+                content = '';
+            } else if (typeof content === 'object') {
+                // 对于对象，尝试获取有意义的字符串表示
+                if (content.error || content.message) {
+                    content = content.error || content.message;
+                } else if (content.toString && typeof content.toString === 'function' && content.toString() !== '[object Object]') {
+                    content = content.toString();
+                } else {
+                    // 作为最后手段，使用JSON.stringify
+                    try {
+                        content = JSON.stringify(content, null, 2);
+                    } catch (e) {
+                        content = '[Complex Object]';
+                    }
+                }
+            } else {
+                content = String(content);
+            }
+        }
+        
+        try {
+            // 检查marked是否已配置
+            if (typeof marked === 'undefined') {
+                console.warn('Marked库未加载，回退到纯文本显示');
+                // 即使回退到纯文本，也要保留换行和基本格式
+                element.innerHTML = content.replace(/\n/g, '<br>');
+                return;
+            }
+            
+            // 使用marked库解析Markdown内容
+            const renderedHtml = marked.parse(content);
+            
+            // 设置解析后的HTML内容
+            element.innerHTML = renderedHtml;
+            
+            // 为未高亮的代码块应用语法高亮
+            if (window.hljs) {
+                element.querySelectorAll('pre code:not(.hljs)').forEach((block) => {
+                    hljs.highlightElement(block);
+                });
+            }
+            
+            // 为所有代码块添加复制按钮
+            this.addCopyButtonsToCodeBlocks(element);
+        } catch (error) {
+            console.error('Markdown解析错误:', error);
+            // 发生错误时也保留换行格式
+            element.innerHTML = content.replace(/\n/g, '<br>');
+        }
+        
+        // 自动滚动到底部
+        element.scrollTop = element.scrollHeight;
+    }
+
+    // 为代码块添加复制按钮
+    addCopyButtonsToCodeBlocks(element) {
+        const codeBlocks = element.querySelectorAll('pre code');
+        
+        codeBlocks.forEach((codeBlock) => {
+            // 检查是否已经有复制按钮
+            if (codeBlock.parentElement.querySelector('.code-copy-btn')) {
+                return;
+            }
+            
+            // 创建包装器
+            const wrapper = document.createElement('div');
+            wrapper.className = 'code-block-wrapper';
+            
+            // 将pre元素包装起来
+            const preElement = codeBlock.parentElement;
+            preElement.parentNode.insertBefore(wrapper, preElement);
+            wrapper.appendChild(preElement);
+            
+            // 创建复制按钮
+            const copyBtn = document.createElement('button');
+            copyBtn.className = 'code-copy-btn';
+            copyBtn.innerHTML = '<i class="fas fa-copy"></i> 复制';
+            copyBtn.title = '复制代码';
+            
+            // 添加点击事件
+            copyBtn.addEventListener('click', async () => {
+                const codeText = codeBlock.textContent;
+                
+                try {
+                    // 尝试使用现代 Clipboard API
+                    if (navigator.clipboard && window.isSecureContext) {
+                        await navigator.clipboard.writeText(codeText);
+                        this.showCopySuccess(copyBtn);
+                        return;
+                    }
+                    
+                    // 降级方案：使用传统的 document.execCommand
+                    const textArea = document.createElement('textarea');
+                    textArea.value = codeText;
+                    textArea.style.position = 'fixed';
+                    textArea.style.left = '-999999px';
+                    textArea.style.top = '-999999px';
+                    document.body.appendChild(textArea);
+                    textArea.focus();
+                    textArea.select();
+                    
+                    const successful = document.execCommand('copy');
+                    document.body.removeChild(textArea);
+                    
+                    if (successful) {
+                        this.showCopySuccess(copyBtn);
+                    } else {
+                        throw new Error('execCommand failed');
+                    }
+                    
+                } catch (error) {
+                    console.error('复制失败:', error);
+                    // 最后的降级方案：选中文本让用户手动复制
+                    this.selectTextForManualCopy(codeBlock, copyBtn);
+                }
+            });
+            
+            // 将按钮添加到包装器
+            wrapper.appendChild(copyBtn);
+        });
+    }
+
+    // 显示复制成功状态
+    showCopySuccess(copyBtn) {
+        copyBtn.innerHTML = '<i class="fas fa-check"></i> 已复制';
+        copyBtn.classList.add('copied');
+        window.uiManager?.showToast('代码已复制到剪贴板', 'success');
+        
+        // 2秒后恢复原状
+        setTimeout(() => {
+            copyBtn.innerHTML = '<i class="fas fa-copy"></i> 复制';
+            copyBtn.classList.remove('copied');
+        }, 2000);
+    }
+
+    // 选中文本供用户手动复制
+    selectTextForManualCopy(codeBlock, copyBtn) {
+        // 选中代码文本
+        const range = document.createRange();
+        range.selectNodeContents(codeBlock);
+        const selection = window.getSelection();
+        selection.removeAllRanges();
+        selection.addRange(range);
+        
+        // 更新按钮状态
+        copyBtn.innerHTML = '<i class="fas fa-hand-pointer"></i> 已选中';
+        copyBtn.classList.add('copied');
+        
+        // 显示提示
+        window.uiManager?.showToast('代码已选中，请按 Ctrl+C 复制', 'info');
+        
+        // 3秒后恢复原状
+        setTimeout(() => {
+            copyBtn.innerHTML = '<i class="fas fa-copy"></i> 复制';
+            copyBtn.classList.remove('copied');
+            selection.removeAllRanges();
+        }, 3000);
+    }
+
+    initializeCropper() {
+        try {
+            // 如果当前没有截图，不要初始化裁剪器
+            if (!this.screenshotImg || !this.screenshotImg.src || this.screenshotImg.src === '') {
+                console.log('No screenshot to crop');
+                return;
+            }
+            
+            // Clean up existing cropper instance
+            if (this.cropper) {
+                this.cropper.destroy();
+                this.cropper = null;
+            }
+
+            const cropArea = document.querySelector('.crop-area');
+            if (!cropArea) {
+                console.error('Crop area element not found');
+                return;
+            }
+            
+            cropArea.innerHTML = '';
+            const clonedImage = this.screenshotImg.cloneNode(true);
+            clonedImage.style.display = 'block';
+            cropArea.appendChild(clonedImage);
+            
+            this.cropContainer.classList.remove('hidden');
+            
+            // Store reference to this for use in ready callback
+            const self = this;
+            
+            this.cropper = new Cropper(clonedImage, {
+                viewMode: 1,
+                dragMode: 'move',
+                aspectRatio: NaN,
+                modal: true,
+                background: true,
+                ready: function() {
+                    // 如果有上次保存的裁剪框数据，应用它
+                    if (self.lastCropBoxData) {
+                        self.cropper.setCropBoxData(self.lastCropBoxData);
+                        console.log('Applied saved crop box data');
+                    }
+                }
+            });
+        } catch (error) {
+            console.error('Failed to initialize cropper', error);
+            window.uiManager.showToast('裁剪器初始化失败', 'error');
+            
+            // 确保在出错时关闭裁剪界面
+            if (this.cropContainer) {
+                this.cropContainer.classList.add('hidden');
+            }
+        }
+    }
+
+    setupEventListeners() {
+        console.log('DEBUG: 设置所有事件监听器（这应该只执行一次）');
+        
+        this.setupCaptureEvents();
+        this.setupCropEvents();
+        this.setupAnalysisEvents();
+        this.setupKeyboardShortcuts();
+        this.setupThinkingToggle();
+        this.setupClipboardFeature();
+        
+        // 监听模型选择变化，更新界面
+        if (window.settingsManager && window.settingsManager.modelSelect) {
+            window.settingsManager.modelSelect.addEventListener('change', () => {
+                this.updateImageActionButtons();
+            });
+        }
+    }
+
+    setupClipboardFeature() {
+        if (!this.clipboardTextarea || !this.clipboardSendButton || !this.clipboardReadButton) {
+            console.warn('Clipboard controls not found in DOM');
+            return;
+        }
+
+        // 读取剪贴板按钮事件
+        this.clipboardReadButton.addEventListener('click', (event) => {
+            event.preventDefault();
+            this.readClipboardText();
+        });
+
+        // 发送到剪贴板按钮事件
+        this.clipboardSendButton.addEventListener('click', (event) => {
+            event.preventDefault();
+            this.sendClipboardText();
+        });
+
+        // 键盘快捷键：Ctrl/Cmd + Enter 发送到剪贴板
+        this.clipboardTextarea.addEventListener('keydown', (event) => {
+            if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
+                event.preventDefault();
+                this.sendClipboardText();
+            }
+        });
+    }
+
+    setupCaptureEvents() {
+        // 添加计数器
+        if (!window.captureCounter) {
+            window.captureCounter = 0;
+        }
+        
+        // 移除现有的事件监听器，防止重复绑定
+        if (this.captureBtn) {
+            // 克隆按钮并替换原按钮，这样可以移除所有事件监听器
+            const newBtn = this.captureBtn.cloneNode(true);
+            this.captureBtn.parentNode.replaceChild(newBtn, this.captureBtn);
+            this.captureBtn = newBtn;
+            
+            console.log('DEBUG: 已清除截图按钮上的事件监听器');
+        }
+        
+        // 截图按钮
+        this.captureBtn.addEventListener('click', () => {
+            if (!this.checkConnectionBeforeAction()) return;
+            
+            try {
+                // 增加计数并记录
+                window.captureCounter++;
+                console.log(`DEBUG: 截图按钮点击计数 = ${window.captureCounter}`);
+                
+                this.captureBtn.disabled = true;  // 禁用按钮防止重复点击
+                this.captureBtn.innerHTML = '<i class="fas fa-spinner fa-spin"></i>';
+                
+                console.log('DEBUG: 发送capture_screenshot事件到服务器');
+                this.socket.emit('capture_screenshot', {});
+            } catch (error) {
+                console.error('Error starting capture:', error);
+                window.uiManager.showToast('启动截图失败', 'error');
+                this.captureBtn.disabled = false;
+                this.captureBtn.innerHTML = '<i class="fas fa-camera"></i>';
+            }
+        });
+    }
+
+    updateClipboardStatus(message, status = 'neutral') {
+        if (!this.clipboardStatus) return;
+
+        if (!message) {
+            this.clipboardStatus.textContent = '';
+            this.clipboardStatus.removeAttribute('data-status');
+            return;
+        }
+
+        this.clipboardStatus.textContent = message;
+        this.clipboardStatus.dataset.status = status;
+    }
+
+    async readClipboardText() {
+        if (!this.clipboardTextarea || !this.clipboardReadButton) return;
+
+        this.updateClipboardStatus('读取中...', 'pending');
+        this.clipboardReadButton.disabled = true;
+
+        try {
+            const response = await fetch('/api/clipboard', {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            const result = await response.json().catch(() => ({}));
+
+            if (response.ok && result?.success) {
+                // 将读取到的内容填入文本框
+                this.clipboardTextarea.value = result.text || '';
+                
+                const successMessage = result.text ? 
+                    `成功读取剪贴板内容 (${result.text.length} 字符)` : 
+                    '剪贴板为空';
+                this.updateClipboardStatus(successMessage, 'success');
+                window.uiManager?.showToast(successMessage, 'success');
+            } else {
+                const errorMessage = result?.message || '读取失败，请稍后重试';
+                this.updateClipboardStatus(errorMessage, 'error');
+                window.uiManager?.showToast(errorMessage, 'error');
+            }
+        } catch (error) {
+            console.error('Failed to read clipboard text:', error);
+            const networkErrorMessage = '网络错误，读取失败';
+            this.updateClipboardStatus(networkErrorMessage, 'error');
+            window.uiManager?.showToast(networkErrorMessage, 'error');
+        } finally {
+            this.clipboardReadButton.disabled = false;
+        }
+    }
+
+    async sendClipboardText() {
+        if (!this.clipboardTextarea) return;
+
+        const text = this.clipboardTextarea.value ?? '';
+        if (!text.trim()) {
+            const warningMessage = '请输入要发送到剪贴板的文字';
+            this.updateClipboardStatus(warningMessage, 'error');
+            window.uiManager?.showToast(warningMessage, 'warning');
+            return;
+        }
+
+        this.updateClipboardStatus('发送中...', 'pending');
+        if (this.clipboardSendButton) {
+            this.clipboardSendButton.disabled = true;
+        }
+
+        try {
+            const response = await fetch('/api/clipboard', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ text })
+            });
+            const result = await response.json().catch(() => ({}));
+
+            if (response.ok && result?.success) {
+                const successMessage = '已复制到服务端剪贴板';
+                this.updateClipboardStatus(successMessage, 'success');
+                window.uiManager?.showToast(successMessage, 'success');
+                
+                // 清空输入框
+                this.clipboardTextarea.value = '';
+            } else {
+                const errorMessage = result?.message || '发送失败，请稍后重试';
+                this.updateClipboardStatus(errorMessage, 'error');
+                window.uiManager?.showToast(errorMessage, 'error');
+            }
+        } catch (error) {
+            console.error('Failed to send clipboard text:', error);
+            const networkErrorMessage = '网络错误，发送失败';
+            this.updateClipboardStatus(networkErrorMessage, 'error');
+            window.uiManager?.showToast(networkErrorMessage, 'error');
+        } finally {
+            if (this.clipboardSendButton) {
+                this.clipboardSendButton.disabled = false;
+            }
+        }
+    }
+
+    setupCropEvents() {
+        // 防止重复绑定事件监听器
+        if (this.cropConfirm) {
+            const newCropConfirm = this.cropConfirm.cloneNode(true);
+            this.cropConfirm.parentNode.replaceChild(newCropConfirm, this.cropConfirm);
+            this.cropConfirm = newCropConfirm;
+        }
+        
+        if (this.cropCancel) {
+            const newCropCancel = this.cropCancel.cloneNode(true);
+            this.cropCancel.parentNode.replaceChild(newCropCancel, this.cropCancel);
+            this.cropCancel = newCropCancel;
+        }
+        
+        const cropResetElement = document.getElementById('cropReset');
+        if (cropResetElement) {
+            const newCropReset = cropResetElement.cloneNode(true);
+            cropResetElement.parentNode.replaceChild(newCropReset, cropResetElement);
+        }
+        
+        if (this.cropSendToAI) {
+            const newCropSendToAI = this.cropSendToAI.cloneNode(true);
+            this.cropSendToAI.parentNode.replaceChild(newCropSendToAI, this.cropSendToAI);
+            this.cropSendToAI = newCropSendToAI;
+        }
+        
+        console.log('DEBUG: 已清除裁剪按钮上的事件监听器，防止重复绑定');
+
+        // 存储裁剪框数据
+        this.lastCropBoxData = null;
+
+        // Crop confirm button
+        this.cropConfirm.addEventListener('click', () => {
+            if (!this.checkConnectionBeforeAction()) return;
+            
+            if (this.cropper) {
+                try {
+                    console.log('Starting crop operation...');
+                    
+                    // Validate cropper instance
+                    if (!this.cropper) {
+                        throw new Error('Cropper not initialized');
+                    }
+
+                    // Get and validate crop box data
+                    const cropBoxData = this.cropper.getCropBoxData();
+                    console.log('Crop box data:', cropBoxData);
+                    
+                    // 保存裁剪框数据以便下次使用
+                    this.lastCropBoxData = cropBoxData;
+                    
+                    if (!cropBoxData || typeof cropBoxData.width !== 'number' || typeof cropBoxData.height !== 'number') {
+                        throw new Error('Invalid crop box data');
+                    }
+
+                    if (cropBoxData.width < 10 || cropBoxData.height < 10) {
+                        throw new Error('Crop area is too small. Please select a larger area (minimum 10x10 pixels).');
+                    }
+
+                    // Get cropped canvas with more conservative size limits
+                    console.log('Getting cropped canvas...');
+                    const canvas = this.cropper.getCroppedCanvas({
+                        maxWidth: 2560,
+                        maxHeight: 1440,
+                        fillColor: '#fff',
+                        imageSmoothingEnabled: true,
+                        imageSmoothingQuality: 'high',
+                    });
+
+                    if (!canvas) {
+                        throw new Error('Failed to create cropped canvas');
+                    }
+
+                    console.log('Canvas created successfully');
+
+                    // Convert to data URL with error handling and compression
+                    console.log('Converting to data URL...');
+                    try {
+                        // Use PNG for better quality
+                        this.croppedImage = canvas.toDataURL('image/png');
+                        console.log('Data URL conversion successful');
+                    } catch (dataUrlError) {
+                        console.error('Data URL conversion error:', dataUrlError);
+                        throw new Error('Failed to process cropped image. The image might be too large or memory insufficient.');
+                    }
+
+                    // Properly destroy the cropper instance
+                    this.cropper.destroy();
+                    this.cropper = null;
+
+                    // Clean up cropper and update UI
+                    this.cropContainer.classList.add('hidden');
+                    document.querySelector('.crop-area').innerHTML = '';
+                    
+                    // Update the screenshot image with the cropped version
+                    this.screenshotImg.src = this.croppedImage;
+                    this.imagePreview.classList.remove('hidden');
+                    
+                    // 根据当前选择的模型类型决定显示哪些按钮
+                    this.updateImageActionButtons();
+                    
+                    window.uiManager.showToast('裁剪成功');
+                    
+                    // 不再自动发送至AI，由用户手动选择
+                } catch (error) {
+                    console.error('Cropping error details:', {
+                        message: error.message,
+                        stack: error.stack,
+                        cropperState: this.cropper ? 'initialized' : 'not initialized'
+                    });
+                    window.uiManager.showToast(error.message || '裁剪图像时出错', 'error');
+                } finally {
+                    // Always clean up the cropper instance
+                    if (this.cropper) {
+                        this.cropper.destroy();
+                        this.cropper = null;
+                    }
+                }
+            }
+        });
+
+        // Crop cancel button
+        this.cropCancel.addEventListener('click', () => {
+            if (this.cropper) {
+                this.cropper.destroy();
+                this.cropper = null;
+            }
+            this.cropContainer.classList.add('hidden');
+            // 取消裁剪时隐藏图像预览和相关按钮
+            this.imagePreview.classList.add('hidden');
+            document.querySelector('.crop-area').innerHTML = '';
+        });
+        
+        // Crop reset button
+        const cropResetBtn = document.getElementById('cropReset');
+        if (cropResetBtn) {
+            cropResetBtn.addEventListener('click', () => {
+                if (this.cropper) {
+                    // 重置裁剪区域到默认状态
+                    this.cropper.reset();
+                    window.uiManager.showToast('已重置裁剪区域');
+                }
+            });
+        }
+        
+        // Crop send to AI button
+        this.cropSendToAI.addEventListener('click', () => {
+            if (!this.checkConnectionBeforeAction()) return;
+            
+            // 如果有裁剪器，尝试获取裁剪结果；否则使用原始图片
+            if (this.cropper) {
+                try {
+                    console.log('Starting crop and send operation...');
+                    
+                    // Validate cropper instance
+                    if (!this.cropper) {
+                        throw new Error('Cropper not initialized');
+                    }
+
+                    // Get and validate crop box data
+                    const cropBoxData = this.cropper.getCropBoxData();
+                    console.log('Crop box data:', cropBoxData);
+                    
+                    // 保存裁剪框数据以便下次使用
+                    this.lastCropBoxData = cropBoxData;
+                    
+                    if (!cropBoxData || typeof cropBoxData.width !== 'number' || typeof cropBoxData.height !== 'number') {
+                        throw new Error('Invalid crop box data');
+                    }
+
+                    if (cropBoxData.width < 10 || cropBoxData.height < 10) {
+                        throw new Error('Crop area is too small. Please select a larger area (minimum 10x10 pixels).');
+                    }
+
+                    // Get cropped canvas
+                    console.log('Getting cropped canvas...');
+                    const canvas = this.cropper.getCroppedCanvas({
+                        maxWidth: 2560,
+                        maxHeight: 1440,
+                        fillColor: '#fff',
+                        imageSmoothingEnabled: true,
+                        imageSmoothingQuality: 'high',
+                    });
+
+                    if (!canvas) {
+                        throw new Error('Failed to create cropped canvas');
+                    }
+
+                    console.log('Canvas created successfully');
+
+                    // Convert to data URL
+                    console.log('Converting to data URL...');
+                    try {
+                        this.croppedImage = canvas.toDataURL('image/png');
+                        console.log('Data URL conversion successful');
+                    } catch (dataUrlError) {
+                        console.error('Data URL conversion error:', dataUrlError);
+                        throw new Error('Failed to process cropped image. The image might be too large or memory insufficient.');
+                    }
+
+                    // Clean up cropper and update UI
+                    this.cropper.destroy();
+                    this.cropper = null;
+                    this.cropContainer.classList.add('hidden');
+                    document.querySelector('.crop-area').innerHTML = '';
+                    
+                    // Update the screenshot image with the cropped version
+                    this.screenshotImg.src = this.croppedImage;
+                    this.imagePreview.classList.remove('hidden');
+                    
+                    // 根据当前选择的模型类型决定显示哪些按钮
+                    this.updateImageActionButtons();
+                    
+                    // 显示Claude分析面板
+                    this.claudePanel.classList.remove('hidden');
+                    this.emptyState.classList.add('hidden');
+                    
+                    // 发送图像到Claude进行分析
+                    this.sendImageToClaude(this.croppedImage);
+                    
+                    window.uiManager.showToast('正在发送至AI分析...');
+                    
+                } catch (error) {
+                    console.error('Crop and send error details:', {
+                        message: error.message,
+                        stack: error.stack,
+                        cropperState: this.cropper ? 'initialized' : 'not initialized'
+                    });
+                    window.uiManager.showToast(error.message || '处理图像时出错', 'error');
+                    
+                    // Clean up on error
+                    if (this.cropper) {
+                        this.cropper.destroy();
+                        this.cropper = null;
+                    }
+                    this.cropContainer.classList.add('hidden');
+                    document.querySelector('.crop-area').innerHTML = '';
+                }
+            } else if (this.originalImage) {
+                // 如果没有裁剪器但有原始图片，直接发送原始图片
+                try {
+                    // 隐藏裁剪容器
+                    this.cropContainer.classList.add('hidden');
+                    
+                    // 显示Claude分析面板
+                    this.claudePanel.classList.remove('hidden');
+                    this.emptyState.classList.add('hidden');
+                    
+                    // 发送原始图像到Claude进行分析
+                    this.sendImageToClaude(this.originalImage);
+                    
+                    window.uiManager.showToast('正在发送至AI分析...');
+                    
+                } catch (error) {
+                    console.error('Send original image error:', error);
+                    window.uiManager.showToast('发送图片失败: ' + error.message, 'error');
+                }
+            } else {
+                window.uiManager.showToast('请先截图', 'error');
+            }
+        });
+    }
+
+    setupAnalysisEvents() {
+        // 防止重复绑定事件监听器
+        if (this.extractTextBtn) {
+            const newExtractBtn = this.extractTextBtn.cloneNode(true);
+            this.extractTextBtn.parentNode.replaceChild(newExtractBtn, this.extractTextBtn);
+            this.extractTextBtn = newExtractBtn;
+        }
+        
+        if (this.sendExtractedTextBtn) {
+            const newSendBtn = this.sendExtractedTextBtn.cloneNode(true);
+            this.sendExtractedTextBtn.parentNode.replaceChild(newSendBtn, this.sendExtractedTextBtn);
+            this.sendExtractedTextBtn = newSendBtn;
+        }
+        
+        if (this.sendToClaudeBtn) {
+            const newClaudeBtn = this.sendToClaudeBtn.cloneNode(true);
+            this.sendToClaudeBtn.parentNode.replaceChild(newClaudeBtn, this.sendToClaudeBtn);
+            this.sendToClaudeBtn = newClaudeBtn;
+        }
+        
+        console.log('DEBUG: 已清除分析按钮上的事件监听器，防止重复绑定');
+        
+        // Extract Text button
+        this.extractTextBtn.addEventListener('click', () => {
+            if (!this.checkConnectionBeforeAction()) return;
+            
+            // 优先使用裁剪后的图片，如果没有则使用原始截图
+            const imageToExtract = this.croppedImage || this.originalImage;
+            
+            if (!imageToExtract) {
+                window.uiManager.showToast('请先截图', 'error');
+                return;
+            }
+
+            this.extractTextBtn.disabled = true;
+            this.sendExtractedTextBtn.disabled = true;  // Disable the send button while extracting
+            this.extractTextBtn.innerHTML = '<i class="fas fa-spinner fa-spin"></i><span>提取中...</span>';
+
+            const settings = window.settingsManager.getSettings();
+            
+            // 根据用户设置的OCR源进行选择
+            const ocrSource = settings.ocrSource || 'auto';
+            const baiduApiKey = window.settingsManager.apiKeyValues.BaiduApiKey;
+            const baiduSecretKey = window.settingsManager.apiKeyValues.BaiduSecretKey;
+            const mathpixApiKey = settings.mathpixApiKey;
+            
+            const hasBaiduOCR = baiduApiKey && baiduSecretKey;
+            const hasMathpix = mathpixApiKey && mathpixApiKey !== ':';
+            
+            // 根据OCR源配置检查可用性
+            let canProceed = false;
+            let missingOCRMessage = '';
+            
+            if (ocrSource === 'baidu') {
+                canProceed = hasBaiduOCR;
+                missingOCRMessage = '请在设置中配置百度OCR API密钥';
+            } else if (ocrSource === 'mathpix') {
+                canProceed = hasMathpix;
+                missingOCRMessage = '请在设置中配置Mathpix API密钥';
+            } else { // auto
+                canProceed = hasBaiduOCR || hasMathpix;
+                missingOCRMessage = '请在设置中配置OCR API密钥：百度OCR（推荐）或Mathpix';
+            }
+            
+            if (!canProceed) {
+                window.uiManager.showToast(missingOCRMessage, 'error');
+                document.getElementById('settingsPanel').classList.add('active');
+                this.extractTextBtn.disabled = false;
+                this.extractTextBtn.innerHTML = '<i class="fas fa-font"></i><span>提取文本</span>';
+                return;
+            }
+
+            // 显示文本框和按钮
+            this.extractedText.classList.remove('hidden');
+            this.sendExtractedTextBtn.classList.remove('hidden');
+            
+            if (this.extractedText) {
+                this.extractedText.value = '正在提取文本...';
+                this.extractedText.disabled = true;
+            }
+
+            try {
+                this.socket.emit('extract_text', {
+                    image: imageToExtract.split(',')[1],
+                    settings: {
+                        ocrSource: settings.ocrSource || 'auto'
+                    }
+                });
+
+                // 监听服务器确认请求的响应
+                this.socket.once('request_acknowledged', (ackResponse) => {
+                    console.log('服务器确认收到文本提取请求', ackResponse);
+                });
+            } catch (error) {
+                window.uiManager.showToast('提取文本失败: ' + error.message, 'error');
+                this.extractTextBtn.disabled = false;
+                this.sendExtractedTextBtn.disabled = false;
+                this.extractTextBtn.innerHTML = '<i class="fas fa-font"></i><span>提取文本</span>';
+                if (this.extractedText) {
+                    this.extractedText.disabled = false;
+                }
+            }
+        });
+
+        // Send Extracted Text button
+        this.sendExtractedTextBtn.addEventListener('click', () => {
+            if (!this.checkConnectionBeforeAction()) return;
+            
+            // 防止重复点击
+            if (this.sendExtractedTextBtn.disabled) return;
+            
+            const text = this.extractedText.value.trim();
+            if (!text) {
+                window.uiManager.showToast('请输入一些文本', 'error');
+                return;
+            }
+
+            const settings = window.settingsManager.getSettings();
+            const apiKeys = {};
+            Object.keys(window.settingsManager.apiKeyInputs).forEach(keyId => {
+                const input = window.settingsManager.apiKeyInputs[keyId];
+                if (input && input.value) {
+                    apiKeys[keyId] = input.value;
+                }
+            });
+            
+            console.log("Debug - 发送文本分析API密钥:", apiKeys);
+            
+            // 禁用按钮防止重复点击
+            this.sendExtractedTextBtn.disabled = true;
+
+            try {
+                this.socket.emit('analyze_text', {
+                    text: text,
+                    settings: {
+                        ...settings,
+                        apiKeys: apiKeys,
+                        model: settings.model || 'claude-3-7-sonnet-20250219',
+                        modelInfo: settings.modelInfo || {},
+                        modelCapabilities: {
+                            supportsMultimodal: settings.modelInfo?.supportsMultimodal || false,
+                            isReasoning: settings.modelInfo?.isReasoning || false
+                        }
+                    }
+                });
+            } catch (error) {
+                this.setElementContent(this.responseContent, 'Error: Failed to send text for analysis - ' + error.message);
+                this.sendExtractedTextBtn.disabled = false;
+                window.uiManager.showToast('发送文本进行分析失败', 'error');
+            }
+        });
+
+        // Send to Claude button
+        this.sendToClaudeBtn.addEventListener('click', () => {
+            if (!this.checkConnectionBeforeAction()) return;
+            
+            // 防止重复点击
+            if (this.sendToClaudeBtn.disabled) return;
+            this.sendToClaudeBtn.disabled = true;
+            
+            // 获取当前模型设置
+            const settings = window.settingsManager.getSettings();
+            const isMultimodalModel = settings.modelInfo?.supportsMultimodal || false;
+            const modelName = settings.model || '未知';
+            
+            if (!isMultimodalModel) {
+                window.uiManager.showToast(`当前选择的模型 ${modelName} 不支持图像分析。请先提取文本或切换到支持多模态的模型。`, 'error');
+                this.sendToClaudeBtn.disabled = false;
+                return;
+            }
+            
+            // 只发送裁剪后的图片，如果没有裁剪过则提示用户先裁剪
+            if (this.croppedImage) {
+                try {
+                    // 清空之前的结果
+                    this.responseContent.innerHTML = '';
+                    this.thinkingContent.innerHTML = '';
+                    
+                    // 显示Claude分析面板
+                    this.claudePanel.classList.remove('hidden');
+                    
+                    // 发送图片进行分析
+                    this.sendImageToClaude(this.croppedImage);
+                } catch (error) {
+                    console.error('Error:', error);
+                    window.uiManager.showToast('发送图片失败: ' + error.message, 'error');
+                    this.sendToClaudeBtn.disabled = false;
+                }
+            } else {
+                window.uiManager.showToast('请先裁剪图片', 'error');
+                this.sendToClaudeBtn.disabled = false;
+            }
+        });
+
+        // Handle Claude panel close button
+        const closeClaudePanel = document.getElementById('closeClaudePanel');
+        if (closeClaudePanel) {
+            closeClaudePanel.addEventListener('click', () => {
+                this.claudePanel.classList.add('hidden');
+                
+                // 如果图像预览也被隐藏，显示空状态
+                if (this.imagePreview.classList.contains('hidden')) {
+                    this.emptyState.classList.remove('hidden');
+                }
+                
+                // 重置状态指示灯
+                this.updateStatusLight('');
+                
+                // 清空响应内容，准备下一次分析
+                this.responseContent.innerHTML = '';
+                
+                // 隐藏思考部分
+                this.thinkingSection.classList.add('hidden');
+                this.thinkingContent.innerHTML = '';
+                this.thinkingContent.className = 'thinking-content collapsed';
+            });
+        }
+    }
+
+    setupThinkingToggle() {
+        // 确保正确获取DOM元素
+        const thinkingSection = document.getElementById('thinkingSection');
+        const thinkingToggle = document.getElementById('thinkingToggle');
+        const thinkingContent = document.getElementById('thinkingContent');
+        
+        if (!thinkingToggle || !thinkingContent) {
+            console.error('思考切换组件未找到必要的DOM元素');
+            return;
+        }
+        
+        // 初始化时隐藏动态省略号
+        this.showThinkingAnimation(false);
+        
+        // 存储DOM引用
+        this.thinkingSection = thinkingSection;
+        this.thinkingToggle = thinkingToggle;
+        this.thinkingContent = thinkingContent;
+        
+        // 直接使用函数，确保作用域正确
+        thinkingToggle.onclick = () => {
+            console.log('点击了思考标题');
+            
+            // 先移除两个类，然后添加正确的类
+            const isExpanded = thinkingContent.classList.contains('expanded');
+            const toggleIcon = thinkingToggle.querySelector('.toggle-btn i');
+            
+            // 从样式上清除当前状态
+            thinkingContent.classList.remove('expanded');
+            thinkingContent.classList.remove('collapsed');
+            
+            if (isExpanded) {
+                console.log('折叠思考内容');
+                // 添加折叠状态
+                thinkingContent.classList.add('collapsed');
+                if (toggleIcon) {
+                    toggleIcon.className = 'fas fa-chevron-down';
+                }
+                // 更新用户偏好
+                this.userThinkingExpanded = false;
+            } else {
+                console.log('展开思考内容');
+                // 添加展开状态
+                thinkingContent.classList.add('expanded');
+                if (toggleIcon) {
+                    toggleIcon.className = 'fas fa-chevron-up';
+                }
+                // 更新用户偏好
+                this.userThinkingExpanded = true;
+                
+                // 当展开思考内容时，确保代码高亮生效
+                if (window.hljs) {
+                    setTimeout(() => {
+                        thinkingContent.querySelectorAll('pre code').forEach((block) => {
+                            hljs.highlightElement(block);
+                        });
+                    }, 100); // 添加一点延迟，确保DOM已完全更新
+                }
+            }
+        };
+        
+        console.log('思考切换组件初始化完成');
+    }
+
+    // 获取用于显示的图像URL，如果原始URL无效则返回占位符
+    getImageForDisplay(imageUrl) {
+        return this.isValidImageDataUrl(imageUrl) ? imageUrl : this.getPlaceholderImageUrl();
+    }
+
+    sendImageToClaude(imageData) {
+        const settings = window.settingsManager.getSettings();
+        
+        // 获取API密钥
+        const apiKeys = {};
+        Object.keys(window.settingsManager.apiKeyInputs).forEach(keyId => {
+            const input = window.settingsManager.apiKeyInputs[keyId];
+            if (input && input.value) {
+                apiKeys[keyId] = input.value;
+            }
+        });
+        
+        console.log("Debug - 发送API密钥:", apiKeys);
+        
+        try {
+            // 处理图像数据，去除base64前缀
+            let processedImageData = imageData;
+            if (imageData.startsWith('data:')) {
+                // 分割数据URL，只保留base64部分
+                processedImageData = imageData.split(',')[1];
+            }
+            
+            this.socket.emit('analyze_image', { 
+                image: processedImageData, 
+                settings: {
+                    ...settings,
+                    apiKeys: apiKeys,
+                    model: settings.model || 'claude-3-7-sonnet-20250219',
+                    modelInfo: settings.modelInfo || {},
+                    modelCapabilities: {
+                        supportsMultimodal: settings.modelInfo?.supportsMultimodal || false,
+                        isReasoning: settings.modelInfo?.isReasoning || false
+                    }
+                }
+            });
+            
+            // 注意：Claude面板的显示已经在点击事件中处理，这里不再重复
+        } catch (error) {
+            this.setElementContent(this.responseContent, 'Error: ' + error.message);
+            window.uiManager.showToast('发送图片分析失败', 'error');
+            this.sendToClaudeBtn.disabled = false;
+        }
+    }
+
+    async initialize() {
+        console.log('Initializing SnapSolver...');
+        
+        // 重置调试计数器
+        window.captureCounter = 0;
+        window.responseCounter = 0;
+        console.log('DEBUG: 重置截图计数器');
+        
+        // 初始化managers
+        // 确保UIManager已经初始化，如果没有，等待它初始化
+        if (!window.uiManager) {
+            console.log('等待UI管理器初始化...');
+            window.uiManager = new UIManager();
+            // 给UIManager一些时间初始化
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        
+        window.settingsManager = new SettingsManager();
+        window.app = this; // 便于从其他地方访问
+        
+        // 等待SettingsManager初始化完成
+        if (window.settingsManager) {
+            // 如果settingsManager还没初始化完成，等待它
+            if (!window.settingsManager.isInitialized) {
+                console.log('等待设置管理器初始化完成...');
+                // 最多等待5秒
+                for (let i = 0; i < 50; i++) {
+                    if (window.settingsManager.isInitialized) break;
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+            }
+        }
+        
+        // 初始化Markdown工具
+        this.initializeMarkdownTools();
+        
+        // 建立与服务器的连接
+        this.connectToServer();
+        
+        // 初始化UI元素和事件处理
+        this.initializeElements();
+        
+        // 设置所有事件监听器（注意：setupEventListeners内部已经调用了setupCaptureEvents，不需要重复调用）
+        this.setupEventListeners();
+        this.setupAutoScroll();
+        
+        // 监听窗口大小变化，调整界面
+        window.addEventListener('resize', this.handleResize.bind(this));
+        
+        // 监听document点击事件，处理面板关闭
+        document.addEventListener('click', (e) => {
+            // 关闭裁剪器
+            if (this.cropContainer &&
+                !this.cropContainer.contains(e.target) &&
+                !e.target.matches('#cropBtn') &&
+                !this.cropContainer.classList.contains('hidden')) {
+                this.cropContainer.classList.add('hidden');
+            }
+        });
+        
+        // 监听页面卸载事件，清除所有计时器
+        window.addEventListener('beforeunload', this.cleanup.bind(this));
+        
+        // 设置默认UI状态
+        this.enableInterface();
+        
+        // 更新图像操作按钮
+        this.updateImageActionButtons();
+        
+        console.log('SnapSolver initialization complete');
+    }
+    
+    // 初始化Markdown工具
+    initializeMarkdownTools() {
+        // 检查marked是否可用
+        if (typeof marked === 'undefined') {
+            console.warn('Marked.js 未加载，Markdown渲染将不可用');
+            return;
+        }
+        
+        // 创建一个备用的hljs对象，以防CDN加载失败
+        if (typeof hljs === 'undefined') {
+            console.warn('Highlight.js未加载，创建备用对象');
+            window.hljs = {
+                highlight: (code, opts) => ({ value: code }),
+                highlightAuto: (code) => ({ value: code }),
+                getLanguage: () => null,
+                configure: () => {}
+            };
+        }
+        
+        // 初始化marked设置
+        marked.setOptions({
+            gfm: true, // 启用GitHub风格的Markdown
+            breaks: true, // 将换行符转换为<br>
+            pedantic: false, // 不使用原始markdown规范
+            sanitize: false, // 不要过滤HTML标签，允许一些HTML
+            smartLists: true, // 使用比原生markdown更智能的列表行为
+            smartypants: false, // 不要使用更智能的标点符号
+            xhtml: false, // 不使用自闭合标签
+            mangle: false, // 不混淆邮箱地址
+            headerIds: false, // 不生成header ID
+            highlight: function(code, lang) {
+                // 如果highlight.js不可用，直接返回代码
+                if (typeof hljs === 'undefined') {
+                    return code;
+                }
+                
+                // 如果指定了语言且hljs支持
+                if (lang && hljs.getLanguage(lang)) {
+                    try {
+                        return hljs.highlight(code, { language: lang }).value;
+                    } catch (err) {
+                        console.error('代码高亮错误:', err);
+                    }
+                }
+                
+                // 尝试自动检测语言
+                try {
+                    return hljs.highlightAuto(code).value;
+                } catch (err) {
+                    console.error('自动语言检测错误:', err);
+                }
+                
+                return code; // 使用默认编码效果
+            }
+        });
+
+        // 配置hljs以支持自动语言检测
+        try {
+            hljs.configure({
+                languages: ['javascript', 'python', 'java', 'cpp', 'csharp', 'html', 'css', 'json', 'xml', 'markdown', 'bash']
+            });
+            console.log('Markdown工具初始化完成');
+        } catch (err) {
+            console.error('配置hljs时出错:', err);
+        }
+    }
+
+    handleResize() {
+        // 如果裁剪器存在，需要调整其大小和位置
+        if (this.cropper) {
+            this.cropper.resize();
+        }
+        
+        // 可以在这里添加其他响应式UI调整
+    }
+
+    enableInterface() {
+        // 启用主要界面元素
+        if (this.captureBtn) {
+            this.captureBtn.disabled = false;
+            this.captureBtn.innerHTML = '<i class="fas fa-camera"></i>';
+        }
+        
+        // 显示默认的空白状态
+        if (this.emptyState && this.imagePreview) {
+            if (!this.originalImage) {
+                this.emptyState.classList.remove('hidden');
+                this.imagePreview.classList.add('hidden');
+            } else {
+                this.emptyState.classList.add('hidden');
+                this.imagePreview.classList.remove('hidden');
+            }
+        }
+        
+        console.log('Interface enabled');
+    }
+
+    connectToServer() {
+        console.log('Connecting to server...');
+        
+        // 创建Socket.IO连接
+        this.socket = io({
+            reconnectionAttempts: 5,
+            reconnectionDelay: 1000,
+            timeout: 20000
+        });
+        
+        // 连接事件处理
+        this.socket.on('connect', () => {
+            console.log('Connected to server');
+            this.updateConnectionStatus('已连接', true);
+            
+            // 连接后启用界面
+            this.enableInterface();
+        });
+        
+        this.socket.on('disconnect', () => {
+            console.log('Disconnected from server');
+            this.updateConnectionStatus('已断开', false);
+            
+            // 断开连接时禁用界面
+            if (this.captureBtn) {
+                this.captureBtn.disabled = true;
+            }
+        });
+        
+        this.socket.on('connect_error', (error) => {
+            console.error('Connection error:', error);
+            this.updateConnectionStatus('连接错误', false);
+        });
+        
+        this.socket.on('reconnect_attempt', (attemptNumber) => {
+            console.log(`Reconnection attempt ${attemptNumber}`);
+            this.updateConnectionStatus('正在重连...', false);
+        });
+        
+        this.socket.on('reconnect', () => {
+            console.log('Reconnected to server');
+            this.updateConnectionStatus('已重连', true);
+            
+            // 重连后启用界面
+            this.enableInterface();
+        });
+        
+        this.socket.on('reconnect_failed', () => {
+            console.error('Failed to reconnect');
+            this.updateConnectionStatus('重连失败', false);
+            window.uiManager.showToast('连接服务器失败，请刷新页面重试', 'error');
+        });
+        
+        // 设置socket事件处理器
+        this.setupSocketEventHandlers();
+    }
+
+    isConnected() {
+        return this.socket && this.socket.connected;
+    }
+
+    checkConnectionBeforeAction(action) {
+        if (!this.isConnected()) {
+            window.uiManager.showToast('未连接到服务器，请等待连接建立后再试', 'error');
+            return false;
+        }
+        return true;
+    }
+
+    scrollToBottom() {
+        if (this.responseContent) {
+            // 使用平滑滚动效果
+            this.responseContent.scrollTo({
+                top: this.responseContent.scrollHeight,
+                behavior: 'smooth'
+            });
+            
+            // 确保Claude面板也滚动到可见区域
+            if (this.claudePanel) {
+                this.claudePanel.scrollIntoView({ 
+                    behavior: 'smooth',
+                    block: 'end'
+                });
+            }
+        }
+    }
+
+    // 新增方法：根据所选模型更新图像操作按钮
+    updateImageActionButtons() {
+        if (!window.settingsManager) {
+            console.error('Settings manager not available');
+            return;
+        }
+        
+        const settings = window.settingsManager.getSettings();
+        const isMultimodalModel = settings.modelInfo?.supportsMultimodal || false;
+        const modelName = settings.model || '未知';
+        
+        console.log(`更新图像操作按钮 - 当前模型: ${modelName}, 是否支持多模态: ${isMultimodalModel}`);
+        
+        // 对于截图后的操作按钮显示逻辑
+        if (this.sendToClaudeBtn && this.extractTextBtn) {
+            if (!isMultimodalModel) {
+                // 非多模态模型：只显示提取文本按钮，隐藏发送到AI按钮
+                console.log('非多模态模型：隐藏"发送图片至AI"按钮');
+                this.sendToClaudeBtn.classList.add('hidden');
+                this.extractTextBtn.classList.remove('hidden');
+            } else {
+                // 多模态模型：显示两个按钮
+                if (!this.imagePreview.classList.contains('hidden')) {
+                    // 只有在有图像时才显示按钮
+                    console.log('多模态模型：显示全部按钮');
+                    this.sendToClaudeBtn.classList.remove('hidden');
+                    this.extractTextBtn.classList.remove('hidden');
+                } else {
+                    // 无图像时隐藏所有按钮
+                    console.log('无图像：隐藏所有按钮');
+                    this.sendToClaudeBtn.classList.add('hidden');
+                    this.extractTextBtn.classList.add('hidden');
+                }
+            }
+        } else {
+            console.warn('按钮元素不可用');
+        }
+    }
+
+    checkClickOutside() {
+        // 点击其他区域时自动关闭悬浮窗
+        document.addEventListener('click', (e) => {
+            // 检查是否点击在设置面板、设置按钮或其子元素之外
+            if (
+                !e.target.closest('#settingsPanel') && 
+                !e.target.matches('#settingsToggle') && 
+                !e.target.closest('#settingsToggle') &&
+                document.getElementById('settingsPanel').classList.contains('active')
+            ) {
+                document.getElementById('settingsPanel').classList.remove('active');
+            }
+            
+            // 检查是否点击在Claude面板、分析按钮或其子元素之外
+            if (
+                !e.target.closest('#claudePanel') && 
+                !e.target.matches('#sendToClaude') && 
+                !e.target.closest('#sendToClaude') &&
+                !e.target.matches('#extractText') && 
+                !e.target.closest('#extractText') &&
+                !e.target.matches('#sendExtractedText') && 
+                !e.target.closest('#sendExtractedText') &&
+                !this.claudePanel.classList.contains('hidden')
+            ) {
+                // 因为分析可能正在进行，不自动关闭Claude面板
+                // 但是可以考虑增加一个最小化功能
+            }
+        });
+    }
+
+    // 新增清理方法，移除计时器相关代码
+    cleanup() {
+        console.log('执行清理操作...');
+        
+        // 清除所有Socket监听器
+        if (this.socket) {
+            this.socket.off('text_extracted');
+            this.socket.off('screenshot_response');
+            this.socket.off('screenshot_complete');
+            this.socket.off('request_acknowledged');
+            this.socket.off('ai_response');
+            this.socket.off('thinking');
+            this.socket.off('thinking_complete');
+            this.socket.off('analysis_complete');
+        }
+        
+        // 销毁裁剪器实例
+        if (this.cropper) {
+            this.cropper.destroy();
+            this.cropper = null;
+        }
+        
+        console.log('清理完成');
+    }
+
+    // 空方法替代键盘快捷键实现
+    setupKeyboardShortcuts() {
+        // 移动端应用不需要键盘快捷键
+        console.log('键盘快捷键已禁用（移动端应用）');
+    }
+
+    // 控制思考动态省略号显示
+    showThinkingAnimation(show) {
+        const dotsElement = document.querySelector('.thinking-title .dots-animation');
+        if (dotsElement) {
+            if (show) {
+                dotsElement.style.display = 'inline-block';
+            } else {
+                dotsElement.style.display = 'none';
+            }
+        }
+    }
+
+    // 添加停止生成方法
+    stopGeneration() {
+        console.log('停止生成请求');
+        
+        // 向服务器发送停止生成信号
+        if (this.socket && this.socket.connected) {
+            this.socket.emit('stop_generation');
+            
+            // 显示提示
+            window.uiManager.showToast('正在停止生成...', 'info');
+            
+            // 隐藏停止按钮
+            this.hideStopGenerationButton();
+        } else {
+            console.error('无法停止生成: Socket未连接');
+            window.uiManager.showToast('无法停止生成: 连接已断开', 'error');
+        }
+    }
+    
+    // 显示停止生成按钮
+    showStopGenerationButton() {
+        if (this.stopGenerationBtn) {
+            this.stopGenerationBtn.classList.add('visible');
+        }
+    }
+    
+    // 隐藏停止生成按钮
+    hideStopGenerationButton() {
+        if (this.stopGenerationBtn) {
+            this.stopGenerationBtn.classList.remove('visible');
+        }
+    }
+}
+
+// Initialize the application when the DOM is loaded
+document.addEventListener('DOMContentLoaded', async () => {
+    try {
+        console.log('Initializing application...');
+        window.app = new SnapSolver();
+        await window.app.initialize();
+        console.log('Application initialized successfully');
+    } catch (error) {
+        console.error('Failed to initialize application:', error);
+        // 在页面上显���错误信息
+        const errorDiv = document.createElement('div');
+        errorDiv.className = 'init-error';
+        errorDiv.innerHTML = `
+            <h2>Initialization Error</h2>
+            <p>${error.message}</p>
+            <pre>${error.stack}</pre>
+        `;
+        document.body.appendChild(errorDiv);
+    }
+});

static/js/ui.js

@@ -0,0 +1,280 @@
+class UIManager {
+    constructor() {
+        // 延迟初始化，确保DOM已加载
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', () => this.init());
+        } else {
+            // 如果DOM已经加载完成，则立即初始化
+            this.init();
+        }
+    }
+    
+    init() {
+        console.log('初始化UI管理器...');
+        // UI elements
+        this.settingsPanel = document.getElementById('settingsPanel');
+        this.settingsToggle = document.getElementById('settingsToggle');
+        this.closeSettings = document.getElementById('closeSettings');
+        this.themeToggle = document.getElementById('themeToggle');
+        this.toastContainer = document.getElementById('toastContainer');
+        
+        // 验证关键元素是否存在
+        if (!this.themeToggle) {
+            console.error('主题切换按钮未找到！');
+            return;
+        }
+        
+        if (!this.toastContainer) {
+            console.error('Toast容器未找到！');
+            // 尝试创建Toast容器
+            this.toastContainer = this.createToastContainer();
+        }
+        
+        // Check for preferred color scheme
+        this.checkPreferredColorScheme();
+        
+        // Initialize event listeners
+        this.setupEventListeners();
+        
+        console.log('UI管理器初始化完成');
+    }
+    
+    createToastContainer() {
+        console.log('创建Toast容器');
+        const container = document.createElement('div');
+        container.id = 'toastContainer';
+        container.className = 'toast-container';
+        document.body.appendChild(container);
+        return container;
+    }
+    
+    checkPreferredColorScheme() {
+        const savedTheme = localStorage.getItem('theme');
+        const prefersDark = window.matchMedia('(prefers-color-scheme: dark)');
+        
+        if (savedTheme) {
+            this.setTheme(savedTheme === 'dark');
+        } else {
+            this.setTheme(prefersDark.matches);
+        }
+        
+        prefersDark.addEventListener('change', (e) => this.setTheme(e.matches));
+    }
+    
+    setTheme(isDark) {
+        try {
+            document.documentElement.setAttribute('data-theme', isDark ? 'dark' : 'light');
+            if (this.themeToggle) {
+                this.themeToggle.innerHTML = `<i class="fas fa-${isDark ? 'sun' : 'moon'}"></i>`;
+            }
+            localStorage.setItem('theme', isDark ? 'dark' : 'light');
+            console.log(`主题已切换为: ${isDark ? '深色' : '浅色'}`);
+        } catch (error) {
+            console.error('设置主题时出错:', error);
+        }
+    }
+    
+    /**
+     * 显示一个Toast消息
+     * @param {string} message 显示的消息内容
+     * @param {string} type 消息类型，可以是'success', 'error', 'info', 'warning'
+     * @param {number} displayTime 显示的时间(毫秒)，如果为-1则持续显示直到手动关闭
+     * @returns {HTMLElement} 返回创建的Toast元素，可用于后续移除
+     */
+    showToast(message, type = 'success', displayTime) {
+        try {
+            if (!message) {
+                console.warn('尝试显示空消息');
+                message = '';
+            }
+            
+            if (!this.toastContainer) {
+                console.error('Toast容器不存在，正在创建新容器');
+                this.toastContainer = this.createToastContainer();
+                if (!this.toastContainer) {
+                    console.error('无法创建Toast容器，放弃显示消息');
+                    return null;
+                }
+            }
+            
+            // 检查是否已经存在相同内容的提示
+            try {
+                const existingToasts = this.toastContainer.querySelectorAll('.toast');
+                for (const existingToast of existingToasts) {
+                    try {
+                        const spanElement = existingToast.querySelector('span');
+                        if (spanElement && spanElement.textContent === message) {
+                            // 已经存在相同的提示，不再创建新的
+                            return existingToast;
+                        }
+                    } catch (e) {
+                        console.warn('检查现有toast时出错:', e);
+                        // 继续检查其他toast元素
+                    }
+                }
+            } catch (e) {
+                console.warn('查询现有toast时出错:', e);
+                // 继续创建新的toast
+            }
+            
+            const toast = document.createElement('div');
+            toast.className = `toast ${type}`;
+            
+            // 根据类型设置图标
+            let icon = 'check-circle';
+            if (type === 'error') icon = 'exclamation-circle';
+            else if (type === 'warning') icon = 'exclamation-triangle';
+            else if (type === 'info') icon = 'info-circle';
+            
+            toast.innerHTML = `
+                <i class="fas fa-${icon}"></i>
+                <span>${message}</span>
+            `;
+            
+            // 如果是持续显示的Toast，添加关闭按钮
+            if (displayTime === -1) {
+                const closeButton = document.createElement('button');
+                closeButton.className = 'toast-close';
+                closeButton.innerHTML = '<i class="fas fa-times"></i>';
+                closeButton.addEventListener('click', (e) => {
+                    this.hideToast(toast);
+                });
+                toast.appendChild(closeButton);
+                toast.classList.add('persistent');
+            }
+            
+            this.toastContainer.appendChild(toast);
+            
+            // 为不同类型的提示设置不同的显示时间
+            if (displayTime !== -1) {
+                // 如果没有指定时间，则根据消息类型和内容长度设置默认时间
+                if (displayTime === undefined) {
+                    displayTime = message === '截图成功' ? 1500 : 
+                                 type === 'error' ? 5000 : 
+                                 message.length > 50 ? 4000 : 3000;
+                }
+                
+                setTimeout(() => {
+                    this.hideToast(toast);
+                }, displayTime);
+            }
+            
+            return toast;
+        } catch (error) {
+            console.error('显示Toast消息时出错:', error);
+            return null;
+        }
+    }
+    
+    /**
+     * 隐藏一个Toast消息
+     * @param {HTMLElement} toast 要隐藏的Toast元素
+     */
+    hideToast(toast) {
+        if (!toast || !toast.parentNode) return;
+        
+        toast.style.opacity = '0';
+        setTimeout(() => {
+            if (toast.parentNode) {
+                toast.remove();
+            }
+        }, 300);
+    }
+    
+    closeAllPanels() {
+        if (this.settingsPanel) {
+            this.settingsPanel.classList.remove('active');
+        }
+    }
+    
+    hideSettingsPanel() {
+        if (this.settingsPanel) {
+            this.settingsPanel.classList.remove('active');
+        }
+    }
+    
+    toggleSettingsPanel() {
+        if (this.settingsPanel) {
+            this.settingsPanel.classList.toggle('active');
+        }
+    }
+    
+    closeSettingsPanel() {
+        if (this.settingsPanel) {
+            this.settingsPanel.classList.remove('active');
+        }
+    }
+    
+    // 检查点击事件，如果点击了设置面板外部，则关闭设置面板
+    checkClickOutsideSettings(e) {
+        if (this.settingsPanel &&
+            !this.settingsPanel.contains(e.target) &&
+            !e.target.closest('#settingsToggle')) {
+            this.settingsPanel.classList.remove('active');
+        }
+    }
+    
+    setupEventListeners() {
+        // 确保所有元素都存在
+        if (!this.settingsToggle || !this.closeSettings || !this.themeToggle) {
+            console.error('无法设置事件监听器：一些UI元素未找到');
+            return;
+        }
+        
+        // Settings panel
+        this.settingsToggle.addEventListener('click', () => {
+            this.closeAllPanels();
+            this.settingsPanel.classList.toggle('active');
+        });
+        
+        this.closeSettings.addEventListener('click', () => {
+            this.settingsPanel.classList.remove('active');
+        });
+        
+        // Theme toggle
+        this.themeToggle.addEventListener('click', () => {
+            try {
+                const currentTheme = document.documentElement.getAttribute('data-theme');
+                console.log('当前主题:', currentTheme);
+                this.setTheme(currentTheme !== 'dark');
+            } catch (error) {
+                console.error('切换主题时出错:', error);
+            }
+        });
+        
+        // Close panels when clicking outside
+        document.addEventListener('click', (e) => {
+            this.checkClickOutsideSettings(e);
+        });
+    }
+}
+
+// 创建全局实例
+window.UIManager = UIManager;
+
+// 确保在DOM加载完毕后才创建UIManager实例
+if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => {
+        window.uiManager = new UIManager();
+    });
+} else {
+    window.uiManager = new UIManager();
+}
+
+// 导出全局辅助函数
+window.showToast = (message, type) => {
+    if (window.uiManager) {
+        return window.uiManager.showToast(message, type);
+    } else {
+        console.error('UI管理器未初始化，无法显示Toast');
+        return null;
+    }
+};
+
+window.closeAllPanels = () => {
+    if (window.uiManager) {
+        window.uiManager.closeAllPanels();
+    } else {
+        console.error('UI管理器未初始化，无法关闭面板');
+    }
+};

styles.css

@@ -1,12 +0,0 @@
-:root {
-  --bslib-sidebar-main-bg: #f8f8f8;
-}
-
-.popover {
-  --bs-popover-header-bg: #222;
-  --bs-popover-header-color: #fff;
-}
-
-.popover .btn-close {
-  filter: var(--bs-btn-close-white-filter);
-}

templates/index.html

@@ -0,0 +1,946 @@
+<!DOCTYPE html>
+<html lang="en" data-theme="light">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <!-- Safari兼容性设置 -->
+    <meta name="apple-mobile-web-app-capable" content="yes">
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
+    <meta name="mobile-web-app-capable" content="yes">
+    <title>Snap Solver</title>
+    <link rel="icon" href="/static/favicon.ico">
+    <link rel="stylesheet" href="/static/style.css">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/cropperjs/1.5.13/cropper.min.css">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js"></script>
+    <script>
+        // 帮助Safari调试
+        window.onerror = function(message, source, lineno, colno, error) {
+            console.error("Error caught: ", message, "at", source, ":", lineno, ":", colno, error);
+            return false;
+        };
+    </script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/cropperjs/1.5.13/cropper.min.js"></script>
+    <!-- 添加Markdown解析库 -->
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <!-- 添加代码高亮库 -->
+    <link rel="stylesheet" href="https://unpkg.com/@highlightjs/cdn-assets@11.8.0/styles/github.min.css">
+    <script src="https://unpkg.com/@highlightjs/cdn-assets@11.8.0/highlight.min.js"></script>
+</head>
+<body class="app-container">
+    <header class="app-header">
+        <div class="header-content">
+            <h1>Snap Solver <span class="version-badge">v<span id="currentVersion">{{ update_info.current_version }}</span></span></h1>
+            <div class="header-middle">
+                <button id="themeToggle" class="btn-icon" title="切换主题">
+                    <i class="fas fa-moon"></i>
+                </button>
+                <button id="settingsToggle" class="btn-icon" title="设置">
+                    <i class="fas fa-cog"></i>
+                </button>
+                <div id="connectionStatus" class="status disconnected">未连接</div>
+            </div>
+            <div class="header-buttons">
+                <button id="captureBtn" class="btn-icon capture-btn-highlight" title="截图" disabled>
+                    <i class="fas fa-camera"></i>
+                    <span>开始截图</span>
+                </button>
+            </div>
+        </div>
+    </header>
+
+    <!-- 更新通知条 -->
+    <div id="updateNotice" class="update-notice hidden">
+        <div class="update-notice-content">
+            <i class="fas fa-arrow-alt-circle-up"></i>
+            <span>发现新版本: <span id="updateVersion"></span></span>
+            <a id="updateLink" href="#" target="_blank" class="update-link">查看更新</a>
+            <button id="closeUpdateNotice" class="btn-icon">
+                <i class="fas fa-times"></i>
+            </button>
+        </div>
+    </div>
+
+    <main class="app-main">
+        <div class="content-panel">
+            <div id="claudePanel" class="claude-panel hidden">
+                <div class="panel-header">
+                    <div class="header-title">
+                        <h2><i class="fas fa-chart-bar"></i> 分析结果</h2>
+                        <div class="analysis-indicator">
+                            <div class="progress-line"></div>
+                            <div class="status-text">准备中</div>
+                        </div>
+                        <button id="stopGenerationBtn" class="btn-stop-generation" title="停止生成">
+                            <i class="fas fa-stop"></i>
+                        </button>
+                    </div>
+                    <button class="btn-icon" id="closeClaudePanel" title="关闭分析结果">
+                        <i class="fas fa-times"></i>
+                    </button>
+                </div>
+                <div id="thinkingSection" class="thinking-section hidden">
+                    <div class="thinking-header" id="thinkingToggle" title="点击查看AI思考过程">
+                        <div class="thinking-title">
+                            <i class="fas fa-brain"></i>
+                            <h3>思考过程<span class="dots-animation"></span></h3>
+                        </div>
+                        <button class="toggle-btn">
+                            <i class="fas fa-chevron-down"></i>
+                        </button>
+                    </div>
+                    <div id="thinkingContent" class="thinking-content collapsed"></div>
+                </div>
+                <div id="responseContent" class="response-content"></div>
+            </div>
+
+            <div id="claudePanel" class="claude-panel hidden">
+                <div class="panel-header">
+                    <div class="header-title">
+                        <h2><i class="fas fa-chart-bar"></i> 分析结果</h2>
+                        <div class="analysis-indicator">
+                            <div class="progress-line"></div>
+                            <div class="status-text">准备中</div>
+                        </div>
+                        <button id="stopGenerationBtn" class="btn-stop-generation" title="停止生成">
+                            <i class="fas fa-stop"></i>
+                        </button>
+                    </div>
+                    <button class="btn-icon" id="closeClaudePanel" title="关闭分析结果">
+                        <i class="fas fa-times"></i>
+                    </button>
+                </div>
+                <div id="thinkingSection" class="thinking-section hidden">
+                    <div class="thinking-header" id="thinkingToggle" title="点击查看AI思考过程">
+                        <div class="thinking-title">
+                            <i class="fas fa-brain"></i>
+                            <h3>思考过程<span class="dots-animation"></span></h3>
+                        </div>
+                        <button class="toggle-btn">
+                            <i class="fas fa-chevron-down"></i>
+                        </button>
+                    </div>
+                    <div id="thinkingContent" class="thinking-content collapsed"></div>
+                </div>
+                <div id="responseContent" class="response-content"></div>
+            </div>
+
+            <div class="capture-section">
+                <div id="emptyState" class="empty-state">
+                    <i class="fas fa-camera-retro"></i>
+                    <h3>准备好开始了吗？</h3>
+                    <p>点击顶部状态栏的"相机"图标捕获屏幕，然后使用AI分析图像或提取文本。您可以截取数学题、代码或任何需要帮助的内容。</p>
+                    <p class="star-prompt">如果觉得好用，别忘了给Github点个 Star ⭐</p>
+                    <div class="empty-state-social">
+                        <a href="https://github.com/Zippland/Snap-Solver/" target="_blank" class="social-link github-link">
+                            <span>GitHub</span>
+                        </a>
+                        <a href="https://www.xiaohongshu.com/user/profile/623e8b080000000010007721" target="_blank" class="social-link xiaohongshu-link">
+                            <span>小红书</span>
+                        </a>
+                    </div>
+                </div>
+                <div id="imagePreview" class="image-preview hidden">
+                    <div class="image-container">
+                        <img id="screenshotImg" src="" alt="截图预览">
+                    </div>
+                    <div class="analysis-button">
+                        <div class="button-group">
+                            <button id="sendToClaude" class="btn-action hidden">
+                                <i class="fas fa-robot"></i>
+                                <span>发送至AI</span>
+                            </button>
+                            <button id="extractText" class="btn-action hidden">
+                                <i class="fas fa-font"></i>
+                                <span>提取文本</span>
+                            </button>
+                        </div>
+                    </div>
+                    
+                    <textarea id="extractedText" class="extracted-text-area hidden" rows="6" placeholder="提取的文本将显示在这里..."></textarea>
+                    <button id="sendExtractedText" class="btn-action send-text-btn hidden">
+                        <i class="fas fa-paper-plane"></i>
+                        <span>发送文本至AI</span>
+                    </button>
+                </div>
+            </div>
+
+            <div class="clipboard-panel">
+                <div class="clipboard-header">
+                    <h3><i class="fas fa-clipboard"></i> 剪贴板操作</h3>
+                    <p class="clipboard-hint">读取宿主机剪贴板内容或发送内容到服务端剪贴板</p>
+                </div>
+                <textarea id="clipboardText" rows="4" placeholder="剪贴板内容将显示在这里，也可以手动输入内容"></textarea>
+                <div class="clipboard-actions">
+                    <button id="clipboardRead" class="btn-action clipboard-read-btn" type="button">
+                        <i class="fas fa-download"></i>
+                        <span>读取剪贴板</span>
+                    </button>
+                    <button id="clipboardSend" class="btn-action clipboard-send-btn" type="button">
+                        <i class="fas fa-clipboard-check"></i>
+                        <span>发送至剪贴板</span>
+                    </button>
+                    <span id="clipboardStatus" class="clipboard-status" aria-live="polite"></span>
+                </div>
+            </div>
+        </div>
+
+        <aside id="settingsPanel" class="settings-panel">
+            <div class="settings-header">
+                <h2><i class="fas fa-cog"></i> 设置</h2>
+                <button id="closeSettings" class="btn-icon">
+                    <i class="fas fa-times"></i>
+                </button>
+            </div>
+            <div class="settings-content">
+                <!-- 1. 首先是最常用的AI模型选择部分 -->
+                <div class="settings-section model-settings">
+                    <h3><i class="fas fa-robot"></i> 模型设置</h3>
+                    <div class="setting-group">
+                        <div class="model-control">
+                            <label for="modelSelect"><i class="fas fa-microchip"></i> AI模型</label>
+                            <!-- 简化模型选择器结构 -->
+                            <div class="model-selector" id="modelSelector">
+                                <div class="model-display">
+                                    <div class="model-display-icon">
+                                        <i class="fas fa-robot"></i>
+                                    </div>
+                                    <div class="model-display-info">
+                                        <div class="model-display-name" id="currentModelName">选择模型</div>
+                                        <div class="model-display-provider" id="currentModelProvider"></div>
+                                    </div>
+                                    <div class="model-display-badges" id="modelBadges">
+                                        <!-- 能力图标由JS生成 -->
+                                    </div>
+                                    <i class="fas fa-chevron-down model-selector-arrow"></i>
+                                </div>
+                            </div>
+                            <!-- 保留原始下拉框用于保持兼容性 -->
+                            <select id="modelSelect" class="hidden">
+                                <!-- 选项通过JS添加 -->
+                            </select>
+                            <div id="modelVersionInfo" class="model-version-info">
+                                <i class="fas fa-info-circle"></i> <span id="modelVersionText">-</span>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="setting-group">
+                        <div class="token-control">
+                            <div class="token-label">
+                                <label for="maxTokens"><i class="fas fa-text-width"></i> 最大输出Token</label>
+                            </div>
+                            <div class="token-slider-container">
+                                <input type="range" id="maxTokens" class="token-slider" min="1000" max="128000" step="1000" value="8192">
+                                <span class="token-value" id="maxTokensValue">8192</span>
+                            </div>
+                            <div class="token-markers">
+                                <span>1K</span>
+                                <span>32K</span>
+                                <span>64K</span>
+                                <span>96K</span>
+                                <span>128K</span>
+                            </div>
+                            <div class="token-presets">
+                                <button class="token-preset" data-value="4000">简短</button>
+                                <button class="token-preset" data-value="16000">标准</button>
+                                <button class="token-preset" data-value="64000">详细</button>
+                                <button class="token-preset" data-value="128000">最大</button>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="setting-group reasoning-setting-group">
+                        <div class="reasoning-control">
+                            <div class="reasoning-label">
+                                <label for="reasoningDepth"><i class="fas fa-brain"></i> 推理深度</label>
+                            </div>
+                            <div class="reasoning-selector">
+                                <div class="reasoning-option" data-value="standard">
+                                    <i class="fas fa-bolt"></i>
+                                    <span class="option-name">标准模式</span>
+                                    <span class="option-desc">快速响应，即时生成</span>
+                                </div>
+                                <div class="reasoning-option" data-value="extended">
+                                    <i class="fas fa-lightbulb"></i>
+                                    <span class="option-name">深度思考</span>
+                                    <span class="option-desc">更详细的分析与推理</span>
+                                </div>
+                            </div>
+                            <select id="reasoningDepth" class="hidden">
+                                <option value="standard">标准模式 (快速响应)</option>
+                                <option value="extended">深度思考 (更详细分析)</option>
+                            </select>
+                        </div>
+                    </div>
+                    <div class="setting-group doubao-thinking-group" style="display: none;">
+                        <div class="doubao-thinking-control">
+                            <div class="doubao-thinking-label">
+                                <label for="doubaoThinkingMode"><i class="fas fa-cogs"></i> 豆包深度思考模式</label>
+                            </div>
+                            <div class="doubao-thinking-selector">
+                                <div class="doubao-thinking-option active" data-value="auto">
+                                    <i class="fas fa-magic"></i>
+                                    <span class="option-name">自动模式</span>
+                                    <span class="option-desc">由AI自动决定是否使用深度思考</span>
+                                </div>
+                                <div class="doubao-thinking-option" data-value="enabled">
+                                    <i class="fas fa-brain"></i>
+                                    <span class="option-name">开启思考</span>
+                                    <span class="option-desc">强制启用深度思考过程</span>
+                                </div>
+                                <div class="doubao-thinking-option" data-value="disabled">
+                                    <i class="fas fa-bolt"></i>
+                                    <span class="option-name">关闭思考</span>
+                                    <span class="option-desc">禁用深度思考，快速响应</span>
+                                </div>
+                            </div>
+                            <select id="doubaoThinkingMode" class="hidden">
+                                <option value="auto">自动模式</option>
+                                <option value="enabled">开启思考</option>
+                                <option value="disabled">关闭思考</option>
+                            </select>
+                            <div class="doubao-thinking-desc">
+                                <div class="doubao-desc-item">
+                                    <i class="fas fa-info-circle"></i>
+                                    <span><strong>自动模式：</strong>AI根据问题复杂度自动决定</span>
+                                </div>
+                                <div class="doubao-desc-item">
+                                    <i class="fas fa-lightbulb"></i>
+                                    <span><strong>开启思考：</strong>显示完整的思考推理过程</span>
+                                </div>
+                                <div class="doubao-desc-item">
+                                    <i class="fas fa-rocket"></i>
+                                    <span><strong>关闭思考：</strong>直接给出答案，响应更快</span>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="setting-group think-budget-group">
+                        <div class="think-budget-control">
+                            <div class="think-budget-label">
+                                <label for="thinkBudgetPercent"><i class="fas fa-hourglass-half"></i> 思考预算占比</label>
+                            </div>
+                            <div class="think-slider-container">
+                                <input type="range" id="thinkBudgetPercent" class="think-slider" min="10" max="80" step="5" value="50">
+                                <span class="think-value-badge" id="thinkBudgetPercentValue">50%</span>
+                            </div>
+                            <div class="think-budget-markers">
+                                <span>10%</span>
+                                <span>30%</span>
+                                <span>50%</span>
+                                <span>70%</span>
+                                <span>80%</span>
+                            </div>
+                            <div class="think-budget-presets">
+                                <button class="think-preset" data-value="20">少量</button>
+                                <button class="think-preset" data-value="50">平衡</button>
+                                <button class="think-preset" data-value="70">深入</button>
+                            </div>
+                            <div class="think-budget-desc">
+                                <div class="think-desc-item">
+                                    <i class="fas fa-tachometer-alt"></i>
+                                    <span>低���比 = 更快响应速度</span>
+                                </div>
+                                <div class="think-desc-item">
+                                    <i class="fas fa-search-plus"></i>
+                                    <span>高占比 = 更深入的分析</span>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    <!-- 已删除重复的豆包思考模式UI元素 -->
+                    <div class="setting-group">
+                        <div class="temperature-control">
+                            <div class="temperature-label">
+                                <label for="temperature"><i class="fas fa-thermometer-half"></i> 温度</label>
+                            </div>
+                            <input type="range" id="temperature" class="temperature-slider" min="0" max="1" step="0.1" value="0.7">
+                            <div class="temperature-markers">
+                                <span>0</span>
+                                <span>0.2</span>
+                                <span>0.4</span>
+                                <span>0.6</span>
+                                <span>0.8</span>
+                                <span>1</span>
+                            </div>
+                            <div class="temperature-description">
+                                <span class="temperature-low">精确</span>
+                                <span class="temperature-high">创意</span>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                
+                <!-- 系统提示词部分 - 简化设计 -->
+                <div class="settings-section prompt-settings">
+                    <h3><i class="fas fa-comment-alt"></i> 系统提示词</h3>
+                    <div class="setting-group prompt-setting-group">
+                        <div class="prompt-container">
+                            <div class="prompt-actions">
+                                <select id="promptSelect" title="选择预设提示词">
+                                </select>
+                                <div class="prompt-buttons">
+                                    <button id="savePromptBtn" class="icon-btn" title="编辑当前提示词">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                    <button id="newPromptBtn" class="icon-btn" title="新建提示词">
+                                        <i class="fas fa-plus"></i>
+                                    </button>
+                                    <button id="deletePromptBtn" class="icon-btn" title="删除当前提示词">
+                                        <i class="fas fa-trash"></i>
+                                    </button>
+                                </div>
+                            </div>
+                            <div class="prompt-preview">
+                                <div id="promptDescription" class="prompt-description">
+                                    <p>您是一位专业的问题解决专家。请逐步分析问题，找出问题所在，并提供详细的解决方案。始终使用用户偏好的语言回答。</p>
+                                </div>
+                                <div class="prompt-preview-overlay">
+                                    <div class="prompt-edit-hint">
+                                        <!-- 移除重复的编辑图标 -->
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                        <textarea id="systemPrompt" class="hidden">您是一位专业的问题解决专家。请逐步分析问题，找出问题所在，并提供详细的解决方案。始终使用用户偏好的语言回答。</textarea>
+                    </div>
+                </div>
+
+                <!-- OCR设置部分 -->
+                <div class="settings-section ocr-settings">
+                    <h3><i class="fas fa-font"></i> OCR 源设置</h3>
+                    <div class="setting-group">
+                        <div class="ocr-source-control">
+                            <div class="ocr-source-selector">
+                                <select id="ocrSourceSelect" class="ocr-source-select">
+                                    <option value="auto">自动选择</option>
+                                    <option value="baidu">百度OCR</option>
+                                    <option value="mathpix">Mathpix</option>
+                                </select>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- 2. 所有API密钥集中在一个区域 -->
+                <div class="settings-section api-key-settings">
+                    <h3><i class="fas fa-key"></i> API密钥设置</h3>
+                    
+                    <!-- API密钥状态显示与编辑区域 -->
+                    <div class="api-keys-list" id="apiKeysList">
+                        <div class="api-key-status">
+                            <span class="key-name">Anthropic API:</span>
+                            <div class="key-status-wrapper">
+                                <!-- 显示状态 -->
+                                <div class="key-display">
+                                    <span id="AnthropicApiKeyStatus" class="key-status" data-key="AnthropicApiKey">未设置</span>
+                                    <button class="btn-icon edit-api-key" data-key-type="AnthropicApiKey" title="编辑此密钥">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                </div>
+                                <!-- 编辑状态 -->
+                                <div class="key-edit hidden">
+                                    <input type="password" class="key-input" data-key-type="AnthropicApiKey" placeholder="输入 Anthropic API key">
+                                    <button class="btn-icon toggle-visibility">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <button class="btn-icon save-api-key" data-key-type="AnthropicApiKey" title="保存密钥">
+                                        <i class="fas fa-save"></i>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="api-key-status">
+                            <span class="key-name">OpenAI API:</span>
+                            <div class="key-status-wrapper">
+                                <!-- 显示状态 -->
+                                <div class="key-display">
+                                    <span id="OpenaiApiKeyStatus" class="key-status" data-key="OpenaiApiKey">未设置</span>
+                                    <button class="btn-icon edit-api-key" data-key-type="OpenaiApiKey" title="编辑此密钥">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                </div>
+                                <!-- 编辑状态 -->
+                                <div class="key-edit hidden">
+                                    <input type="password" class="key-input" data-key-type="OpenaiApiKey" placeholder="输入 OpenAI API key">
+                                    <button class="btn-icon toggle-visibility">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <button class="btn-icon save-api-key" data-key-type="OpenaiApiKey" title="保存密钥">
+                                        <i class="fas fa-save"></i>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="api-key-status">
+                            <span class="key-name">DeepSeek API:</span>
+                            <div class="key-status-wrapper">
+                                <!-- 显示状态 -->
+                                <div class="key-display">
+                                    <span id="DeepseekApiKeyStatus" class="key-status" data-key="DeepseekApiKey">未设置</span>
+                                    <button class="btn-icon edit-api-key" data-key-type="DeepseekApiKey" title="编辑此密钥">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                </div>
+                                <!-- 编辑状态 -->
+                                <div class="key-edit hidden">
+                                    <input type="password" class="key-input" data-key-type="DeepseekApiKey" placeholder="输入 DeepSeek API key">
+                                    <button class="btn-icon toggle-visibility">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <button class="btn-icon save-api-key" data-key-type="DeepseekApiKey" title="保存密钥">
+                                        <i class="fas fa-save"></i>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="api-key-status">
+                            <span class="key-name">Alibaba API:</span>
+                            <div class="key-status-wrapper">
+                                <!-- 显示状态 -->
+                                <div class="key-display">
+                                    <span id="AlibabaApiKeyStatus" class="key-status" data-key="AlibabaApiKey">未设置</span>
+                                    <button class="btn-icon edit-api-key" data-key-type="AlibabaApiKey" title="编辑此密钥">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                </div>
+                                <!-- 编辑状态 -->
+                                <div class="key-edit hidden">
+                                    <input type="password" class="key-input" data-key-type="AlibabaApiKey" placeholder="输入 Alibaba API key">
+                                    <button class="btn-icon toggle-visibility">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <button class="btn-icon save-api-key" data-key-type="AlibabaApiKey" title="保存密钥">
+                                        <i class="fas fa-save"></i>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="api-key-status">
+                            <span class="key-name">Google API:</span>
+                            <div class="key-status-wrapper">
+                                <!-- 显示状态 -->
+                                <div class="key-display">
+                                    <span id="GoogleApiKeyStatus" class="key-status" data-key="GoogleApiKey">未设置</span>
+                                    <button class="btn-icon edit-api-key" data-key-type="GoogleApiKey" title="编辑此密钥">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                </div>
+                                <!-- 编辑状态 -->
+                                <div class="key-edit hidden">
+                                    <input type="password" class="key-input" data-key-type="GoogleApiKey" placeholder="输入 Google API key">
+                                    <button class="btn-icon toggle-visibility">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <button class="btn-icon save-api-key" data-key-type="GoogleApiKey" title="保存密钥">
+                                        <i class="fas fa-save"></i>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="api-key-status">
+                            <span class="key-name">Doubao API:</span>
+                            <div class="key-status-wrapper">
+                                <!-- 显示状态 -->
+                                <div class="key-display">
+                                    <span id="DoubaoApiKeyStatus" class="key-status" data-key="DoubaoApiKey">未设置</span>
+                                    <button class="btn-icon edit-api-key" data-key-type="DoubaoApiKey" title="编辑此密钥">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                </div>
+                                <!-- 编辑状态 -->
+                                <div class="key-edit hidden">
+                                    <input type="password" class="key-input" data-key-type="DoubaoApiKey" placeholder="输入Doubao API key">
+                                    <button class="btn-icon toggle-visibility">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <button class="btn-icon save-api-key" data-key-type="DoubaoApiKey" title="保存密钥">
+                                        <i class="fas fa-save"></i>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                        
+                        <!-- 百度OCR API Key配置 -->
+                        <div class="api-key-status">
+                            <span class="key-name">百度OCR API Key:</span>
+                            <div class="key-status-wrapper">
+                                <!-- 显示状态 -->
+                                <div class="key-display">
+                                    <span id="BaiduApiKeyStatus" class="key-status" data-key="BaiduApiKey">未设置</span>
+                                    <button class="btn-icon edit-api-key" data-key-type="BaiduApiKey" title="编辑此密钥">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                </div>
+                                <!-- 编辑状态 -->
+                                <div class="key-edit hidden">
+                                    <input type="password" class="key-input" data-key-type="BaiduApiKey" placeholder="输入百度OCR API Key">
+                                    <button class="btn-icon toggle-visibility">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <button class="btn-icon save-api-key" data-key-type="BaiduApiKey" title="保存密钥">
+                                        <i class="fas fa-save"></i>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="api-key-status">
+                            <span class="key-name">百度OCR Secret Key:</span>
+                            <div class="key-status-wrapper">
+                                <!-- 显示状态 -->
+                                <div class="key-display">
+                                    <span id="BaiduSecretKeyStatus" class="key-status" data-key="BaiduSecretKey">未设置</span>
+                                    <button class="btn-icon edit-api-key" data-key-type="BaiduSecretKey" title="编辑此密钥">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                </div>
+                                <!-- 编辑状态 -->
+                                <div class="key-edit hidden">
+                                    <input type="password" class="key-input" data-key-type="BaiduSecretKey" placeholder="输入百度OCR Secret Key">
+                                    <button class="btn-icon toggle-visibility">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <button class="btn-icon save-api-key" data-key-type="BaiduSecretKey" title="保存密钥">
+                                        <i class="fas fa-save"></i>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                        
+                        <div class="api-key-status">
+                            <span class="key-name">Mathpix App ID:</span>
+                            <div class="key-status-wrapper">
+                                <!-- 显示状态 -->
+                                <div class="key-display">
+                                    <span id="MathpixAppIdStatus" class="key-status" data-key="MathpixAppId">未设置</span>
+                                    <button class="btn-icon edit-api-key" data-key-type="MathpixAppId" title="编辑此密钥">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                </div>
+                                <!-- 编辑状态 -->
+                                <div class="key-edit hidden">
+                                    <input type="password" class="key-input" data-key-type="MathpixAppId" placeholder="输入 Mathpix App ID">
+                                    <button class="btn-icon toggle-visibility">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <button class="btn-icon save-api-key" data-key-type="MathpixAppId" title="保存密钥">
+                                        <i class="fas fa-save"></i>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="api-key-status">
+                            <span class="key-name">Mathpix App Key:</span>
+                            <div class="key-status-wrapper">
+                                <!-- 显示状态 -->
+                                <div class="key-display">
+                                    <span id="MathpixAppKeyStatus" class="key-status" data-key="MathpixAppKey">未设置</span>
+                                    <button class="btn-icon edit-api-key" data-key-type="MathpixAppKey" title="编辑此密钥">
+                                        <i class="fas fa-edit"></i>
+                                    </button>
+                                </div>
+                                <!-- 编辑状态 -->
+                                <div class="key-edit hidden">
+                                    <input type="password" class="key-input" data-key-type="MathpixAppKey" placeholder="输入 Mathpix App Key">
+                                    <button class="btn-icon toggle-visibility">
+                                        <i class="fas fa-eye"></i>
+                                    </button>
+                                    <button class="btn-icon save-api-key" data-key-type="MathpixAppKey" title="保存密钥">
+                                        <i class="fas fa-save"></i>
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- 添加中转 API url 设置区域 -->
+                <div class="settings-section api-url-settings">
+                    <h3><i class="fas fa-link"></i> 中转 API url 设置</h3>
+                    <div class="setting-group">
+                        <div class="api-keys-list" id="apiBaseUrlsList">
+                            <div class="api-key-status">
+                                <span class="key-name">Anthropic API URL:</span>
+                                <div class="key-status-wrapper">
+                                    <!-- 显示状态 -->
+                                    <div class="key-display">
+                                            <span id="AnthropicApiBaseUrlStatus" class="key-status" data-key="AnthropicApiBaseUrl">未设置</span>
+                                            <button class="btn-icon edit-api-base-url" data-key-type="AnthropicApiBaseUrl" title="编辑此URL">
+                                                <i class="fas fa-edit"></i>
+                                            </button>
+                                        </div>
+                                        <!-- 编辑状态 -->
+                                        <div class="key-edit hidden">
+                                            <input type="text" class="key-input" data-key-type="AnthropicApiBaseUrl" placeholder="https://api.anthropic.com/v1">
+                                            <button class="btn-icon save-api-base-url" data-key-type="AnthropicApiBaseUrl" title="保存URL">
+                                                <i class="fas fa-save"></i>
+                                            </button>
+                                        </div>
+                                    </div>
+                                </div>
+                                <div class="api-key-status">
+                                    <span class="key-name">OpenAI API URL:</span>
+                                    <div class="key-status-wrapper">
+                                        <!-- 显示状态 -->
+                                        <div class="key-display">
+                                            <span id="OpenaiApiBaseUrlStatus" class="key-status" data-key="OpenaiApiBaseUrl">未设置</span>
+                                            <button class="btn-icon edit-api-base-url" data-key-type="OpenaiApiBaseUrl" title="编辑此URL">
+                                                <i class="fas fa-edit"></i>
+                                            </button>
+                                        </div>
+                                        <!-- 编辑状态 -->
+                                        <div class="key-edit hidden">
+                                            <input type="text" class="key-input" data-key-type="OpenaiApiBaseUrl" placeholder="https://api.openai.com/v1">
+                                            <button class="btn-icon save-api-base-url" data-key-type="OpenaiApiBaseUrl" title="保存URL">
+                                                <i class="fas fa-save"></i>
+                                            </button>
+                                        </div>
+                                    </div>
+                                </div>
+                                <div class="api-key-status">
+                                    <span class="key-name">DeepSeek API URL:</span>
+                                    <div class="key-status-wrapper">
+                                        <!-- 显示状态 -->
+                                        <div class="key-display">
+                                            <span id="DeepseekApiBaseUrlStatus" class="key-status" data-key="DeepseekApiBaseUrl">未设置</span>
+                                            <button class="btn-icon edit-api-base-url" data-key-type="DeepseekApiBaseUrl" title="编辑此URL">
+                                                <i class="fas fa-edit"></i>
+                                            </button>
+                                        </div>
+                                        <!-- 编辑状态 -->
+                                        <div class="key-edit hidden">
+                                            <input type="text" class="key-input" data-key-type="DeepseekApiBaseUrl" placeholder="https://api.deepseek.com/v1">
+                                            <button class="btn-icon save-api-base-url" data-key-type="DeepseekApiBaseUrl" title="保存URL">
+                                                <i class="fas fa-save"></i>
+                                            </button>
+                                        </div>
+                                    </div>
+                                </div>
+                                <div class="api-key-status">
+                                    <span class="key-name">Alibaba API URL:</span>
+                                    <div class="key-status-wrapper">
+                                        <!-- 显示状态 -->
+                                        <div class="key-display">
+                                            <span id="AlibabaApiBaseUrlStatus" class="key-status" data-key="AlibabaApiBaseUrl">未设置</span>
+                                            <button class="btn-icon edit-api-base-url" data-key-type="AlibabaApiBaseUrl" title="编辑此URL">
+                                                <i class="fas fa-edit"></i>
+                                            </button>
+                                        </div>
+                                        <!-- 编辑状态 -->
+                                        <div class="key-edit hidden">
+                                            <input type="text" class="key-input" data-key-type="AlibabaApiBaseUrl" placeholder="https://dashscope.aliyuncs.com/api/v1">
+                                            <button class="btn-icon save-api-base-url" data-key-type="AlibabaApiBaseUrl" title="保存URL">
+                                                <i class="fas fa-save"></i>
+                                            </button>
+                                        </div>
+                                    </div>
+                                </div>
+                                <div class="api-key-status">
+                                    <span class="key-name">Google API URL:</span>
+                                    <div class="key-status-wrapper">
+                                        <!-- 显示状态 -->
+                                        <div class="key-display">
+                                            <span id="GoogleApiBaseUrlStatus" class="key-status" data-key="GoogleApiBaseUrl">未设置</span>
+                                            <button class="btn-icon edit-api-base-url" data-key-type="GoogleApiBaseUrl" title="编辑此URL">
+                                                <i class="fas fa-edit"></i>
+                                            </button>
+                                        </div>
+                                        <!-- 编辑状态 -->
+                                        <div class="key-edit hidden">
+                                            <input type="text" class="key-input" data-key-type="GoogleApiBaseUrl" placeholder="https://generativelanguage.googleapis.com/v1beta">
+                                            <button class="btn-icon save-api-base-url" data-key-type="GoogleApiBaseUrl" title="保存URL">
+                                                <i class="fas fa-save"></i>
+                                            </button>
+                                        </div>
+                                    </div>
+                                </div>
+                                <div class="api-key-status">
+                                    <span class="key-name">Doubao API URL:</span>
+                                    <div class="key-status-wrapper">
+                                        <!-- 显示状态 -->
+                                        <div class="key-display">
+                                            <span id="DoubaoApiBaseUrlStatus" class="key-status" data-key="DoubaoApiBaseUrl">未设置</span>
+                                            <button class="btn-icon edit-api-base-url" data-key-type="DoubaoApiBaseUrl" title="编辑此URL">
+                                                <i class="fas fa-edit"></i>
+                                            </button>
+                                        </div>
+                                        <!-- 编辑状态 -->
+                                        <div class="key-edit hidden">
+                                            <input type="text" class="key-input" data-key-type="DoubaoApiBaseUrl" placeholder="https://ark.cn-beijing.volces.com/api/v3">
+                                            <button class="btn-icon save-api-base-url" data-key-type="DoubaoApiBaseUrl" title="保存URL">
+                                                <i class="fas fa-save"></i>
+                                            </button>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- 3. 不常用的其他设置放在后面 -->
+                <div class="settings-section proxy-settings-section">
+                    <h3><i class="fas fa-cog"></i> 其他设置</h3>
+                    <div class="setting-group">
+                        <label for="language"><i class="fas fa-language"></i> 语言</label>
+                        <input type="text" id="language" value="中文" placeholder="输入首选语言">
+                    </div>
+                    <div class="setting-group">
+                        <label class="checkbox-label">
+                            <input type="checkbox" id="proxyEnabled">
+                            <span>启用 VPN 代理</span>
+                        </label>
+                    </div>
+                    <div id="proxySettings" class="proxy-settings">
+                        <div class="setting-group">
+                            <label for="proxyHost"><i class="fas fa-server"></i> 代理主机</label>
+                            <input type="text" id="proxyHost" value="127.0.0.1" placeholder="输入代理主机">
+                        </div>
+                        <div class="setting-group">
+                            <label for="proxyPort"><i class="fas fa-plug"></i> 代理端口</label>
+                            <input type="number" id="proxyPort" value="4780" placeholder="输入代理端口">
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </aside>
+    </main>
+
+    <div id="cropContainer" class="crop-container hidden">
+        <div class="crop-actions crop-actions-top">
+            <button id="cropCancel" class="btn-secondary">
+                <i class="fas fa-times"></i>
+                <span>取消</span>
+            </button>
+            <div class="crop-bottom-buttons">
+                <button id="cropReset" class="btn-secondary crop-half-btn">
+                    <i class="fas fa-undo"></i>
+                    <span>重置</span>
+                </button>
+                <button id="cropConfirm" class="btn-secondary crop-half-btn">
+                    <i class="fas fa-check"></i>
+                    <span>确认</span>
+                </button>
+            </div>
+            <button id="cropSendToAI" class="btn-primary">
+                <i class="fas fa-paper-plane"></i>
+                <span>发送</span>
+            </button>
+        </div>
+        <div class="crop-wrapper">
+            <div class="crop-area"></div>
+        </div>
+    </div>
+    
+    <div id="toastContainer" class="toast-container"></div>
+
+    <footer class="app-footer">
+        <div class="footer-content">
+            <div class="footer-text">
+                <span>© 2024 Snap-Solver</span>
+            </div>
+            <div class="footer-links">
+                <a href="https://github.com/Zippland/Snap-Solver/" target="_blank" class="footer-link">
+                    <span class="star-icon">⭐</span>
+                    <span>GitHub</span>
+                </a>
+                <a href="https://www.xiaohongshu.com/user/profile/623e8b080000000010007721?xsec_token=YBdeHZTp_aVwi1Ijmras5CgQC6pxlpd4RmozT8Hr_-NCA%3D&xsec_source=app_share&xhsshare=CopyLink&appuid=623e8b080000000010007721&apptime=1742201089&share_id=a2704ab48e2c4e1aa321ce63168811b5&share_channel=copy_link" target="_blank" class="footer-link xiaohongshu-link">
+                    <i class="fas fa-book"></i>
+                    <span>小红书</span>
+                </a>
+            </div>
+        </div>
+    </footer>
+
+    <!-- 提示词对话框 -->
+    <div class="dialog-overlay" id="promptDialogOverlay"></div>
+    <div class="prompt-dialog" id="promptDialog">
+        <h3>添加/编辑提示词</h3>
+        <div class="form-group">
+            <label for="promptId">提示词ID</label>
+            <input type="text" id="promptId" placeholder="英文字母和下划线，如math_problems">
+        </div>
+        <div class="form-group">
+            <label for="promptName">名称</label>
+            <input type="text" id="promptName" placeholder="提示词名称">
+        </div>
+        <div class="form-group">
+            <label for="promptContent">内容</label>
+            <textarea id="promptContent" placeholder="输入提示词内容..."></textarea>
+        </div>
+        <div class="form-group">
+            <label for="promptDescriptionEdit">描述（可选）</label>
+            <input type="text" id="promptDescriptionEdit" placeholder="简短描述">
+        </div>
+        <div class="dialog-buttons">
+            <button class="cancel-btn" id="cancelPromptBtn">取消</button>
+            <button class="save-btn" id="confirmPromptBtn">保存</button>
+        </div>
+    </div>
+
+    <!-- 确保按照正确的顺序加载脚本 -->
+    <!-- 先加载UI管理器，确保它能在DOM加载完成后初始化 -->
+    <script src="{{ url_for('static', filename='js/ui.js') }}"></script>
+    <!-- 然后加载设置管理器，它依赖UI管理器 -->
+    <script src="{{ url_for('static', filename='js/settings.js') }}"></script>
+    <!-- 最后加载主应用逻辑 -->
+    <script src="{{ url_for('static', filename='js/main.js') }}"></script>
+    
+    <!-- 更新检查初始化 -->
+    <script>
+        document.addEventListener('DOMContentLoaded', function() {
+            // 初始化更新检查
+            try {
+                const updateInfo = JSON.parse('{{ update_info|tojson|safe }}');
+                if (updateInfo && updateInfo.has_update) {
+                    showUpdateNotice(updateInfo);
+                }
+                
+                // 24小时后再次检查更新
+                setTimeout(checkForUpdates, 24 * 60 * 60 * 1000);
+            } catch (error) {
+                console.error('更新检查初始化失败:', error);
+            }
+        });
+        
+        function showUpdateNotice(updateInfo) {
+            const updateNotice = document.getElementById('updateNotice');
+            const updateVersion = document.getElementById('updateVersion');
+            const updateLink = document.getElementById('updateLink');
+            
+            if (updateInfo.latest_version) {
+                updateVersion.textContent = updateInfo.latest_version;
+            }
+            
+            if (updateInfo.release_url) {
+                updateLink.href = updateInfo.release_url;
+            } else {
+                updateLink.href = 'https://github.com/Zippland/Snap-Solver/releases/latest';
+            }
+            
+            updateNotice.classList.remove('hidden');
+            
+            // 绑定关闭按钮事件
+            document.getElementById('closeUpdateNotice').addEventListener('click', function() {
+                updateNotice.classList.add('hidden');
+                // 记住用户已关闭此版本的通知
+                localStorage.setItem('dismissedUpdate', updateInfo.latest_version);
+            });
+        }
+        
+        function checkForUpdates() {
+            fetch('/api/check-update')
+                .then(function(response) { return response.json(); })
+                .then(function(updateInfo) {
+                    const dismissedVersion = localStorage.getItem('dismissedUpdate');
+                    
+                    // 只有当有更新且用户没有关闭过此版本的通知时才显示
+                    if (updateInfo.has_update && dismissedVersion !== updateInfo.latest_version) {
+                        showUpdateNotice(updateInfo);
+                    }
+                })
+                .catch(function(error) { console.error('检查更新失败:', error); });
+        }
+    </script>
+</body>
+</html>

tips.csv

@@ -1,245 +0,0 @@
-total_bill,tip,sex,smoker,day,time,size
-16.99,1.01,Female,No,Sun,Dinner,2
-10.34,1.66,Male,No,Sun,Dinner,3
-21.01,3.5,Male,No,Sun,Dinner,3
-23.68,3.31,Male,No,Sun,Dinner,2
-24.59,3.61,Female,No,Sun,Dinner,4
-25.29,4.71,Male,No,Sun,Dinner,4
-8.77,2.0,Male,No,Sun,Dinner,2
-26.88,3.12,Male,No,Sun,Dinner,4
-15.04,1.96,Male,No,Sun,Dinner,2
-14.78,3.23,Male,No,Sun,Dinner,2
-10.27,1.71,Male,No,Sun,Dinner,2
-35.26,5.0,Female,No,Sun,Dinner,4
-15.42,1.57,Male,No,Sun,Dinner,2
-18.43,3.0,Male,No,Sun,Dinner,4
-14.83,3.02,Female,No,Sun,Dinner,2
-21.58,3.92,Male,No,Sun,Dinner,2
-10.33,1.67,Female,No,Sun,Dinner,3
-16.29,3.71,Male,No,Sun,Dinner,3
-16.97,3.5,Female,No,Sun,Dinner,3
-20.65,3.35,Male,No,Sat,Dinner,3
-17.92,4.08,Male,No,Sat,Dinner,2
-20.29,2.75,Female,No,Sat,Dinner,2
-15.77,2.23,Female,No,Sat,Dinner,2
-39.42,7.58,Male,No,Sat,Dinner,4
-19.82,3.18,Male,No,Sat,Dinner,2
-17.81,2.34,Male,No,Sat,Dinner,4
-13.37,2.0,Male,No,Sat,Dinner,2
-12.69,2.0,Male,No,Sat,Dinner,2
-21.7,4.3,Male,No,Sat,Dinner,2
-19.65,3.0,Female,No,Sat,Dinner,2
-9.55,1.45,Male,No,Sat,Dinner,2
-18.35,2.5,Male,No,Sat,Dinner,4
-15.06,3.0,Female,No,Sat,Dinner,2
-20.69,2.45,Female,No,Sat,Dinner,4
-17.78,3.27,Male,No,Sat,Dinner,2
-24.06,3.6,Male,No,Sat,Dinner,3
-16.31,2.0,Male,No,Sat,Dinner,3
-16.93,3.07,Female,No,Sat,Dinner,3
-18.69,2.31,Male,No,Sat,Dinner,3
-31.27,5.0,Male,No,Sat,Dinner,3
-16.04,2.24,Male,No,Sat,Dinner,3
-17.46,2.54,Male,No,Sun,Dinner,2
-13.94,3.06,Male,No,Sun,Dinner,2
-9.68,1.32,Male,No,Sun,Dinner,2
-30.4,5.6,Male,No,Sun,Dinner,4
-18.29,3.0,Male,No,Sun,Dinner,2
-22.23,5.0,Male,No,Sun,Dinner,2
-32.4,6.0,Male,No,Sun,Dinner,4
-28.55,2.05,Male,No,Sun,Dinner,3
-18.04,3.0,Male,No,Sun,Dinner,2
-12.54,2.5,Male,No,Sun,Dinner,2
-10.29,2.6,Female,No,Sun,Dinner,2
-34.81,5.2,Female,No,Sun,Dinner,4
-9.94,1.56,Male,No,Sun,Dinner,2
-25.56,4.34,Male,No,Sun,Dinner,4
-19.49,3.51,Male,No,Sun,Dinner,2
-38.01,3.0,Male,Yes,Sat,Dinner,4
-26.41,1.5,Female,No,Sat,Dinner,2
-11.24,1.76,Male,Yes,Sat,Dinner,2
-48.27,6.73,Male,No,Sat,Dinner,4
-20.29,3.21,Male,Yes,Sat,Dinner,2
-13.81,2.0,Male,Yes,Sat,Dinner,2
-11.02,1.98,Male,Yes,Sat,Dinner,2
-18.29,3.76,Male,Yes,Sat,Dinner,4
-17.59,2.64,Male,No,Sat,Dinner,3
-20.08,3.15,Male,No,Sat,Dinner,3
-16.45,2.47,Female,No,Sat,Dinner,2
-3.07,1.0,Female,Yes,Sat,Dinner,1
-20.23,2.01,Male,No,Sat,Dinner,2
-15.01,2.09,Male,Yes,Sat,Dinner,2
-12.02,1.97,Male,No,Sat,Dinner,2
-17.07,3.0,Female,No,Sat,Dinner,3
-26.86,3.14,Female,Yes,Sat,Dinner,2
-25.28,5.0,Female,Yes,Sat,Dinner,2
-14.73,2.2,Female,No,Sat,Dinner,2
-10.51,1.25,Male,No,Sat,Dinner,2
-17.92,3.08,Male,Yes,Sat,Dinner,2
-27.2,4.0,Male,No,Thur,Lunch,4
-22.76,3.0,Male,No,Thur,Lunch,2
-17.29,2.71,Male,No,Thur,Lunch,2
-19.44,3.0,Male,Yes,Thur,Lunch,2
-16.66,3.4,Male,No,Thur,Lunch,2
-10.07,1.83,Female,No,Thur,Lunch,1
-32.68,5.0,Male,Yes,Thur,Lunch,2
-15.98,2.03,Male,No,Thur,Lunch,2
-34.83,5.17,Female,No,Thur,Lunch,4
-13.03,2.0,Male,No,Thur,Lunch,2
-18.28,4.0,Male,No,Thur,Lunch,2
-24.71,5.85,Male,No,Thur,Lunch,2
-21.16,3.0,Male,No,Thur,Lunch,2
-28.97,3.0,Male,Yes,Fri,Dinner,2
-22.49,3.5,Male,No,Fri,Dinner,2
-5.75,1.0,Female,Yes,Fri,Dinner,2
-16.32,4.3,Female,Yes,Fri,Dinner,2
-22.75,3.25,Female,No,Fri,Dinner,2
-40.17,4.73,Male,Yes,Fri,Dinner,4
-27.28,4.0,Male,Yes,Fri,Dinner,2
-12.03,1.5,Male,Yes,Fri,Dinner,2
-21.01,3.0,Male,Yes,Fri,Dinner,2
-12.46,1.5,Male,No,Fri,Dinner,2
-11.35,2.5,Female,Yes,Fri,Dinner,2
-15.38,3.0,Female,Yes,Fri,Dinner,2
-44.3,2.5,Female,Yes,Sat,Dinner,3
-22.42,3.48,Female,Yes,Sat,Dinner,2
-20.92,4.08,Female,No,Sat,Dinner,2
-15.36,1.64,Male,Yes,Sat,Dinner,2
-20.49,4.06,Male,Yes,Sat,Dinner,2
-25.21,4.29,Male,Yes,Sat,Dinner,2
-18.24,3.76,Male,No,Sat,Dinner,2
-14.31,4.0,Female,Yes,Sat,Dinner,2
-14.0,3.0,Male,No,Sat,Dinner,2
-7.25,1.0,Female,No,Sat,Dinner,1
-38.07,4.0,Male,No,Sun,Dinner,3
-23.95,2.55,Male,No,Sun,Dinner,2
-25.71,4.0,Female,No,Sun,Dinner,3
-17.31,3.5,Female,No,Sun,Dinner,2
-29.93,5.07,Male,No,Sun,Dinner,4
-10.65,1.5,Female,No,Thur,Lunch,2
-12.43,1.8,Female,No,Thur,Lunch,2
-24.08,2.92,Female,No,Thur,Lunch,4
-11.69,2.31,Male,No,Thur,Lunch,2
-13.42,1.68,Female,No,Thur,Lunch,2
-14.26,2.5,Male,No,Thur,Lunch,2
-15.95,2.0,Male,No,Thur,Lunch,2
-12.48,2.52,Female,No,Thur,Lunch,2
-29.8,4.2,Female,No,Thur,Lunch,6
-8.52,1.48,Male,No,Thur,Lunch,2
-14.52,2.0,Female,No,Thur,Lunch,2
-11.38,2.0,Female,No,Thur,Lunch,2
-22.82,2.18,Male,No,Thur,Lunch,3
-19.08,1.5,Male,No,Thur,Lunch,2
-20.27,2.83,Female,No,Thur,Lunch,2
-11.17,1.5,Female,No,Thur,Lunch,2
-12.26,2.0,Female,No,Thur,Lunch,2
-18.26,3.25,Female,No,Thur,Lunch,2
-8.51,1.25,Female,No,Thur,Lunch,2
-10.33,2.0,Female,No,Thur,Lunch,2
-14.15,2.0,Female,No,Thur,Lunch,2
-16.0,2.0,Male,Yes,Thur,Lunch,2
-13.16,2.75,Female,No,Thur,Lunch,2
-17.47,3.5,Female,No,Thur,Lunch,2
-34.3,6.7,Male,No,Thur,Lunch,6
-41.19,5.0,Male,No,Thur,Lunch,5
-27.05,5.0,Female,No,Thur,Lunch,6
-16.43,2.3,Female,No,Thur,Lunch,2
-8.35,1.5,Female,No,Thur,Lunch,2
-18.64,1.36,Female,No,Thur,Lunch,3
-11.87,1.63,Female,No,Thur,Lunch,2
-9.78,1.73,Male,No,Thur,Lunch,2
-7.51,2.0,Male,No,Thur,Lunch,2
-14.07,2.5,Male,No,Sun,Dinner,2
-13.13,2.0,Male,No,Sun,Dinner,2
-17.26,2.74,Male,No,Sun,Dinner,3
-24.55,2.0,Male,No,Sun,Dinner,4
-19.77,2.0,Male,No,Sun,Dinner,4
-29.85,5.14,Female,No,Sun,Dinner,5
-48.17,5.0,Male,No,Sun,Dinner,6
-25.0,3.75,Female,No,Sun,Dinner,4
-13.39,2.61,Female,No,Sun,Dinner,2
-16.49,2.0,Male,No,Sun,Dinner,4
-21.5,3.5,Male,No,Sun,Dinner,4
-12.66,2.5,Male,No,Sun,Dinner,2
-16.21,2.0,Female,No,Sun,Dinner,3
-13.81,2.0,Male,No,Sun,Dinner,2
-17.51,3.0,Female,Yes,Sun,Dinner,2
-24.52,3.48,Male,No,Sun,Dinner,3
-20.76,2.24,Male,No,Sun,Dinner,2
-31.71,4.5,Male,No,Sun,Dinner,4
-10.59,1.61,Female,Yes,Sat,Dinner,2
-10.63,2.0,Female,Yes,Sat,Dinner,2
-50.81,10.0,Male,Yes,Sat,Dinner,3
-15.81,3.16,Male,Yes,Sat,Dinner,2
-7.25,5.15,Male,Yes,Sun,Dinner,2
-31.85,3.18,Male,Yes,Sun,Dinner,2
-16.82,4.0,Male,Yes,Sun,Dinner,2
-32.9,3.11,Male,Yes,Sun,Dinner,2
-17.89,2.0,Male,Yes,Sun,Dinner,2
-14.48,2.0,Male,Yes,Sun,Dinner,2
-9.6,4.0,Female,Yes,Sun,Dinner,2
-34.63,3.55,Male,Yes,Sun,Dinner,2
-34.65,3.68,Male,Yes,Sun,Dinner,4
-23.33,5.65,Male,Yes,Sun,Dinner,2
-45.35,3.5,Male,Yes,Sun,Dinner,3
-23.17,6.5,Male,Yes,Sun,Dinner,4
-40.55,3.0,Male,Yes,Sun,Dinner,2
-20.69,5.0,Male,No,Sun,Dinner,5
-20.9,3.5,Female,Yes,Sun,Dinner,3
-30.46,2.0,Male,Yes,Sun,Dinner,5
-18.15,3.5,Female,Yes,Sun,Dinner,3
-23.1,4.0,Male,Yes,Sun,Dinner,3
-15.69,1.5,Male,Yes,Sun,Dinner,2
-19.81,4.19,Female,Yes,Thur,Lunch,2
-28.44,2.56,Male,Yes,Thur,Lunch,2
-15.48,2.02,Male,Yes,Thur,Lunch,2
-16.58,4.0,Male,Yes,Thur,Lunch,2
-7.56,1.44,Male,No,Thur,Lunch,2
-10.34,2.0,Male,Yes,Thur,Lunch,2
-43.11,5.0,Female,Yes,Thur,Lunch,4
-13.0,2.0,Female,Yes,Thur,Lunch,2
-13.51,2.0,Male,Yes,Thur,Lunch,2
-18.71,4.0,Male,Yes,Thur,Lunch,3
-12.74,2.01,Female,Yes,Thur,Lunch,2
-13.0,2.0,Female,Yes,Thur,Lunch,2
-16.4,2.5,Female,Yes,Thur,Lunch,2
-20.53,4.0,Male,Yes,Thur,Lunch,4
-16.47,3.23,Female,Yes,Thur,Lunch,3
-26.59,3.41,Male,Yes,Sat,Dinner,3
-38.73,3.0,Male,Yes,Sat,Dinner,4
-24.27,2.03,Male,Yes,Sat,Dinner,2
-12.76,2.23,Female,Yes,Sat,Dinner,2
-30.06,2.0,Male,Yes,Sat,Dinner,3
-25.89,5.16,Male,Yes,Sat,Dinner,4
-48.33,9.0,Male,No,Sat,Dinner,4
-13.27,2.5,Female,Yes,Sat,Dinner,2
-28.17,6.5,Female,Yes,Sat,Dinner,3
-12.9,1.1,Female,Yes,Sat,Dinner,2
-28.15,3.0,Male,Yes,Sat,Dinner,5
-11.59,1.5,Male,Yes,Sat,Dinner,2
-7.74,1.44,Male,Yes,Sat,Dinner,2
-30.14,3.09,Female,Yes,Sat,Dinner,4
-12.16,2.2,Male,Yes,Fri,Lunch,2
-13.42,3.48,Female,Yes,Fri,Lunch,2
-8.58,1.92,Male,Yes,Fri,Lunch,1
-15.98,3.0,Female,No,Fri,Lunch,3
-13.42,1.58,Male,Yes,Fri,Lunch,2
-16.27,2.5,Female,Yes,Fri,Lunch,2
-10.09,2.0,Female,Yes,Fri,Lunch,2
-20.45,3.0,Male,No,Sat,Dinner,4
-13.28,2.72,Male,No,Sat,Dinner,2
-22.12,2.88,Female,Yes,Sat,Dinner,2
-24.01,2.0,Male,Yes,Sat,Dinner,4
-15.69,3.0,Male,Yes,Sat,Dinner,3
-11.61,3.39,Male,No,Sat,Dinner,2
-10.77,1.47,Male,No,Sat,Dinner,2
-15.53,3.0,Male,Yes,Sat,Dinner,2
-10.07,1.25,Male,No,Sat,Dinner,2
-12.6,1.0,Male,Yes,Sat,Dinner,2
-32.83,1.17,Male,Yes,Sat,Dinner,2
-35.83,4.67,Female,No,Sat,Dinner,3
-29.03,5.92,Male,No,Sat,Dinner,3
-27.18,2.0,Female,Yes,Sat,Dinner,2
-22.67,2.0,Male,Yes,Sat,Dinner,2
-17.82,1.75,Male,No,Sat,Dinner,2
-18.78,3.0,Female,No,Thur,Dinner,2