stuff

Author: CLowbrow

bindings/typescript/src/generated/AssistantContentPart.ts

@@ -13,4 +13,4 @@ export type AssistantContentPart = { "type": "text" } & TextContentPart | { "typ
  * Providers will occasionally return encrypted content for reasoning parts which can
  * be useful when you send a follow up message.
  */
-encrypted_content?: string, } | { "type": "tool_call", tool_call_id: string, tool_name: string, arguments: ToolCallArguments, status?: string, caller?: ToolCaller, encrypted_content?: string, provider_options?: ProviderOptions, provider_executed?: boolean, } | { "type": "builtin_tool_call", tool_call_id?: string, tool_name?: string, builtin_tool: BuiltinToolIdentity, arguments?: ToolCallArguments, status?: string, provider_options?: ProviderOptions, provider_executed?: boolean, } | { "type": "program", call_id: string, code: string, fingerprint?: string, id?: string, } | { "type": "program_output", call_id: string, result: string, status: string, id?: string, } | { "type": "tool_discovery_call", tool_call_id: string, discovery_tool_name: string, query?: string, arguments?: unknown, status?: string, execution?: string, provider_options?: ProviderOptions, } | { "type": "tool_result", tool_call_id: string, tool_name: string, output: unknown, caller?: ToolCaller, provider_options?: ProviderOptions, };
+encrypted_content?: string, } | { "type": "tool_call", tool_call_id: string, tool_name: string, arguments: ToolCallArguments, status?: string, caller?: ToolCaller, encrypted_content?: string, provider_options?: ProviderOptions, provider_executed?: boolean, } | { "type": "builtin_tool_call", tool_call_id?: string, tool_name?: string, builtin_tool: BuiltinToolIdentity, arguments?: ToolCallArguments, status?: string, encrypted_content?: string, provider_options?: ProviderOptions, provider_executed?: boolean, } | { "type": "program", call_id: string, code: string, fingerprint?: string, id?: string, } | { "type": "program_output", call_id: string, result: string, status: string, id?: string, } | { "type": "tool_discovery_call", tool_call_id: string, discovery_tool_name: string, query?: string, arguments?: unknown, status?: string, execution?: string, provider_options?: ProviderOptions, } | { "type": "tool_result", tool_call_id: string, tool_name: string, output: unknown, caller?: ToolCaller, provider_options?: ProviderOptions, };

crates/lingua/src/processing/dedup.rs

@@ -191,13 +191,15 @@ fn hash_assistant_content(content: &AssistantContent, hasher: &mut DefaultHasher
                         builtin_tool,
                         arguments,
                         status,
+                        encrypted_content,
                         ..
                     } => {
                         "builtin_tool_call".hash(hasher);
                         tool_call_id.hash(hasher);
                         tool_name.hash(hasher);
                         builtin_tool.hash(hasher);
                         status.hash(hasher);
+                        encrypted_content.hash(hasher);
                         match arguments {
                             Some(crate::universal::ToolCallArguments::Valid(map)) => {
                                 "valid".hash(hasher);

crates/lingua/src/processing/transform.rs

@@ -777,6 +777,7 @@ fn assistant_content_to_stream_delta(content: &AssistantContent) -> UniversalStr
                         tool_name,
                         builtin_tool,
                         arguments,
+                        encrypted_content,
                         ..
                     } => {
                         let tool_call_index = tool_calls.len() as u32;
@@ -794,6 +795,9 @@ fn assistant_content_to_stream_delta(content: &AssistantContent) -> UniversalStr
                                 arguments: arguments.as_ref().map(ToString::to_string),
                             }),
                         });
+                        if reasoning_signature.is_none() {
+                            reasoning_signature = encrypted_content.clone();
+                        }
                     }
                     AssistantContentPart::File { .. }
                     | AssistantContentPart::ToolResult { .. }

crates/lingua/src/providers/google/adapter.rs

@@ -645,9 +645,13 @@ impl ProviderAdapter for GoogleAdapter {
                 ..
             } = m
             {
-                parts
-                    .iter()
-                    .any(|p| matches!(p, AssistantContentPart::ToolCall { .. }))
+                parts.iter().any(|p| {
+                    matches!(
+                        p,
+                        AssistantContentPart::ToolCall { .. }
+                            | AssistantContentPart::BuiltinToolCall { .. }
+                    )
+                })
             } else {
                 false
             }
@@ -1781,6 +1785,48 @@ mod tests {
         assert_eq!(back_typed.model_version.as_deref(), Some("gemini-1.5"));
     }
 
+    #[test]
+    fn test_google_response_builtin_tool_call_sets_tool_calls_finish_reason() {
+        let adapter = GoogleAdapter;
+        let payload = json!({
+            "candidates": [{
+                "content": {
+                    "role": "model",
+                    "parts": [{
+                        "thoughtSignature": "google_builtin_signature",
+                        "toolCall": {
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "args": {"query": "Lingua"}
+                        }
+                    }]
+                },
+                "finishReason": "STOP"
+            }]
+        });
+
+        let universal = adapter.response_to_universal(payload).unwrap();
+
+        assert_eq!(universal.finish_reason, Some(FinishReason::ToolCalls));
+        assert_eq!(universal.finish_reasons, vec![FinishReason::Stop]);
+        let Message::Assistant {
+            content: AssistantContent::Array(parts),
+            ..
+        } = &universal.messages[0]
+        else {
+            panic!("expected assistant content parts");
+        };
+        let AssistantContentPart::BuiltinToolCall {
+            encrypted_content, ..
+        } = &parts[0]
+        else {
+            panic!("expected built-in tool call");
+        };
+        assert_eq!(
+            encrypted_content.as_deref(),
+            Some("google_builtin_signature")
+        );
+    }
+
     #[test]
     fn test_google_stream_tool_call_sets_tool_calls_finish_reason() {
         let adapter = GoogleAdapter;

crates/lingua/src/providers/google/convert.rs

@@ -287,6 +287,7 @@ impl TryFromLLM<GoogleContent> for Message {
                             builtin_tool: builtin_identity_from_google_tool_type(tool_type),
                             arguments: tool_call.args.clone().map(ToolCallArguments::Valid),
                             status: None,
+                            encrypted_content: part.thought_signature.clone(),
                             provider_options: None,
                             provider_executed: Some(true),
                         });
