Feat/gemini thought signature (#1)

* feat: parts thought signature

* feat: gemini adapter thought signature support

- Add ContentPart::ThoughtSignature with accessors and helpers.
- Introduce InterStreamEvent::ThoughtSignatureChunk and ChatStreamEvent::ThoughtSignatureChunk.
- Capture thought signatures into StreamEnd.captured_content when enabled.
- Update printer to display ThoughtSignatureChunk events (non-captured).
- Gemini adapter: parse thoughtSignature (fallback: thought) and include in outgoing messages.
- Gemini streamer: surface thought as ThoughtSignatureChunk and record in captured_thought_signatures.
- Preserve thoughtSignature in assistant history before tool calls when looping tools.
- Example c10-tooluse-streaming.rs: switch to gemini-3-pro-preview, log thoughtSignature chunks, and prepend captured thoughts to assistant message.

* chore: impl thought signature

* chore: no API change

Author: ii64

examples/c10-tooluse-streaming.rs

@@ -3,11 +3,13 @@ use genai::Client;
 use genai::chat::printer::{PrintChatStreamOptions, print_chat_stream};
 use genai::chat::{ChatMessage, ChatOptions, ChatRequest, Tool, ToolResponse};
 use genai::chat::{ChatStreamEvent, ToolCall};
+use genai::resolver::AuthData;
 use serde_json::json;
 use tracing_subscriber::EnvFilter;
 
 // const MODEL: &str = "gemini-2.0-flash";
-const MODEL: &str = "deepseek-chat";
+// const MODEL: &str = "deepseek-chat";
+const MODEL: &str = "gemini-3-pro-preview";
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -18,6 +20,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 	let client = Client::default();
 
+	println!("--- Model: {MODEL}");
+
 	// 1. Define a tool for getting weather information
 	let weather_tool = Tool::new("get_weather")
 		.with_description("Get the current weather for a location")
@@ -53,6 +57,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 	let mut chat_stream = client.exec_chat_stream(MODEL, chat_req.clone(), Some(&chat_options)).await?;
 
 	let mut tool_calls: Vec<ToolCall> = [].to_vec();
+	let mut captured_thoughts: Option<Vec<String>> = None;
+
 	// print_chat_stream(chat_res, Some(&print_options)).await?;
 	println!("--- Streaming response with tool calls");
 	while let Some(result) = chat_stream.stream.next().await {
@@ -63,25 +69,53 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 			ChatStreamEvent::Chunk(chunk) => {
 				print!("{}", chunk.content);
 			}
-			ChatStreamEvent::ToolCallChunk(tool_chunk) => {
-				println!(
-					"\nTool Call: {} with args: {}",
-					tool_chunk.tool_call.fn_name, tool_chunk.tool_call.fn_arguments
-				);
+			ChatStreamEvent::ToolCallChunk(chunk) => {
+				println!("  ToolCallChunk: {:?}", chunk.tool_call);
 			}
 			ChatStreamEvent::ReasoningChunk(chunk) => {
-				println!("\nReasoning: {}", chunk.content);
+				println!("  ReasoningChunk: {:?}", chunk.content);
+			}
+			ChatStreamEvent::ThoughtSignatureChunk(chunk) => {
+				println!("  ThoughtSignatureChunk: {:?}", chunk.content);
 			}
 			ChatStreamEvent::End(end) => {
 				println!("\nStream ended");
 
 				// Check if we captured any tool calls
-				if let Some(captured_tool_calls) = end.captured_into_tool_calls() {
-					println!("\nCaptured Tool Calls:");
-					tool_calls = captured_tool_calls.clone();
-					for tool_call in captured_tool_calls {
-						println!("- Function: {}", tool_call.fn_name);
-						println!("  Arguments: {}", tool_call.fn_arguments);
+				// Note: captured_into_tool_calls consumes self, so we can't use end afterwards.
+				// We should access captured_content directly or use references if possible,
+				// but StreamEnd getters often consume or clone.
+				// Let's access captured_content directly since we need both tool calls and thoughts.
+
+				if let Some(content) = end.captured_content {
+					// Let's refactor to avoid ownership issues.
+					// We have `content` (MessageContent).
+					// We want `tool_calls` (Vec<ToolCall>) and `thoughts` (Vec<String>).
+
+					// We can iterate and split.
+					let parts = content.into_parts();
+					let mut extracted_tool_calls = Vec::new();
+					let mut extracted_thoughts = Vec::new();
+
+					for part in parts {
+						match part {
+							genai::chat::ContentPart::ToolCall(tc) => extracted_tool_calls.push(tc),
+							genai::chat::ContentPart::ThoughtSignature(t) => extracted_thoughts.push(t),
+							_ => {}
+						}
+					}
+
+					if !extracted_tool_calls.is_empty() {
+						println!("\nCaptured Tool Calls:");
+						for tool_call in &extracted_tool_calls {
+							println!("- Function: {}", tool_call.fn_name);
+							println!("  Arguments: {}", tool_call.fn_arguments);
+						}
+						tool_calls = extracted_tool_calls;
+					}
+
+					if !extracted_thoughts.is_empty() {
+						captured_thoughts = Some(extracted_thoughts);
 					}
 				}
 			}
@@ -107,7 +141,19 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 	);
 
 	// Add both the tool calls and response to chat history
-	let chat_req = chat_req.append_message(tool_calls).append_message(tool_response);
+	// Note: For Gemini 3, we MUST include the thoughtSignature in the history if it was generated.
+	let mut assistant_msg = ChatMessage::from(tool_calls);
+	if let Some(thoughts) = captured_thoughts {
+		// We need to insert the thought at the beginning.
+		// MessageContent wraps Vec<ContentPart>, but doesn't expose insert.
+		// We can convert to Vec, insert, and convert back.
+		let mut parts = assistant_msg.content.into_parts();
+		for thought in thoughts.into_iter().rev() {
+			parts.insert(0, genai::chat::ContentPart::ThoughtSignature(thought));
+		}
+		assistant_msg.content = genai::chat::MessageContent::from_parts(parts);
+	}
+	let chat_req = chat_req.append_message(assistant_msg).append_message(tool_response);
 
 	// Get final streaming response
 	let chat_options = ChatOptions::default();

src/adapter/adapters/anthropic/adapter_impl.rs

@@ -252,6 +252,7 @@ impl Adapter for AnthropicAdapter {
 						call_id,
 						fn_name,
 						fn_arguments,
+						thought_signatures: None,
 					};
 
 					let part = ContentPart::ToolCall(tool_call);
@@ -451,6 +452,7 @@ impl AnthropicAdapter {
 										"tool_use_id": tool_response.call_id,
 									}));
 								}
+								ContentPart::ThoughtSignature(_) => {}
 							}
 						}
 						let values = apply_cache_control_to_parts(is_cache_control, values);
