Update openai_ondemand_adapter.py

openai_ondemand_adapter.py

@@ -255,35 +255,32 @@ def _execute_one_stream_attempt(apikey_for_attempt, session_id_for_attempt, quer
     accumulated_text_parts = []
     api_error_yielded = False 
     
-    # Inner retry loop for 500 errors specifically for this attempt
     max_500_retries_for_this_call = 5
     current_500_retry_count = 0
 
     while current_500_retry_count < max_500_retries_for_this_call:
         current_500_retry_count += 1
-        if current_500_retry_count > 1: # Log if this is a 500-retry
+        if current_500_retry_count > 1: 
             logging.info(f"【流式请求子尝试 {current_attempt_num_logging} - 500错误重试 {current_500_retry_count-1}/{max_500_retries_for_this_call-1}】Key: {keymgr.display_key(apikey_for_attempt)}")
         else:
              logging.info(f"【流式请求子尝试 {current_attempt_num_logging}】发送到 OnDemand: Session={session_id_for_attempt}, Endpoint={endpoint_id}, Key={keymgr.display_key(apikey_for_attempt)}")
 
-
         try:
             with requests.post(url, json=payload, headers=headers, stream=True, timeout=180) as resp:
-                if resp.status_code == 500: # Specific handling for 500 error
+                if resp.status_code == 500: 
                     logging.warning(f"【OnDemand流错误】(子尝试 {current_attempt_num_logging}, 500重试 {current_500_retry_count}) 收到500错误。Session: {session_id_for_attempt}")
                     if current_500_retry_count >= max_500_retries_for_this_call:
                         logging.error(f"【OnDemand流错误】(子尝试 {current_attempt_num_logging}) 达到500错误最大重试次数。将错误传递给上层。")
-                        # Yield a specific error for persistent 500 after retries
                         api_error_yielded = True
                         error_payload = {"error": {"message": f"OnDemand API persistent 500 error after {max_500_retries_for_this_call} retries (Attempt {current_attempt_num_logging}).", 
                                                    "type": "on_demand_persistent_500_error", "code": 500}}
                         yield format_openai_sse_delta(error_payload)
                         yield "data: [DONE]\n\n"
                         return "".join(accumulated_text_parts).strip(), api_error_yielded
-                    time.sleep(1) # Wait before retrying the 500 error
-                    continue # Go to the next iteration of the 500-retry loop
+                    time.sleep(1) 
+                    continue 
 
-                if resp.status_code != 200: # Handle other non-200, non-500 errors
+                if resp.status_code != 200: 
                     api_error_yielded = True
                     error_text = resp.text
                     logging.error(f"【OnDemand流错误】请求失败 (子尝试 {current_attempt_num_logging})。状态码: {resp.status_code}, Session: {session_id_for_attempt}, 响应: {error_text[:500]}")
@@ -298,7 +295,6 @@ def _execute_one_stream_attempt(apikey_for_attempt, session_id_for_attempt, quer
                     yield "data: [DONE]\n\n"
                     return "".join(accumulated_text_parts).strip(), api_error_yielded 
 
-                # Successful 200 response, process stream
                 first_chunk_sent = False
                 last_line_str = "" 
                 for line_bytes in resp.iter_lines():
@@ -356,17 +352,13 @@ def _execute_one_stream_attempt(apikey_for_attempt, session_id_for_attempt, quer
                 if not api_error_yielded and not last_line_str.startswith("data: [DONE]"): 
                      logging.info(f"【OnDemand流】(子尝试 {current_attempt_num_logging}) 流迭代完成，补充发送 [DONE]。Session: {session_id_for_attempt}")
                      yield "data: [DONE]\n\n"
-                return "".join(accumulated_text_parts).strip(), api_error_yielded # Success for this attempt
+                return "".join(accumulated_text_parts).strip(), api_error_yielded 
 
         except requests.exceptions.RequestException as e_req_inner: 
-            # This catches network errors or HTTP errors if resp.raise_for_status() was called (e.g. for persistent 500)
             logging.error(f"【OnDemand流】(子尝试 {current_attempt_num_logging}) 请求时发生异常: {e_req_inner}, Key: {keymgr.display_key(apikey_for_attempt)}")
-            # If this was the last 500-retry, or another RequestException, re-raise to be handled by handle_stream_request's try-except
             if current_500_retry_count >= max_500_retries_for_this_call or (hasattr(e_req_inner, 'response') and e_req_inner.response is not None and e_req_inner.response.status_code != 500):
                 raise e_req_inner 
-            # If it was a 500 and we still have retries for 500, the loop will continue after a delay.
-            time.sleep(1) # Wait before retrying the 500 error
-            # The loop will continue to the next 500-retry.
+            time.sleep(1) 
         
         except Exception as e_inner_unknown: 
             logging.error(f"【OnDemand流】处理流时发生未知��误 (子尝试 {current_attempt_num_logging}): {e_inner_unknown}, Session: {session_id_for_attempt}", exc_info=True)
@@ -378,10 +370,7 @@ def _execute_one_stream_attempt(apikey_for_attempt, session_id_for_attempt, quer
             yield "data: [DONE]\n\n"
             return "".join(accumulated_text_parts).strip(), api_error_yielded
     
-    # If 500-retry loop exhausted without returning (should ideally raise inside or return success)
     logging.error(f"【OnDemand流】(子尝试 {current_attempt_num_logging}) 500错误重试循环意外结束。")
-    # This case should ideally not be reached if logic inside loop is correct.
-    # Re-raise a generic error to be caught by the caller if it does.
     raise requests.exceptions.RequestException(f"Exhausted internal 500 retries for attempt {current_attempt_num_logging} without success or specific error propagation.")
 
 
@@ -517,7 +506,7 @@ def handle_stream_request(initial_apikey, initial_session_id, query_str, endpoin
     while empty_retry_attempt_num < max_empty_response_retries:
         empty_retry_attempt_num += 1
         accumulated_text_this_attempt = ""
-        api_error_in_attempt = False # Renamed from api_error_yielded for clarity in this scope
+        api_error_in_attempt = False 
         
         if empty_retry_attempt_num > 1: 
             logging.info(f"【流式请求-空回复重试 {empty_retry_attempt_num-1}】获取新Key/Session...")
@@ -553,7 +542,6 @@ def handle_stream_request(initial_apikey, initial_session_id, query_str, endpoin
         log_attempt_str = f"初始尝试" if empty_retry_attempt_num == 1 else f"空回复重试 {empty_retry_attempt_num-1}"
 
         try:
-            # result_tuple will be (accumulated_text, api_error_yielded_flag_from_execute)
             result_tuple = yield from _execute_one_stream_attempt(
                 current_apikey_for_attempt, 
                 current_session_id_for_attempt, 
@@ -563,9 +551,9 @@ def handle_stream_request(initial_apikey, initial_session_id, query_str, endpoin
                 f"{log_attempt_str} (Overall attempt {empty_retry_attempt_num})"
             )
             accumulated_text_this_attempt = result_tuple[0]
-            api_error_in_attempt = result_tuple[1] # This tells if _execute_one_stream_attempt itself yielded an error SSE
+            api_error_in_attempt = result_tuple[1] 
 
-        except requests.exceptions.RequestException as e_req: # Catch errors from _execute_one_stream_attempt's requests.post
+        except requests.exceptions.RequestException as e_req: 
             log_key_display = keymgr.display_key(current_apikey_for_attempt) if current_apikey_for_attempt else "N/A"
             status_code_from_exc_stream = None
             if hasattr(e_req, 'response') and e_req.response is not None:
@@ -582,11 +570,8 @@ def handle_stream_request(initial_apikey, initial_session_id, query_str, endpoin
                     keymgr.mark_bad(current_apikey_for_attempt)
 
             if empty_retry_attempt_num == 1: 
-                # If the very first attempt (initial_apikey) fails with RequestException,
-                # re-raise to let with_valid_key_and_session handle key rotation.
                 raise e_req 
             
-            # If it's an empty-response retry (attempt_num > 1) that failed with RequestException
             if empty_retry_attempt_num >= max_empty_response_retries:
                 final_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
                 final_error_code = "max_retries_check_context_contact_admin"
@@ -595,20 +580,16 @@ def handle_stream_request(initial_apikey, initial_session_id, query_str, endpoin
                 yield "data: [DONE]\n\n"
                 return 
             time.sleep(1)
-            continue # To the next iteration of the empty_retry_attempt_num loop (will try new key/session)
+            continue 
             
-        # After _execute_one_stream_attempt has finished (either normally or yielded its own error)
         if api_error_in_attempt: 
-            # This means _execute_one_stream_attempt handled an API error (like 429, or persistent 500) and yielded an error SSE.
-            # The stream is already complete with an error.
             logging.warning(f"【流式请求】({log_attempt_str}) 子尝试已处理并流式传输API错误。")
-            return # Stop further empty response retries.
+            return 
 
         if accumulated_text_this_attempt: 
             logging.info(f"【流式请求】({log_attempt_str}) 成功获取非空内容。")
-            return # Stream was successful and content yielded.
+            return 
         
-        # If we reach here, content was empty from _execute_one_stream_attempt, and no API error was yielded by it.
         logging.warning(f"【流式请求】({log_attempt_str}) 返回空内容。")
         if empty_retry_attempt_num >= max_empty_response_retries:
             final_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
@@ -637,6 +618,8 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
     current_apikey_for_attempt = initial_apikey
     current_session_id_for_attempt = initial_session_id
     
+    ai_response_content = "" # Define ai_response_content outside the try block to ensure it's available for the final empty check
+
     while empty_retry_attempt_num < max_empty_response_retries:
         empty_retry_attempt_num += 1
         
@@ -671,10 +654,12 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
         
         log_attempt_str = f"初始尝试" if empty_retry_attempt_num == 1 else f"空回复重试 {empty_retry_attempt_num-1}"
         
-        # Inner loop for 500-error retries for the current key/session
         max_500_retries_for_this_call = 5
         current_500_retry_count = 0
         
+        # Reset ai_response_content for each new attempt (especially for the 500-retry loop)
+        ai_response_content = "" 
+        
         while current_500_retry_count < max_500_retries_for_this_call:
             current_500_retry_count += 1
             if current_500_retry_count > 1:
@@ -682,8 +667,9 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
             else:
                 logging.info(f"【同步请求】({log_attempt_str}, 总尝试 {empty_retry_attempt_num}) Session={current_session_id_for_attempt}, Key={keymgr.display_key(current_apikey_for_attempt)}")
 
-            url = f"{ONDEMAND_API_BASE}/sessions/{current_session_id_for_attempt}/query" # Ensure URL uses current session
-            payload = { "query": final_query_to_ondemand, "endpointId": target_endpoint_id, "pluginIds": [], "responseMode": "sync" } # Use correct query and endpoint
+            url = f"{ONDEMAND_API_BASE}/sessions/{current_session_id_for_attempt}/query" 
+            # Corrected: Use query_str and endpoint_id parameters passed to the function
+            payload = { "query": query_str, "endpointId": endpoint_id, "pluginIds": [], "responseMode": "sync" } 
             headers = {"apikey": current_apikey_for_attempt, "Content-Type": "application/json"}
             
             try:
@@ -693,13 +679,12 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
                     logging.warning(f"【OnDemand同步错误】({log_attempt_str}, 500重试 {current_500_retry_count}) 收到500错误。")
                     if current_500_retry_count >= max_500_retries_for_this_call:
                         logging.error(f"【OnDemand同步错误】({log_attempt_str}) 达到500错误最大重试次数。将错误传递给上层。")
-                        resp.raise_for_status() # Re-raise HTTPError(500) to be caught by outer RequestException handler
+                        resp.raise_for_status() 
                     time.sleep(1) 
-                    continue # Next 500-retry iteration
+                    continue 
 
-                resp.raise_for_status() # For other non-200 errors (will be caught by RequestException below)
+                resp.raise_for_status() 
 
-                # Successful 200 OK
                 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]}")
@@ -718,13 +703,10 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
                     }
                     return jsonify(openai_response_obj) # SUCCESS
                 else: 
-                    # Empty response after a 200 OK (and non-500 error)
                     logging.warning(f"【同步请求】({log_attempt_str}, 500重试 {current_500_retry_count}) 返回空回复。")
-                    # This attempt (for this key/session) resulted in an empty response.
-                    # Break from the 500-retry loop to let the outer empty-response loop handle it.
-                    break # Break from current_500_retry_count loop
+                    break 
             
-            except requests.exceptions.RequestException as e_req: # Catches HTTPError (including re-raised 500) or other network issues
+            except requests.exceptions.RequestException as e_req: 
                 log_key_display_sync = keymgr.display_key(current_apikey_for_attempt) if current_apikey_for_attempt else "N/A"
                 status_code_from_exc_sync = None
                 if hasattr(e_req, 'response') and e_req.response is not None:
@@ -732,38 +714,25 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
                 
                 logging.warning(f"【同步请求】({log_attempt_str}, 500重试 {current_500_retry_count} using key {log_key_display_sync}) 发生请求级错误: {e_req}, Status: {status_code_from_exc_sync}")
                 
-                # Key marking is handled by with_valid_key_and_session based on what's re-raised.
-                # If it's a 500 that exhausted its inner retries, it will be re-raised.
-                # If it's another RequestException, it's also re-raised.
-                
-                # If this was the initial overall attempt (empty_retry_attempt_num == 1)
-                # AND this specific 500-retry loop has exhausted OR it's not a 500 error that can be retried by this inner loop:
                 if current_500_retry_count >= max_500_retries_for_this_call or status_code_from_exc_sync != 500:
                     if empty_retry_attempt_num == 1:
-                        raise e_req # Re-raise for with_valid_key_and_session to handle key rotation
+                        raise e_req 
                     else: 
-                        # This was an empty-response retry that then hit a persistent 500 or other RequestException.
-                        # This attempt for this key has failed. Break 500-retry loop to go to next empty-response attempt.
-                        # To signal this failure for the current key/session to the outer empty-response loop:
-                        raise e_req # This will be caught by the outer try-except in the empty_retry_attempt_num loop
+                        raise e_req 
                 
-                # If it was a 500 and we still have 500-retries, the loop will continue after sleep.
                 time.sleep(1)
-                continue # To the next iteration of current_500_retry_count loop
+                # Continue to the next iteration of current_500_retry_count loop
             
             except (ValueError, KeyError, json.JSONDecodeError) as e_parse: 
                 logging.error(f"【同步请求】({log_attempt_str}, 500重试 {current_500_retry_count}) 处理响应或格式时出错: {e_parse}", exc_info=True)
-                if empty_retry_attempt_num == 1 and current_500_retry_count == 1 : # Format error on very first try
+                if empty_retry_attempt_num == 1 and current_500_retry_count == 1 : 
                      raise requests.exceptions.RequestException(f"Response format error on first attempt: {e_parse}") from e_parse
-                # If format error during a retry, it's a failure for this key/session attempt
-                # Break from 500-retry loop, let empty-response loop handle it.
-                # To signal this failure for the current key/session:
                 raise requests.exceptions.RequestException(f"Response format error during retry: {e_parse}") from e_parse
 
-
-        # If the 500-retry loop completed (either successfully got non-empty, or broke due to empty, or raised an error)
-        # Check if we are here because of an empty response (meaning the 500-retry loop broke after a 200 OK but empty content)
-        if not ai_response_content.strip() and not ( 'resp' in locals() and resp.status_code != 200 ): # Check if it was an empty response from a 200 OK
+        # After the 500-retry loop for the current key/session
+        if ai_response_content.strip(): # Should have been returned if non-empty
+            pass # Should not reach here if content was found
+        else: # Content is still empty for this key/session after 500-retries (or if 200 OK but empty)
             if empty_retry_attempt_num >= max_empty_response_retries:
                 final_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
                 final_error_code = "max_retries_check_context_contact_admin"
@@ -777,12 +746,8 @@ def handle_non_stream_request(initial_apikey, initial_session_id, query_str, end
                 }), 500 
             logging.info(f"【同步请求】空回复（在500-重试循环之后），准备进行下一个空回复尝试。当前总尝试 {empty_retry_attempt_num}/{max_empty_response_retries}")
             time.sleep(1) 
-            # Outer loop (empty_retry_attempt_num) will continue
-        # If we are here and didn't return a success, it means the 500-retry loop might have been exhausted by 500s
-        # but didn't re-raise correctly, or some other path. This is a fallback.
-        # However, if it exhausted 500s, it should have re-raised an exception.
+            # Outer loop (empty_retry_attempt_num) will continue to try a new key/session
 
-    # Fallback if outer empty_retry_attempt_num loop finishes
     final_fallback_error_message = "重试次数过多，请检查上下文长度! 或联系管理员!"
     final_fallback_error_code = "max_retries_check_context_contact_admin_fallback"
     logging.error(f"【同步请求】意外退出空回复重试循环。返回最终错误。")