Struct GenerationResponse

pub struct GenerationResponse {
    pub candidates: Vec<Candidate>,
    pub prompt_feedback: Option<PromptFeedback>,
    pub usage_metadata: Option<UsageMetadata>,
}

Response from the Gemini API for content generation

Fields

candidates: Vec<Candidate>

The candidates generated

prompt_feedback: Option<PromptFeedback>

The prompt feedback

usage_metadata: Option<UsageMetadata>

Usage metadata

Implementations

impl GenerationResponse

pub fn text(&self) -> String

Get the text of the first candidate

Examples found in repository

examples/test_api.rs (line 20)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("GEMINI_API_KEY")?;
    
    // Create client with the default model (gemini-2.0-flash)
    let client = Gemini::new(api_key);
    
    println!("Sending request to Gemini API...");
    
    // Simple text completion with minimal content
    let response = client
        .generate_content()
        .with_user_message("Say hello")
        .execute()
        .await?;
    
    println!("Response: {}", response.text());
    
    Ok(())
}

examples/google_search.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GOOGLE_API_KEY")
        .expect("GOOGLE_API_KEY environment variable not set");

    // Create client
    let client = Gemini::new(api_key);

    println!("--- Google Search tool example ---");
    
    // Create a Google Search tool
    let google_search_tool = Tool::google_search();

    // Create a request with Google Search tool
    let response = client
        .generate_content()
        .with_user_message("What is the current Google stock price?")
        .with_tool(google_search_tool)
        .execute()
        .await?;

    println!("Response: {}", response.text());

    Ok(())
}

examples/curl_google_search.rs (line 54)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GOOGLE_API_KEY")
        .expect("GOOGLE_API_KEY environment variable not set");

    println!("--- Curl equivalent with Google Search tool ---");
    
    // This is equivalent to the curl example:
    // curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    //   -H "Content-Type: application/json" \
    //   -d '{
    //       "contents": [
    //           {
    //               "parts": [
    //                   {"text": "What is the current Google stock price?"}
    //               ]
    //           }
    //       ],
    //       "tools": [
    //           {
    //               "google_search": {}
    //           }
    //       ]
    //   }'
    
    // Create client
    let client = Gemini::new(api_key);
    
    // Create a content part that matches the JSON in the curl example
    let text_part = Part::Text { 
        text: "What is the current Google stock price?".to_string() 
    };
    
    let content = Content {
        parts: vec![text_part],
        role: None,
    };
    
    // Create a Google Search tool
    let google_search_tool = Tool::google_search();
    
    // Add the content and tool directly to the request
    // This exactly mirrors the JSON structure in the curl example
    let mut content_builder = client.generate_content();
    content_builder.contents.push(content);
    content_builder = content_builder.with_tool(google_search_tool);
    
    let response = content_builder.execute().await?;
    
    println!("Response: {}", response.text());

    Ok(())
}

examples/curl_equivalent.rs (line 38)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY")
        .expect("GEMINI_API_KEY environment variable not set");

    // This is equivalent to the curl example:
    // curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$YOUR_API_KEY" \
    //   -H 'Content-Type: application/json' \
    //   -X POST \
    //   -d '{
    //     "contents": [
    //       {
    //         "parts": [
    //           {
    //             "text": "Explain how AI works in a few words"
    //           }
    //         ]
    //       }
    //     ]
    //   }'

    // Create client - now using gemini-2.0-flash by default
    let client = Gemini::new(api_key);
    
    // Method 1: Using the high-level API (simplest approach)
    println!("--- Method 1: Using the high-level API ---");
    
    let response = client
        .generate_content()
        .with_user_message("Explain how AI works in a few words")
        .execute()
        .await?;

    println!("Response: {}", response.text());

    // Method 2: Using Content directly to match the curl example exactly
    println!("\n--- Method 2: Matching curl example structure exactly ---");
    
    // Create a content part that matches the JSON in the curl example
    let text_part = Part::Text { 
        text: "Explain how AI works in a few words".to_string() 
    };
    
    let content = Content {
        parts: vec![text_part],
        role: None,
    };
    
    // Add the content directly to the request
    // This exactly mirrors the JSON structure in the curl example
    let mut content_builder = client.generate_content();
    content_builder.contents.push(content);
    let response = content_builder.execute().await?;

    println!("Response: {}", response.text());

    Ok(())
}

