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/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(())
}

examples/streaming.rs (line 28)

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 streaming generation
    println!("--- Streaming generation ---");
    
    let mut stream = client
        .generate_content()
        .with_system_prompt("You are a helpful, creative assistant.")
        .with_user_message("Write a short story about a robot who learns to feel emotions.")
        .execute_stream()
        .await?;

    print!("Streaming response: ");
    while let Some(chunk_result) = stream.next().await {
        match chunk_result {
            Ok(chunk) => {
                print!("{}", chunk.text());
                std::io::Write::flush(&mut std::io::stdout())?;
            }
            Err(e) => eprintln!("Error in stream: {}", e),
        }
    }
    println!("\n");

    // Multi-turn conversation
    println!("--- Multi-turn conversation ---");
    
    // First turn
    let response1 = client
        .generate_content()
        .with_system_prompt("You are a helpful travel assistant.")
        .with_user_message("I'm planning a trip to Japan. What are the best times to visit?")
        .execute()
        .await?;

    println!("User: I'm planning a trip to Japan. What are the best times to visit?");
    println!("Assistant: {}\n", response1.text());

    // Second turn (continuing the conversation)
    let response2 = client
        .generate_content()
        .with_system_prompt("You are a helpful travel assistant.")
        .with_user_message("I'm planning a trip to Japan. What are the best times to visit?")
        .with_model_message(response1.text())
        .with_user_message("What about cherry blossom season? When exactly does that happen?")
        .execute()
        .await?;

    println!("User: What about cherry blossom season? When exactly does that happen?");
    println!("Assistant: {}\n", response2.text());

    // Third turn (continuing the conversation)
    let response3 = client
        .generate_content()
        .with_system_prompt("You are a helpful travel assistant.")
        .with_user_message("I'm planning a trip to Japan. What are the best times to visit?")
        .with_model_message(response1.text())
        .with_user_message("What about cherry blossom season? When exactly does that happen?")
        .with_model_message(response2.text())
        .with_user_message("What are some must-visit places in Tokyo?")
        .execute()
        .await?;

    println!("User: What are some must-visit places in Tokyo?");
    println!("Assistant: {}", response3.text());

    Ok(())
}

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

Get function calls from the response

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.