added more error handling

app/api_helpers.py

@@ -45,21 +45,39 @@ def create_generation_config(request: OpenAIRequest) -> Dict[str, Any]:
     return config
 
 def is_response_valid(response):
-    if response is None: return False
-    if hasattr(response, 'text') and response.text: return True
+    if response is None:
+        print("DEBUG: Response is None, therefore invalid.")
+        return False
+    
+    # Check for direct text attribute
+    if hasattr(response, 'text') and isinstance(response.text, str) and response.text.strip():
+        # print("DEBUG: Response valid due to response.text")
+        return True
+        
+    # Check candidates for text content
     if hasattr(response, 'candidates') and response.candidates:
-        candidate = response.candidates[0]
-        if hasattr(candidate, 'text') and candidate.text: return True
-        if hasattr(candidate, 'content') and hasattr(candidate.content, 'parts'):
-            for part in candidate.content.parts:
-                if hasattr(part, 'text') and part.text: return True
-    if hasattr(response, 'candidates') and response.candidates: return True # For fake streaming
-    for attr in dir(response):
-        if attr.startswith('_'): continue
-        try:
-            if isinstance(getattr(response, attr), str) and getattr(response, attr): return True
-        except: pass
-    print("DEBUG: Response is invalid, no usable content found")
+        for candidate in response.candidates: # Iterate through all candidates
+            if hasattr(candidate, 'text') and isinstance(candidate.text, str) and candidate.text.strip():
+                # print(f"DEBUG: Response valid due to candidate.text in candidate")
+                return True
+            if hasattr(candidate, 'content') and hasattr(candidate.content, 'parts') and candidate.content.parts:
+                for part in candidate.content.parts:
+                    if hasattr(part, 'text') and isinstance(part.text, str) and part.text.strip():
+                        # print(f"DEBUG: Response valid due to part.text in candidate's content part")
+                        return True
+                        
+    # Check for prompt_feedback, which indicates the API processed the request,
+    # even if the content is empty (e.g. due to safety filtering).
+    # The fake_stream_generator should still attempt to process this to convey safety messages if present.
+    if hasattr(response, 'prompt_feedback'):
+        # Check if there's any block reason, which might be interesting to log or handle
+        if hasattr(response.prompt_feedback, 'block_reason') and response.prompt_feedback.block_reason:
+            print(f"DEBUG: Response has prompt_feedback with block_reason: {response.prompt_feedback.block_reason}, considering it valid for processing.")
+        else:
+            print("DEBUG: Response has prompt_feedback (no block_reason), considering it valid for processing.")
+        return True
+        
+    print("DEBUG: Response is invalid, no usable text content or prompt_feedback found.")
     return False
 
 async def fake_stream_generator(client_instance, model_name: str, prompt: Union[types.Content, List[types.Content]], current_gen_config: Dict[str, Any], request_obj: OpenAIRequest):