@@ -483,6 +485,7 @@ impl AnthropicAdapter {
 							// Unsupported for assistant role in Anthropic message content
 							ContentPart::Binary(_) => {}
 							ContentPart::ToolResponse(_) => {}
+							ContentPart::ThoughtSignature(_) => {}
 						}
 					}
 

src/adapter/adapters/anthropic/streamer.rs

@@ -136,6 +136,7 @@ impl futures::Stream for AnthropicStreamer {
 										call_id: id,
 										fn_name: name,
 										fn_arguments: serde_json::from_str(&input)?,
+										thought_signatures: None,
 									};
 
 									// Add to the captured_tool_calls if chat options say so
@@ -182,6 +183,7 @@ impl futures::Stream for AnthropicStreamer {
 								captured_text_content: self.captured_data.content.take(),
 								captured_reasoning_content: self.captured_data.reasoning_content.take(),
 								captured_tool_calls: self.captured_data.tool_calls.take(),
+								captured_thought_signatures: None,
 							};
 
 							// TODO: Need to capture the data as needed

src/adapter/adapters/cohere/streamer.rs

@@ -108,6 +108,7 @@ impl futures::Stream for CohereStreamer {
 										captured_text_content: self.captured_data.content.take(),
 										captured_reasoning_content: self.captured_data.reasoning_content.take(),
 										captured_tool_calls: self.captured_data.tool_calls.take(),
+										captured_thought_signatures: None,
 									};
 
 									InterStreamEvent::End(inter_stream_end)

