Struct FunctionDeclaration 

pub struct FunctionDeclaration {
    pub name: String,
    pub description: String,
    pub parameters: FunctionParameters,
}

Declaration of a function that can be called by the model

Fields

name: String

The name of the function

description: String

The description of the function

parameters: FunctionParameters

The parameters for the function

Implementations

impl FunctionDeclaration

pub fn new( name: impl Into<String>, description: impl Into<String>, parameters: FunctionParameters, ) -> Self

Create a new function declaration

Examples found in repository

examples/advanced.rs (lines 16-30)

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 = Some(vec![Part::FunctionCall {
            function_call: (*function_call).clone(),
        }]);
        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/simple.rs (lines 34-48)

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_user_message("Hello, can you tell me a joke about programming?")
        .with_generation_config(GenerationConfig {
            temperature: Some(0.7),
            max_output_tokens: Some(1000),
            ..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);

        // Create model content with function call
        let model_content = Content::function_call((*function_call).clone());

        // Add as model message
        let model_message = Message {
            content: model_content,
            role: Role::Model,
        };

        // 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_message(model_message)
            .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/google_search_with_functions.rs (lines 19-46)

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!("--- Meeting Scheduler Function Calling example ---");

    // Define a meeting scheduler function that matches the curl example
    let schedule_meeting = FunctionDeclaration::new(
        "schedule_meeting",
        "Schedules a meeting with specified attendees at a given time and date.",
        FunctionParameters::object()
            .with_property(
                "attendees",
                PropertyDetails::array(
                    "List of people attending the meeting.",
                    PropertyDetails::string("Attendee name"),
                ),
                true,
            )
            .with_property(
                "date",
                PropertyDetails::string("Date of the meeting (e.g., '2024-07-29')"),
                true,
            )
            .with_property(
                "time",
                PropertyDetails::string("Time of the meeting (e.g., '15:00')"),
                true,
            )
            .with_property(
                "topic",
                PropertyDetails::string("The subject or topic of the meeting."),
                true,
            ),
    );

    // Create function tool
    let function_tool = Tool::new(schedule_meeting);

    // Create a request with the tool - matching the curl example
    let response = client
        .generate_content()
        .with_user_message("Schedule a meeting with Bob and Alice for 03/27/2025 at 10:00 AM about the Q3 planning.")
        .with_tool(function_tool.clone())
        .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 schedule_meeting function
        if function_call.name == "schedule_meeting" {
            let attendees: Vec<String> = function_call.get("attendees")?;
            let date: String = function_call.get("date")?;
            let time: String = function_call.get("time")?;
            let topic: String = function_call.get("topic")?;

            println!("Scheduling meeting:");
            println!("  Attendees: {:?}", attendees);
            println!("  Date: {}", date);
            println!("  Time: {}", time);
            println!("  Topic: {}", topic);

            // Simulate scheduling the meeting
            let meeting_id = format!(
                "meeting_{}",
                std::time::SystemTime::now()
                    .duration_since(std::time::UNIX_EPOCH)
                    .unwrap()
                    .as_secs()
            );

            let function_response = json!({
                "success": true,
                "meeting_id": meeting_id,
                "message": format!("Meeting '{}' scheduled for {} at {} with {:?}", topic, date, time, attendees)
            });

            // Create conversation with function response
            let mut conversation = client.generate_content();

            // 1. Add original user message
            conversation = conversation
                .with_user_message("Schedule a meeting with Bob and Alice for 03/27/2025 at 10:00 AM about the Q3 planning.");

            // 2. Add model message with function call
            let model_function_call =
                FunctionCall::new("schedule_meeting", function_call.args.clone());
            let model_content = Content::function_call(model_function_call).with_role(Role::Model);
            let model_message = Message {
                content: model_content,
                role: Role::Model,
            };
            conversation = conversation.with_message(model_message);

            // 3. Add function response
            conversation =
                conversation.with_function_response("schedule_meeting", function_response);

            // Execute final request
            let final_response = conversation.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/thinking_advanced.rs (lines 57-73)

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::with_model(api_key, "models/gemini-2.5-pro".to_string());

    println!("=== Gemini 2.5 Thinking Advanced Example ===\n");

    // Example 1: Streaming with thinking
    println!("--- Example 1: Streaming with thinking ---");
    let mut stream = client
        .generate_content()
        .with_system_prompt("You are a mathematics expert skilled at solving complex mathematical problems.")
        .with_user_message("Solve this math problem: Find the sum of the first 50 prime numbers. Please explain your solution process in detail.")
        .with_thinking_budget(2048)
        .with_thoughts_included(true)
        .execute_stream()
        .await?;

    println!("Streaming response:");
    let mut thoughts_shown = false;
    while let Some(chunk_result) = stream.next().await {
        match chunk_result {
            Ok(chunk) => {
                // Check if there's thinking content
                let thoughts = chunk.thoughts();
                if !thoughts.is_empty() && !thoughts_shown {
                    println!("\nThinking process:");
                    for (i, thought) in thoughts.iter().enumerate() {
                        println!("Thought {}: {}", i + 1, thought);
                    }
                    println!("\nAnswer:");
                    thoughts_shown = true;
                }

                // Display general text content
                print!("{}", chunk.text());
                std::io::Write::flush(&mut std::io::stdout())?;
            }
            Err(e) => eprintln!("Streaming error: {}", e),
        }
    }
    println!("\n");

    // Example 2: Thinking combined with function calls
    println!("--- Example 2: Thinking combined with function calls ---");

    // Define a calculator function
    let calculator = FunctionDeclaration::new(
        "calculate",
        "Perform basic mathematical calculations",
        FunctionParameters::object()
            .with_property(
                "expression",
                PropertyDetails::string(
                    "The mathematical expression to calculate, e.g., '2 + 3 * 4'",
                ),
                true,
            )
            .with_property(
                "operation_type",
                PropertyDetails::enum_type("Type of calculation", ["arithmetic", "advanced"]),
                false,
            ),
    );

    let response = client
        .generate_content()
        .with_system_prompt("You are a mathematics assistant. When calculations are needed, use the provided calculator function.")
        .with_user_message("Calculate the result of (15 + 25) * 3 - 8 and explain the calculation steps.")
        .with_function(calculator)
        .with_thinking_budget(1024)
        .with_thoughts_included(true)
        .execute()
        .await?;

    // Display thinking process
    let thoughts = response.thoughts();
    if !thoughts.is_empty() {
        println!("Thinking process:");
        for (i, thought) in thoughts.iter().enumerate() {
            println!("Thought {}: {}\n", i + 1, thought);
        }
    }

    // Check for function calls
    let function_calls = response.function_calls();
    if !function_calls.is_empty() {
        println!("Function calls:");
        for (i, call) in function_calls.iter().enumerate() {
            println!("Call {}: {} Args: {}", i + 1, call.name, call.args);
        }
        println!();
    }

    println!("Answer: {}\n", response.text());

    // Example 3: Complex reasoning task
    println!("--- Example 3: Complex reasoning task ---");
    let complex_response = client
        .generate_content()
        .with_system_prompt("You are a logical reasoning expert.")
        .with_user_message(
            "There are three people: Alice, Bob, and Carol, who live in red, green, and blue houses respectively.\
            Given:\
            1. The person in the red house owns a cat\
            2. Bob does not live in the green house\
            3. Carol owns a dog\
            4. The green house is to the left of the red house\
            5. Alice does not own a cat\
            Please reason out which color house each person lives in and what pets they own.",
        )
        .with_thinking_config(
            ThinkingConfig::new()
                .with_thinking_budget(3072)
                .with_thoughts_included(true),
        )
        .execute()
        .await?;

    // Display thinking process
    let complex_thoughts = complex_response.thoughts();
    if !complex_thoughts.is_empty() {
        println!("Reasoning process:");
        for (i, thought) in complex_thoughts.iter().enumerate() {
            println!("Reasoning step {}: {}\n", i + 1, thought);
        }
    }

    println!("Conclusion: {}\n", complex_response.text());

    // Display token usage statistics
    if let Some(usage) = &complex_response.usage_metadata {
        println!("Token usage statistics:");
        println!("  Prompt tokens: {}", usage.prompt_token_count);
        println!(
            "  Response tokens: {}",
            usage.candidates_token_count.unwrap_or(0)
        );
        if let Some(thinking_tokens) = usage.thoughts_token_count {
            println!("  Thinking tokens: {}", thinking_tokens);
        }
        println!("  Total tokens: {}", usage.total_token_count);
    }

    Ok(())
}

examples/tools.rs (lines 19-33)

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();

                // Based on the curl example, we need to structure the conversation properly:
                // 1. A user message with the original query
                // 2. A model message containing the function call
                // 3. A user message containing the function response

                // Construct conversation following the exact curl pattern
                let mut conversation = client.generate_content();

                // 1. Add user message with original query and system prompt
                conversation = conversation
                    .with_system_prompt("You are a helpful assistant that can check weather and perform calculations.")
                    .with_user_message("What's 42 times 12?");

                // 2. Create model content with function call
                let model_content = Content::function_call((*function_call).clone());

                // Add as model message
                let model_message = Message {
                    content: model_content,
                    role: Role::Model,
                };
                conversation = conversation.with_message(model_message);

                // 3. Add user message with function response
                conversation =
                    conversation.with_function_response_str("calculate", function_response)?;

                // Execute the request
                let final_response = conversation.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();

                // Based on the curl example, we need to structure the conversation properly:
                // 1. A user message with the original query
                // 2. A model message containing the function call
                // 3. A user message containing the function response

                // Construct conversation following the exact curl pattern
                let mut conversation = client.generate_content();

                // 1. Add user message with original query and system prompt
                conversation = conversation
                    .with_system_prompt("You are a helpful assistant that can check weather and perform calculations.")
                    .with_user_message("What's 42 times 12?");

                // 2. Create model content with function call
                let model_content = Content::function_call((*function_call).clone());

                // Add as model message
                let model_message = Message {
                    content: model_content,
                    role: Role::Model,
                };
                conversation = conversation.with_message(model_message);

                // 3. Add user message with function response
                conversation =
                    conversation.with_function_response_str("get_weather", weather_response)?;

                // Execute the request
                let final_response = conversation.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 FunctionDeclaration

fn clone(&self) -> FunctionDeclaration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FunctionDeclaration

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FunctionDeclaration

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FunctionDeclaration

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

where __S: Serializer,

Serialize this value into the given Serde serializer.