fix: ensure token usage recording, validate response model on stream

Author: greysonlalonde

conftest.py

@@ -136,6 +136,10 @@ def _filter_request_headers(request: Request) -> Request:  # type: ignore[no-any
 
 def _filter_response_headers(response: dict[str, Any]) -> dict[str, Any]:
     """Filter sensitive headers from response before recording."""
+    # Remove Content-Encoding to prevent decompression issues on replay
+    for encoding_header in ["Content-Encoding", "content-encoding"]:
+        response["headers"].pop(encoding_header, None)
+
     for header_name, replacement in HEADERS_TO_FILTER.items():
         for variant in [header_name, header_name.upper(), header_name.title()]:
             if variant in response["headers"]:

lib/crewai/pyproject.toml

@@ -84,7 +84,7 @@ bedrock = [
     "boto3~=1.40.45",
 ]
 google-genai = [
-    "google-genai~=1.2.0",
+    "google-genai~=1.49.0",
 ]
 azure-ai-inference = [
     "azure-ai-inference~=1.0.0b9",

lib/crewai/src/crewai/llms/providers/anthropic/completion.py

@@ -679,40 +679,38 @@ def _handle_streaming_completion(
             params["messages"], full_response, from_agent
         )
 
-    def _handle_tool_use_conversation(
+    def _execute_tools_and_collect_results(
         self,
-        initial_response: Message,
         tool_uses: list[ToolUseBlock],
-        params: dict[str, Any],
         available_functions: dict[str, Any],
         from_task: Any | None = None,
         from_agent: Any | None = None,
-    ) -> str:
-        """Handle the complete tool use conversation flow.
+    ) -> list[dict[str, Any]]:
+        """Execute tools and collect results in Anthropic format.
 
-        This implements the proper Anthropic tool use pattern:
-        1. Claude requests tool use
-        2. We execute the tools
-        3. We send tool results back to Claude
-        4. Claude processes results and generates final response
+        Args:
+            tool_uses: List of tool use blocks from Claude's response
+            available_functions: Available functions for tool calling
+            from_task: Task that initiated the call
+            from_agent: Agent that initiated the call
+
+        Returns:
+            List of tool result dictionaries in Anthropic format
         """
-        # Execute all requested tools and collect results
         tool_results = []
 
         for tool_use in tool_uses:
             function_name = tool_use.name
             function_args = tool_use.input
 
-            # Execute the tool
             result = self._handle_tool_execution(
                 function_name=function_name,
-                function_args=function_args,
+                function_args=cast(dict[str, Any], function_args),
                 available_functions=available_functions,
                 from_task=from_task,
                 from_agent=from_agent,
             )
 
-            # Create tool result in Anthropic format
             tool_result = {
                 "type": "tool_result",
                 "tool_use_id": tool_use.id,
@@ -722,7 +720,29 @@ def _handle_tool_use_conversation(
             }
             tool_results.append(tool_result)
 
-        # Prepare follow-up conversation with tool results
+        return tool_results
+
+    def _handle_tool_use_conversation(
+        self,
+        initial_response: Message,
+        tool_uses: list[ToolUseBlock],
+        params: dict[str, Any],
+        available_functions: dict[str, Any],
+        from_task: Any | None = None,
+        from_agent: Any | None = None,
+    ) -> str:
+        """Handle the complete tool use conversation flow.
+
+        This implements the proper Anthropic tool use pattern:
+        1. Claude requests tool use
+        2. We execute the tools
+        3. We send tool results back to Claude
+        4. Claude processes results and generates final response
+        """
+        tool_results = self._execute_tools_and_collect_results(
+            tool_uses, available_functions, from_task, from_agent
+        )
+
         follow_up_params = params.copy()
 
         # Add Claude's tool use response to conversation
@@ -810,7 +830,7 @@ def _handle_tool_use_conversation(
             logging.error(f"Tool follow-up conversation failed: {e}")
             # Fallback: return the first tool result if follow-up fails
             if tool_results:
-                return tool_results[0]["content"]
+                return cast(str, tool_results[0]["content"])
             raise e
 
     async def _ahandle_completion(
@@ -1003,28 +1023,9 @@ async def _ahandle_tool_use_conversation(
         3. We send tool results back to Claude
         4. Claude processes results and generates final response
         """
-        tool_results = []
-
-        for tool_use in tool_uses:
-            function_name = tool_use.name
-            function_args = tool_use.input
-
-            result = self._handle_tool_execution(
-                function_name=function_name,
-                function_args=function_args,
-                available_functions=available_functions,
-                from_task=from_task,
-                from_agent=from_agent,
-            )
-
-            tool_result = {
-                "type": "tool_result",
-                "tool_use_id": tool_use.id,
-                "content": str(result)
-                if result is not None
-                else "Tool execution completed",
-            }
-            tool_results.append(tool_result)
+        tool_results = self._execute_tools_and_collect_results(
+            tool_uses, available_functions, from_task, from_agent
+        )
 
         follow_up_params = params.copy()
 
@@ -1079,7 +1080,7 @@ async def _ahandle_tool_use_conversation(
 
             logging.error(f"Tool follow-up conversation failed: {e}")
             if tool_results:
-                return tool_results[0]["content"]
+                return cast(str, tool_results[0]["content"])
             raise e
 
     def supports_function_calling(self) -> bool:
@@ -1115,7 +1116,8 @@ def get_context_window_size(self) -> int:
         # Default context window size for Claude models
         return int(200000 * CONTEXT_WINDOW_USAGE_RATIO)
 
-    def _extract_anthropic_token_usage(self, response: Message) -> dict[str, Any]:
+    @staticmethod
+    def _extract_anthropic_token_usage(response: Message) -> dict[str, Any]:
         """Extract token usage from Anthropic response."""
         if hasattr(response, "usage") and response.usage:
             usage = response.usage