Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

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.rs
index 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.rs
index 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.rs
index 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.