Update app.py

app.py

@@ -19,43 +19,36 @@ GPT_OSS_HEADERS = {
     'x-selected-model': 'gpt-oss-120b',
 }
 
-# 3. 根路由
+# 3. 根路由，用于健康检查
 @app.route('/', methods=['GET'])
 def root():
-    return jsonify({
-        "message": "欢迎使用 GPT-OSS to OpenAI 格式代理API",
-        "status": "ok",
-        "api_endpoint": "/v1/chat/completions",
-        "features": {
-            "stream": "支持",
-            "non_stream": "支持",
-            "conditional_reasoning": "思考过程在流式模式下通过 <think> 标签显示"
-        }
-    })
+    return jsonify({"message": "欢迎使用 GPT-OSS to OpenAI 格式代理API", "status": "ok"})
+
+# 辅助函数：创建一个标准的OpenAI流式数据块
+def create_openai_chunk(content, model="gpt-oss-120b", custom_id_prefix="chatcmpl"):
+    return {
+        "id": f"{custom_id_prefix}-{str(uuid.uuid4())}",
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [{"index": 0, "delta": {"content": content}, "finish_reason": None}]
+    }
 
 # 4. 核心API端点
 @app.route('/v1/chat/completions', methods=['POST'])
 def chat_completions_proxy():
     try:
         openai_request_data = request.json
-        messages = openai_request_data.get("messages", [])
-        user_prompt = next((m['content'] for m in reversed(messages) if m.get('role') == 'user'), None)
-        
-        if not user_prompt:
-            return jsonify({"error": "在请求中未找到用户消息。"}), 400
-            
+        user_prompt = next((m['content'] for m in reversed(openai_request_data.get("messages", [])) if m.get('role') == 'user'), None)
+        if not user_prompt: return jsonify({"error": "未找到用户消息。"}), 400
         stream_requested = openai_request_data.get("stream", False)
     except Exception as e:
         return jsonify({"error": f"请求格式无效: {e}"}), 400
 
     request_headers = GPT_OSS_HEADERS.copy()
-    if stream_requested:
-        request_headers['x-show-reasoning'] = 'true'
-    else:
-        request_headers['x-show-reasoning'] = 'false'
+    request_headers['x-show-reasoning'] = 'true' if stream_requested else 'false'
         
-    random_user_id = str(uuid.uuid4())
-    gpt_oss_cookies = {'user_id': random_user_id}
+    gpt_oss_cookies = {'user_id': str(uuid.uuid4())}
     gpt_oss_payload = {
         "op": "threads.create",
         "params": {"input": {"text": user_prompt, "content": [{"type": "input_text", "text": user_prompt}]}}
@@ -69,81 +62,48 @@ def chat_completions_proxy():
             ) as response:
                 response.raise_for_status()
                 for line in response.iter_lines():
-                    if line:
-                        line_str = line.decode('utf-8')
-                        if line_str.startswith('data: '):
-                            json_data_str = line_str[6:]
-                            try:
-                                yield json.loads(json_data_str)
-                            except json.JSONDecodeError:
-                                continue
+                    if line and line.decode('utf-8').startswith('data: '):
+                        try:
+                            yield json.loads(line.decode('utf-8')[6:])
+                        except json.JSONDecodeError: continue
         except requests.exceptions.RequestException as e:
             raise IOError(f"与后端服务通信失败: {e}")
 
     if stream_requested:
         def stream_formatter():
             try:
-                # --- 关键改动在这里 ---
-                # 用于拼接所有思考过程的变量
-                all_thoughts = []
-
                 for gpt_oss_data in _internal_proxy_stream():
                     event_type = gpt_oss_data.get('type')
+                    update_type = gpt_oss_data.get('update', {}).get('type')
                     
-                    # 步骤1: 捕获并暂存所有思考过程
-                    if (event_type == 'thread.item_updated' and 
-                        gpt_oss_data.get('update', {}).get('type') == 'cot.entry_added'):
+                    # --- 关键改动：模拟思考过程的打字效果 ---
+                    if event_type == 'thread.item_updated' and update_type == 'cot.entry_added':
                         thought = gpt_oss_data['update']['entry']['content']
