feat: add code execution and update grounding to support v2 models

Author: Joshua Tracey

examples/code_execution.rs

@@ -0,0 +1,55 @@
+use std::collections::HashMap;
+
+use gemini_client_rs::{
+    types::{GenerateContentRequest, PartResponse},
+    GeminiClient,
+};
+
+use dotenvy::dotenv;
+use serde_json::json;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    dotenv().ok();
+
+    let api_key = std::env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY must be set");
+
+    let client = GeminiClient::new(api_key);
+    let model_name = "gemini-2.0-flash";
+
+    let req_json = json!({
+        "contents": [
+            {
+                "parts": [
+                    {
+                        "text": "Calculate the square root of 16"
+                    }
+                ],
+                "role": "user"
+            }
+        ],
+        "tools": [
+            {
+                "code_execution": {}
+            }
+        ]
+    });
+
+    let request = serde_json::from_value::<GenerateContentRequest>(req_json)?;
+    let response = client
+        .generate_content_with_function_calling(model_name, request, &HashMap::new())
+        .await?;
+
+    let candidates = response.candidates.unwrap();
+
+    for candidate in &candidates {
+        for part in &candidate.content.parts {
+            match part {
+                PartResponse::Text(text) => println!("{}", text),
+                _ => { /* Ignore other part types as we are not using tools */ }
+            }
+        }
+    }
+
+    Ok(())
+}

examples/custom_tool.rs

@@ -83,6 +83,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         PartResponse::Text(text) => text,
         PartResponse::FunctionCall(_) => "Function call found",
         PartResponse::FunctionResponse(_) => "Function response found",
+        PartResponse::ExecutableCode(_) => "Executable code found",
+        PartResponse::CodeExecutionResult(_) => "Code execution result found",
     };
 
     println!("{}", weather);

examples/grounded_2.rs

@@ -0,0 +1,56 @@
+use std::collections::HashMap;
+
+use gemini_client_rs::{
+    types::{GenerateContentRequest, PartResponse},
+    GeminiClient,
+};
+
+use dotenvy::dotenv;
+use serde_json::json;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    dotenv().ok();
+
+    let api_key = std::env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY must be set");
+
+    let client = GeminiClient::new(api_key);
+    let model_name = "gemini-2.0-flash";
+
+    let req_json = json!({
+        "contents": [
+            {
+                "parts": [
+                    {
+                        "text": "What's the weather like in London, UK?"
+                    }
+                ],
+                "role": "user"
+            }
+        ],
+        "tools": [
+            {
+                "google_search": {
+                }
+            }
+        ]
+    });
+
+    let request = serde_json::from_value::<GenerateContentRequest>(req_json)?;
+    let response = client
+        .generate_content_with_function_calling(model_name, request, &HashMap::new())
+        .await?;
+
+    let candidates = response.candidates.unwrap();
+
+    for candidate in &candidates {
+        for part in &candidate.content.parts {
+            match part {
+                PartResponse::Text(text) => println!("{}", text),
+                _ => { /* Ignore other part types as we are not using tools */ }
+            }
+        }
+    }
+
+    Ok(())
+}

src/lib.rs

@@ -105,6 +105,8 @@ impl GeminiClient {
                                 }
                             }
                             PartResponse::FunctionResponse(_) => return Ok(response),
+                            PartResponse::ExecutableCode(_) => return Ok(response),
+                            PartResponse::CodeExecutionResult(_) => return Ok(response),
                         }
                     } else {
                         return Ok(response);
@@ -118,3 +120,4 @@ impl GeminiClient {
         }
     }
 }
+

src/types.rs

@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use std::collections::HashMap;
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -23,11 +24,24 @@ pub struct GenerateContentRequest {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum ToolConfig {
+    // will work for both v1 and v2 models
     #[serde(rename = "function_declaration")]
     FunctionDeclaration(ToolConfigFunctionDeclaration),
+
+    /* NOTE: For v1 models will be depreciated by google in 2025 */
     DynamicRetieval {
         google_search_retrieval: DynamicRetrieval,
     },
+
+    /* NOTE: Used by v2 models if they have search built in */
+    GoogleSearch {
+        google_search: serde_json::Value,
+    },
+
+    /* NOTE: Used by v2 models if they have the code execution built in */
+    CodeExecution {
+        code_execution: serde_json::Value,
+    },
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -44,6 +58,10 @@ pub enum ContentPart {
     FunctionCall(FunctionCall),
     #[serde(rename = "functionResponse")]
     FunctionResponse(FunctionResponse),
+    #[serde(rename = "executableCode")]
+    ExecutableCode(ExecutableCode),
+    #[serde(rename = "codeExecutionResult")]
+    CodeExecutionResult(Value),
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -111,6 +129,10 @@ pub enum PartResponse {
     FunctionCall(FunctionCall),
     #[serde(rename = "functionResponse")]
     FunctionResponse(FunctionResponse),
+    #[serde(rename = "executableCode")]
+    ExecutableCode(ExecutableCode),
+    #[serde(rename = "codeExecutionResult")]
+    CodeExecutionResult(Value),
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -130,3 +152,8 @@ pub struct FunctionResponse {
 pub struct FunctionResponsePayload {
     pub content: serde_json::Value,
 }
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ExecutableCode {
+    pub code: String,
+}