examples/generation_config.rs (line 34)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY")
        .expect("GEMINI_API_KEY environment variable not set");

    // Create client
    let client = Gemini::new(api_key);

    // Using the full generation config
    println!("--- Using full generation config ---");
    let response1 = client
        .generate_content()
        .with_system_prompt("You are a helpful assistant.")
        .with_user_message("Write a short poem about Rust programming language.")
        .with_generation_config(
            GenerationConfig {
                temperature: Some(0.9),
                top_p: Some(0.8),
                top_k: Some(20),
                max_output_tokens: Some(200),
                candidate_count: Some(1),
                stop_sequences: Some(vec!["END".to_string()]),
                response_mime_type: None,
                response_schema: None,
            }
        )
        .execute()
        .await?;

    println!("Response with high temperature (0.9):\n{}\n", response1.text());

    // Using individual generation parameters
    println!("--- Using individual generation parameters ---");
    let response2 = client
        .generate_content()
        .with_system_prompt("You are a helpful assistant.")
        .with_user_message("Write a short poem about Rust programming language.")
        .with_temperature(0.2)
        .with_max_output_tokens(100)
        .execute()
        .await?;

    println!("Response with low temperature (0.2):\n{}\n", response2.text());

    // Setting multiple parameters individually
    println!("--- Setting multiple parameters individually ---");
    let response3 = client
        .generate_content()
        .with_system_prompt("You are a helpful assistant.")
        .with_user_message("List 3 benefits of using Rust.")
        .with_temperature(0.7)
        .with_top_p(0.9)
        .with_max_output_tokens(150)
        .with_stop_sequences(vec!["4.".to_string()])
        .execute()
        .await?;

    println!("Response with custom parameters and stop sequence:\n{}", response3.text());

    Ok(())
}

examples/structured_response.rs (line 58)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY")
        .expect("GEMINI_API_KEY environment variable not set");

    // Create client
    let client = Gemini::new(api_key);

    // Using response_schema for structured output
    println!("--- Structured Response Example ---");
    
    // Define a JSON schema for the response
    let schema = json!({
        "type": "object",
        "properties": {
            "name": {
                "type": "string",
                "description": "Name of the programming language"
            },
            "year_created": {
                "type": "integer",
                "description": "Year the programming language was created"
            },
            "creator": {
                "type": "string",
                "description": "Person or organization who created the language"
            },
            "key_features": {
                "type": "array",
                "items": {
                    "type": "string"
                },
                "description": "Key features of the programming language"
            },
            "popularity_score": {
                "type": "integer",
                "description": "Subjective popularity score from 1-10"
            }
        },
        "required": ["name", "year_created", "creator", "key_features", "popularity_score"]
    });

    let response = client
        .generate_content()
        .with_system_prompt("You provide information about programming languages in JSON format.")
        .with_user_message("Tell me about the Rust programming language.")
        .with_response_mime_type("application/json")
        .with_response_schema(schema)
        .execute()
        .await?;

    println!("Structured JSON Response:");
    println!("{}", response.text());
    
    // Parse the JSON response
    let json_response: serde_json::Value = serde_json::from_str(&response.text())?;
    
    println!("\nAccessing specific fields:");
    println!("Language: {}", json_response["name"]);
    println!("Created in: {}", json_response["year_created"]);
    println!("Created by: {}", json_response["creator"]);
    println!("Popularity: {}/10", json_response["popularity_score"]);
    
    println!("\nKey Features:");
    if let Some(features) = json_response["key_features"].as_array() {
        for (i, feature) in features.iter().enumerate() {
            println!("{}. {}", i+1, feature);
        }
    }

    Ok(())
}

