识别提交验证码

.env

@@ -0,0 +1,3 @@
+TESSERACT_CMD=C:\Program Files\Tesseract-OCR\tesseract.exe
+DEEPSIDER_TOKEN=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkYXRhIjp7ImVtYWlsIjoib3J6Y2F0QGNhbnRlcmxvdC5lZHUucGwiLCJ1aWQiOiI2N2UyMWY5ZjJiNjhlYTlmYzJiMjhiNzgiLCJ2ZXJzaW9uIjowLCJjaGFubmVsVGFnIjoiIn0sImV4cGlyZSI6MTc1MTQyNTU5MTAxNywiaWF0IjoxNzQzNjQ5NTkxLCJleHAiOjE3NTE0MjU1OTF9.gMrecWLlsfLrTGf0VeciJeIhR7edZ2BBJ6a_-wWut24
+ADMIN_KEY=sk-123456

README.md

@@ -9,3 +9,96 @@ license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# DeepSider API代理
+
+这是一个将OpenAI API请求代理到DeepSider API的服务，支持验证码自动识别和处理功能。
+
+## 功能特点
+
+- 支持OpenAI API的主要格式
+- 自动映射模型名称
+- 流式响应支持
+- 多Token轮询支持
+- 自动验证码识别与提交功能
+- 思维链(reasoning_content)支持
+
+## 依赖要求
+
+- Python 3.8+
+- FastAPI
+- uvicorn
+- Pillow
+- ddddocr
+- requests
+
+## 安装步骤
+
+1. 克隆仓库
+
+```bash
+git clone https://github.com/yourusername/deepsider-api-proxy.git
+cd deepsider-api-proxy
+```
+
+2. 安装Python依赖
+
+```bash
+pip install -r requirements.txt
+```
+
+3. 创建.env文件并设置环境变量
+
+```
+ADMIN_KEY=你的管理员密钥
+DEEPSIDER_TOKEN=你的DeepSider API令牌
+PORT=7860  # 可选，默认为7860
+```
+
+4. 启动服务
+
+```bash
+python app.py
+```
+
+## API使用
+
+服务启动后，可以通过以下URL访问：
+
+```
+http://localhost:7860
+```
+
+### 请求示例
+
+```bash
+curl http://localhost:7860/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_ADMIN_KEY" \
+  -d '{
+    "model": "gpt-4",
+    "messages": [{"role": "user", "content": "Hello, who are you?"}],
+    "stream": true
+  }'
+```
+
+## 验证码自动处理
+
+当DeepSider API返回验证码挑战时，系统会自动:
+
+1. 检测到验证码图片
+2. 使用ddddocr识别验证码
+3. 自动提交验证码
+4. 继续处理请求
+
+### 关于验证码识别
+
+本项目使用[ddddocr](https://github.com/sml2h3/ddddocr)库进行验证码识别，它是一个基于深度学习的通用验证码识别库：
+
+- 无需配置复杂的环境和依赖
+- 识别速度快，准确率高
+- 支持多种类型的验证码
+
+## 许可证
+
+MIT

app.py

@@ -11,7 +11,13 @@ import requests
 from datetime import datetime
 import logging
 import os
+import re
+import base64
+import io
+from PIL import Image
+import ddddocr
 from dotenv import load_dotenv
+from PIL import ImageFilter
 
 # 加载环境变量
 load_dotenv()
@@ -43,6 +49,9 @@ app.add_middleware(
 DEEPSIDER_API_BASE = "https://api.chargpt.ai/api/v2"
 TOKEN_INDEX = 0
 
+# 验证码识别器实例
+ocr = ddddocr.DdddOcr()
+
 # 模型映射表
 MODEL_MAPPING = {
     "gpt-3.5-turbo": "anthropic/claude-3.5-sonnet",
@@ -249,11 +258,70 @@ async def generate_openai_response(full_response: str, request_id: str, model: s
         
     return response_data
 
-async def stream_openai_response(response, request_id: str, model: str, api_key, token_index):
+# 验证码处理函数
+def extract_captcha_image(content: str) -> Optional[str]:
+    """从内容中提取Base64编码的验证码图片"""
+    # 匹配 markdown 格式的图片 ![](data:image/png;base64,...)
+    pattern = r'!\[\]\(data:image\/[^;]+;base64,([^)]+)\)'
+    match = re.search(pattern, content)
+    if match:
+        return match.group(1)
+    return None
+
+def recognize_captcha(base64_img: str) -> str:
+    """使用ddddocr识别验证码"""
+    try:
+        # 解码base64图片
+        img_data = base64.b64decode(base64_img)
+        
+        # 使用ddddocr识别验证码
+        captcha_text = ocr.classification(img_data)
+        
+        logger.info(f"识别到的验证码: {captcha_text}")
+        return captcha_text
+    except Exception as e:
+        logger.error(f"验证码识别出错: {str(e)}")
+        return ""
+
+async def submit_captcha(api_key: str, conversation_id: str, captcha: str, model: str) -> Optional[requests.Response]:
+    """提交验证码到DeepSider API"""
+    logger.info(f"提交验证码: {captcha}, 会话ID: {conversation_id}, 模型: {model}")
+    
+    headers = get_headers(api_key)
+    
+    try:
+        # 准备验证码提交请求体
+        payload = {
+            "clId": conversation_id,
+            "model": model, # 使用原始请求中的模型
+            "prompt": captcha, # 验证码作为提示
+            "webAccess": "close",
+            "timezone": "Asia/Shanghai"
+        }
+        
+        # 发送验证码提交请求
+        response = requests.post(
+            f"{DEEPSIDER_API_BASE}/chat/conversation",
+            headers=headers,
+            json=payload,
+            stream=True, # 验证码提交后，响应也是流式的
+            timeout=30
+        )
+        
+        return response
+    except Exception as e:
+        logger.error(f"提交验证码时出错: {str(e)}")
+        return None
+
+# 修改流式响应处理
+async def stream_openai_response(response, request_id: str, model: str, api_key, token_index, deepsider_model: str, is_post_captcha: bool = False):
     """流式返回OpenAI API格式的响应"""
     timestamp = int(time.time())
     full_response = ""
     full_reasoning = ""  # 添加思维链内容累积变量
+    conversation_id = None  # 会话ID
+    captcha_base64 = None  # 验证码图片
+    captcha_detected_in_stream = False # 新增标志位，仅用于当前流
     
     try:
         # 使用iter_content替代iter_lines
@@ -271,13 +339,23 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
                                 data = json.loads(line[6:])
                                 logger.debug(f"Received data: {data}")
                                 
+                                # 获取会话ID (所有流都可能包含)
+                                if data.get('code') == 201:
+                                    conversation_id = data.get('data', {}).get('clId')
+                                    logger.info(f"会话ID: {conversation_id}")
+                                
                                 if data.get('code') == 202 and data.get('data', {}).get('type') == "chat":
                                     content = data.get('data', {}).get('content', '')
                                     reasoning_content = data.get('data', {}).get('reasoning_content', '')
                                     
-                                    if content:
-                                        full_response += content
-                                        chunk = {
+                                    # 检测是否含有验证码 (仅在非递归调用时检测)
+                                    if not is_post_captcha and "验证码提示" in content and "![](data:image" in content:
+                                        captcha_detected_in_stream = True # 标记在本流中检测到验证码
+                                        logger.info("检测到验证码响应")
+                                        captcha_base64 = extract_captcha_image(content)
+                                        
+                                        # 向客户端发送验证码提示
+                                        captcha_message = {
                                             "id": f"chatcmpl-{request_id}",
                                             "object": "chat.completion.chunk",
                                             "created": timestamp,
@@ -286,15 +364,36 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
                                                 {
                                                     "index": 0,
                                                     "delta": {
-                                                        "content": content
+                                                        "content": "[系统检测到验证码，正在自动识别...]"
                                                     },
                                                     "finish_reason": None
                                                 }
                                             ]
                                         }
-                                        yield f"data: {json.dumps(chunk)}\n\n"
+                                        yield f"data: {json.dumps(captcha_message)}\n\n"
+                                    
+                                    if content:
+                                        full_response += content
+                                        # 如果在本流中检测到了验证码，则不发送实际内容，直到验证码处理完毕
+                                        if not captcha_detected_in_stream:
+                                            chunk_content = {
+                                                "id": f"chatcmpl-{request_id}",
+                                                "object": "chat.completion.chunk",
+                                                "created": timestamp,
+                                                "model": model,
+                                                "choices": [
+                                                    {
+                                                        "index": 0,
+                                                        "delta": {
+                                                            "content": content
+                                                        },
+                                                        "finish_reason": None
+                                                    }
+                                                ]
+                                            }
+                                            yield f"data: {json.dumps(chunk_content)}\n\n"
                                     
-                                    # 处理思维链内容
+                                    # 处理思维链内容 (始终发送)
                                     if reasoning_content:
                                         full_reasoning += reasoning_content
                                         reasoning_chunk = {
@@ -315,22 +414,156 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
                                         yield f"data: {json.dumps(reasoning_chunk)}\n\n"
                                         
                                 elif data.get('code') == 203:
-                                    # 生成完成信号
-                                    chunk = {
-                                        "id": f"chatcmpl-{request_id}",
-                                        "object": "chat.completion.chunk",
-                                        "created": timestamp,
-                                        "model": model,
-                                        "choices": [
-                                            {
-                                                "index": 0,
-                                                "delta": {},
-                                                "finish_reason": "stop"
+                                    # 如果在本流检测到验证码且会话结束，处理验证码
+                                    # 确保只在原始流（非递归调用）中处理
+                                    if not is_post_captcha and captcha_detected_in_stream and captcha_base64 and conversation_id:
+                                        captcha_text = recognize_captcha(captcha_base64)
+                                        
+                                        if captcha_text:
+                                            # 发送验证码识别结果通知
+                                            captcha_result = {
+                                                "id": f"chatcmpl-{request_id}",
+                                                "object": "chat.completion.chunk",
+                                                "created": timestamp,
+                                                "model": model,
+                                                "choices": [
+                                                    {
+                                                        "index": 0,
+                                                        "delta": {
+                                                            "content": f"\n[系统已自动识别验证码: {captcha_text}，正在提交...]"
+                                                        },
+                                                        "finish_reason": None
+                                                    }
+                                                ]
+                                            }
+                                            yield f"data: {json.dumps(captcha_result)}\n\n"
+                                            
+                                            # 提交验证码
+                                            captcha_response = await submit_captcha(api_key, conversation_id, captcha_text, deepsider_model)
+                                            
+                                            if captcha_response is None:
+                                                # 请求本身失败 (网络错误等)
+                                                error_msg = "\n[验证码提交请求失败，请检查网络或服务日志]"
+                                                error_chunk = {
+                                                    "id": f"chatcmpl-{request_id}",
+                                                    "object": "chat.completion.chunk",
+                                                    "created": timestamp,
+                                                    "model": model,
+                                                    "choices": [
+                                                        {
+                                                            "index": 0,
+                                                            "delta": {
+                                                                "content": error_msg
+                                                            },
+                                                            "finish_reason": "stop"
+                                                        }
+                                                    ]
+                                                }
+                                                yield f"data: {json.dumps(error_chunk)}\n\n"
+                                                yield "data: [DONE]\n\n"
+                                                return
+                                            elif not captcha_response.ok:
+                                                # API返回了错误状态码 (4xx, 5xx)
+                                                status_code = captcha_response.status_code
+                                                logger.error(f"提交验证码后API返回错误: {status_code}")
+                                                error_body_text = ""
+                                                error_message = f"HTTP Status {status_code}"
+                                                try:
+                                                    # 尝试读取错误响应体
+                                                    error_body_text = captcha_response.text
+                                                    logger.error(f"错误响应体: {error_body_text}")
+                                                    # 尝试解析JSON错误信息
+                                                    error_data = captcha_response.json()
+                                                    error_message = error_data.get('message', str(error_data))
+                                                except Exception as parse_err:
+                                                    logger.warning(f"解析错误响应体失败: {parse_err}")
+                                                    if error_body_text:
+                                                        error_message = error_body_text[:100] # 截断以防过长
+                                                
+                                                error_msg = f"\n[验证码提交后出错: {error_message}]"
+                                                error_chunk = {
+                                                    "id": f"chatcmpl-{request_id}",
+                                                    "object": "chat.completion.chunk",
+                                                    "created": timestamp,
+                                                    "model": model,
+                                                    "choices": [
+                                                        {
+                                                            "index": 0,
+                                                            "delta": {
+                                                                "content": error_msg
+                                                            },
+                                                            "finish_reason": "stop"
+                                                        }
+                                                    ]
+                                                }
+                                                yield f"data: {json.dumps(error_chunk)}\n\n"
+                                                yield "data: [DONE]\n\n"
+                                                return
+                                            else:
+                                                # 验证码提交成功 (2xx)，继续处理响应流
+                                                # 发送验证码提交成功通知
+                                                captcha_submitted_message = {
+                                                    "id": f"chatcmpl-{request_id}",
+                                                    "object": "chat.completion.chunk",
+                                                    "created": timestamp,
+                                                    "model": model,
+                                                    "choices": [
+                                                        {
+                                                            "index": 0,
+                                                            "delta": {
+                                                                "content": "\n[验证码已提交，正在获取响应...]"
+                                                            },
+                                                            "finish_reason": None
+                                                        }
+                                                    ]
+                                                }
+                                                yield f"data: {json.dumps(captcha_submitted_message)}\n\n"
+                                                
+                                                # 启动递归调用处理成功的响应流
+                                                async for chunk_after_captcha in stream_openai_response(
+                                                    captcha_response, request_id, model, api_key, token_index, deepsider_model, is_post_captcha=True
+                                                ):
+                                                    yield chunk_after_captcha
+                                                return # 正常结束验证码处理
+                                        else:
+                                            # 验证码识别失败的处理
+                                            error_msg = "\n[验证码识别失败，请重试]"
+                                            error_chunk = {
+                                                "id": f"chatcmpl-{request_id}",
+                                                "object": "chat.completion.chunk",
+                                                "created": timestamp,
+                                                "model": model,
+                                                "choices": [
+                                                    {
+                                                        "index": 0,
+                                                        "delta": {
+                                                            "content": error_msg
+                                                        },
+                                                        "finish_reason": "stop"
+                                                    }
+                                                ]
                                             }
-                                        ]
-                                    }
-                                    yield f"data: {json.dumps(chunk)}\n\n"
-                                    yield "data: [DONE]\n\n"
+                                            yield f"data: {json.dumps(error_chunk)}\n\n"
+                                            yield "data: [DONE]\n\n"
+                                            return
+
+                                    # 普通完成信号 (如果没有在本流检测到验证码，或者是在递归调用中)
+                                    if not captcha_detected_in_stream or is_post_captcha:
+                                        final_chunk = {
+                                            "id": f"chatcmpl-{request_id}",
+                                            "object": "chat.completion.chunk",
+                                            "created": timestamp,
+                                            "model": model,
+                                            "choices": [
+                                                {
+                                                    "index": 0,
+                                                    "delta": {},
+                                                    "finish_reason": "stop"
+                                                }
+                                            ]
+                                        }
+                                        yield f"data: {json.dumps(final_chunk)}\n\n"
+                                        yield "data: [DONE]\n\n"
                                     
                             except json.JSONDecodeError as e:
                                 logger.warning(f"JSON解析失败: {line}, 错误: {str(e)}")
@@ -345,6 +578,7 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
         logger.error(f"流式响应处理出错: {str(e)}")
         
         # 返回错误信息
+        error_msg = "\n\n[处理响应时出错: {str(e)}]"
         error_chunk = {
             "id": f"chatcmpl-{request_id}",
             "object": "chat.completion.chunk",
@@ -354,7 +588,7 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
                 {
                     "index": 0,
                     "delta": {
-                        "content": f"\n\n[处理响应时出错: {str(e)}]"
+                        "content": error_msg
                     },
                     "finish_reason": "stop"
                 }
@@ -454,9 +688,9 @@ async def create_chat_completion(
         
         # 处理流式或非流式响应
         if chat_request.stream:
-            # 返回流式响应
+            # 返回流式响应 - 初始调用 is_post_captcha 默认为 False
             return StreamingResponse(
-                stream_openai_response(response, request_id, chat_request.model, api_key, TOKEN_INDEX),
+                stream_openai_response(response, request_id, chat_request.model, api_key, TOKEN_INDEX, deepsider_model),
                 media_type="text/event-stream"
             )
         else:

requirements.txt

@@ -1,5 +1,7 @@
-fastapi==0.103.1
-uvicorn==0.23.2
+fastapi==0.110.0
+uvicorn==0.27.1
+pydantic==2.6.1
+python-dotenv==1.0.1
 requests==2.31.0
-python-dotenv==1.0.0
-pydantic==2.3.0
+Pillow==10.4.0
+ddddocr==1.4.8