增加多次验证

app.py

@@ -321,7 +321,8 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
     full_reasoning = ""  # 添加思维链内容累积变量
     conversation_id = None  # 会话ID
     captcha_base64 = None  # 验证码图片
-    captcha_detected_in_stream = False # 新增标志位，仅用于当前流
+    captcha_detected = False  # 验证码检测标志
+    captcha_content = ""  # 验证码响应内容
     
     try:
         # 使用iter_content替代iter_lines
@@ -348,13 +349,26 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
                                     content = data.get('data', {}).get('content', '')
                                     reasoning_content = data.get('data', {}).get('reasoning_content', '')
                                     
-                                    # 检测是否含有验证码 (仅在非递归调用时检测)
-                                    if not is_post_captcha and "验证码提示" in content and "![](data:image" in content:
-                                        captcha_detected_in_stream = True # 标记在本流中检测到验证码
+                                    # 检测是否含有验证码
+                                    if "验证码提示" in content and "![](data:image" in content and "系统检测到您当前存在异常" in content:
+                                        captcha_detected = True
+                                        captcha_content = content
                                         logger.info("检测到验证码响应")
                                         captcha_base64 = extract_captcha_image(content)
+                                    
+                                    # 累积非验证码响应内容
+                                    if not captcha_detected:
+                                        full_response += content
+                                    
+                                    # 处理思维链内容
+                                    if reasoning_content:
+                                        full_reasoning += reasoning_content
                                         
-                                        # 先向客户端发送原始验证码响应
+                                # 当整个响应结束时处理验证码
+                                elif data.get('code') == 203:
+                                    # 如果检测到验证码，进行验证码处理
+                                    if captcha_detected and captcha_base64 and conversation_id:
+                                        # 先向客户端发送验证码响应
                                         original_captcha_message = {
                                             "id": f"chatcmpl-{request_id}",
                                             "object": "chat.completion.chunk",
@@ -364,7 +378,7 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
                                                 {
                                                     "index": 0,
                                                     "delta": {
-                                                        "content": content
+                                                        "content": captcha_content
                                                     },
                                                     "finish_reason": None
                                                 }
@@ -372,7 +386,7 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
                                         }
                                         yield f"data: {json.dumps(original_captcha_message)}\n\n"
                                         
-                                        # 然后显示自动识别提示
+                                        # 显示自动识别提示
                                         captcha_message = {
                                             "id": f"chatcmpl-{request_id}",
                                             "object": "chat.completion.chunk",
@@ -389,52 +403,8 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
                                             ]
                                         }
                                         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 = {
-                                            "id": f"chatcmpl-{request_id}",
-                                            "object": "chat.completion.chunk",
-                                            "created": timestamp,
-                                            "model": model,
-                                            "choices": [
-                                                {
-                                                    "index": 0,
-                                                    "delta": {
-                                                        "reasoning_content": reasoning_content
-                                                    },
-                                                    "finish_reason": None
-                                                }
-                                            ]
-                                        }
-                                        yield f"data: {json.dumps(reasoning_chunk)}\n\n"
                                         
-                                elif data.get('code') == 203:
-                                    # 如果在本流检测到验证码且会话结束，处理验证码
-                                    # 确保只在原始流（非递归调用）中处理
-                                    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:
@@ -537,12 +507,13 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
                                                 }
                                                 yield f"data: {json.dumps(captcha_submitted_message)}\n\n"
                                                 
-                                                # 启动递归调用处理成功的响应流
+                                                # 处理验证码后的响应（可能还有验证码）
+                                                # 创建一个新的stream_openai_response流，但检测是否还有验证码
                                                 async for chunk_after_captcha in stream_openai_response(
-                                                    captcha_response, request_id, model, api_key, token_index, deepsider_model, is_post_captcha=True
+                                                    captcha_response, request_id, model, api_key, token_index, deepsider_model
                                                 ):
                                                     yield chunk_after_captcha
-                                                return # 正常结束验证码处理
+                                                return
                                         else:
                                             # 验证码识别失败的处理
                                             error_msg = "\n[验证码识别失败，请重试]"
@@ -564,9 +535,48 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
                                             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:
+                                    
+                                    # 非验证码响应，直接流式输出到目前为止收集的内容
+                                    if not captcha_detected:
+                                        # 流式输出响应内容
+                                        if full_response:
+                                            content_chunk = {
+                                                "id": f"chatcmpl-{request_id}",
+                                                "object": "chat.completion.chunk",
+                                                "created": timestamp,
+                                                "model": model,
+                                                "choices": [
+                                                    {
+                                                        "index": 0,
+                                                        "delta": {
+                                                            "content": full_response
+                                                        },
+                                                        "finish_reason": None
+                                                    }
+                                                ]
+                                            }
+                                            yield f"data: {json.dumps(content_chunk)}\n\n"
+                                        
+                                        # 流式输出思维链内容（如果有）
+                                        if full_reasoning:
+                                            reasoning_chunk = {
+                                                "id": f"chatcmpl-{request_id}",
+                                                "object": "chat.completion.chunk",
+                                                "created": timestamp,
+                                                "model": model,
+                                                "choices": [
+                                                    {
+                                                        "index": 0,
+                                                        "delta": {
+                                                            "reasoning_content": full_reasoning
+                                                        },
+                                                        "finish_reason": None
+                                                    }
+                                                ]
+                                            }
+                                            yield f"data: {json.dumps(reasoning_chunk)}\n\n"
+                                        
+                                        # 发送完成信号
                                         final_chunk = {
                                             "id": f"chatcmpl-{request_id}",
                                             "object": "chat.completion.chunk",