fix: integration test cases

Author: TejasGhatte

core/schemas/providers/anthropic/responses.go

@@ -263,6 +263,8 @@ func ToAnthropicResponsesResponse(bifrostResp *schemas.BifrostResponsesResponse)
 
 	if len(contentBlocks) > 0 {
 		anthropicResp.Content = contentBlocks
+	} else {
+		anthropicResp.Content = []AnthropicContentBlock{}
 	}
 
 	// Set default stop reason - could be enhanced based on additional context
@@ -466,17 +468,42 @@ func ToAnthropicResponsesStreamResponse(bifrostResp *schemas.BifrostResponsesStr
 	// Map ResponsesStreamResponse types to Anthropic stream events
 	switch bifrostResp.Type {
 	case schemas.ResponsesStreamResponseTypeOutputItemAdded:
-		streamResp.Type = AnthropicStreamEventTypeMessageStart
-		if bifrostResp.Item != nil {
-			// Create message start event
-			streamMessage := &AnthropicMessageResponse{
-				Type: "message",
-				Role: string(schemas.ResponsesInputMessageRoleAssistant),
+		// Check if this is a function call (tool use) message
+		if bifrostResp.Item != nil && bifrostResp.Item.Type != nil && *bifrostResp.Item.Type == schemas.ResponsesMessageTypeFunctionCall {
+			// Convert function call to tool_use content_block_start event
+			streamResp.Type = AnthropicStreamEventTypeContentBlockStart
+			if bifrostResp.ContentIndex != nil {
+				streamResp.Index = bifrostResp.ContentIndex
+			}
+
+			contentBlock := &AnthropicContentBlock{
+				Type: AnthropicContentBlockTypeToolUse,
+			}
+
+			if bifrostResp.Item.ResponsesToolMessage != nil {
+				if bifrostResp.Item.ResponsesToolMessage.CallID != nil {
+					contentBlock.ID = bifrostResp.Item.ResponsesToolMessage.CallID
+				}
+				if bifrostResp.Item.ResponsesToolMessage.Name != nil {
+					contentBlock.Name = bifrostResp.Item.ResponsesToolMessage.Name
+				}
 			}
-			if bifrostResp.Item.ID != nil {
-				streamMessage.ID = *bifrostResp.Item.ID
+
+			streamResp.ContentBlock = contentBlock
+		} else {
+			// Regular message start event
+			streamResp.Type = AnthropicStreamEventTypeMessageStart
+			if bifrostResp.Item != nil {
+				// Create message start event
+				streamMessage := &AnthropicMessageResponse{
+					Type: "message",
+					Role: string(schemas.ResponsesInputMessageRoleAssistant),
+				}
+				if bifrostResp.Item.ID != nil {
+					streamMessage.ID = *bifrostResp.Item.ID
+				}
+				streamResp.Message = streamMessage
 			}
-			streamResp.Message = streamMessage
 		}
 
 	case schemas.ResponsesStreamResponseTypeContentPartAdded:
@@ -540,11 +567,6 @@ func ToAnthropicResponsesStreamResponse(bifrostResp *schemas.BifrostResponsesStr
 
 	case schemas.ResponsesStreamResponseTypeOutputItemDone:
 		streamResp.Type = AnthropicStreamEventTypeMessageDelta
-		// Add stop reason if available (this would need to be passed through somehow)
-		streamResp.Delta = &AnthropicStreamDelta{
-			Type: AnthropicStreamDeltaTypeText, // Use text delta type for message deltas
-			// StopReason would be set based on the completion reason
-		}
 
 	case schemas.ResponsesStreamResponseTypeCompleted:
 		streamResp.Type = AnthropicStreamEventTypeMessageStop

core/schemas/providers/gemini/chat.go

@@ -415,7 +415,52 @@ func ToGeminiChatResponse(bifrostResp *schemas.BifrostChatResponse) *GenerateCon
 
 			// Convert message content to Gemini parts
 			var parts []*Part
-			if choice.ChatNonStreamResponseChoice != nil && choice.ChatNonStreamResponseChoice.Message != nil {
+			var role string
+
+			// Handle streaming responses
+			if choice.ChatStreamResponseChoice != nil && choice.ChatStreamResponseChoice.Delta != nil {
+				delta := choice.ChatStreamResponseChoice.Delta
+
+				// Set role from delta if available
+				if delta.Role != nil {
+					role = *delta.Role
+				} else {
+					role = "model" // Default role for streaming responses
+				}
+
+				// Handle content text
+				if delta.Content != nil && *delta.Content != "" {
+					parts = append(parts, &Part{Text: *delta.Content})
+				}
+
+				// Handle tool calls in streaming
+				if delta.ToolCalls != nil {
+					for _, toolCall := range delta.ToolCalls {
+						argsMap := make(map[string]interface{})
+						if toolCall.Function.Arguments != "" {
+							json.Unmarshal([]byte(toolCall.Function.Arguments), &argsMap)
+						}
+						if toolCall.Function.Name != nil {
+							fc := &FunctionCall{
+								Name: *toolCall.Function.Name,
+								Args: argsMap,
+							}
+							if toolCall.ID != nil {
+								fc.ID = *toolCall.ID
+							}
+							parts = append(parts, &Part{FunctionCall: fc})
+						}
+					}
+				}
+
+				if len(parts) > 0 {
+					candidate.Content = &Content{
+						Parts: parts,
+						Role:  role,
+					}
+				}
+			} else if choice.ChatNonStreamResponseChoice != nil && choice.ChatNonStreamResponseChoice.Message != nil {
+				// Handle non-streaming responses
 				if choice.ChatNonStreamResponseChoice.Message.Content != nil {
 					if choice.ChatNonStreamResponseChoice.Message.Content.ContentStr != nil && *choice.ChatNonStreamResponseChoice.Message.Content.ContentStr != "" {
 						parts = append(parts, &Part{Text: *choice.ChatNonStreamResponseChoice.Message.Content.ContentStr})

tests/integrations/tests/integrations/test_anthropic.py

@@ -75,7 +75,7 @@ def anthropic_client():
     client_kwargs = {
         "api_key": api_key,
         "base_url": base_url,
-        "timeout": api_config.get("timeout", 30),
+        "timeout": api_config.get("timeout", 120),
         "max_retries": api_config.get("max_retries", 3),
     }
 
@@ -483,7 +483,7 @@ def test_10_complex_end2end(self, anthropic_client, test_config):
             # Anthropic might return empty content if tool result is sufficient
             # This is valid behavior - just check that we got a response
             assert final_response is not None
-            if len(final_response.content) > 0:
+            if final_response.content and len(final_response.content) > 0:
                 # If there is content, validate it
                 assert_valid_chat_response(final_response)
             else:
@@ -537,17 +537,17 @@ def test_11_integration_specific_features(self, anthropic_client, test_config):
     @skip_if_no_api_key("anthropic")
     def test_12_error_handling_invalid_roles(self, anthropic_client, test_config):
         """Test Case 12: Error handling for invalid roles"""
-        with pytest.raises(Exception) as exc_info:
-            anthropic_client.messages.create(
-                model=get_model("anthropic", "chat"),
-                messages=INVALID_ROLE_MESSAGES,
-                max_tokens=100,
-            )
+        # bifrost handles invalid roles internally so this test should not raise an exception
+        response = anthropic_client.messages.create(
+            model=get_model("anthropic", "chat"),
+            messages=INVALID_ROLE_MESSAGES,
+            max_tokens=100,
+        )
 
-        # Verify the error is properly caught and contains role-related information
-        error = exc_info.value
-        assert_valid_error_response(error, "tester")
-        assert_error_propagation(error, "anthropic")
+        # Verify the response is successful
+        assert response is not None
+        assert hasattr(response, "content")
+        assert len(response.content) > 0
 
     @skip_if_no_api_key("anthropic")
     def test_13_streaming(self, anthropic_client, test_config):
@@ -561,7 +561,7 @@ def test_13_streaming(self, anthropic_client, test_config):
         )
 
         content, chunk_count, tool_calls_detected = collect_streaming_content(
-            stream, "anthropic", timeout=30
+            stream, "anthropic", timeout=120
         )
 
         # Validate streaming results
@@ -579,13 +579,20 @@ def test_13_streaming(self, anthropic_client, test_config):
         )
 
         content_tools, chunk_count_tools, tool_calls_detected_tools = (
-            collect_streaming_content(stream_with_tools, "anthropic", timeout=30)
+            collect_streaming_content(stream_with_tools, "anthropic", timeout=120)
         )
 
         # Validate tool streaming results
         assert chunk_count_tools > 0, "Should receive at least one chunk with tools"
         assert tool_calls_detected_tools, "Should receive at least one chunk with tools"
 
+    @skip_if_no_api_key("anthropic")
+    def test_14_list_models(self, anthropic_client, test_config):
+        """Test Case 14: List models"""
+        response = anthropic_client.models.list(limit=5)
+        assert response.data is not None
+        assert len(response.data) == 5
+
 
 # Additional helper functions specific to Anthropic
 def extract_anthropic_tool_calls(response: Any) -> List[Dict[str, Any]]:

tests/integrations/tests/integrations/test_google.py

@@ -144,8 +144,12 @@ def load_image_from_url(url: str):
         img_data = base64.b64decode(data)
         image = Image.open(io.BytesIO(img_data))
     else:
-        # URL image
-        response = requests.get(url)
+        # URL image - use headers to avoid 403 errors from servers like Wikipedia
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        response = requests.get(url, headers=headers, timeout=30)
+        response.raise_for_status()  # Raise an error for bad status codes
         image = Image.open(io.BytesIO(response.content))
 
     # Resize image to reduce payload size (max width/height of 512px)
@@ -462,12 +466,21 @@ def test_13_streaming(self, google_client, test_config):
         # Collect streaming content
         for chunk in stream:
             chunk_count += 1
-            if chunk.text:
+            # Google GenAI streaming returns chunks with candidates containing parts with text
+            if hasattr(chunk, 'candidates') and chunk.candidates:
+                for candidate in chunk.candidates:
+                    if hasattr(candidate, 'content') and candidate.content:
+                        if hasattr(candidate.content, 'parts') and candidate.content.parts:
+                            for part in candidate.content.parts:
+                                if hasattr(part, 'text') and part.text:
+                                    content += part.text
+            # Fallback to direct text attribute (for compatibility)
+            elif hasattr(chunk, 'text') and chunk.text:
                 content += chunk.text
 
         # Validate streaming results
         assert chunk_count > 0, "Should receive at least one chunk"
-        assert len(content) > 10, "Should receive substantial content"
+        assert len(content) > 5, "Should receive substantial content"
 
         # Check for robot-related terms (the story might not use the exact word "robot")
         robot_terms = [
@@ -484,10 +497,6 @@ def test_13_streaming(self, google_client, test_config):
         assert (
             has_robot_content
         ), f"Content should relate to robots. Found content: {content[:200]}..."
-
-        print(
-            f"✅ Streaming test passed: {chunk_count} chunks, {len(content)} characters"
-        )
 
     @skip_if_no_api_key("google")
     def test_14_single_text_embedding(self, google_client, test_config):
@@ -501,6 +510,13 @@ def test_14_single_text_embedding(self, google_client, test_config):
 
         # Verify response structure
         assert len(response.embeddings) == 1, "Should have exactly one embedding"
+    
+    @skip_if_no_api_key("google")
+    def test_15_list_models(self, google_client, test_config):
+        """Test Case 15: List models"""
+        response = google_client.models.list(config={"page_size": 5})
+        assert response is not None
+        assert len(response) == 5
 
 
 # Additional helper functions specific to Google GenAI

tests/integrations/tests/integrations/test_openai.py

@@ -163,7 +163,7 @@ def openai_client():
     client_kwargs = {
         "api_key": api_key,
         "base_url": base_url,
-        "timeout": api_config.get("timeout", 30),
+        "timeout": api_config.get("timeout", 120),
         "max_retries": api_config.get("max_retries", 3),
     }
 
@@ -455,6 +455,7 @@ def test_12_error_handling_invalid_roles(self, openai_client, test_config):
 
         # Verify the error is properly caught and contains role-related information
         error = exc_info.value
+        print(error)
         assert_valid_error_response(error, "tester")
         assert_error_propagation(error, "openai")
 
@@ -470,7 +471,7 @@ def test_13_streaming(self, openai_client, test_config):
         )
 
         content, chunk_count, tool_calls_detected = collect_streaming_content(
-            stream, "openai", timeout=30
+            stream, "openai", timeout=120
         )
 
         # Validate streaming results
@@ -488,7 +489,7 @@ def test_13_streaming(self, openai_client, test_config):
         )
 
         content_tools, chunk_count_tools, tool_calls_detected_tools = (
-            collect_streaming_content(stream_with_tools, "openai", timeout=30)
+            collect_streaming_content(stream_with_tools, "openai", timeout=120)
         )
 
         # Validate tool streaming results
@@ -570,7 +571,7 @@ def test_16_transcription_streaming(self, openai_client, test_config):
             # If streaming is supported, collect the text chunks
             if hasattr(response, "__iter__"):
                 text_content, chunk_count = collect_streaming_transcription_content(
-                    response, "openai", timeout=60
+                    response, "openai", timeout=120
                 )
                 assert chunk_count > 0, "Should receive at least one text chunk"
                 assert_valid_transcription_response(
@@ -1054,3 +1055,10 @@ def test_30_embedding_usage_tracking(self, openai_client, test_config):
         assert (
             0.5 * texts_ratio <= token_ratio <= 2.0 * texts_ratio
         ), f"Token usage ratio ({token_ratio:.2f}) should be roughly proportional to text count ({texts_ratio})"
+    
+    @skip_if_no_api_key("openai")
+    def test_31_list_models(self, openai_client, test_config):
+        """Test Case 31: List models"""
+        response = openai_client.models.list()
+        assert response.data is not None
+        assert len(response.data) > 0

tests/integrations/tests/utils/common.py

@@ -614,18 +614,6 @@ def assert_error_propagation(error_response: Any, integration: str):
         if hasattr(error_response, "response"):
             error_data = error_response.response.json()
             assert "error" in error_data, "OpenAI error should have 'error' field"
-            assert (
-                "type" in error_data
-            ), "OpenAI error should have top-level 'type' field"
-            assert (
-                "event_id" in error_data
-            ), "OpenAI error should have top-level 'event_id' field"
-            assert isinstance(
-                error_data["type"], str
-            ), "OpenAI error type should be a string"
-            assert isinstance(
-                error_data["event_id"], str
-            ), "OpenAI error event_id should be a string"
 
             # Check nested error structure
             error_obj = error_data["error"]
@@ -634,9 +622,6 @@ def assert_error_propagation(error_response: Any, integration: str):
             ), "OpenAI error.error should have 'message' field"
             assert "type" in error_obj, "OpenAI error.error should have 'type' field"
             assert "code" in error_obj, "OpenAI error.error should have 'code' field"
-            assert (
-                "event_id" in error_obj
-            ), "OpenAI error.error should have 'event_id' field"
 
     elif integration.lower() == "anthropic":
         # Anthropic format: should have 'type' and 'error' with 'type' and 'message'
@@ -754,11 +739,6 @@ def assert_valid_streaming_response(
                     assert hasattr(
                         chunk.delta, "partial_json"
                     ), "Input JSON delta should have partial_json field"
-            else:
-                # Fallback: if no type specified, assume text_delta for backward compatibility
-                assert hasattr(
-                    chunk.delta, "text"
-                ), "Content delta should have text field"
         elif chunk.type == "message_delta" and is_final:
             assert hasattr(chunk, "usage"), "Final message delta should have usage"