@@ -664,6 +665,7 @@ impl TryFromLLM<Message> for GoogleContent {
                                     tool_name,
                                     builtin_tool,
                                     arguments,
+                                    encrypted_content,
                                     provider_executed,
                                     ..
                                 } => {
@@ -696,6 +698,7 @@ impl TryFromLLM<Message> for GoogleContent {
                                                 )?,
                                             ),
                                         }),
+                                        thought_signature: encrypted_content,
                                         ..Default::default()
                                     });
                                 }
@@ -2028,6 +2031,7 @@ mod tests {
                     tool_name: None,
                     tool_type: Some(GoogleToolType::GoogleSearchWeb),
                 }),
+                thought_signature: Some("google_builtin_signature".to_string()),
                 ..Default::default()
             }]),
         };
@@ -2045,6 +2049,7 @@ mod tests {
             tool_call_id,
             tool_name,
             builtin_tool,
+            encrypted_content,
             provider_executed,
             ..
         } = &parts[0]
@@ -2055,6 +2060,10 @@ mod tests {
         assert_eq!(tool_name, &None);
         assert_eq!(builtin_tool.provider, BuiltinToolProvider::Google);
         assert_eq!(builtin_tool.builtin_type, "GOOGLE_SEARCH_WEB");
+        assert_eq!(
+            encrypted_content.as_deref(),
+            Some("google_builtin_signature")
+        );
         assert_eq!(*provider_executed, Some(true));
 
         let roundtrip = <GoogleContent as TryFromLLM<Message>>::try_from(universal)

crates/lingua/src/universal/message.rs

@@ -128,6 +128,8 @@ pub enum AssistantContentPart {
         #[ts(optional)]
         status: Option<String>,
         #[ts(optional)]
+        encrypted_content: Option<String>,
+        #[ts(optional)]
         provider_options: Option<ProviderOptions>,
         #[ts(optional)]
         provider_executed: Option<bool>,

plan.md

@@ -7,6 +7,8 @@
 - The Google adapter lifts a small canonical subset of `generationConfig` and discards every other typed field, including `audioTranscriptionConfig` and request-level `mediaResolution`.
 - Google streaming conversion only inspects `Part.functionCall`, so native `Part.toolCall` chunks are silently reduced to empty assistant deltas and may receive the wrong finish reason.
 - Google declares built-in `ToolCall.id` and `ToolResponse.id` optional, but the universal built-in parts currently require a string and the converter rejects valid provider payloads with no ID.
+- Non-streaming Google built-in tool calls discard `Part.thoughtSignature`, so replaying provider-executed call history can fail Gemini signature validation.
+- Non-streaming response finish-reason detection recognizes only ordinary function calls, so a built-in call paired with Google `STOP` is incorrectly classified as a completed turn.
 
 ## Target files
 
@@ -27,6 +29,8 @@
 - Dedicated universal builtin-tool call and result parts carry an optional free-form name plus a typed identity (`provider` and `builtin_type`). Google server-side tool calls/results round-trip with `provider_executed: true` without fabricating a function name, while ordinary function-tool parts remain source-compatible.
 - Built-in call/result correlation IDs are optional so a missing Google ID round-trips as absent rather than being rejected or synthesized. Real IDs remain unchanged.
 - Native Google streaming `toolCall` parts become typed universal built-in tool-call deltas, set the `tool_calls` finish reason, and round-trip back to Google. Streaming targets that cannot represent the built-in identity fail explicitly instead of treating it as a function call.
+- Built-in calls carry optional opaque `encrypted_content`, allowing Google `thoughtSignature` values to survive non-streaming and full-response streaming roundtrips.
+- Non-streaming responses containing either ordinary or built-in tool calls use the canonical `ToolCalls` finish reason.
 - Providers that cannot represent a provider-executed builtin return an explicit unsupported-mapping error instead of silently dropping it.
 - Google-to-universal preserves only the unmapped, typed remainder of `generationConfig` in Google-scoped extras. Universal-to-Google starts from that typed remainder and lets canonical fields override it, avoiding duplicate sources of truth.
 - The accepted REST `audioTranscriptionConfig` subtree and request-level `mediaResolution` survive Google round trips byte-for-byte at the semantic JSON level.
@@ -37,6 +41,8 @@
 - Add Google converter tests for named and unnamed provider-executed builtin calls and responses.
 - Add Google converter tests for built-in calls and responses with absent IDs.
 - Add Google streaming tests for typed built-in call conversion, absent-ID preservation, Google roundtrip, finish-reason handling, and explicit rejection by non-Google targets.
+- Add a Google built-in call test with `thoughtSignature` and assert exact non-streaming roundtrip preservation.
+- Add a Google response test proving a built-in call overrides provider `STOP` with canonical `ToolCalls`.
 - Add Google params/adapter tests proving unmapped `generationConfig` fields survive while canonical temperature/reasoning/response-format values take precedence.
 - Keep payload cases `googleProviderExecutedToolRoundtrip` and `audioTranscriptionConfigParam`; recapture after the logic fix.
 - Update existing universal/provider tests for optional tool names and builtin identities.