Additional examples can be found in:

• examples/streaming.rs
• examples/advanced.rs
• examples/google_search_with_functions.rs
• examples/simple.rs
• examples/tools.rs

pub fn function_calls(&self) -> Vec<&FunctionCall>

Get function calls from the response

Examples found in repository

examples/advanced.rs (line 46)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("GEMINI_API_KEY")?;
    
    // Create client
    let client = Gemini::new(api_key);
    
    // Define a weather function
    let get_weather = FunctionDeclaration::new(
        "get_weather",
        "Get the current weather for a location",
        FunctionParameters::object()
            .with_property(
                "location",
                PropertyDetails::string("The city and state, e.g., San Francisco, CA"),
                true,
            )
            .with_property(
                "unit",
                PropertyDetails::enum_type(
                    "The unit of temperature", 
                    ["celsius", "fahrenheit"]
                ),
                false,
            ),
    );

    // Create a request with function calling
    println!("Sending function call request...");
    let response = client
        .generate_content()
        .with_user_message("What's the weather like in Tokyo right now?")
        .with_function(get_weather)
        .with_function_calling_mode(FunctionCallingMode::Any)
        .execute()
        .await?;

    // Check if there are function calls
    if let Some(function_call) = response.function_calls().first() {
        println!(
            "Function call received: {} with args: {}",
            function_call.name,
            function_call.args
        );

        // Get parameters from the function call
        let location: String = function_call.get("location")?;
        let unit = function_call.get::<String>("unit").unwrap_or_else(|_| String::from("celsius"));
        
        println!("Location: {}, Unit: {}", location, unit);
        
        // Simulate function execution (in a real app, this would call a weather API)
        // Create a JSON response object
        let weather_response = serde_json::json!({
            "temperature": 22,
            "unit": unit,
            "condition": "sunny",
            "location": location
        });

        // Continue the conversation with the function result
        // We need to replay the entire conversation with the function response
        println!("Sending function response...");
        
        // First, need to recreate the original prompt and the model's response
        let mut final_request = client.generate_content()
            .with_user_message("What's the weather like in Tokyo right now?");
        
        // Add the function call from the model's response
        let mut call_content = Content::default();
        call_content.parts.push(Part::FunctionCall { 
            function_call: (*function_call).clone()
        });
        let call_content = call_content.with_role(Role::Model);
        final_request.contents.push(call_content);
        
        // Now add the function response using the JSON value
        final_request = final_request.with_function_response("get_weather", weather_response);
        
        // Execute the request
        let final_response = final_request.execute().await?;

        println!("Final response: {}", final_response.text());
    } else {
        println!("No function calls in the response.");
        println!("Response text: {}", response.text());
    }

    Ok(())
}