src/adapter/adapters/gemini/adapter_impl.rs

@@ -208,15 +208,41 @@ impl Adapter for GeminiAdapter {
 			usage,
 		} = gemini_response;
 
-		// FIXME: Needs to take the content list
-		let mut content: MessageContent = MessageContent::default();
+		let mut thoughts: Vec<String> = Vec::new();
+		let mut texts: Vec<String> = Vec::new();
+		let mut tool_calls: Vec<ToolCall> = Vec::new();
+
 		for g_item in gemini_content {
 			match g_item {
-				GeminiChatContent::Text(text) => content.push(text),
-				GeminiChatContent::ToolCall(tool_call) => content.push(tool_call),
+				GeminiChatContent::Text(text) => texts.push(text),
+				GeminiChatContent::ToolCall(tool_call) => tool_calls.push(tool_call),
+				GeminiChatContent::ThoughtSignature(thought) => thoughts.push(thought),
+			}
+		}
+
+		let thought_signatures_for_call = (!thoughts.is_empty() && !tool_calls.is_empty()).then(|| thoughts.clone());
+		let mut parts: Vec<ContentPart> = thoughts.into_iter().map(ContentPart::ThoughtSignature).collect();
+
+		if let Some(signatures) = thought_signatures_for_call {
+			if let Some(first_call) = tool_calls.first_mut() {
+				first_call.thought_signatures = Some(signatures);
 			}
 		}
 
+		if !texts.is_empty() {
+			let total_len: usize = texts.iter().map(|t| t.len()).sum();
+			let mut combined_text = String::with_capacity(total_len);
+			for text in texts {
+				combined_text.push_str(&text);
+			}
+			if !combined_text.is_empty() {
+				parts.push(ContentPart::Text(combined_text));
+			}
+		}
+
+		parts.extend(tool_calls.into_iter().map(ContentPart::ToolCall));
+		let content = MessageContent::from_parts(parts);
+
 		Ok(ChatResponse {
 			content,
 			reasoning_content: None,
@@ -293,13 +319,36 @@ impl GeminiAdapter {
 		};
 
 		for mut part in parts {
+			// -- Capture eventual thought signature
+			{
+				if let Some(thought) = part
+					.x_take::<Value>("thoughtSignature")
+					.ok()
+					.and_then(|v| if let Value::String(v) = v { Some(v) } else { None })
+				{
+					content.push(GeminiChatContent::ThoughtSignature(thought));
+				}
+				// Note: sometime the thought is in "thought" (undocumented, but observed in some cases or older models?)
+				//       But for Gemini 3 it is thoughtSignature. Keeping this just in case or for backward compat if it was used.
+				//       Actually, let's stick to thoughtSignature as per docs, but if we see "thought" we might want to capture it too.
+				//       Let's check for "thought" if "thoughtSignature" was not found.
+				else if let Some(thought) = part
+					.x_take::<Value>("thought")
+					.ok()
+					.and_then(|v| if let Value::String(v) = v { Some(v) } else { None })
+				{
+					content.push(GeminiChatContent::ThoughtSignature(thought));
+				}
+			}
+
 			// -- Capture eventual function call
 			if let Ok(fn_call_value) = part.x_take::<Value>("functionCall") {
 				let tool_call = ToolCall {
 					// NOTE: Gemini does not have call_id so, use name
 					call_id: fn_call_value.x_get("name").unwrap_or("".to_string()), // TODO: Handle this, gemini does not return the call_id
 					fn_name: fn_call_value.x_get("name").unwrap_or("".to_string()),
 					fn_arguments: fn_call_value.x_get("args").unwrap_or(Value::Null),
+					thought_signatures: None,
 				};
 				content.push(GeminiChatContent::ToolCall(tool_call))
 			}
@@ -458,29 +507,66 @@ impl GeminiAdapter {
 									}
 								}));
 							}
