Update openai_ondemand_adapter.py

openai_ondemand_adapter.py

@@ -440,11 +440,14 @@ def chat_completions():
                 logging.warning(f"【请求处理 - Key轮换尝试 {key_retry_count}】HTTP/请求错误。Status: {status_code_from_exc}, Key: {keymgr.display_key(selected_apikey_for_outer_retry) if selected_apikey_for_outer_retry else 'N/A'}, Error: {http_err_outer}")
                 
                 if selected_apikey_for_outer_retry: 
-                    if status_code_from_exc == 524:
+                    if status_code_from_exc == 524: # HTTP 524: A Timeout Occurred (Cloudflare)
                         logging.info(f"【KeyManager】Key {keymgr.display_key(selected_apikey_for_outer_retry)} not marked bad due to 524 error.")
-                    else: 
+                    # For other client/server errors that might indicate a key issue or persistent service issue with this key
+                    elif status_code_from_exc and (400 <= status_code_from_exc < 500 or status_code_from_exc in [500, 502, 503]): # excluding 524
                         keymgr.mark_bad(selected_apikey_for_outer_retry)
-                
+                    elif not status_code_from_exc : # Network errors without a status code (e.g., connection refused, DNS failure)
+                         keymgr.mark_bad(selected_apikey_for_outer_retry)
+
                 if key_retry_count >= max_key_retries:
                     logging.error(f"【请求处理】所有Key轮换尝试均失败。最后错误: {last_exception_for_key_retry}")
                     break 
@@ -455,22 +458,23 @@ def chat_completions():
             except Exception as e_outer: 
                 last_exception_for_key_retry = e_outer
                 logging.error(f"【请求处理 - Key轮换尝试 {key_retry_count}】发生意外严重错误: {e_outer}", exc_info=True)
-                if selected_apikey_for_outer_retry:
+                if selected_apikey_for_outer_retry: # Mark key bad on any other unexpected exception during setup
                     keymgr.mark_bad(selected_apikey_for_outer_retry) 
                 break 
         
-        error_message = "All attempts to process the request failed after multiple key/session retries."
-        if last_exception_for_key_retry:
-            error_message += f" Last known error during key/session phase: {str(last_exception_for_key_retry)}"
-        logging.error(error_message)
+        # This block is reached if all key_retry_count attempts in with_valid_key_and_session fail
+        error_message = "重试次数过多，请检查上下文长度! 或联系管理员!" # User requested message
+        error_code_str = "max_retries_check_context_contact_admin" # Custom code for this scenario
+        
+        logging.error(f"【请求处理】所有Key/Session获取尝试失败。最终错误: {error_message} Last underlying exception: {last_exception_for_key_retry}")
 
         if is_stream_request:
             def error_stream_gen():
-                yield format_openai_sse_delta({"error": {"message": error_message, "type": "proxy_setup_error", "code": "proxy_error_503"}}) # Changed code
+                yield format_openai_sse_delta({"error": {"message": error_message, "type": "proxy_setup_error_max_retries", "code": error_code_str}})
                 yield "data: [DONE]\n\n"
-            return Response(error_stream_gen(), content_type='text/event-stream', status=503)
+            return Response(error_stream_gen(), content_type='text/event-stream', status=500) # Status 500 as requested
         else:
-            return jsonify({"error": error_message, "code": "proxy_error_503"}), 503 # Added code here
+            return jsonify({"error": error_message, "code": error_code_str}), 500 # Status 500 as requested
 
     return with_valid_key_and_session(attempt_ondemand_request_wrapper)
 