examples/google_search_with_functions.rs (line 61)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GOOGLE_API_KEY")
        .expect("GOOGLE_API_KEY environment variable not set");

    // Create client
    let client = Gemini::new(api_key);

    println!("--- Google Search with Function Calling example ---");
    
    // Define a calculator function
    let calculate = FunctionDeclaration::new(
        "calculate",
        "Perform a calculation",
        FunctionParameters::object()
            .with_property(
                "operation",
                PropertyDetails::enum_type(
                    "The mathematical operation to perform",
                    ["add", "subtract", "multiply", "divide"]
                ),
                true,
            )
            .with_property(
                "a",
                PropertyDetails::number("The first number"),
                true,
            )
            .with_property(
                "b",
                PropertyDetails::number("The second number"),
                true,
            ),
    );
    
    // Create function tool
    let function_tool = Tool::new(calculate);
    
    // Create Google Search tool
    let google_search_tool = Tool::google_search();
    
    // Create a request with both tools
    let response = client
        .generate_content()
        .with_user_message("What is the current Google stock price multiplied by 2?")
        .with_tool(google_search_tool)
        .with_tool(function_tool)
        .with_function_calling_mode(FunctionCallingMode::Any)
        .execute()
        .await?;
    
    // Check if there are function calls
    if let Some(function_call) = response.function_calls().first() {
        println!(
            "Function call: {} with args: {}",
            function_call.name,
            function_call.args
        );
        
        // Handle the calculate function
        if function_call.name == "calculate" {
            let operation: String = function_call.get("operation")?;
            let a: f64 = function_call.get("a")?;
            let b: f64 = function_call.get("b")?;
            
            println!("Calculation: {} {} {}", a, operation, b);
            
            let result = match operation.as_str() {
                "add" => a + b,
                "subtract" => a - b,
                "multiply" => a * b,
                "divide" => a / b,
                _ => panic!("Unknown operation"),
            };
            
            let function_response = json!({
                "result": result,
            }).to_string();
            
            // Continue the conversation with the function result
            let final_response = client
                .generate_content()
                .with_user_message("What is the current Google stock price multiplied by 2?")
                .with_function_response_str("calculate", function_response)?
                .execute()
                .await?;
            
            println!("Final response: {}", final_response.text());
        } else {
            println!("Unknown function call: {}", function_call.name);
        }
    } else {
        println!("No function calls in the response.");
        println!("Direct response: {}", response.text());
    }

    Ok(())
}

examples/simple.rs (line 68)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY")
        .expect("GEMINI_API_KEY environment variable not set");

    // Create client
    let client = Gemini::new(api_key);

    // Simple generation
    println!("--- Simple generation ---");
    let response = client
        .generate_content()
        .with_system_prompt("You are a helpful assistant.")
        .with_user_message("Hello, can you tell me a joke about programming?")
        .with_generation_config(
            GenerationConfig {
                temperature: Some(0.7),
                max_output_tokens: Some(100),
                ..Default::default()
            }
        )
        .execute()
        .await?;

    println!("Response: {}", response.text());

    // Function calling example
    println!("\n--- Function calling example ---");
    
    // Define a weather function
    let get_weather = FunctionDeclaration::new(
        "get_weather",
        "Get the current weather for a location",
        FunctionParameters::object()
            .with_property(
                "location",
                PropertyDetails::string("The city and state, e.g., San Francisco, CA"),
                true,
            )
            .with_property(
                "unit",
                PropertyDetails::enum_type(
                    "The unit of temperature", 
                    ["celsius", "fahrenheit"]
                ),
                false,
            ),
    );

    // Create a request with function calling
    let response = client
        .generate_content()
        .with_system_prompt("You are a helpful weather assistant.")
        .with_user_message("What's the weather like in San Francisco right now?")
        .with_function(get_weather)
        .with_function_calling_mode(FunctionCallingMode::Any)
        .execute()
        .await?;

    // Check if there are function calls
    if let Some(function_call) = response.function_calls().first() {
        println!(
            "Function call: {} with args: {}",
            function_call.name,
            function_call.args
        );

        // Get parameters from the function call
        let location: String = function_call.get("location")?;
        let unit = function_call.get::<String>("unit").unwrap_or_else(|_| String::from("celsius"));
        
        println!("Location: {}, Unit: {}", location, unit);
        
        // Simulate function execution
        let weather_response = format!(
            "{{\"temperature\": 22, \"unit\": \"{}\", \"condition\": \"sunny\"}}",
            unit
        );

        // Continue the conversation with the function result
        let final_response = client
            .generate_content()
            .with_system_prompt("You are a helpful weather assistant.")
            .with_user_message("What's the weather like in San Francisco right now?")
            .with_function_response_str("get_weather", weather_response)?
            .with_generation_config(
                GenerationConfig {
                    temperature: Some(0.7),
                    max_output_tokens: Some(100),
                    ..Default::default()
                }
            )
            .execute()
            .await?;

        println!("Final response: {}", final_response.text());
    } else {
        println!("No function calls in the response.");
    }

    Ok(())
}

