Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
fix(databases): preserve Gemini tool JSON schemas (#7409)
Wolf Mermelstein3317c4d6e770
diff --git a/crates/agent/src/model/gemini.rs b/crates/agent/src/model/gemini.rsindex 57cfe2e98b..fdfde4db37 100644--- a/crates/agent/src/model/gemini.rs+++ b/crates/agent/src/model/gemini.rs@@ -1,4 +1,8 @@use crate::model::types::Model;+use rig_core::completion::{+ CompletionError, CompletionModel, CompletionRequest, CompletionResponse,+};+use rig_core::streaming::StreamingCompletionResponse;use rig_core::{client::CompletionClient, http_client::HttpClientExt, providers::gemini};use std::sync::Arc;@@ -26,8 +30,8 @@ impl<'a, H: HttpClientExt + Clone + 'static> GeminiModel<'a, H> {/// The rig completion model for this id. The id is passed verbatim to the/// Gemini API.- pub fn completion(&self) -> gemini::completion::CompletionModel<H> {- self.client.completion_model(self.model.name().to_string())+ pub fn completion(&self) -> GeminiCompletionModel<H> {+ GeminiCompletionModel(self.client.completion_model(self.model.name().to_string()))}/// Ask Gemini to include thought summaries so reasoning deltas reach the@@ -52,5 +56,76 @@ impl<'a, H: HttpClientExt + Clone + 'static> GeminiModel<'a, H> {}}+/// Sends tool schemas through Gemini's native JSON Schema field. Rig's legacy+/// `parameters` conversion recursively inlines references, which overflows the+/// process stack for recursive schemas such as database view filters. It also+/// loses nested nullable unions, producing an invalid empty Gemini `type`.+#[derive(Clone)]+pub struct GeminiCompletionModel<H>(gemini::completion::CompletionModel<H>);++impl<H: HttpClientExt + Clone + 'static> CompletionModel for GeminiCompletionModel<H> {+ type Response = <gemini::completion::CompletionModel<H> as CompletionModel>::Response;+ type StreamingResponse =+ <gemini::completion::CompletionModel<H> as CompletionModel>::StreamingResponse;+ type Client = gemini::Client<H>;++ fn make(client: &Self::Client, model: impl Into<String>) -> Self {+ Self(gemini::completion::CompletionModel::make(client, model))+ }++ async fn completion(+ &self,+ request: CompletionRequest,+ ) -> Result<CompletionResponse<Self::Response>, CompletionError> {+ self.0.completion(native_tool_schemas(request)?).await+ }++ async fn stream(+ &self,+ request: CompletionRequest,+ ) -> Result<StreamingCompletionResponse<Self::StreamingResponse>, CompletionError> {+ self.0.stream(native_tool_schemas(request)?).await+ }+}++fn native_tool_schemas(+ mut request: CompletionRequest,+) -> Result<CompletionRequest, CompletionError> {+ if request.tools.is_empty() {+ return Ok(request);+ }+ let declarations: Vec<_> = request+ .tools+ .drain(..)+ .map(|tool| {+ let mut declaration = serde_json::json!({+ "name": tool.name,+ "description": tool.description,+ });+ if !tool.parameters.is_null() {+ declaration["parametersJsonSchema"] = tool.parameters;+ }+ declaration+ })+ .collect();+ let params = request+ .additional_params+ .get_or_insert_with(|| serde_json::json!({}));+ let object = params.as_object_mut().ok_or_else(|| {+ CompletionError::RequestError("Gemini additional parameters must be an object".into())+ })?;+ let tools = object+ .entry("tools")+ .or_insert_with(|| serde_json::json!([]));+ let tools = tools.as_array_mut().ok_or_else(|| {+ CompletionError::RequestError("Gemini additional tools must be an array".into())+ })?;+ tools.insert(+ 0,+ serde_json::json!({ "functionDeclarations": declarations }),+ );+ Ok(request)+}+#[cfg(test)]mod test;diff --git a/crates/agent/src/model/gemini/test.rs b/crates/agent/src/model/gemini/test.rsindex 641cf06cd7..cfbf95cbd1 100644--- a/crates/agent/src/model/gemini/test.rs+++ b/crates/agent/src/model/gemini/test.rs@@ -31,3 +31,234 @@ fn thinking_params_ask_for_thought_summaries() {"unparsed keys would be sent as unknown Gemini fields");}++use bytes::Bytes;+use futures::StreamExt;+use rig_core::completion::{Message, ToolDefinition};+use rig_core::http_client::{self, LazyBody, MultipartForm, Request, Response, StreamingResponse};+use serde_json::{Value, json};+use std::sync::Mutex;++/// Records the final serialized HTTP body, after Rig's provider conversion.+#[derive(Clone, Default)]+struct CaptureTransport(Arc<Mutex<Vec<(String, Value)>>>);++impl CaptureTransport {+ fn capture<T: Into<Bytes>>(&self, request: Request<T>) {+ let url = request.uri().to_string();+ let body = serde_json::from_slice(&request.into_body().into()).unwrap();+ self.0.lock().unwrap().push((url, body));+ }+}++impl HttpClientExt for CaptureTransport {+ fn send<T, U>(+ &self,+ request: Request<T>,+ ) -> impl Future<Output = http_client::Result<Response<LazyBody<U>>>> + Send + 'static+ where+ T: Into<Bytes> + Send,+ U: From<Bytes> + Send + 'static,+ {+ self.capture(request);+ std::future::ready(Err(http_client::Error::StreamEnded))+ }++ fn send_multipart<U>(+ &self,+ _: Request<MultipartForm>,+ ) -> impl Future<Output = http_client::Result<Response<LazyBody<U>>>> + Send + 'static+ where+ U: From<Bytes> + Send + 'static,+ {+ std::future::ready(Err(http_client::Error::StreamEnded))+ }++ async fn send_streaming<T>(&self, request: Request<T>) -> http_client::Result<StreamingResponse>+ where+ T: Into<Bytes> + Send,+ {+ self.capture(request);+ Err(http_client::Error::StreamEnded)+ }+}++// These shapes reproduce QueryDatabase's nullable documented enum and+// SaveDatabaseView's recursive filter, using the same AI schema generator.+#[derive(schemars::JsonSchema)]+#[expect(dead_code, reason = "Only the generated tool schema is exercised")]+#[serde(rename_all = "camelCase")]+/// Query a database.+struct QueryDatabase {+ sql: String,+ display: Option<Display>,+}++#[derive(schemars::JsonSchema)]+#[expect(dead_code, reason = "Only the generated tool schema is exercised")]+#[serde(rename_all = "lowercase")]+enum Display {+ /// Show rows in a table.+ Table,+ /// Show one scalar value.+ Scalar,+}++#[derive(schemars::JsonSchema)]+#[expect(dead_code, reason = "Only the generated tool schema is exercised")]+/// Save a database view.+struct SaveDatabaseView {+ filter: Option<Filter>,+}++#[derive(schemars::JsonSchema)]+#[expect(dead_code, reason = "Only the generated tool schema is exercised")]+enum Filter {+ Equals { column: String, value: String },+ And { filters: Vec<Filter> },+}++fn tool<T: schemars::JsonSchema>() -> ToolDefinition {+ let generated = ai_toolset::schema::generate_validated_input_schema::<T>().unwrap();+ ToolDefinition {+ name: generated.name,+ description: generated.description,+ parameters: generated.schema.to_value(),+ }+}++fn request() -> CompletionRequest {+ CompletionRequest {+ model: Some("gemini-3.8-flash".into()),+ preamble: Some("Answer database questions.".into()),+ chat_history: rig_core::OneOrMany::one(Message::user("Find books")),+ documents: vec![],+ tools: vec![tool::<QueryDatabase>(), tool::<SaveDatabaseView>()],+ temperature: Some(0.2),+ max_tokens: Some(512),+ tool_choice: Some(rig_core::completion::message::ToolChoice::Required),+ additional_params: Some(json!({+ "generationConfig": {"thinkingConfig": {"includeThoughts": true}},+ "tools": [{"googleSearch": {}}],+ "safetySettings": [{"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_ONLY_HIGH"}]+ })),+ output_schema: Some(schemars::schema_for!(String)),+ record_telemetry_content: false,+ }+}++async fn assert_native_wire_body(streaming: bool) {+ let transport = CaptureTransport::default();+ let client = gemini::Client::builder()+ .api_key("test-google-key")+ .http_client(transport.clone())+ .build()+ .unwrap();+ let model = GeminiModel::new(+ Model::try_from("google/gemini-3.8-flash").unwrap(),+ Arc::new(client),+ );+ let request = request();+ let tools = request.tools.clone();+ // Guard the fixture: nested nullable enums and recursive references must+ // survive generation, otherwise these tests would miss the regressions.+ assert!(tools[0].parameters["properties"]["display"]["anyOf"][0]["anyOf"].is_array());+ assert!(tools[1].parameters.to_string().contains("$ref"));+ if streaming {+ let mut response = model.completion().stream(request).await.unwrap();+ // Rig starts its HTTP request lazily on the first stream poll.+ let _ = response.next().await;+ } else {+ assert!(model.completion().completion(request).await.is_err());+ }+ let captured = transport.0.lock().unwrap();+ assert_eq!(captured.len(), 1, "request must reach the HTTP boundary");+ let (url, body) = &captured[0];+ assert!(url.contains(if streaming {+ "streamGenerateContent"+ } else {+ ":generateContent"+ }));+ let declarations = body["tools"][0]["functionDeclarations"].as_array().unwrap();+ assert_eq!(declarations.len(), tools.len());+ for (declaration, tool) in declarations.iter().zip(tools) {+ assert_eq!(declaration["name"], tool.name);+ assert_eq!(declaration["description"], tool.description);+ assert_eq!(declaration["parametersJsonSchema"], tool.parameters);+ assert!(declaration.get("parameters").is_none());+ }+ assert_eq!(body["tools"][1], json!({"googleSearch": {}}));+ assert_eq!(+ body["generationConfig"]["thinkingConfig"]["includeThoughts"],+ true+ );+ assert_eq!(body["generationConfig"]["maxOutputTokens"], 512);+ assert_eq!(body["generationConfig"]["temperature"], 0.2);+ assert_eq!(+ body["generationConfig"]["responseMimeType"],+ "application/json"+ );+ assert_eq!(+ body["generationConfig"]["responseJsonSchema"],+ schemars::schema_for!(String).to_value()+ );+ assert_eq!(body["toolConfig"]["functionCallingConfig"]["mode"], "ANY");+ assert_eq!(body["safetySettings"][0]["threshold"], "BLOCK_ONLY_HIGH");+ assert_eq!(+ body["systemInstruction"]["parts"][0]["text"],+ "Answer database questions."+ );+ assert_eq!(body["contents"][0]["parts"][0]["text"], "Find books");+}++#[tokio::test]+async fn completion_preserves_native_schemas_and_request_settings() {+ assert_native_wire_body(false).await;+}++#[tokio::test]+async fn stream_preserves_native_schemas_and_request_settings() {+ assert_native_wire_body(true).await;+}++#[test]+fn requests_without_function_tools_are_unchanged() {+ let mut request = request();+ request.tools.clear();+ let original = serde_json::to_value(&request).unwrap();+ assert_eq!(+ serde_json::to_value(native_tool_schemas(request).unwrap()).unwrap(),+ original+ );+}++#[test]+fn native_tools_work_without_additional_parameters_and_omit_null_schema() {+ let mut request = request();+ request.additional_params = None;+ request.tools = vec![ToolDefinition {+ name: "NoArguments".into(),+ description: "No input required".into(),+ parameters: Value::Null,+ }];+ let request = native_tool_schemas(request).unwrap();+ assert!(request.tools.is_empty());+ assert_eq!(+ request.additional_params.unwrap(),+ json!({"tools": [{"functionDeclarations": [{+ "name": "NoArguments", "description": "No input required"+ }]}]})+ );+}++#[test]+fn invalid_additional_parameters_fail_before_transport() {+ for params in [json!([]), json!({"tools": {}})] {+ let mut request = request();+ request.additional_params = Some(params);+ assert!(matches!(+ native_tool_schemas(request),+ Err(CompletionError::RequestError(_))+ ));+ }+}diff --git a/crates/agent/src/model/router.rs b/crates/agent/src/model/router.rsindex 6d5000560b..86bd4590a8 100644--- a/crates/agent/src/model/router.rs+++ b/crates/agent/src/model/router.rs@@ -35,7 +35,7 @@ use rig_core::streaming::StreamedAssistantContent;use tracing::Instrument as _;use super::anthropic::AnthropicModel;-use super::gemini::GeminiModel;+use super::gemini::{GeminiCompletionModel, GeminiModel};use super::metering::{MeteringContext, WireProtocol};use super::metering_http::MeteredHttpClient;use super::openai::{OpenAiChatCompletionsModel, OpenAiResponsesModel};@@ -183,7 +183,7 @@ pub(crate) enum ProviderAgent</// An agent over Anthropic's native completion model.Anthropic(Agent<TracedModel<anthropic::completion::CompletionModel<H>>>),/// An agent over Gemini's native GenerateContent model.- Gemini(Agent<TracedModel<gemini::completion::CompletionModel<H>>>),+ Gemini(Agent<TracedModel<GeminiCompletionModel<H>>>),/// An agent over the OpenAI Chat Completions model.OpenAiChatCompletions(Agent<TracedModel<openai::completion::CompletionModel<H>>>),/// An agent over the OpenAI Responses model.