@@ -494,17 +498,22 @@ def handle_stream_request(initial_apikey, initial_session_id, query_str, endpoin
                 logging.info(f"【流式请求-空回复重试 {empty_retry_attempt_num-1}】新Key/Session获取成功: Key={keymgr.display_key(current_apikey_for_attempt)}, Session={current_session_id_for_attempt}")
             except (ValueError, requests.exceptions.RequestException) as e_key_session:
                 logging.warning(f"【流式请求-空回复重试 {empty_retry_attempt_num-1}】获取新Key/Session失败: {e_key_session}")
+                status_code_from_exc_retry_setup = None
+                if hasattr(e_key_session, 'response') and e_key_session.response is not None:
+                    status_code_from_exc_retry_setup = e_key_session.response.status_code
+
                 if current_apikey_for_attempt and not isinstance(e_key_session, ValueError): 
-                    status_code_from_exc = None
-                    if hasattr(e_key_session, 'response') and e_key_session.response is not None:
-                        status_code_from_exc = e_key_session.response.status_code
-                    if status_code_from_exc == 524:
-                        logging.info(f"【KeyManager】Key {keymgr.display_key(current_apikey_for_attempt)} not marked bad for 524 error during key/session acquisition for retry.")
+                    if status_code_from_exc_retry_setup == 524:
+                        logging.info(f"【KeyManager】Key {keymgr.display_key(current_apikey_for_attempt)} not marked bad for 524 error during key/session acquisition for stream retry.")
                     else:
                         keymgr.mark_bad(current_apikey_for_attempt)
 
                 if empty_retry_attempt_num >= max_empty_response_retries:
-                    yield format_openai_sse_delta({"error": {"message": f"Failed to get new key/session for final empty stream retry. Error: {str(e_key_session)}", "type": "internal_proxy_error", "code": "proxy_retry_setup_failed"}})
+                    # Final failure to get key/session for the last empty response retry
+                    final_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
+                    final_error_code = "max_retries_check_context_contact_admin"
+                    logging.error(f"【流式请求】无法为最终空回复重试获取新Key/Session。错误: {e_key_session}")
+                    yield format_openai_sse_delta({"error": {"message": final_error_message, "type": "proxy_final_retry_setup_failed", "code": final_error_code}})
                     yield "data: [DONE]\n\n"
                     return 
                 time.sleep(1)
@@ -543,8 +552,10 @@ def handle_stream_request(initial_apikey, initial_session_id, query_str, endpoin
                 raise e_req 
             
             if empty_retry_attempt_num >= max_empty_response_retries:
-                logging.error(f"【流式请求】在最后一次空回复重试时发生请求错误。")
-                yield format_openai_sse_delta({"error": {"message": f"Request failed on final empty stream retry attempt: {str(e_req)}", "type": "internal_proxy_error", "code": "proxy_final_retry_failed"}})
+                final_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
+                final_error_code = "max_retries_check_context_contact_admin"
+                logging.error(f"【流式请求】在最后一次空回复重试时发生请求错误: {e_req}")
+                yield format_openai_sse_delta({"error": {"message": final_error_message, "type": "proxy_final_retry_request_failed", "code": final_error_code}})
                 yield "data: [DONE]\n\n"
                 return 
             time.sleep(1)
@@ -560,9 +571,11 @@ def handle_stream_request(initial_apikey, initial_session_id, query_str, endpoin
         
         logging.warning(f"【流式请求】({log_attempt_str}) 返回空内容。")
         if empty_retry_attempt_num >= max_empty_response_retries:
-            logging.error(f"【流式请求】达到最大空回复重试次数 ({max_empty_response_retries})。")
+            final_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
+            final_error_code = "max_retries_check_context_contact_admin"
+            logging.error(f"【流式请求】达到最大空回复重试次数 ({max_empty_response_retries})。将返回指定错误。")
             yield format_openai_sse_delta({
-                "error": {"message": "返回空回复，请重试", "type": "empty_response_after_retries", "code": "empty_response_please_retry"} # Changed message and code
+                "error": {"message": final_error_message, "type": "max_retries_exceeded_empty_response", "code": final_error_code}
             })
             yield "data: [DONE]\n\n"
             return 
@@ -570,8 +583,13 @@ def handle_stream_request(initial_apikey, initial_session_id, query_str, endpoin
         logging.info(f"【流式请求】空回复，将在1秒后重试下一个Key。当前总尝试 {empty_retry_attempt_num}/{max_empty_response_retries}")
         time.sleep(1)
 
-    logging.error("【流式请求】意外退出空回复重试循环。")
-    yield format_openai_sse_delta({"error": {"message": "Unexpected error in stream handling.", "type": "internal_proxy_error", "code":"unexpected_stream_exit"}})
+    # Fallback if loop finishes unexpectedly (shouldn't happen with current logic)
+    # This case means all max_empty_response_retries were exhausted, and the last one was also empty.
+    # The specific error for this is handled inside the loop. This is a safeguard.
+    final_fallback_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
+    final_fallback_error_code = "max_retries_check_context_contact_admin_fallback"
+    logging.error(f"【流式请求】意外退出空回复重试循环。返回最终错误。")
+    yield format_openai_sse_delta({"error": {"message": final_fallback_error_message, "type": "internal_proxy_error_unexpected_exit", "code": final_fallback_error_code}})
     yield "data: [DONE]\n\n"
 
 
@@ -596,16 +614,21 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
                 logging.info(f"【同步请求-空回复重试 {empty_retry_attempt_num-1}】新Key/Session获取成功: Key={keymgr.display_key(current_apikey_for_attempt)}, Session={current_session_id_for_attempt}")
             except (ValueError, requests.exceptions.RequestException) as e_key_session:
                 logging.warning(f"【同步请求-空回复重试 {empty_retry_attempt_num-1}】获取新Key/Session失败: {e_key_session}")
+                status_code_from_exc_retry_setup_ns = None
+                if hasattr(e_key_session, 'response') and e_key_session.response is not None:
+                    status_code_from_exc_retry_setup_ns = e_key_session.response.status_code
+                
                 if current_apikey_for_attempt and not isinstance(e_key_session, ValueError): 
-                    status_code_from_exc = None
-                    if hasattr(e_key_session, 'response') and e_key_session.response is not None:
-                        status_code_from_exc = e_key_session.response.status_code
-                    if status_code_from_exc == 524:
+                    if status_code_from_exc_retry_setup_ns == 524:
                         logging.info(f"【KeyManager】Key {keymgr.display_key(current_apikey_for_attempt)} not marked bad for 524 error during key/session acquisition for non-stream retry.")
                     else:
                         keymgr.mark_bad(current_apikey_for_attempt)
                 if empty_retry_attempt_num >= max_empty_response_retries:
-                    return jsonify({"error": f"Failed to get new key/session for final empty response retry. Error: {str(e_key_session)}", "code":"proxy_retry_setup_failed"}), 503
+                    # Final failure to get key/session for the last empty response retry
+                    final_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
+                    final_error_code = "max_retries_check_context_contact_admin"
+                    logging.error(f"【同步请求】无法为最终空回复重试获取新Key/Session。错误: {e_key_session}")
+                    return jsonify({"error": final_error_message, "code": final_error_code}), 500 # Status 500
                 time.sleep(1)
                 current_apikey_for_attempt = None 
                 continue 
@@ -623,7 +646,10 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
             response_json = resp.json()
             if "data" not in response_json or "answer" not in response_json["data"]:
                 logging.error(f"【OnDemand同步错误】响应格式不符合预期 ({log_attempt_str})。Session: {current_session_id_for_attempt}, 响应: {str(response_json)[:500]}")
-                raise ValueError("OnDemand API sync response missing 'data.answer' field.") 
+                # This is an API format error, not an empty response.
+                # If this happens on the first attempt, it will be re-raised to with_valid_key_and_session
+                # If on a retry for empty response, it's a new kind of failure for that attempt.
+                raise ValueError(f"OnDemand API sync response missing 'data.answer' field on attempt {empty_retry_attempt_num}.") 
             
             ai_response_content = response_json["data"]["answer"]
             if ai_response_content is None: ai_response_content = "" 
@@ -640,15 +666,17 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
             else: 
                 logging.warning(f"【同步请求】({log_attempt_str}) 返回空回复。")
                 if empty_retry_attempt_num >= max_empty_response_retries:
-                    logging.error(f"【同步请求】达到最大空回复重试次数 ({max_empty_response_retries})。")
+                    final_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
+                    final_error_code = "max_retries_check_context_contact_admin"
+                    logging.error(f"【同步请求】达到最大空回复重试次数 ({max_empty_response_retries})。将返回指定错误。")
                     return jsonify({
-                        "error": "返回空回复，请重试", # Changed message
+                        "error": final_error_message, 
                         "id": "chatcmpl-" + str(uuid.uuid4())[:12], "object": "chat.completion", "created": int(time.time()),
                         "model": openai_model_name_for_response,
-                        "choices": [{"index": 0, "message": {"role": "assistant", "content": ""}, "finish_reason": "length"}], # or "error" finish_reason
+                        "choices": [{"index": 0, "message": {"role": "assistant", "content": ""}, "finish_reason": "length"}], 
                         "usage": {},
-                        "code": "empty_response_please_retry" # Added code
-                    }), 503 # Changed status code to 503 for "please retry"
+                        "code": final_error_code 
+                    }), 500 # Status 500 as requested
                 logging.info(f"【同步请求】空回复，将在1秒后重试下一个Key。当前总尝试 {empty_retry_attempt_num}/{max_empty_response_retries}")
                 time.sleep(1) 
         
@@ -669,16 +697,34 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
             if empty_retry_attempt_num == 1: 
                 raise e_req 
             if empty_retry_attempt_num >= max_empty_response_retries:
-                logging.error(f"【同步请求】在最后一次空回复重试时发生请求错误。")
-                return jsonify({"error": f"Request failed on final empty response retry attempt. Last error: {str(e_req)}", "code":"proxy_final_retry_failed"}), 503
+                final_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
+                final_error_code = "max_retries_check_context_contact_admin"
+                logging.error(f"【同步请求】在最后一次空回复重试时发生请求错误: {e_req}")
+                return jsonify({"error": final_error_message, "code":final_error_code, "details": str(e_req)}), 500 # Status 500
             time.sleep(1)
             continue 
         except (ValueError, KeyError, json.JSONDecodeError) as e_parse: 
-            logging.error(f"【同步请求】({log_attempt_str}) 处理响应时出错: {e_parse}", exc_info=True)
-            return jsonify({"error": f"Error processing OnDemand sync response: {str(e_parse)}", "code": "on_demand_parse_error"}), 502 
+            # This catches the ValueError from "data.answer" missing, or JSON decode errors
+            logging.error(f"【同步请求】({log_attempt_str}) 处理响应或格式时出错: {e_parse}", exc_info=True)
+            if empty_retry_attempt_num == 1:
+                 # If format error on first attempt, re-raise to be caught by with_valid_key_and_session
+                 # This implies a more fundamental issue than just an empty response.
+                 raise requests.exceptions.RequestException(f"Response format error on first attempt: {e_parse}") from e_parse
+
+            # If it's a format error during an empty-response retry, it's problematic.
+            if empty_retry_attempt_num >= max_empty_response_retries:
+                final_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
+                final_error_code = "max_retries_check_context_contact_admin"
+                logging.error(f"【同步请求】在最后一次空回复重试时发生响应解析错误: {e_parse}")
+                return jsonify({"error": final_error_message, "code": final_error_code, "details": f"Parse error: {str(e_parse)}"}), 500 # Status 500
+            time.sleep(1)
+            continue # Try next key for empty response retry
     
-    logging.error(f"【同步请求】意外退出空回复重试循环。") 
-    return jsonify({"error": "返回空回复，请重试", "code": "unexpected_empty_retry_exit_please_retry"}), 503 # Changed message and code, and status
+    # Fallback if loop finishes unexpectedly (e.g. all retries were empty and the last one didn't hit the specific return)
+    final_fallback_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
+    final_fallback_error_code = "max_retries_check_context_contact_admin_fallback"
+    logging.error(f"【同步请求】意外退出空回复重试循环。返回最终错误。") 
+    return jsonify({"error": final_fallback_error_message, "code": final_fallback_error_code}), 500 # Status 500
 
 
 @app.route("/v1/models", methods=["GET"])