feat(core): 更新配置和请求处理逻辑

- 移除 docker-compose.yml 中的版本声明
- 在 config.py 中添加强制禁用签名验证的配置
- 优化动态请求头生成，更新 User-Agent 和相关字段
- 在 openai.py 中增强错误处理逻辑，支持认证和速率限制错误的重试
- 改进 SSE 流处理，优化数据解析和完整性检查
- 在 zai_transformer.py 中添加请求签名生成和查询参数构建功能

app/core/config.py

@@ -32,6 +32,11 @@ class Settings(BaseSettings):
     SCAN_LIMIT: int = int(os.getenv("SCAN_LIMIT", "200000"))
     SKIP_AUTH_TOKEN: bool = os.getenv("SKIP_AUTH_TOKEN", "false").lower() == "true"
     
+    # Signature Configuration - 强制禁用，忽略所有环境变量
+    ENABLE_SIGNATURE: bool = False  # 强制禁用签名验证
+    SIGNATURE_SECRET_KEY: str = "disabled"  # 已禁用
+    SIGNATURE_ALGORITHM: str = "disabled"   # 已禁用
+    
     # Token Pool Configuration
     TOKEN_FILE_PATH: str = os.getenv("TOKEN_FILE_PATH", "./tokens.txt")
     TOKEN_MAX_FAILURES: int = int(os.getenv("TOKEN_MAX_FAILURES", "3"))
@@ -46,17 +51,22 @@ class Settings(BaseSettings):
     HTTP_PROXY: Optional[str] = os.getenv("HTTP_PROXY")
     HTTPS_PROXY: Optional[str] = os.getenv("HTTPS_PROXY")
     
-    # Browser Headers
+    # Browser Headers - 匹配真实F12调试信息
     CLIENT_HEADERS: Dict[str, str] = {
-        "Content-Type": "application/json",
-        "Accept": "application/json, text/event-stream",
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 Edg/139.0.0.0",
+        "Accept": "*/*",
+        "Accept-Encoding": "gzip, deflate, br, zstd",
         "Accept-Language": "zh-CN",
-        "sec-ch-ua": '"Not;A=Brand";v="99", "Microsoft Edge";v="139", "Chromium";v="139"',
-        "sec-ch-ua-mobile": "?0",
-        "sec-ch-ua-platform": '"Windows"',
-        "X-FE-Version": "prod-fe-1.0.70",
+        "Content-Type": "application/json", 
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0",
+        "Sec-Ch-Ua": '"Chromium";v="140", "Not=A?Brand";v="24", "Microsoft Edge";v="140"',
+        "Sec-Ch-Ua-Mobile": "?0",
+        "Sec-Ch-Ua-Platform": '"Windows"',
+        "Sec-Fetch-Dest": "empty",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Site": "same-origin",
+        "X-Fe-Version": "prod-fe-1.0.83",  # 匹配F12信息中的版本
         "Origin": "https://chat.z.ai",
+        "Connection": "keep-alive",
     }
     
     class Config:

app/core/openai.py

@@ -90,7 +90,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
 
                     async with httpx.AsyncClient(timeout=60.0) as client:
                         # 发送请求到上游
