fix: gemini parsing with thoughts (#2215)

<!-- ELLIPSIS_HIDDEN -->



> [!IMPORTANT]
> Fixes Google response parsing to handle non-thought parts correctly
and adds a new `Gemini25ProThinking` client with tests.
> 
>   - **Behavior**:
> - Fixes `text_content_part()` in `response_handler.rs` to concatenate
non-thought parts instead of returning the first one.
> - Adds `Gemini25ProThinking` client in `clients.baml` with
`thinkingConfig` options.
>   - **Tests**:
> - Adds `test_parse_google_response_with_thinking()` and
`test_parse_google_response_with_multiple_non_thought_parts()` in
`response_handler.rs`.
>     - Adds `TestGeminiThinking` function and test in `gemini.baml`.
>   - **Misc**:
> - Updates various client and function definitions across multiple
files to support the new `Gemini25ProThinking` client.
> 
> <sup>This description was created by </sup>[<img alt="Ellipsis"
src="https://img.shields.io/badge/Ellipsis-blue?color=175173">](https://www.ellipsis.dev?ref=BoundaryML%2Fbaml&utm_source=github&utm_medium=referral)<sup>
for eb63880. You can
[customize](https://app.ellipsis.dev/BoundaryML/settings/summaries) this
summary. It will automatically update as commits are pushed.</sup>

<!-- ELLIPSIS_HIDDEN -->

Author: ba11b0y

engine/baml-runtime/src/internal/llm_client/primitive/google/response_handler.rs

@@ -102,10 +102,17 @@ pub fn parse_google_response<C: WithClient + RequestBuilder>(
 }
 
 fn text_content_part(parts: &[Part]) -> Option<String> {
-    parts
+    let non_thought_parts: Vec<&str> = parts
         .iter()
-        .position(|part| !part.text.is_empty() && !part.thought.unwrap_or(false))
-        .map(|index| parts[index].text.clone())
+        .filter(|part| !part.thought.unwrap_or(false))
+        .map(|part| part.text.as_str())
+        .collect();
+
+    if non_thought_parts.is_empty() {
+        None
+    } else {
+        Some(non_thought_parts.join(""))
+    }
 }
 
 pub fn scan_google_response_stream(
@@ -291,4 +298,133 @@ mod tests {
             panic!("Expected LLMResponse::Success, got {result:?}");
         }
     }
+
+    #[test]
+    fn test_parse_google_response_with_thinking() {
+        // Test case that reproduces the bug with thinking responses
+        let response_json = r#"
+{
+  "candidates": [
+    {
+      "content": {
+        "parts": [
+          {
+            "text": "Analyzing the image to determine what type of product this is. It appears to be some kind of car accessory. Looking at the shape and structure...",
+            "thought": true
+          },
+          {
+            "text": "Based on the mesh pattern and the mounting points, this looks like it's designed to fit in a vehicle's cargo area.",
+            "thought": true
+          },
+          {
+            "text": "This product is a \"dog cargo guard\" or a barrier designed to separate the trunk/boot from the passenger area of a car. Its main purpose is to safely contain a pet or cargo."
+          }
+        ],
+        "role": "model"
+      },
+      "finishReason": "STOP"
+    }
+  ],
+  "usageMetadata": {
+    "promptTokenCount": 100,
+    "candidatesTokenCount": 50,
+    "totalTokenCount": 150
+  }
+}
+        "#;
+
+        let client = MockClient::new();
+        let prompt = vec![];
+        let response_body: serde_json::Value = serde_json::from_str(response_json.trim()).unwrap();
+        let system_now = web_time::SystemTime::now();
+        let instant_now = web_time::Instant::now();
+        let model_name = Some("gemini-2.5-pro".to_string());
+
+        let result = parse_google_response(
+            &client,
+            either::Right(prompt.as_slice()),
+            response_body,
+            system_now,
+            instant_now,
+            model_name,
+        );
+
+        if let LLMResponse::Success(actual_result) = result {
+            // Should contain only the non-thought content
+            assert_eq!(
+                actual_result.content,
+                "This product is a \"dog cargo guard\" or a barrier designed to separate the trunk/boot from the passenger area of a car. Its main purpose is to safely contain a pet or cargo."
+            );
+        } else {
+            panic!("Expected LLMResponse::Success, got {result:?}");
+        }
+    }
+
+    #[test]
+    fn test_parse_google_response_with_multiple_non_thought_parts() {
+        // Test case showing the bug: when there are multiple non-thought parts
+        let response_json = r#"
+{
+  "candidates": [
+    {
+      "content": {
+        "parts": [
+          {
+            "text": "Let me analyze this image...",
+            "thought": true
+          },
+          {
+            "text": "I can see it's related to vehicles.",
+            "thought": true
+          },
+          {
+            "text": "This product is a "
+          },
+          {
+            "text": "\"dog cargo guard\""
+          },
+          {
+            "text": " or a barrier designed to separate the trunk/boot from the passenger area of a car."
+          }
+        ],
+        "role": "model"
+      },
+      "finishReason": "STOP"
+    }
+  ],
+  "usageMetadata": {
+    "promptTokenCount": 100,
+    "candidatesTokenCount": 50,
+    "totalTokenCount": 150
+  }
+}
+        "#;
+
+        let client = MockClient::new();
+        let prompt = vec![];
+        let response_body: serde_json::Value = serde_json::from_str(response_json.trim()).unwrap();
+        let system_now = web_time::SystemTime::now();
+        let instant_now = web_time::Instant::now();
+        let model_name = Some("gemini-2.5-pro".to_string());
+
+        let result = parse_google_response(
+            &client,
+            either::Right(prompt.as_slice()),
+            response_body,
+            system_now,
+            instant_now,
+            model_name,
+        );
+
+        if let LLMResponse::Success(actual_result) = result {
+            // Currently this will only return "This product is a " (the first non-thought part)
+            // But it should concatenate all non-thought parts
+            assert_eq!(
+                actual_result.content,
+                "This product is a \"dog cargo guard\" or a barrier designed to separate the trunk/boot from the passenger area of a car."
+            );
+        } else {
+            panic!("Expected LLMResponse::Success, got {result:?}");
+        }
+    }
 }

integ-tests/baml_src/clients.baml

@@ -152,6 +152,21 @@ client<llm> Gemini {
   }
 }
 
+client<llm> Gemini25ProThinking {
+  provider google-ai
+  retry_policy Constant
+  options {
+    model "gemini-2.5-pro"
+    api_key env.GOOGLE_API_KEY
+    generationConfig {
+      thinkingConfig {
+          thinkingBudget 1024
+          includeThoughts true
+      }
+    }
+  }
+}
+
 client<llm> GeminiOpenAiGeneric {
   provider "openai-generic"
   options {

integ-tests/baml_src/test-files/providers/gemini.baml

@@ -30,6 +30,20 @@ function TestGeminiOpenAiGeneric() -> string {
   "#
 }
 
+function TestGeminiThinking(input: string) -> string {
+  client Gemini25ProThinking
+  prompt #"
+    Analyze this product and tell me what it is: {{ input }}
+  "#
+}
+
+test TestGeminiThinking {
+  functions [TestGeminiThinking]
+  args {
+    input "A mesh barrier with mounting points designed for vehicle cargo areas"
+  }
+}
+
 test TestName {
   functions [TestGeminiSystem]
   args {

integ-tests/baml_src/test-files/providers/tests.baml

@@ -16,7 +16,7 @@ test TestAWS {
 
 test TestProvider {
   functions [
-    TestAnthropic, TestVertex, PromptTestOpenAI, TestAzure, TestOllama, TestGemini, TestAws,
+    TestAnthropic, TestVertex, PromptTestOpenAI, TestAzure, TestOllama, TestGemini, TestGeminiThinking, TestAws,
     TestAwsInvalidRegion,
     TestOpenAIShorthand,
     TestAnthropicShorthand,