Struct Part 

pub struct Part {
    pub video_metadata: Option<VideoMetadata>,
    pub code_execution_result: Option<CodeExecutionResult>,
    pub executable_code: Option<ExecutableCode>,
    pub file_data: Option<FileData>,
    pub function_call: Option<FunctionCall>,
    pub function_response: Option<FunctionResponse>,
    pub inline_data: Option<Blob>,
    pub text: Option<String>,
}

Fields

video_metadata: Option<VideoMetadata>

code_execution_result: Option<CodeExecutionResult>

executable_code: Option<ExecutableCode>

file_data: Option<FileData>

function_call: Option<FunctionCall>

function_response: Option<FunctionResponse>

inline_data: Option<Blob>

text: Option<String>

Implementations

impl Part

pub fn video_metadata(self, value: impl Into<VideoMetadata>) -> Self

Sets the video_metadata field of this struct.

pub fn code_execution_result( self, value: impl Into<CodeExecutionResult>, ) -> Self

Sets the code_execution_result field of this struct.

pub fn executable_code(self, value: impl Into<ExecutableCode>) -> Self

Sets the executable_code field of this struct.

pub fn file_data(self, value: impl Into<FileData>) -> Self

Sets the file_data field of this struct.

pub fn function_call(self, value: impl Into<FunctionCall>) -> Self

Sets the function_call field of this struct.

pub fn function_response(self, value: impl Into<FunctionResponse>) -> Self

Sets the function_response field of this struct.

pub fn inline_data(self, value: impl Into<Blob>) -> Self

Sets the inline_data field of this struct.

pub fn text(self, value: impl Into<String>) -> Self

Sets the text field of this struct.

Examples found in repository

examples/req.rs (line 11)

async fn main() -> google_genai::error::Result<()> {
    let api_key = std::env::var("GOOGLEAI_API_KEY")
        .expect("GOOGLEAI_API_KEY environment variable must be set");

    let params = GenerateContentParameters::default()
        .contents(vec![Content {
            parts: Some(vec![
                Part::default().text("Tell me a joke about programming.")
            ]),
            role: Some("user".to_string()),
        }])
        .model("gemini-exp-1206");

    let request = google_genai::datatypes::GenerateContentReq::default()
        .contents(params.contents.unwrap())
        .model(params.model.unwrap());

    let response = google_genai::generate_content(&api_key, request).await?;

    println!("Response: {:#?}", response);

    Ok(())
}

examples/strm.rs (line 11)

async fn main() -> google_genai::error::Result<()> {
    let api_key = env::var("GOOGLEAI_API_KEY").expect("GOOGLE_API_KEY must be set");

    let params =
        GenerateContentParameters::default().contents(vec![Content::default().parts(vec![
            Part::default().text("Write a story about a magic backpack."),
        ])]);

    let request = google_genai::datatypes::GenerateContentReq::default()
        .contents(params.contents.unwrap())
        .model(params.model.unwrap());

    let mut stream = google_genai::generate_content_stream(&api_key, request).await?;

    while let Some(response) = stream.next().await {
        match response {
            Ok(content) => {
                if content.candidates.is_none() {
                    // This is our [DONE] marker
                    break;
                }
                if let Some(candidates) = content.candidates {
                    for candidate in candidates {
                        if let Some(content) = candidate.content {
                            if let Some(parts) = content.parts {
                                for part in parts {
                                    if let Some(text) = part.text {
                                        print!("{}", text);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            Err(e) => eprintln!("Error: {}", e),
        }
    }

    Ok(())
}

Trait Implementations

impl Clone for Part

fn clone(&self) -> Part

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Part

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

Formats the value using the given formatter.

impl Default for Part

fn default() -> Part

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Part

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Part

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

where __S: Serializer,

Serialize this value into the given Serde serializer.