-                        all_thoughts.append(thought)
-                    
-                    # 步骤2: 当第一个文本片段出现时，一次性将所有思考过程格式化并发送
-                    if (event_type == 'thread.item_updated' and 
-                        gpt_oss_data.get('update', {}).get('type') == 'assistant_message.content_part.text_delta' and
-                        all_thoughts): # 确保只在第一次发送
-                        
-                        # 格式化所有思考过程
-                        formatted_thoughts = "<think>\n"
-                        for i, t in enumerate(all_thoughts, 1):
-                            formatted_thoughts += f"  Step {i}: {t}\n"
-                        formatted_thoughts += "</think>\n\n"
-                        
-                        # 构建一个标准的OpenAI流块来发送思考过程
-                        openai_chunk = {
-                            "id": f"chatcmpl-{str(uuid.uuid4())}", "object": "chat.completion.chunk",
-                            "created": int(time.time()), "model": "gpt-oss-120b",
-                            "choices": [{"index": 0, "delta": {"content": formatted_thoughts}, "finish_reason": None}]
-                        }
-                        yield f"data: {json.dumps(openai_chunk)}\n\n"
-                        
-                        # 清空思考过程，防止重复发送
-                        all_thoughts = []
+                        # 立即发送前缀
+                        yield f"data: {json.dumps(create_openai_chunk('[思考中] '))}\n\n"
+                        # 逐字流式传输思考内容
+                        for char in thought:
+                            yield f"data: {json.dumps(create_openai_chunk(char))}\n\n"
+                            time.sleep(0.02) # 加入微小延迟，以获得更好的视觉效果
+                        # 发送换行符以分隔
+                        yield f"data: {json.dumps(create_openai_chunk('\\n\\n'))}\n\n"
 
-                    # 步骤3: 正常发送文本片段
-                    if (event_type == 'thread.item_updated' and 
-                        gpt_oss_data.get('update', {}).get('type') == 'assistant_message.content_part.text_delta'):
+                    # 普通文本片段的流式传输（这部分本身就是逐字/逐词的）
+                    if event_type == 'thread.item_updated' and update_type == 'assistant_message.content_part.text_delta':
                         delta_content = gpt_oss_data['update'].get('delta', '')
-                        openai_chunk = {
-                            "id": f"chatcmpl-{str(uuid.uuid4())}", "object": "chat.completion.chunk",
-                            "created": int(time.time()), "model": "gpt-oss-120b",
-                            "choices": [{"index": 0, "delta": {"content": delta_content}, "finish_reason": None}]
-                        }
-                        yield f"data: {json.dumps(openai_chunk)}\n\n"
+                        yield f"data: {json.dumps(create_openai_chunk(delta_content))}\n\n"
                 
                 yield "data: [DONE]\n\n"
             except IOError as e:
-                 error_chunk = {"error": str(e)}
-                 yield f"data: {json.dumps(error_chunk)}\n\n"
+                 yield f"data: {json.dumps({'error': str(e)})}\n\n"
 
         return Response(stream_formatter(), mimetype='text/event-stream')
     
-    else:
-        # 非流式逻辑保持不变
+    else: # 非流式请求逻辑保持不变
         try:
             full_response_content = ""
             for gpt_oss_data in _internal_proxy_stream():
-                event_type = gpt_oss_data.get('type')
-                if (event_type == 'thread.item_updated' and 
-                    gpt_oss_data.get('update', {}).get('type') == 'assistant_message.content_part.text_delta'):
+                if gpt_oss_data.get('type') == 'thread.item_updated' and gpt_oss_data.get('update', {}).get('type') == 'assistant_message.content_part.text_delta':
                     full_response_content += gpt_oss_data['update'].get('delta', '')
             
             final_response = {
@@ -153,7 +113,6 @@ def chat_completions_proxy():
                 "usage": {"prompt_tokens": None, "completion_tokens": None, "total_tokens": None}
             }
             return jsonify(final_response)
-        
         except IOError as e:
             return jsonify({"error": str(e)}), 500