bug fix

app/direct_vertex_client.py

@@ -349,32 +349,74 @@ class DirectVertexClient:
                     error_msg = error_data.get("error", {}).get("message", f"HTTP {response.status}") if isinstance(error_data, dict) else str(error_data)
                     raise Exception(f"Vertex AI API error: {error_msg}")
                 
-                # The Vertex AI streaming endpoint returns Server-Sent Events
-                # We need to parse these and yield them as objects
+                # The Vertex AI streaming endpoint returns JSON array elements
+                # We need to parse these as they arrive
                 buffer = ""
+                
                 async for chunk in response.content.iter_any():
-                    buffer += chunk.decode('utf-8')
+                    decoded_chunk = chunk.decode('utf-8')
+                    buffer += decoded_chunk
                     
-                    # Process complete SSE messages
-                    while '\n\n' in buffer:
-                        message, buffer = buffer.split('\n\n', 1)
+                    # Try to extract complete JSON objects from the buffer
+                    while True:
+                        # Skip whitespace and array brackets
+                        buffer = buffer.lstrip()
+                        if buffer.startswith('['):
+                            buffer = buffer[1:].lstrip()
+                            continue
+                        if buffer.startswith(']'):
+                            # End of array
+                            return
                         
-                        if not message.strip():
+                        # Skip comma and whitespace between objects
+                        if buffer.startswith(','):
+                            buffer = buffer[1:].lstrip()
                             continue
                         
-                        # Parse SSE format
-                        if message.startswith('data: '):
-                            data_str = message[6:]
-                            
-                            if data_str.strip() == '[DONE]':
-                                return
+                        # Look for a complete JSON object
+                        if buffer.startswith('{'):
+                            # Find the matching closing brace
+                            brace_count = 0
+                            in_string = False
+                            escape_next = False
                             
-                            try:
-                                # Parse JSON and convert to object
-                                chunk_data = json.loads(data_str)
-                                yield self._dict_to_obj(chunk_data)
-                            except json.JSONDecodeError:
-                                continue
+                            for i, char in enumerate(buffer):
+                                if escape_next:
+                                    escape_next = False
+                                    continue
+                                
+                                if char == '\\' and in_string:
+                                    escape_next = True
+                                    continue
+                                
+                                if char == '"' and not in_string:
+                                    in_string = True
+                                elif char == '"' and in_string:
+                                    in_string = False
+                                elif char == '{' and not in_string:
+                                    brace_count += 1
+                                elif char == '}' and not in_string:
+                                    brace_count -= 1
+                                    
+                                    if brace_count == 0:
+                                        # Found complete object
+                                        obj_str = buffer[:i+1]
+                                        buffer = buffer[i+1:]
+                                        
+                                        try:
+                                            chunk_data = json.loads(obj_str)
+                                            converted_obj = self._dict_to_obj(chunk_data)
+                                            yield converted_obj
+                                        except json.JSONDecodeError as e:
+                                            print(f"ERROR: DirectVertexClient - Failed to parse JSON: {e}")
+                                        
+                                        break
+                            else:
+                                # No complete object found, need more data
+                                break
+                        else:
+                            # No more objects to process in current buffer
+                            break
                             
         except Exception as e:
             print(f"ERROR: Direct Vertex streaming API call failed: {e}")

app/message_processing.py

@@ -241,7 +241,7 @@ def parse_gemini_response_for_reasoning_and_content(gemini_response_candidate: A
                 reasoning_text_parts.append(part_text)
             else:
                 normal_text_parts.append(part_text)
-    if candidate_part_text: # Candidate had text but no parts and was not a thought itself
+    elif candidate_part_text: # Candidate had text but no parts and was not a thought itself
         normal_text_parts.append(candidate_part_text)
     # If no parts and no direct text on candidate, both lists remain empty.
     
@@ -291,10 +291,14 @@ def convert_to_openai_format(gemini_response: Any, model: str) -> Dict[str, Any]
 def convert_chunk_to_openai(chunk: Any, model: str, response_id: str, candidate_index: int = 0) -> str:
     is_encrypt_full = model.endswith("-encrypt-full")
     delta_payload = {}
-    finish_reason = None 
+    finish_reason = None
 
     if hasattr(chunk, 'candidates') and chunk.candidates:
-        candidate = chunk.candidates[0] 
+        candidate = chunk.candidates[0]
+        
+        # Check for finish reason
+        if hasattr(candidate, 'finishReason') and candidate.finishReason:
+            finish_reason = "stop"  # Convert Gemini finish reasons to OpenAI format
         
         # For a streaming chunk, candidate might be simpler, or might have candidate.content with parts.
         # parse_gemini_response_for_reasoning_and_content is designed to handle both candidate and candidate.content
@@ -308,7 +312,6 @@ def convert_chunk_to_openai(chunk: Any, model: str, response_id: str, candidate_
         if normal_text or (not reasoning_text and not delta_payload): # Ensure content key if nothing else
             delta_payload['content'] = normal_text if normal_text else ""
 
-
     chunk_data = {
         "id": response_id, "object": "chat.completion.chunk", "created": int(time.time()), "model": model,
         "choices": [{"index": candidate_index, "delta": delta_payload, "finish_reason": finish_reason}]