@@ -83,12 +101,20 @@ async def fake_stream_generator(client_instance, model_name: str, prompt: Union[
             if not is_response_valid(response): 
                 raise ValueError(f"Invalid/empty response in fake stream: {str(response)[:200]}")
             full_text = ""
-            if hasattr(response, 'text'): full_text = response.text
+            if hasattr(response, 'text'):
+                full_text = response.text or "" # Coalesce None to empty string
             elif hasattr(response, 'candidates') and response.candidates:
+                # Typically, we focus on the first candidate for non-streaming synthesis
                 candidate = response.candidates[0]
-                if hasattr(candidate, 'text'): full_text = candidate.text
-                elif hasattr(candidate.content, 'parts'):
-                    full_text = "".join(part.text for part in candidate.content.parts if hasattr(part, 'text'))
+                if hasattr(candidate, 'text'):
+                    full_text = candidate.text or "" # Coalesce None to empty string
+                elif hasattr(candidate, 'content') and hasattr(candidate.content, 'parts') and candidate.content.parts:
+                    # Ensure parts are iterated and text is joined correctly even if some parts have no text or part.text is None
+                    texts = []
+                    for part in candidate.content.parts:
+                        if hasattr(part, 'text') and part.text is not None: # Check part.text exists and is not None
+                            texts.append(part.text)
+                    full_text = "".join(texts)
             if request_obj.model.endswith("-encrypt-full"):
                 full_text = deobfuscate_text(full_text)
             
@@ -141,8 +167,16 @@ async def execute_gemini_call(
                 yield "data: [DONE]\n\n"
             except Exception as e_stream_call:
                 print(f"Streaming Error in _execute_gemini_call: {e_stream_call}")
-                err_resp_content_call = create_openai_error_response(500, str(e_stream_call), "server_error")
-                yield f"data: {json.dumps(err_resp_content_call)}\n\n"
+                
+                error_message_str = str(e_stream_call)
+                # Truncate very long error messages to prevent excessively large JSON payloads.
+                if len(error_message_str) > 1024: # Max length for the error string
+                    error_message_str = error_message_str[:1024] + "..."
+                
+                err_resp_content_call = create_openai_error_response(500, error_message_str, "server_error")
+                json_payload_for_error = json.dumps(err_resp_content_call)
+                print(f"DEBUG: Yielding error JSON payload during true streaming: {json_payload_for_error}")
+                yield f"data: {json_payload_for_error}\n\n"
                 yield "data: [DONE]\n\n"
                 raise # Re-raise to be caught by retry logic if any
         return StreamingResponse(_stream_generator_inner_for_execute(), media_type="text/event-stream")

app/message_processing.py

@@ -344,11 +344,14 @@ def convert_to_openai_format(gemini_response, model: str) -> Dict[str, Any]:
         for i, candidate in enumerate(gemini_response.candidates):
             content = ""
             if hasattr(candidate, 'text'):
-                content = candidate.text
+                content = candidate.text or "" # Coalesce None to empty string
             elif hasattr(candidate, 'content') and hasattr(candidate.content, 'parts'):
+                # Ensure content remains a string even if parts have None text
+                parts_texts = []
                 for part_item in candidate.content.parts:
-                    if hasattr(part_item, 'text'):
-                        content += part_item.text
+                    if hasattr(part_item, 'text') and part_item.text is not None:
+                        parts_texts.append(part_item.text)
+                content = "".join(parts_texts)
             
             if is_encrypt_full:
                 content = deobfuscate_text(content)
@@ -359,9 +362,9 @@ def convert_to_openai_format(gemini_response, model: str) -> Dict[str, Any]:
                 "finish_reason": "stop"
             })
     elif hasattr(gemini_response, 'text'):
-         content = gemini_response.text
+         content = gemini_response.text or "" # Coalesce None to empty string
          if is_encrypt_full:
-             content = deobfuscate_text(content)
+             content = deobfuscate_text(content) # deobfuscate_text should also be robust to empty string
          choices.append({
              "index": 0,
              "message": {"role": "assistant", "content": content},
@@ -392,14 +395,27 @@ def convert_to_openai_format(gemini_response, model: str) -> Dict[str, Any]:
 def convert_chunk_to_openai(chunk, model: str, response_id: str, candidate_index: int = 0) -> str:
     """Converts Gemini stream chunk to OpenAI format, applying deobfuscation if needed."""
     is_encrypt_full = model.endswith("-encrypt-full")
-    chunk_content = ""
+    chunk_content_str = "" # Renamed for clarity and to ensure it's always a string
 
-    if hasattr(chunk, 'parts') and chunk.parts:
-         for part_item in chunk.parts:
-             if hasattr(part_item, 'text'):
-                 chunk_content += part_item.text
-    elif hasattr(chunk, 'text'):
-         chunk_content = chunk.text
+    try:
+        if hasattr(chunk, 'parts') and chunk.parts:
+            current_parts_texts = []
+            for part_item in chunk.parts:
+                # Ensure part_item.text exists, is not None, and convert to string
+                if hasattr(part_item, 'text') and part_item.text is not None:
+                    current_parts_texts.append(str(part_item.text))
+            chunk_content_str = "".join(current_parts_texts)
+        elif hasattr(chunk, 'text') and chunk.text is not None:
+            # Ensure chunk.text is converted to string if it's not None
+            chunk_content_str = str(chunk.text)
+        # If chunk has neither .parts nor .text, or if .text is None, chunk_content_str remains ""
+    except Exception as e_chunk_extract:
+        # Log the error and the problematic chunk structure
+        print(f"WARNING: Error extracting content from chunk in convert_chunk_to_openai: {e_chunk_extract}. Chunk type: {type(chunk)}. Chunk data: {str(chunk)[:200]}")
+        chunk_content_str = "" # Default to empty string in case of any error
+
+    if is_encrypt_full:
+        chunk_content_str = deobfuscate_text(chunk_content_str) # deobfuscate_text should handle empty string
 
     if is_encrypt_full:
         chunk_content = deobfuscate_text(chunk_content)
@@ -415,7 +431,7 @@ def convert_chunk_to_openai(chunk, model: str, response_id: str, candidate_index
         "choices": [
             {
                 "index": candidate_index,
-                "delta": {**({"content": chunk_content} if chunk_content else {})},
+                "delta": {**({"content": chunk_content_str} if chunk_content_str else {})},
                 "finish_reason": finish_reason
             }
         ]