examples/tools.rs (line 78)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY")
        .expect("GEMINI_API_KEY environment variable not set");

    // Create client
    let client = Gemini::new(api_key);

    println!("--- Tools example with multiple functions ---");
    
    // Define a weather function
    let get_weather = FunctionDeclaration::new(
        "get_weather",
        "Get the current weather for a location",
        FunctionParameters::object()
            .with_property(
                "location",
                PropertyDetails::string("The city and state, e.g., San Francisco, CA"),
                true,
            )
            .with_property(
                "unit",
                PropertyDetails::enum_type(
                    "The unit of temperature", 
                    ["celsius", "fahrenheit"]
                ),
                false,
            ),
    );
    
    // Define a calculator function
    let calculate = FunctionDeclaration::new(
        "calculate",
        "Perform a calculation",
        FunctionParameters::object()
            .with_property(
                "operation",
                PropertyDetails::enum_type(
                    "The mathematical operation to perform",
                    ["add", "subtract", "multiply", "divide"]
                ),
                true,
            )
            .with_property(
                "a",
                PropertyDetails::number("The first number"),
                true,
            )
            .with_property(
                "b",
                PropertyDetails::number("The second number"),
                true,
            ),
    );
    
    // Create a tool with multiple functions
    let tool = Tool::with_functions(vec![get_weather, calculate]);

    // Create a request with tool functions
    let response = client
        .generate_content()
        .with_system_prompt("You are a helpful assistant that can check weather and perform calculations.")
        .with_user_message("What's 42 times 12?")
        .with_tool(tool)
        .with_function_calling_mode(FunctionCallingMode::Any)
        .execute()
        .await?;

    // Process function calls
    if let Some(function_call) = response.function_calls().first() {
        println!(
            "Function call: {} with args: {}",
            function_call.name,
            function_call.args
        );
        
        // Handle different function calls
        match function_call.name.as_str() {
            "calculate" => {
                let operation: String = function_call.get("operation")?;
                let a: f64 = function_call.get("a")?;
                let b: f64 = function_call.get("b")?;
                
                println!("Calculation: {} {} {}", a, operation, b);
                
                let result = match operation.as_str() {
                    "add" => a + b,
                    "subtract" => a - b,
                    "multiply" => a * b,
                    "divide" => a / b,
                    _ => panic!("Unknown operation"),
                };
                
                let function_response = json!({
                    "result": result,
                }).to_string();
                
                // Continue the conversation with the function result
                let final_response = client
                    .generate_content()
                    .with_system_prompt("You are a helpful assistant that can check weather and perform calculations.")
                    .with_user_message("What's 42 times 12?")
                    .with_function_response_str("calculate", function_response)?
                    .execute()
                    .await?;
                
                println!("Final response: {}", final_response.text());
            },
            "get_weather" => {
                let location: String = function_call.get("location")?;
                let unit = function_call.get::<String>("unit").unwrap_or_else(|_| String::from("celsius"));
                
                println!("Weather request for: {}, Unit: {}", location, unit);
                
                let weather_response = json!({
                    "temperature": 22,
                    "unit": unit,
                    "condition": "sunny"
                }).to_string();
                
                // Continue the conversation with the function result
                let final_response = client
                    .generate_content()
                    .with_system_prompt("You are a helpful assistant that can check weather and perform calculations.")
                    .with_user_message("What's 42 times 12?")
                    .with_function_response_str("get_weather", weather_response)?
                    .execute()
                    .await?;
                
                println!("Final response: {}", final_response.text());
            },
            _ => println!("Unknown function"),
        }
    } else {
        println!("No function calls in the response.");
        println!("Response: {}", response.text());
    }

    Ok(())
}

Trait Implementations

impl Clone for GenerationResponse

fn clone(&self) -> GenerationResponse

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GenerationResponse

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GenerationResponse

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GenerationResponse

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.