+							ContentPart::ThoughtSignature(thought) => {
+								parts_values.push(json!({
+									"thoughtSignature": thought
+								}));
+							}
 						}
 					}
 
 					contents.push(json!({"role": "user", "parts": parts_values}));
 				}
 				ChatRole::Assistant => {
 					let mut parts_values: Vec<Value> = Vec::new();
+					let mut pending_thought: Option<String> = None;
 					for part in msg.content {
 						match part {
-							ContentPart::Text(text) => parts_values.push(json!({"text": text})),
+							ContentPart::Text(text) => {
+								if let Some(thought) = pending_thought.take() {
+									parts_values.push(json!({"thoughtSignature": thought}));
+								}
+								parts_values.push(json!({"text": text}));
+							}
 							ContentPart::ToolCall(tool_call) => {
-								parts_values.push(json!({
-									"functionCall": {
+								let mut part_obj = serde_json::Map::new();
+								part_obj.insert(
+									"functionCall".to_string(),
+									json!({
 										"name": tool_call.fn_name,
 										"args": tool_call.fn_arguments,
-									}
-								}));
+									}),
+								);
+
+								if let Some(thought) = pending_thought.take() {
+									// Inject thoughtSignature alongside functionCall in the same Part object
+									part_obj.insert("thoughtSignature".to_string(), json!(thought));
+								}
+
+								parts_values.push(Value::Object(part_obj));
+							}
+							ContentPart::ThoughtSignature(thought) => {
+								if let Some(prev_thought) = pending_thought.take() {
+									parts_values.push(json!({"thoughtSignature": prev_thought}));
+								}
+								pending_thought = Some(thought);
 							}
 							// Ignore unsupported parts for Assistant role
-							ContentPart::Binary(_) => {}
-							ContentPart::ToolResponse(_) => {}
+							ContentPart::Binary(_) => {
+								if let Some(thought) = pending_thought.take() {
+									parts_values.push(json!({"thoughtSignature": thought}));
+								}
+							}
+							ContentPart::ToolResponse(_) => {
+								if let Some(thought) = pending_thought.take() {
+									parts_values.push(json!({"thoughtSignature": thought}));
+								}
+							}
 						}
 					}
+					if let Some(thought) = pending_thought {
+						parts_values.push(json!({"thoughtSignature": thought}));
+					}
 					if !parts_values.is_empty() {
 						contents.push(json!({"role": "model", "parts": parts_values}));
 					}
@@ -508,10 +594,15 @@ impl GeminiAdapter {
 									}
 								}));
 							}
+							ContentPart::ThoughtSignature(thought) => {
+								parts_values.push(json!({
+									"thoughtSignature": thought
+								}));
+							}
 							_ => {
 								return Err(Error::MessageContentTypeNotSupported {
 									model_iden: model_iden.clone(),
-									cause: "ChatRole::Tool can only contain ToolCall or ToolResponse content parts",
+									cause: "ChatRole::Tool can only contain ToolCall, ToolResponse, or Thought content parts",
 								});
 							}
 						}
@@ -580,6 +671,7 @@ pub(super) struct GeminiChatResponse {
 pub(super) enum GeminiChatContent {
 	Text(String),
 	ToolCall(ToolCall),
+	ThoughtSignature(String),
 }
 
 struct GeminiChatRequestParts {