-                        debug_log(f"🎯 发送请求到 Z.AI: {transformed['config']['url']}")
+                        # debug_log(f"🎯 发送请求到 Z.AI: {transformed['config']['url']}")
                         async with client.stream(
                             "POST",
                             transformed["config"]["url"],
@@ -125,18 +125,70 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                     yield "data: [DONE]\n\n"
                                     return
 
+                            elif response.status_code == 401:
+                                # 认证错误，可能需要重新获取token
+                                debug_log(f"❌ 认证失败 (401)，标记token失效")
+                                if current_token:
+                                    transformer.mark_token_failure(current_token, Exception("401 Unauthorized"))
+                                
+                                retry_count += 1
+                                last_error = "401 Unauthorized - Token may be invalid"
+                                
+                                if retry_count <= settings.MAX_RETRIES:
+                                    continue
+                                else:
+                                    error_response = {
+                                        "error": {
+                                            "message": "Authentication failed after retries",
+                                            "type": "auth_error",
+                                            "code": 401
+                                        }
+                                    }
+                                    yield f"data: {json.dumps(error_response)}\n\n"
+                                    yield "data: [DONE]\n\n"
+                                    return
+                            
+                            elif response.status_code == 429:
+                                # 速率限制，延长等待时间重试
+                                debug_log(f"❌ 速率限制 (429)，将延长等待时间重试")
+                                retry_count += 1
+                                last_error = "429 Rate Limited"
+                                
+                                if retry_count <= settings.MAX_RETRIES:
+                                    continue
+                                else:
+                                    error_response = {
+                                        "error": {
+                                            "message": "Rate limit exceeded",
+                                            "type": "rate_limit_error", 
+                                            "code": 429
+                                        }
+                                    }
+                                    yield f"data: {json.dumps(error_response)}\n\n"
+                                    yield "data: [DONE]\n\n"
+                                    return
+                            
                             elif response.status_code != 200:
-                                # 其他错误，直接返回
-                                debug_log(f"❌ 上游返回错误: {response.status_code}")
+                                # 其他错误，检查是否需要重试
                                 error_text = await response.aread()
                                 error_msg = error_text.decode('utf-8', errors='ignore')
-                                debug_log(f"❌ 错误详情: {error_msg}")
-
+                                debug_log(f"❌ 上游返回错误: {response.status_code}, 详情: {error_msg}")
+                                
+                                # 某些错误可以重试
+                                retryable_codes = [502, 503, 504]
+                                if response.status_code in retryable_codes and retry_count < settings.MAX_RETRIES:
+                                    retry_count += 1
+                                    last_error = f"{response.status_code}: {error_msg}"
+                                    debug_log(f"⚠️ 服务器错误 {response.status_code}，准备重试")
+                                    continue
+                                
+                                # 不可重试的错误或已达到重试上限
                                 error_response = {
                                     "error": {
                                         "message": f"Upstream error: {response.status_code}",
                                         "type": "upstream_error",
-                                        "code": response.status_code
+                                        "code": response.status_code,
+                                        "details": error_msg[:500]  # 限制错误详情长度
                                     }
                                 }
                                 yield f"data: {json.dumps(error_response)}\n\n"
@@ -173,131 +225,96 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                             # 处理状态
                             has_thinking = False
                             thinking_signature = None
+                            first_thinking_chunk = True
 
-                            # 处理SSE流
-                            buffer = ""
+                            # 处理SSE流 - 优化的buffer处理
+                            buffer = bytearray()
+                            incomplete_line = ""
                             line_count = 0
+                            chunk_count = 0
+                            last_activity = time.time()
                             debug_log("📡 开始接收 SSE 流数据...")
 
-                            async for line in response.aiter_lines():
-                                line_count += 1
-                                if not line:
+                            async for chunk in response.aiter_bytes():
+                                chunk_count += 1
+                                last_activity = time.time()
+                                
+                                if not chunk:
                                     continue
 
-                                # 累积到buffer处理完整的数据行
-                                buffer += line + "\n"
+                                # 将新数据添加到buffer
+                                buffer.extend(chunk)
+                                
+                                # 尝试解码并处理完整的行
+                                try:
+                                    # 解码为字符串并处理
+                                    text_data = buffer.decode('utf-8')
+                                    
+                                    # 分割为行
+                                    lines = text_data.split('\n')
+                                    
+                                    # 最后一行可能不完整，保存到incomplete_line
+                                    if not text_data.endswith('\n'):
+                                        incomplete_line = lines[-1]
+                                        lines = lines[:-1]
+                                    else:
+                                        # 如果有未完成的行，将其与第一行合并
+                                        if incomplete_line:
+                                            lines[0] = incomplete_line + lines[0]
+                                            incomplete_line = ""
+                                    
+                                    # 清空buffer，开始处理新的数据
+                                    buffer = bytearray()
+                                    if incomplete_line:
+                                        buffer.extend(incomplete_line.encode('utf-8'))
+                                    
+                                    # 处理完整的行
+                                    for current_line in lines:
+                                        line_count += 1
+                                        if not current_line.strip():
+                                            continue
 
-                                # 检查是否有完整的data行
-                                while "\n" in buffer:
-                                    current_line, buffer = buffer.split("\n", 1)
-                                    if not current_line.strip():
-                                        continue
+                                        if current_line.startswith("data:"):
+                                            chunk_str = current_line[5:].strip()
+                                            if not chunk_str or chunk_str == "[DONE]":
+                                                if chunk_str == "[DONE]":
+                                                    debug_log("📡 收到 [DONE] 信号")
+                                                    yield "data: [DONE]\n\n"
+                                                continue
 
-                                    if current_line.startswith("data:"):
-                                        chunk_str = current_line[5:].strip()
-                                        if not chunk_str or chunk_str == "[DONE]":
-                                            if chunk_str == "[DONE]":
-                                                yield "data: [DONE]\n\n"
-                                            continue
+                                            # debug_log(f"📦 解析数据块: {chunk_str[:200]}..." if len(chunk_str) > 200 else f"📦 解析数据块: {chunk_str}")
 
-                                        debug_log(f"📦 解析数据块: {chunk_str[:200]}..." if len(chunk_str) > 200 else f"📦 ��析数据块: {chunk_str}")
-
-                                        try:
-                                            chunk = json.loads(chunk_str)
-
-                                            if chunk.get("type") == "chat:completion":
-                                                data = chunk.get("data", {})
-                                                phase = data.get("phase")
-
-                                                # 记录每个阶段（只在阶段变化时记录）
-                                                if phase and phase != getattr(stream_response, '_last_phase', None):
-                                                    debug_log(f"📈 SSE 阶段: {phase}")
-                                                    stream_response._last_phase = phase
-
-                                                # 处理工具调用
-                                                if phase == "tool_call" and tool_handler:
-                                                    for output in tool_handler.process_tool_call_phase(data, True):
-                                                        yield output
-
-                                                # 处理其他阶段（工具结束）
-                                                elif phase == "other" and tool_handler:
-                                                    for output in tool_handler.process_other_phase(data, True):
-                                                        yield output
-
-                                                # 处理思考内容
-                                                elif phase == "thinking":
-                                                    if not has_thinking:
-                                                        has_thinking = True
-                                                        # 发送初始角色
-                                                        role_chunk = {
-                                                            "choices": [
-                                                                {
-                                                                    "delta": {"role": "assistant"},
-                                                                    "finish_reason": None,
-                                                                    "index": 0,
-                                                                    "logprobs": None,
-                                                                }
-                                                            ],
-                                                            "created": int(time.time()),
-                                                            "id": transformed["body"]["chat_id"],
-                                                            "model": request.model,
-                                                            "object": "chat.completion.chunk",
-                                                            "system_fingerprint": "fp_zai_001",
-                                                        }
-                                                        yield f"data: {json.dumps(role_chunk)}\n\n"
-
-                                                    delta_content = data.get("delta_content", "")
-                                                    if delta_content:
-                                                        # 处理思考内容格式
-                                                        if delta_content.startswith("<details"):
-                                                            content = (
-                                                                delta_content.split("</summary>\n>")[-1].strip()
-                                                                if "</summary>\n>" in delta_content
-                                                                else delta_content
-                                                            )
-                                                        else:
-                                                            content = delta_content
-
-                                                        thinking_chunk = {
-                                                            "choices": [
-                                                                {
-                                                                    "delta": {
-                                                                        "role": "assistant",
-                                                                        "thinking": {"content": content},
-                                                                    },
-                                                                    "finish_reason": None,
-                                                                    "index": 0,
-                                                                    "logprobs": None,
-                                                                }
-                                                            ],
-                                                            "created": int(time.time()),
-                                                            "id": transformed["body"]["chat_id"],
-                                                            "model": request.model,
-                                                            "object": "chat.completion.chunk",
-                                                            "system_fingerprint": "fp_zai_001",
-                                                        }
-                                                        yield f"data: {json.dumps(thinking_chunk)}\n\n"
-
-                                                # 处理答案内容
-                                                elif phase == "answer":
-                                                    edit_content = data.get("edit_content", "")
-                                                    delta_content = data.get("delta_content", "")
-
-                                                    # 处理思考结束和答案开始
-                                                    if edit_content and "</details>\n" in edit_content:
-                                                        if has_thinking:
-                                                            # 发送思考签名
-                                                            thinking_signature = str(int(time.time() * 1000))
-                                                            sig_chunk = {
+                                            try:
+                                                chunk = json.loads(chunk_str)
+
+                                                if chunk.get("type") == "chat:completion":
+                                                    data = chunk.get("data", {})
+                                                    phase = data.get("phase")
+
+                                                    # 记录每个阶段（只在阶段变化时记录）
+                                                    if phase and phase != getattr(stream_response, '_last_phase', None):
+                                                        debug_log(f"📈 SSE 阶段: {phase}")
+                                                        stream_response._last_phase = phase
+
+                                                    # 处理工具调用
+                                                    if phase == "tool_call" and tool_handler:
+                                                        for output in tool_handler.process_tool_call_phase(data, True):
+                                                            yield output
+
+                                                    # 处理其他阶段（工具结束）
+                                                    elif phase == "other" and tool_handler:
+                                                        for output in tool_handler.process_other_phase(data, True):
+                                                            yield output
+
+                                                    # 处理思考内容
+                                                    elif phase == "thinking":
+                                                        if not has_thinking:
+                                                            has_thinking = True
+                                                            # 发送初始角色
+                                                            role_chunk = {
                                                                 "choices": [
                                                                     {
-                                                                        "delta": {
-                                                                            "role": "assistant",
-                                                                            "thinking": {
-                                                                                "content": "",
-                                                                                "signature": thinking_signature,
-                                                                            },
-                                                                        },
+                                                                        "delta": {"role": "assistant"},
                                                                         "finish_reason": None,
                                                                         "index": 0,
                                                                         "logprobs": None,
@@ -309,17 +326,33 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                                                 "object": "chat.completion.chunk",
                                                                 "system_fingerprint": "fp_zai_001",
                                                             }
-                                                            yield f"data: {json.dumps(sig_chunk)}\n\n"
+                                                            yield f"data: {json.dumps(role_chunk)}\n\n"
 
-                                                        # 提取答案内容
-                                                        content_after = edit_content.split("</details>\n")[-1]
-                                                        if content_after:
-                                                            content_chunk = {
+                                                        delta_content = data.get("delta_content", "")
+                                                        if delta_content:
+                                                            # 处理思考内容格式
+                                                            if delta_content.startswith("<details"):
+                                                                content = (
+                                                                    delta_content.split("</summary>\n>")[-1].strip()
+                                                                    if "</summary>\n>" in delta_content
+                                                                    else delta_content
+                                                                )
+                                                            else:
+                                                                content = delta_content
+                                                            
+                                                            # 第一个思考块添加<think>开始标签，其他块保持纯内容
+                                                            if first_thinking_chunk:
+                                                                formatted_content = f"<think>{content}"
+                                                                first_thinking_chunk = False
+                                                            else:
+                                                                formatted_content = content
+
+                                                            thinking_chunk = {
                                                                 "choices": [
                                                                     {
                                                                         "delta": {
                                                                             "role": "assistant",
-                                                                            "content": content_after,
+                                                                            "content": formatted_content,
                                                                         },
                                                                         "finish_reason": None,
                                                                         "index": 0,
@@ -332,12 +365,16 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                                                 "object": "chat.completion.chunk",
                                                                 "system_fingerprint": "fp_zai_001",
                                                             }
-                                                            yield f"data: {json.dumps(content_chunk)}\n\n"
+                                                            yield f"data: {json.dumps(thinking_chunk)}\n\n"
 
-                                                    # 处理增量内容
-                                                    elif delta_content:
-                                                        # 如果还没有发送角色
+                                                    # 处理答案内容
+                                                    elif phase == "answer":
+                                                        edit_content = data.get("edit_content", "")
+                                                        delta_content = data.get("delta_content", "")
+
+                                                        # 如果还没有发送角色，先发送角色chunk
                                                         if not has_thinking:
+                                                            has_thinking = True  # 设置标志避免重复发送
                                                             role_chunk = {
                                                                 "choices": [
                                                                     {
@@ -353,31 +390,102 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                                                 "object": "chat.completion.chunk",
                                                                 "system_fingerprint": "fp_zai_001",
                                                             }
+                                                            debug_log("➡️ 发送初始角色chunk")
                                                             yield f"data: {json.dumps(role_chunk)}\n\n"
 
-                                                        content_chunk = {
-                                                            "choices": [
-                                                                {
-                                                                    "delta": {
-                                                                        "role": "assistant",
-                                                                        "content": delta_content,
-                                                                    },
-                                                                    "finish_reason": None,
-                                                                    "index": 0,
-                                                                    "logprobs": None,
+                                                        # 处理思考结束和答案开始
+                                                        if edit_content and "</details>\n" in edit_content:
+                                                            if has_thinking and not first_thinking_chunk:
+                                                                # 发送思考结束标记</think>
+                                                                thinking_signature = str(int(time.time() * 1000))
+                                                                sig_chunk = {
+                                                                    "choices": [
+                                                                        {
+                                                                            "delta": {
+                                                                                "role": "assistant",
+                                                                                "content": "</think>",
+                                                                            },
+                                                                            "finish_reason": None,
+                                                                            "index": 0,
+                                                                            "logprobs": None,
+                                                                        }
+                                                                    ],
+                                                                    "created": int(time.time()),
+                                                                    "id": transformed["body"]["chat_id"],
+                                                                    "model": request.model,
+                                                                    "object": "chat.completion.chunk",
+                                                                    "system_fingerprint": "fp_zai_001",
                                                                 }
-                                                            ],
-                                                            "created": int(time.time()),
-                                                            "id": transformed["body"]["chat_id"],
-                                                            "model": request.model,
-                                                            "object": "chat.completion.chunk",
-                                                            "system_fingerprint": "fp_zai_001",
-                                                        }
-                                                        output_data = f"data: {json.dumps(content_chunk)}\n\n"
-                                                        debug_log(f"➡️ 输出内容块到客户端: {output_data[:200]}...")
-                                                        yield output_data
-
-                                                    # 处理完成
+                                                                yield f"data: {json.dumps(sig_chunk)}\n\n"
+
+                                                            # 提取答案内容
+                                                            content_after = edit_content.split("</details>\n")[-1]
+                                                            if content_after:
+                                                                content_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {
+                                                                            "role": "assistant",
+                                                                            "content": content_after,
+                                                                        },
+                                                                        "finish_reason": None,
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            yield f"data: {json.dumps(content_chunk)}\n\n"
+
+                                                        # 处理增量内容
+                                                        elif delta_content:
+                                                            # 如果还没有发送角色
+                                                            if not has_thinking:
+                                                                has_thinking = True  # 避免重复发送
+                                                                role_chunk = {
+                                                                    "choices": [
+                                                                        {
+                                                                            "delta": {"role": "assistant"},
+                                                                            "finish_reason": None,
+                                                                            "index": 0,
+                                                                            "logprobs": None,
+                                                                        }
+                                                                    ],
+                                                                    "created": int(time.time()),
+                                                                    "id": transformed["body"]["chat_id"],
+                                                                    "model": request.model,
+                                                                    "object": "chat.completion.chunk",
+                                                                    "system_fingerprint": "fp_zai_001",
+                                                                }
+                                                                debug_log("➡️ 发送初始角色chunk")
+                                                                yield f"data: {json.dumps(role_chunk)}\n\n"
+
+                                                            content_chunk = {
+                                                                "choices": [
+                                                                    {
+                                                                        "delta": {
+                                                                            "content": delta_content,
+                                                                        },
+                                                                        "finish_reason": None,
+                                                                        "index": 0,
+                                                                        "logprobs": None,
+                                                                    }
+                                                                ],
+                                                                "created": int(time.time()),
+                                                                "id": transformed["body"]["chat_id"],
+                                                                "model": request.model,
+                                                                "object": "chat.completion.chunk",
+                                                                "system_fingerprint": "fp_zai_001",
+                                                            }
+                                                            output_data = f"data: {json.dumps(content_chunk)}\n\n"
+                                                            # debug_log(f"➡️ 输出内容块到客户端: {delta_content[:50]}...")
+                                                            yield output_data
+
+                                                    # 处理完成 - 当收到usage信息时
                                                     if data.get("usage"):
                                                         debug_log(f"📦 完成响应 - 使用统计: {json.dumps(data['usage'])}")
 
@@ -386,7 +494,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                                             finish_chunk = {
                                                                 "choices": [
                                                                     {
-                                                                        "delta": {"role": "assistant", "content": ""},
+                                                                        "delta": {},  # 空的delta表示结束
                                                                         "finish_reason": "stop",
                                                                         "index": 0,
                                                                         "logprobs": None,
@@ -400,22 +508,82 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                                                                 "system_fingerprint": "fp_zai_001",
                                                             }
                                                             finish_output = f"data: {json.dumps(finish_chunk)}\n\n"
-                                                            debug_log(f"➡️ 发送完成信号: {finish_output[:200]}...")
+                                                            debug_log("➡️ 发送完成信号")
                                                             yield finish_output
                                                             debug_log("➡️ 发送 [DONE]")
                                                             yield "data: [DONE]\n\n"
 
-                                        except json.JSONDecodeError as e:
-                                            debug_log(f"❌ JSON解析错误: {e}, 内容: {chunk_str[:200]}")
-                                        except Exception as e:
-                                            debug_log(f"❌ 处理chunk错误: {e}")
+                                            except json.JSONDecodeError as e:
+                                                debug_log(f"❌ JSON解析错误: {e}, 内容: {chunk_str[:200]}")
+                                            except Exception as e:
+                                                debug_log(f"❌ 处理chunk错误: {e}")
+                                
+                                except UnicodeDecodeError:
+                                    # 如果解码失败，可能是数据不完整，继续接收
+                                    debug_log(f"⚠️ 数据解码失败，缓冲区大小: {len(buffer)}")
+                                    if len(buffer) > 1024 * 1024:  # 1MB限制
+                                        debug_log("❌ 缓冲区过大，清空重试")
+                                        buffer = bytearray()
+                                        incomplete_line = ""
+                                except Exception as e:
+                                    debug_log(f"❌ Buffer处理异常: {e}")
+                                    # 清空buffer继续处理
+                                    buffer = bytearray()
+                                    incomplete_line = ""
+                                
+                                # 检查是否长时间没有活动（超时检查）
+                                if time.time() - last_activity > 30:  # 30秒超时
+                                    debug_log("⚠️ 检测到长时间无活动，可能连接中断")
+                                    break
 
                             # 确保发送结束信号
                             if not tool_handler or not tool_handler.has_tool_call:
                                 debug_log("📤 发送最终 [DONE] 信号")
                                 yield "data: [DONE]\n\n"
 
-                            debug_log(f"✅ SSE 流处理完成，共处理 {line_count} 行数据")
+                            debug_log(f"✅ SSE 流处理完成，共处理 {line_count} 行数据，{chunk_count} 个数据块")
+                            
+                            # 检查处理完整性
+                            is_complete = True
+                            completion_issues = []
+                            
+                            if line_count == 0:
+                                is_complete = False
+                                completion_issues.append("没有处理任何数据行")
+                            elif chunk_count == 0:
+                                is_complete = False
+                                completion_issues.append("没有收到任何数据块")
+                            elif chunk_count > 0:
+                                debug_log(f"📊 平均每个数据块包含 {line_count/chunk_count:.1f} 行")
+                            
+                            # 检查工具调用完整性
+                            if tool_handler and tool_handler.has_tool_call:
+                                if not tool_handler.completed_tools:
+                                    completion_issues.append("工具调用未正常完成")
+                                else:
+                                    debug_log(f"✅ 工具调用完成: {len(tool_handler.completed_tools)} 个工具")
+                            
+                            # 检查思考内容完整性（只有真正的thinking模式才需要签名）
+                            # 注意：普通的answer阶段不需要thinking签名，只有thinking阶段才需要
+                            # if has_thinking and not thinking_signature:
+                            #     completion_issues.append("思考内容缺少签名")
+                            
+                            # 报告完整性状态
+                            if is_complete and not completion_issues:
+                                debug_log("✅ 响应完整性检查通过")
+                            else:
+                                debug_log(f"⚠️ 响应完整性问题: {', '.join(completion_issues)}")
+                                
+                                # 如果问题严重且还有重试机会，考虑重试
+                                critical_issues = ["没有处理任何数据行", "没有收到任何数据块"]
+                                has_critical_issue = any(issue in completion_issues for issue in critical_issues)
+                                
+                                if has_critical_issue and retry_count < settings.MAX_RETRIES:
+                                    debug_log("🔄 检测到严重完整性问题，准备重试")
+                                    retry_count += 1
+                                    last_error = f"Incomplete response: {', '.join(completion_issues)}"
+                                    continue
+                            
                             # 成功处理完成，退出重试循环
                             return
 
@@ -455,7 +623,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                 debug_log("📤 开始向客户端流式传输数据...")
                 async for chunk in stream_response():
                     chunk_count += 1
-                    debug_log(f"📤 发送块[{chunk_count}]: {chunk[:200]}..." if len(chunk) > 200 else f"  📤 发送块[{chunk_count}]: {chunk}")
+                    # debug_log(f"📤 发送块[{chunk_count}]: {chunk[:200]}..." if len(chunk) > 200 else f"  📤 发送块[{chunk_count}]: {chunk}")
                     yield chunk
                 debug_log(f"✅ 流式传输完成，共发送 {chunk_count} 个数据块")
             except Exception as e:

app/core/response_handlers.py

@@ -1,376 +1,397 @@
-"""
-Response handlers for streaming and non-streaming responses
-"""
-
-import json
-import time
-from typing import Generator, Optional
-import requests
-from fastapi import HTTPException
-from fastapi.responses import JSONResponse, StreamingResponse
-
-from app.core.config import settings
-from app.models.schemas import (
-    Message, Delta, Choice, Usage, OpenAIResponse, 
-    UpstreamRequest, UpstreamData, UpstreamError, ModelItem
-)
-from app.utils.helpers import debug_log, call_upstream_api, transform_thinking_content
-from app.core.token_manager import token_manager
-from app.utils.sse_parser import SSEParser
+"""
+Response handlers for streaming and non-streaming responses
+"""
+
+import json
+import time
+from typing import Generator, Optional
+import requests
+from fastapi import HTTPException
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from app.core.config import settings
+from app.models.schemas import (
+    Message, Delta, Choice, Usage, OpenAIResponse, 
+    UpstreamRequest, UpstreamData, UpstreamError, ModelItem
+)
+from app.utils.helpers import debug_log, call_upstream_api, transform_thinking_content
+from app.core.token_manager import token_manager
+from app.utils.sse_parser import SSEParser
 from app.utils.tools import extract_tool_invocations, remove_tool_json_content
-from app.utils.sse_tool_handler import SSEToolHandler
-
-
-def create_openai_response_chunk(
-    model: str,
-    delta: Optional[Delta] = None,
-    finish_reason: Optional[str] = None
-) -> OpenAIResponse:
-    """Create OpenAI response chunk for streaming"""
-    return OpenAIResponse(
-        id=f"chatcmpl-{int(time.time())}",
-        object="chat.completion.chunk",
-        created=int(time.time()),
-        model=model,
-        choices=[Choice(
-            index=0,
-            delta=delta or Delta(),
-            finish_reason=finish_reason
-        )]
-    )
-
-
-def handle_upstream_error(error: UpstreamError) -> Generator[str, None, None]:
-    """Handle upstream error response"""
-    debug_log(f"上游错误: code={error.code}, detail={error.detail}")
-    
-    # Send end chunk
-    end_chunk = create_openai_response_chunk(
-        model=settings.PRIMARY_MODEL,
-        finish_reason="stop"
-    )
-    yield f"data: {end_chunk.model_dump_json()}\n\n"
-    yield "data: [DONE]\n\n"
-
-
-class ResponseHandler:
-    """Base class for response handling"""
-    
-    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str):
-        self.upstream_req = upstream_req
-        self.chat_id = chat_id
-        self.auth_token = auth_token
-    
-    def _call_upstream(self) -> requests.Response:
-        """Call upstream API with error handling"""
-        max_retries = settings.MAX_RETRIES
-        retry_count = 0
-        
-        while retry_count < max_retries:
-            try:
-                debug_log(f"尝试调用上游API (第 {retry_count + 1}/{max_retries} 次)")
-                response = call_upstream_api(self.upstream_req, self.chat_id, self.auth_token)
-                
-                # Check if response is successful
-                if response.status_code == 200:
-                    # Mark token as successful
-                    token_manager.mark_token_success(self.auth_token)
-                    debug_log("上游API调用成功")
-                    return response
-                elif response.status_code in [401, 403]:
-                    # Authentication/authorization error - mark token as failed
-                    debug_log(f"Token认证失败 (状态码: {response.status_code}): {self.auth_token[:20]}...")
-                    token_manager.mark_token_failed(self.auth_token)
-                    
-                    # Try to get a new token
-                    new_token = token_manager.get_next_token()
-                    if new_token and new_token != self.auth_token:
-                        debug_log(f"尝试使用新token: {new_token[:20]}...")
-                        self.auth_token = new_token
-                        retry_count += 1
-                        continue
-                    else:
-                        debug_log("没有更多可用token")
-                        return response
-                elif response.status_code in [429]:
-                    # Rate limit - don't mark token as failed, just retry
-                    debug_log(f"遇到速率限制 (状态码: {response.status_code})，等待后重试")
-                    if retry_count < max_retries - 1:
-                        import time
-                        time.sleep(2 ** retry_count)  # 指数退避
-                        retry_count += 1
-                        continue
-                    else:
-                        return response
-                elif response.status_code >= 500:
-                    # Server error - retry without marking token as failed
-                    debug_log(f"服务器错误 (状态码: {response.status_code})，稍后重试")
-                    if retry_count < max_retries - 1:
-                        import time
-                        time.sleep(1)
-                        retry_count += 1
-                        continue
-                    else:
-                        return response
-                else:
-                    # Other client errors, return response as-is
-                    debug_log(f"客户端错误 (状态码: {response.status_code})")
-                    return response
-                    
-            except Exception as e:
-                error_msg = str(e)
-                debug_log(f"调用上游失败 (尝试 {retry_count + 1}/{max_retries}): {error_msg}")
-                
-                # 判断是否是连接问题还是token问题
-                is_connection_error = any(keyword in error_msg.lower() for keyword in [
-                    'connection', 'timeout', 'network', 'dns', 'socket', 'ssl'
-                ])
-                
-                if is_connection_error:
-                    debug_log("检测到网络连接问题，不标记token失败")
-                    # 网络问题不标记token失败，直接重试
-                    if retry_count < max_retries - 1:
-                        import time
-                        time.sleep(2)  # 等待2秒后重试
-                        retry_count += 1
-                        continue
-                    else:
-                        raise Exception(f"网络连接问题，重试{max_retries}次后仍失败: {error_msg}")
-                else:
-                    # 其他错误可能是token问题，标记失败并尝试新token
-                    debug_log("检测到可能的token问题，标记token失败")
-                    token_manager.mark_token_failed(self.auth_token)
-                    
-                    # Try to get a new token
-                    new_token = token_manager.get_next_token()
-                    if new_token and new_token != self.auth_token and retry_count < max_retries - 1:
-                        debug_log(f"尝试使用新token: {new_token[:20]}...")
-                        self.auth_token = new_token
-                        retry_count += 1
-                        continue
-                    else:
-                        raise
-        
-        # If we get here, all retries failed
-        raise Exception("所有重试尝试均失败")
-    
-    def _handle_upstream_error(self, response: requests.Response) -> None:
-        """Handle upstream error response"""
-        debug_log(f"上游返回错误状态: {response.status_code}")
-        if settings.DEBUG_LOGGING:
-            debug_log(f"上游错误响应: {response.text}")
-
-
-class StreamResponseHandler(ResponseHandler):
-    """Handler for streaming responses"""
-    
-    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str, has_tools: bool = False):
-        super().__init__(upstream_req, chat_id, auth_token)
-        self.has_tools = has_tools
-        self.buffered_content = ""
+from app.utils.sse_tool_handler import SSEToolHandler
+
+
+def create_openai_response_chunk(
+    model: str,
+    delta: Optional[Delta] = None,
+    finish_reason: Optional[str] = None
+) -> OpenAIResponse:
+    """Create OpenAI response chunk for streaming"""
+    return OpenAIResponse(
+        id=f"chatcmpl-{int(time.time())}",
+        object="chat.completion.chunk",
+        created=int(time.time()),
+        model=model,
+        choices=[Choice(
+            index=0,
+            delta=delta or Delta(),
+            finish_reason=finish_reason
+        )]
+    )
+
+
+def handle_upstream_error(error: UpstreamError) -> Generator[str, None, None]:
+    """Handle upstream error response"""
+    debug_log(f"上游错误: code={error.code}, detail={error.detail}")
+    
+    # Send end chunk
+    end_chunk = create_openai_response_chunk(
+        model=settings.PRIMARY_MODEL,
+        finish_reason="stop"
+    )
+    yield f"data: {end_chunk.model_dump_json()}\n\n"
+    yield "data: [DONE]\n\n"
+
+
+class ResponseHandler:
+    """Base class for response handling"""
+    
+    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str):
+        self.upstream_req = upstream_req
+        self.chat_id = chat_id
+        self.auth_token = auth_token
+    
+    def _call_upstream(self) -> requests.Response:
+        """Call upstream API with error handling"""
+        max_retries = settings.MAX_RETRIES
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                debug_log(f"尝试调用上游API (第 {retry_count + 1}/{max_retries} 次)")
+                response = call_upstream_api(self.upstream_req, self.chat_id, self.auth_token)
+                
+                # Check if response is successful
+                if response.status_code == 200:
+                    # Mark token as successful
+                    token_manager.mark_token_success(self.auth_token)
+                    debug_log("上游API调用成功")
+                    return response
+                elif response.status_code in [401, 403]:
+                    # Authentication/authorization error - mark token as failed
+                    debug_log(f"Token认证失败 (状态码: {response.status_code}): {self.auth_token[:20]}...")
+                    token_manager.mark_token_failed(self.auth_token)
+                    
+                    # Try to get a new token
+                    new_token = token_manager.get_next_token()
+                    if new_token and new_token != self.auth_token:
+                        debug_log(f"尝试使用新token: {new_token[:20]}...")
+                        self.auth_token = new_token
+                        retry_count += 1
+                        continue
+                    else:
+                        debug_log("没有更多可用token")
+                        return response
+                elif response.status_code in [429]:
+                    # Rate limit - don't mark token as failed, just retry
+                    debug_log(f"遇到速率限制 (状态码: {response.status_code})，等待后重试")
+                    if retry_count < max_retries - 1:
+                        import time
+                        time.sleep(2 ** retry_count)  # 指数退避
+                        retry_count += 1
+                        continue
+                    else:
+                        return response
+                elif response.status_code >= 500:
+                    # Server error - retry without marking token as failed
+                    debug_log(f"服务器错误 (状态码: {response.status_code})，稍后重试")
+                    if retry_count < max_retries - 1:
+                        import time
+                        time.sleep(1)
+                        retry_count += 1
+                        continue
+                    else:
+                        return response
+                else:
+                    # Other client errors, return response as-is
+                    debug_log(f"客户端错误 (状态码: {response.status_code})")
+                    return response
+                    
+            except Exception as e:
+                error_msg = str(e)
+                debug_log(f"调用上游失败 (尝试 {retry_count + 1}/{max_retries}): {error_msg}")
+                
+                # 判断是否是连接问题还是token问题
+                is_connection_error = any(keyword in error_msg.lower() for keyword in [
+                    'connection', 'timeout', 'network', 'dns', 'socket', 'ssl'
+                ])
+                
+                if is_connection_error:
+                    debug_log("检测到网络连接问题，不标记token失败")
+                    # 网络问题不标记token失败，直接重试
+                    if retry_count < max_retries - 1:
+                        import time
+                        time.sleep(2)  # 等待2秒后重试
+                        retry_count += 1
+                        continue
+                    else:
+                        raise Exception(f"网络连接问题，重试{max_retries}次后仍失败: {error_msg}")
+                else:
+                    # 其他错误可能是token问题，标记失败并尝试新token
+                    debug_log("检测到可能的token问题，标记token失败")
+                    token_manager.mark_token_failed(self.auth_token)
+                    
+                    # Try to get a new token
+                    new_token = token_manager.get_next_token()
+                    if new_token and new_token != self.auth_token and retry_count < max_retries - 1:
+                        debug_log(f"尝试使用新token: {new_token[:20]}...")
+                        self.auth_token = new_token
+                        retry_count += 1
+                        continue
+                    else:
+                        raise
+        
+        # If we get here, all retries failed
+        raise Exception("所有重试尝试均失败")
+    
+    def _handle_upstream_error(self, response: requests.Response) -> None:
+        """Handle upstream error response"""
+        debug_log(f"上游返回错误状态: {response.status_code}")
+        if settings.DEBUG_LOGGING:
+            debug_log(f"上游错误响应: {response.text}")
+
+
+class StreamResponseHandler(ResponseHandler):
+    """Handler for streaming responses"""
+    
+    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str, has_tools: bool = False):
+        super().__init__(upstream_req, chat_id, auth_token)
+        self.has_tools = has_tools
+        self.buffered_content = ""
         self.tool_calls = None
         # Initialize SSE tool handler for improved tool processing
-        self.tool_handler = SSEToolHandler(chat_id, settings.PRIMARY_MODEL) if has_tools else None
-    
-    def handle(self) -> Generator[str, None, None]:
-        """Handle streaming response"""
-        debug_log(f"开始处理流式响应 (chat_id={self.chat_id})")
-        
-        try:
-            response = self._call_upstream()
-        except Exception:
-            yield "data: {\"error\": \"Failed to call upstream\"}\n\n"
-            return
-        
-        if response.status_code != 200:
-            self._handle_upstream_error(response)
-            yield "data: {\"error\": \"Upstream error\"}\n\n"
-            return
-        
-        # Send initial role chunk
-        first_chunk = create_openai_response_chunk(
-            model=settings.PRIMARY_MODEL,
-            delta=Delta(role="assistant")
-        )
-        yield f"data: {first_chunk.model_dump_json()}\n\n"
-        
-        # Process stream
-        debug_log("开始读取上游SSE流")
-        sent_initial_answer = False
-        stream_ended_normally = False
-        
-        try:
-            with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
-                for event in parser.iter_json_data(UpstreamData):
-                    upstream_data = event['data']
-                    
-                    # Check for errors
-                    if self._has_error(upstream_data):
-                        error = self._get_error(upstream_data)
-                        yield from handle_upstream_error(error)
-                        stream_ended_normally = True
-                        break
-                    
-                    debug_log(f"解析成功 - 类型: {upstream_data.type}, 阶段: {upstream_data.data.phase}, "
-                             f"内容长度: {len(upstream_data.data.delta_content or '')}, 完成: {upstream_data.data.done}")
-                    
-                    # Process content
-                    yield from self._process_content_with_tools(upstream_data, sent_initial_answer)
-                    
-                    # Update sent_initial_answer flag if we sent content
-                    if not sent_initial_answer and (upstream_data.data.delta_content or upstream_data.data.edit_content):
-                        sent_initial_answer = True
-                    
-                    # Check if done
-                    if upstream_data.data.done or upstream_data.data.phase == "done":
-                        debug_log("检测到流结束信号")
-                        yield from self._send_end_chunk()
-                        stream_ended_normally = True
-                        break
-                        
-        except Exception as e:
-            debug_log(f"SSE流处理异常: {e}")
-            # 流异常结束，发送错误响应
-            if not stream_ended_normally:
-                error_chunk = create_openai_response_chunk(
-                    model=settings.PRIMARY_MODEL,
-                    delta=Delta(content=f"\n\n[系统提示: 连接中断，响应可能不完整]")
-                )
-                yield f"data: {error_chunk.model_dump_json()}\n\n"
-        
-        # 确保流正常结束
-        if not stream_ended_normally:
-            debug_log("流未正常结束，发送结束信号")
-            yield from self._send_end_chunk(force_stop=True)
-    
-    def _has_error(self, upstream_data: UpstreamData) -> bool:
-        """Check if upstream data contains error"""
-        return bool(
-            upstream_data.error or 
-            upstream_data.data.error or 
-            (upstream_data.data.inner and upstream_data.data.inner.error)
-        )
-    
-    def _get_error(self, upstream_data: UpstreamData) -> UpstreamError:
-        """Get error from upstream data"""
-        return (
-            upstream_data.error or 
-            upstream_data.data.error or 
-            (upstream_data.data.inner.error if upstream_data.data.inner else None)
-        )
-    
-    def _process_content(
-        self, 
-        upstream_data: UpstreamData, 
-        sent_initial_answer: bool
-    ) -> Generator[str, None, None]:
-        """Process content from upstream data"""
-        content = upstream_data.data.delta_content or upstream_data.data.edit_content
-        
-        if not content:
-            return
-        
-        # Transform thinking content
-        if upstream_data.data.phase == "thinking":
-            content = transform_thinking_content(content)
-        
-        # Buffer content if tools are enabled
-        if self.has_tools:
-            self.buffered_content += content
-        else:
-            # Handle initial answer content
-            if (not sent_initial_answer and 
-                upstream_data.data.edit_content and 
-                upstream_data.data.phase == "answer"):
-                
-                content = self._extract_edit_content(upstream_data.data.edit_content)
-                if content:
-                    debug_log(f"发送普通内容: {content}")
-                    chunk = create_openai_response_chunk(
-                        model=settings.PRIMARY_MODEL,
-                        delta=Delta(content=content)
-                    )
-                    yield f"data: {chunk.model_dump_json()}\n\n"
-                    sent_initial_answer = True
-            
-            # Handle delta content
-            if upstream_data.data.delta_content:
-                if content:
-                    if upstream_data.data.phase == "thinking":
-                        debug_log(f"发送思考内容: {content}")
-                        chunk = create_openai_response_chunk(
-                            model=settings.PRIMARY_MODEL,
-                            delta=Delta(reasoning_content=content)
-                        )
-                    else:
-                        debug_log(f"发送普通内容: {content}")
-                        chunk = create_openai_response_chunk(
-                            model=settings.PRIMARY_MODEL,
-                            delta=Delta(content=content)
-                        )
-                    yield f"data: {chunk.model_dump_json()}\n\n"
-    
-    def _extract_edit_content(self, edit_content: str) -> str:
-        """Extract content from edit_content field"""
-        parts = edit_content.split("</details>")
-        return parts[1] if len(parts) > 1 else ""
-    
-    def _send_end_chunk(self, force_stop: bool = False) -> Generator[str, None, None]:
-        """Send end chunk and DONE signal"""
-        finish_reason = "stop"
-        
-        if self.has_tools and not force_stop:
-            # Try to extract tool calls from buffered content
-            self.tool_calls = extract_tool_invocations(self.buffered_content)
-            
-            if self.tool_calls:
-                debug_log(f"检测到工具调用: {len(self.tool_calls)} 个")
-                # Send tool calls with proper format
-                for i, tc in enumerate(self.tool_calls):
-                    tool_call_delta = {
-                        "index": i,
-                        "id": tc.get("id"),
-                        "type": tc.get("type", "function"),
-                        "function": tc.get("function", {}),
-                    }
-                    
-                    out_chunk = create_openai_response_chunk(
-                        model=settings.PRIMARY_MODEL,
-                        delta=Delta(tool_calls=[tool_call_delta])
-                    )
-                    yield f"data: {out_chunk.model_dump_json()}\n\n"
-                
-                finish_reason = "tool_calls"
-            else:
-                # Send regular content
-                trimmed_content = remove_tool_json_content(self.buffered_content)
-                if trimmed_content:
-                    debug_log(f"发送常规内容: {len(trimmed_content)} 字符")
-                    content_chunk = create_openai_response_chunk(
-                        model=settings.PRIMARY_MODEL,
-                        delta=Delta(content=trimmed_content)
-                    )
-                    yield f"data: {content_chunk.model_dump_json()}\n\n"
-        elif force_stop:
-            # 强制结束时，发送缓冲的内容（如果有）
-            if self.buffered_content:
-                debug_log(f"强制结束，发送缓冲内容: {len(self.buffered_content)} 字符")
-                content_chunk = create_openai_response_chunk(
-                    model=settings.PRIMARY_MODEL,
-                    delta=Delta(content=self.buffered_content)
-                )
-                yield f"data: {content_chunk.model_dump_json()}\n\n"
-        
-        # Send final chunk
-        end_chunk = create_openai_response_chunk(
-            model=settings.PRIMARY_MODEL,
-            finish_reason=finish_reason
-        )
-        yield f"data: {end_chunk.model_dump_json()}\n\n"
-        yield "data: [DONE]\n\n"
-        debug_log(f"流式响应完成 (finish_reason: {finish_reason})")
-
-
    
+        self.tool_handler = SSEToolHandler(chat_id, settings.PRIMARY_MODEL) if has_tools else None
+        # 思考状态跟踪
+        self.first_thinking_chunk = True
+    
+    def handle(self) -> Generator[str, None, None]:
+        """Handle streaming response"""
+        debug_log(f"开始处理流式响应 (chat_id={self.chat_id})")
+        
+        try:
+            response = self._call_upstream()
+        except Exception:
+            yield "data: {\"error\": \"Failed to call upstream\"}\n\n"
+            return
+        
+        if response.status_code != 200:
+            self._handle_upstream_error(response)
+            yield "data: {\"error\": \"Upstream error\"}\n\n"
+            return
+        
+        # Send initial role chunk
+        first_chunk = create_openai_response_chunk(
+            model=settings.PRIMARY_MODEL,
+            delta=Delta(role="assistant")
+        )
+        yield f"data: {first_chunk.model_dump_json()}\n\n"
+        
+        # Process stream
+        debug_log("开始读取上游SSE流")
+        sent_initial_answer = False
+        stream_ended_normally = False
+        
+        try:
+            with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
+                for event in parser.iter_json_data(UpstreamData):
+                    upstream_data = event['data']
+                    
+                    # Check for errors
+                    if self._has_error(upstream_data):
+                        error = self._get_error(upstream_data)
+                        yield from handle_upstream_error(error)
+                        stream_ended_normally = True
+                        break
+                    
+                    debug_log(f"解析成功 - 类型: {upstream_data.type}, 阶段: {upstream_data.data.phase}, "
+                             f"内容长度: {len(upstream_data.data.delta_content or '')}, 完成: {upstream_data.data.done}")
+                    
+                    # Process content
+                    yield from self._process_content_with_tools(upstream_data, sent_initial_answer)
+                    
+                    # Update sent_initial_answer flag if we sent content
+                    if not sent_initial_answer and (upstream_data.data.delta_content or upstream_data.data.edit_content):
+                        sent_initial_answer = True
+                    
+                    # Check if done
+                    if upstream_data.data.done or upstream_data.data.phase == "done":
+                        debug_log("检测到流结束信号")
+                        yield from self._send_end_chunk()
+                        stream_ended_normally = True
+                        break
+                        
+        except Exception as e:
+            debug_log(f"SSE流处理异常: {e}")
+            # 流异常结束，发送错误响应
+            if not stream_ended_normally:
+                error_chunk = create_openai_response_chunk(
+                    model=settings.PRIMARY_MODEL,
+                    delta=Delta(content=f"\n\n[系统提示: 连接中断，响应可能不完整]")
+                )
+                yield f"data: {error_chunk.model_dump_json()}\n\n"
+        
+        # 确保流正常结束
+        if not stream_ended_normally:
+            debug_log("流未正常结束，发送结束信号")
+            yield from self._send_end_chunk(force_stop=True)
+    
+    def _has_error(self, upstream_data: UpstreamData) -> bool:
+        """Check if upstream data contains error"""
+        return bool(
+            upstream_data.error or 
+            upstream_data.data.error or 
+            (upstream_data.data.inner and upstream_data.data.inner.error)
+        )
+    
+    def _get_error(self, upstream_data: UpstreamData) -> UpstreamError:
+        """Get error from upstream data"""
+        return (
+            upstream_data.error or 
+            upstream_data.data.error or 
+            (upstream_data.data.inner.error if upstream_data.data.inner else None)
+        )
+    
+    def _process_content(
+        self, 
+        upstream_data: UpstreamData, 
+        sent_initial_answer: bool
+    ) -> Generator[str, None, None]:
+        """Process content from upstream data"""
+        content = upstream_data.data.delta_content or upstream_data.data.edit_content
+        
+        if not content:
+            return
+        
+        # Transform thinking content
+        if upstream_data.data.phase == "thinking":
+            content = transform_thinking_content(content)
+        
+        # Buffer content if tools are enabled
+        if self.has_tools:
+            self.buffered_content += content
+        else:
+            # Handle initial answer content
+            if (not sent_initial_answer and 
+                upstream_data.data.edit_content and 
+                upstream_data.data.phase == "answer"):
+                
+                content = self._extract_edit_content(upstream_data.data.edit_content)
+                if content:
+                    debug_log(f"发送普通内容: {content}")
+                    chunk = create_openai_response_chunk(
+                        model=settings.PRIMARY_MODEL,
+                        delta=Delta(content=content)
+                    )
+                    yield f"data: {chunk.model_dump_json()}\n\n"
+                    sent_initial_answer = True
+            
+            # Handle delta content
+            if upstream_data.data.delta_content:
+                if content:
+                    if upstream_data.data.phase == "thinking":
+                        # 第一个思考块添加<think>开始标签，其他块保持纯内容
+                        if self.first_thinking_chunk:
+                            formatted_content = f"<think>{content}"
+                            self.first_thinking_chunk = False
+                        else:
+                            formatted_content = content
+                        
+                        debug_log(f"发送思考内容: {content}")
+                        chunk = create_openai_response_chunk(
+                            model=settings.PRIMARY_MODEL,
+                            delta=Delta(content=formatted_content)
+                        )
+                    else:
+                        # 如果从thinking阶段转到其他阶段，需要结束thinking标签
+                        if not self.first_thinking_chunk and upstream_data.data.phase == "answer":
+                            # 先发送思考结束标签
+                            thinking_end_chunk = create_openai_response_chunk(
+                                model=settings.PRIMARY_MODEL,
+                                delta=Delta(content="</think>")
+                            )
+                            yield f"data: {thinking_end_chunk.model_dump_json()}\n\n"
+                            # 重置状态
+                            self.first_thinking_chunk = True
+                        
+                        debug_log(f"发送普通内容: {content}")
+                        chunk = create_openai_response_chunk(
+                            model=settings.PRIMARY_MODEL,
+                            delta=Delta(content=content)
+                        )
+                    yield f"data: {chunk.model_dump_json()}\n\n"
+    
+    def _extract_edit_content(self, edit_content: str) -> str:
+        """Extract content from edit_content field"""
+        parts = edit_content.split("</details>")
+        return parts[1] if len(parts) > 1 else ""
+    
+    def _send_end_chunk(self, force_stop: bool = False) -> Generator[str, None, None]:
+        """Send end chunk and DONE signal"""
+        finish_reason = "stop"
+        
+        if self.has_tools and not force_stop:
+            # Try to extract tool calls from buffered content
+            self.tool_calls = extract_tool_invocations(self.buffered_content)
+            
+            if self.tool_calls:
+                debug_log(f"检测到工具调用: {len(self.tool_calls)} 个")
+                # Send tool calls with proper format
+                for i, tc in enumerate(self.tool_calls):
+                    tool_call_delta = {
+                        "index": i,
+                        "id": tc.get("id"),
+                        "type": tc.get("type", "function"),
+                        "function": tc.get("function", {}),
+                    }
+                    
+                    out_chunk = create_openai_response_chunk(
+                        model=settings.PRIMARY_MODEL,
+                        delta=Delta(tool_calls=[tool_call_delta])
+                    )
+                    yield f"data: {out_chunk.model_dump_json()}\n\n"
+                
+                finish_reason = "tool_calls"
+            else:
+                # Send regular content
+                trimmed_content = remove_tool_json_content(self.buffered_content)
+                if trimmed_content:
+                    debug_log(f"发送常规内容: {len(trimmed_content)} 字符")
+                    content_chunk = create_openai_response_chunk(
+                        model=settings.PRIMARY_MODEL,
+                        delta=Delta(content=trimmed_content)
+                    )
+                    yield f"data: {content_chunk.model_dump_json()}\n\n"
+        elif force_stop:
+            # 强制结束时，发送缓冲的内容（如果有）
+            if self.buffered_content:
+                debug_log(f"强制结束，发送缓冲内容: {len(self.buffered_content)} 字符")
+                content_chunk = create_openai_response_chunk(
+                    model=settings.PRIMARY_MODEL,
+                    delta=Delta(content=self.buffered_content)
+                )
+                yield f"data: {content_chunk.model_dump_json()}\n\n"
+        
+        # Send final chunk
+        end_chunk = create_openai_response_chunk(
+            model=settings.PRIMARY_MODEL,
+            finish_reason=finish_reason
+        )
+        yield f"data: {end_chunk.model_dump_json()}\n\n"
+        yield "data: [DONE]\n\n"
+        debug_log(f"流式响应完成 (finish_reason: {finish_reason})")
+
+
+    
     def _process_content_with_tools(
         self, 
         upstream_data: UpstreamData, 
@@ -399,101 +420,127 @@ class StreamResponseHandler(ResponseHandler):
         yield from self._process_content(upstream_data, sent_initial_answer)
 
 
-class NonStreamResponseHandler(ResponseHandler):
-    """Handler for non-streaming responses"""
-    
-    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str, has_tools: bool = False):
-        super().__init__(upstream_req, chat_id, auth_token)
-        self.has_tools = has_tools
-    
-    def handle(self) -> JSONResponse:
-        """Handle non-streaming response"""
-        debug_log(f"开始处理非流式响应 (chat_id={self.chat_id})")
-        
-        try:
-            response = self._call_upstream()
-        except Exception as e:
-            debug_log(f"调用上游失败: {e}")
-            raise HTTPException(status_code=502, detail="Failed to call upstream")
-        
-        if response.status_code != 200:
-            self._handle_upstream_error(response)
-            raise HTTPException(status_code=502, detail="Upstream error")
-        
-        # Collect full response
-        full_content = []
-        debug_log("开始收集完整响应内容")
-        response_completed = False
-        
-        try:
-            with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
-                for event in parser.iter_json_data(UpstreamData):
-                    upstream_data = event['data']
-                    
-                    if upstream_data.data.delta_content:
-                        content = upstream_data.data.delta_content
-                        
-                        if upstream_data.data.phase == "thinking":
-                            content = transform_thinking_content(content)
-                        
-                        if content:
-                            full_content.append(content)
-                    
-                    if upstream_data.data.done or upstream_data.data.phase == "done":
-                        debug_log("检测到完成信号，停止收集")
-                        response_completed = True
-                        break
-                        
-        except Exception as e:
-            debug_log(f"非流式响应收集异常: {e}")
-            if not full_content:
-                # 如果没有收集到任何内容，抛出异常
-                raise HTTPException(status_code=502, detail=f"Response collection failed: {str(e)}")
-            else:
-                debug_log(f"部分内容收集成功，继续处理 ({len(full_content)} 个片段)")
-        
-        if not response_completed and not full_content:
-            debug_log("响应未完成且无内容，可能是连接问题")
-            raise HTTPException(status_code=502, detail="Incomplete response from upstream")
-        
-        final_content = "".join(full_content)
-        debug_log(f"内容收集完成，最终长度: {len(final_content)}")
-        
-        # Handle tool calls for non-streaming
-        tool_calls = None
-        finish_reason = "stop"
-        message_content = final_content
-        
-        if self.has_tools:
-            tool_calls = extract_tool_invocations(final_content)
-            if tool_calls:
-                # Content must be null when tool_calls are present (OpenAI spec)
-                message_content = None
-                finish_reason = "tool_calls"
-                debug_log(f"提取到工具调用: {json.dumps(tool_calls, ensure_ascii=False)}")
-            else:
-                # Remove tool JSON from content
-                message_content = remove_tool_json_content(final_content)
-                if not message_content:
-                    message_content = final_content  # 保留原内容如果清理后为空
-        
-        # Build response
-        response_data = OpenAIResponse(
-            id=f"chatcmpl-{int(time.time())}",
-            object="chat.completion",
-            created=int(time.time()),
-            model=settings.PRIMARY_MODEL,
-            choices=[Choice(
-                index=0,
-                message=Message(
-                    role="assistant",
-                    content=message_content,
-                    tool_calls=tool_calls
-                ),
-                finish_reason=finish_reason
-            )],
-            usage=Usage()
-        )
-        
-        debug_log("非流式响应发送完成")
+class NonStreamResponseHandler(ResponseHandler):
+    """Handler for non-streaming responses"""
+    
+    def __init__(self, upstream_req: UpstreamRequest, chat_id: str, auth_token: str, has_tools: bool = False):
+        super().__init__(upstream_req, chat_id, auth_token)
+        self.has_tools = has_tools
+        # 思考状态跟踪
+        self.first_thinking_chunk = True
+        self.in_thinking_phase = False
+    
+    def handle(self) -> JSONResponse:
+        """Handle non-streaming response"""
+        debug_log(f"开始处理非流式响应 (chat_id={self.chat_id})")
+        
+        try:
+            response = self._call_upstream()
+        except Exception as e:
+            debug_log(f"调用上游失败: {e}")
+            raise HTTPException(status_code=502, detail="Failed to call upstream")
+        
+        if response.status_code != 200:
+            self._handle_upstream_error(response)
+            raise HTTPException(status_code=502, detail="Upstream error")
+        
+        # Collect full response
+        full_content = []
+        debug_log("开始收集完整响应内容")
+        response_completed = False
+        
+        try:
+            with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
+                for event in parser.iter_json_data(UpstreamData):
+                    upstream_data = event['data']
+                    
+                    if upstream_data.data.delta_content:
+                        content = upstream_data.data.delta_content
+                        
+                        if upstream_data.data.phase == "thinking":
+                            content = transform_thinking_content(content)
+                            
+                            # 处理思考内容的分块格式
+                            if not self.in_thinking_phase:
+                                # 进入思考阶段，添加开始标签
+                                self.in_thinking_phase = True
+                                if self.first_thinking_chunk:
+                                    content = f"<think>{content}"
+                                    self.first_thinking_chunk = False
+                                else:
+                                    content = f"<think>{content}"
+                            # 如果已经在思考阶段，保持纯内容
+                        else:
+                            # 如果从thinking阶段转到其他阶段
+                            if self.in_thinking_phase:
+                                # 添加结束标签到前一个内容
+                                if full_content and not self.first_thinking_chunk:
+                                    full_content.append("</think>")
+                                self.in_thinking_phase = False
+                                self.first_thinking_chunk = True
+                        
+                        if content:
+                            full_content.append(content)
+                    
+                    if upstream_data.data.done or upstream_data.data.phase == "done":
+                        debug_log("检测到完成信号，停止收集")
+                        response_completed = True
+                        break
+                        
+        except Exception as e:
+            debug_log(f"非流式响应收集异常: {e}")
+            if not full_content:
+                # 如果没有收集到任何内容，抛出异常
+                raise HTTPException(status_code=502, detail=f"Response collection failed: {str(e)}")
+            else:
+                debug_log(f"部分内容收集成功，继续处理 ({len(full_content)} 个片段)")
+        
+        if not response_completed and not full_content:
+            debug_log("响应未完成且无内容，可能是连接问题")
+            raise HTTPException(status_code=502, detail="Incomplete response from upstream")
+        
+        # 如果响应结束时还在思考阶段，需要添加结束标签
+        if self.in_thinking_phase and not self.first_thinking_chunk:
+            full_content.append("</think>")
+        
+        final_content = "".join(full_content)
+        debug_log(f"内容收集完成，最终长度: {len(final_content)}")
+        
+        # Handle tool calls for non-streaming
+        tool_calls = None
+        finish_reason = "stop"
+        message_content = final_content
+        
+        if self.has_tools:
+            tool_calls = extract_tool_invocations(final_content)
+            if tool_calls:
+                # Content must be null when tool_calls are present (OpenAI spec)
+                message_content = None
+                finish_reason = "tool_calls"
+                debug_log(f"提取到工具调用: {json.dumps(tool_calls, ensure_ascii=False)}")
+            else:
+                # Remove tool JSON from content
+                message_content = remove_tool_json_content(final_content)
+                if not message_content:
+                    message_content = final_content  # 保留原内容如果清理后为空
+        
+        # Build response
+        response_data = OpenAIResponse(
+            id=f"chatcmpl-{int(time.time())}",
+            object="chat.completion",
+            created=int(time.time()),
+            model=settings.PRIMARY_MODEL,
+            choices=[Choice(
+                index=0,
+                message=Message(
+                    role="assistant",
+                    content=message_content,
+                    tool_calls=tool_calls
+                ),
+                finish_reason=finish_reason
+            )],
+            usage=Usage()
+        )
+        
+        debug_log("非流式响应发送完成")
         return JSONResponse(content=response_data.model_dump(exclude_none=True))

app/core/zai_transformer.py

@@ -5,6 +5,9 @@ import json
 import time
 import uuid
 import random
+import hashlib
+import hmac
+import urllib.parse
 from datetime import datetime
 from typing import Dict, List, Any, Optional, Generator, AsyncGenerator
 import httpx
@@ -27,31 +30,31 @@ def get_user_agent_instance() -> UserAgent:
     return _user_agent_instance
 
 
-def get_dynamic_headers(chat_id: str = "") -> Dict[str, str]:
+def get_dynamic_headers(chat_id: str = "", user_agent: str = "") -> Dict[str, str]:
     """生成动态浏览器headers，包含随机User-Agent"""
-    ua = get_user_agent_instance()
-
-    # 随机选择浏览器类型，偏向Chrome和Edge
-    browser_choices = ["chrome", "chrome", "chrome", "edge", "edge", "firefox", "safari"]
-    browser_type = random.choice(browser_choices)
-
-    try:
-        if browser_type == "chrome":
-            user_agent = ua.chrome
-        elif browser_type == "edge":
-            user_agent = ua.edge
-        elif browser_type == "firefox":
-            user_agent = ua.firefox
-        elif browser_type == "safari":
-            user_agent = ua.safari
-        else:
+    if not user_agent:
+        ua = get_user_agent_instance()
+        # 随机选择浏览器类型，偏向Chrome和Edge
+        browser_choices = ["chrome", "chrome", "chrome", "edge", "edge", "firefox", "safari"]
+        browser_type = random.choice(browser_choices)
+
+        try:
+            if browser_type == "chrome":
+                user_agent = ua.chrome
+            elif browser_type == "edge":
+                user_agent = ua.edge
+            elif browser_type == "firefox":
+                user_agent = ua.firefox
+            elif browser_type == "safari":
+                user_agent = ua.safari
+            else:
+                user_agent = ua.random
+        except:
             user_agent = ua.random
-    except:
-        user_agent = ua.random
 
     # 提取版本信息
-    chrome_version = "139"
-    edge_version = "139"
+    chrome_version = "140"  # 更新版本号匹配F12信息
+    edge_version = "140"
 
     if "Chrome/" in user_agent:
         try:
@@ -62,27 +65,32 @@ def get_dynamic_headers(chat_id: str = "") -> Dict[str, str]:
     if "Edg/" in user_agent:
         try:
             edge_version = user_agent.split("Edg/")[1].split(".")[0]
-            sec_ch_ua = f'"Microsoft Edge";v="{edge_version}", "Chromium";v="{chrome_version}", "Not_A Brand";v="24"'
+            sec_ch_ua = f'"Microsoft Edge";v="{edge_version}", "Chromium";v="{chrome_version}", "Not=A?Brand";v="24"'
         except:
-            sec_ch_ua = f'"Not_A Brand";v="8", "Chromium";v="{chrome_version}", "Google Chrome";v="{chrome_version}"'
+            sec_ch_ua = f'"Chromium";v="{chrome_version}", "Not=A?Brand";v="24", "Microsoft Edge";v="{edge_version}"'
     elif "Firefox/" in user_agent:
         sec_ch_ua = None  # Firefox不使用sec-ch-ua
     else:
-        sec_ch_ua = f'"Not_A Brand";v="8", "Chromium";v="{chrome_version}", "Google Chrome";v="{chrome_version}"'
+        sec_ch_ua = f'"Chromium";v="{chrome_version}", "Not=A?Brand";v="24", "Google Chrome";v="{chrome_version}"'
 
     headers = {
+        "Accept": "*/*",
+        "Accept-Encoding": "gzip, deflate, br, zstd",
+        "Accept-Language": "zh-CN",
         "Content-Type": "application/json",
-        "Accept": "application/json, text/event-stream",
         "User-Agent": user_agent,
-        "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
-        "X-FE-Version": "prod-fe-1.0.79",
+        "X-Fe-Version": "prod-fe-1.0.83",  # 匹配F12信息中的版本
         "Origin": "https://chat.z.ai",
+        "Connection": "keep-alive",
+        "Sec-Fetch-Dest": "empty",
+        "Sec-Fetch-Mode": "cors", 
+        "Sec-Fetch-Site": "same-origin",
     }
 
     if sec_ch_ua:
-        headers["sec-ch-ua"] = sec_ch_ua
-        headers["sec-ch-ua-mobile"] = "?0"
-        headers["sec-ch-ua-platform"] = '"Windows"'
+        headers["Sec-Ch-Ua"] = sec_ch_ua
+        headers["Sec-Ch-Ua-Mobile"] = "?0"
+        headers["Sec-Ch-Ua-Platform"] = '"Windows"'
 
     if chat_id:
         headers["Referer"] = f"https://chat.z.ai/c/{chat_id}"
@@ -97,6 +105,114 @@ def generate_uuid() -> str:
     return str(uuid.uuid4())
 
 
+def generate_signature(data: str, timestamp: str, secret_key: str = "") -> str:
+    """生成请求签名
+    
+    Args:
+        data: 请求数据
+        timestamp: 时间戳
+        secret_key: 密钥（使用配置中的值）
+    
+    Returns:
+        签名字符串
+    """
+    if not settings.ENABLE_SIGNATURE:
+        return ""  # 如果禁用签名，返回空字符串
+        
+    if not secret_key:
+        secret_key = settings.SIGNATURE_SECRET_KEY
+    
+    # 构建签名字符串
+    sign_string = f"{data}{timestamp}{secret_key}"
+    
+    # 根据配置选择签名算法
+    if settings.SIGNATURE_ALGORITHM.lower() == "md5":
+        signature = hashlib.md5(sign_string.encode('utf-8')).hexdigest()
+    elif settings.SIGNATURE_ALGORITHM.lower() == "sha1":
+        signature = hashlib.sha1(sign_string.encode('utf-8')).hexdigest()
+    else:  # 默认使用sha256
+        signature = hashlib.sha256(sign_string.encode('utf-8')).hexdigest()
+    
+    return signature
+
+
+def build_query_params(
+    timestamp: int, 
+    request_id: str, 
+    token: str,
+    user_agent: str,
+    chat_id: str = ""
+) -> Dict[str, str]:
+    """构建查询参数，模拟真实的浏览器请求
+    
+    Args:
+        timestamp: 时间戳（毫秒）
+        request_id: 请求ID
+        token: 用户token
+        user_agent: 用户代理字符串
+        chat_id: 聊天ID
+        
+    Returns:
+        查询参数字典
+    """
+    # 生成用户ID（从token中提取或生成假的）
+    user_id = "guest-user-" + str(abs(hash(token)) % 1000000)
+    
+    # 编码用户代理
+    encoded_user_agent = urllib.parse.quote_plus(user_agent)
+    
+    # 当前时间相关
+    current_time = datetime.now()
+    local_time = current_time.isoformat() + "Z"
+    utc_time = current_time.strftime("%a, %d %b %Y %H:%M:%S GMT")
+    
+    # 构建当前URL
+    current_url = f"https://chat.z.ai/c/{chat_id}" if chat_id else "https://chat.z.ai/"
+    pathname = f"/c/{chat_id}" if chat_id else "/"
+    
+    query_params = {
+        "timestamp": str(timestamp),
+        "requestId": request_id,
+        "version": "0.0.1",
+        "platform": "web",
+        "user_id": user_id,
+        "token": token,
+        "user_agent": encoded_user_agent,
+        "language": "zh-CN",
+        "languages": "zh-CN,en,en-GB,en-US",
+        "timezone": "Asia/Shanghai",
+        "cookie_enabled": "true",
+        "screen_width": "1536",
+        "screen_height": "864",
+        "screen_resolution": "1536x864",
+        "viewport_height": "331",
+        "viewport_width": "1528",
+        "viewport_size": "1528x331",
+        "color_depth": "24",
+        "pixel_ratio": "1.25",
+        "current_url": urllib.parse.quote_plus(current_url),
+        "pathname": pathname,
+        "search": "",
+        "hash": "",
+        "host": "chat.z.ai",
+        "hostname": "chat.z.ai",
+        "protocol": "https:",
+        "referrer": "",
+        "title": "Chat with Z.ai - Free AI Chatbot powered by GLM-4.5",
+        "timezone_offset": "-480",
+        "local_time": local_time,
+        "utc_time": utc_time,
+        "is_mobile": "false",
+        "is_touch": "false",
+        "max_touch_points": "10",
+        "browser_name": "Chrome",
+        "os_name": "Windows",
+        # "signature_timestamp": str(timestamp),  # 已移除签名相关参数
+    }
+    
+    return query_params
+
+
 def get_auth_token_sync() -> str:
     """同步获取认证令牌（用于非异步场景）"""
     if settings.ANONYMOUS_MODE:
@@ -303,21 +419,37 @@ class ZAITransformer:
         else:
             body["tools"] = None
 
+        # 生成时间戳和请求ID
+        timestamp = int(time.time() * 1000)  # 毫秒时间戳
+        request_id = generate_uuid()
+        
         # 构建请求配置
-        dynamic_headers = get_dynamic_headers(chat_id)
+        user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0"
+        dynamic_headers = get_dynamic_headers(chat_id, user_agent)
+        
+        # 构建查询参数
+        query_params = build_query_params(timestamp, request_id, token, user_agent, chat_id)
+        
+        # 签名已强制禁用 - 不生成任何签名
+        # request_body_str = json.dumps(body, ensure_ascii=False, separators=(',', ':'))
+        # signature = generate_signature(request_body_str, str(timestamp))
+        
+        # 构建完整的URL（包含查询参数）
+        url_with_params = f"{self.api_url}?" + "&".join([f"{k}={v}" for k, v in query_params.items()])
+
+        headers = {
+            **dynamic_headers,  # 使用动态生成的headers
+            "Authorization": f"Bearer {token}",
+            "Cache-Control": "no-cache",
+            "Pragma": "no-cache",
+        }
+        
+        # 签名功能已禁用
+        debug_log("  🔓 签名验证已禁用")
 
         config = {
-            "url": self.api_url,  # 使用原始URL
-            "headers": {
-                **dynamic_headers,  # 使用动态生成的headers
-                "Authorization": f"Bearer {token}",
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "Pragma": "no-cache",
-                "Sec-Fetch-Dest": "empty",
-                "Sec-Fetch-Mode": "cors",
-                "Sec-Fetch-Site": "same-origin",
-            },
+            "url": url_with_params,
+            "headers": headers,
         }
 
         debug_log("✅ 请求转换完成")

docker-compose.yml

@@ -1,5 +1,3 @@
-version: '3.8'
-
 services:
   z-ai2api:
     image: julienol/z-ai2api-python:latest