Enum Part 

pub enum Part {
    Thought {
        text: String,
        thought: bool,
    },
    Text {
        text: String,
    },
    InlineData {
        inline_data: Blob,
    },
    FunctionCall {
        function_call: FunctionCall,
    },
    FunctionResponse {
        function_response: FunctionResponse,
    },
    ExecutableCode {
        executable_code: ExecutableCode,
    },
    CodeExecutionResult {
        code_execution_result: CodeExecutionResult,
    },
}

A single part of a Content message. Parts are polymorphic — discriminated by field presence, not a type tag.

Deserialization reads the part’s fields once and picks the variant by the same precedence #[serde(untagged)] uses (thought, text, inline data, function call, function response, executable code, code execution result); see the Deserialize impl below.

Variants

Thought

A thought/reasoning part from the model (when includeThoughts is enabled).

Fields

text: String

The thought content.

thought: bool

Always true for thought parts.

Text

A text part.

Fields

text: String

The text content.

InlineData

An inline data blob (audio, image, etc.).

Fields

inline_data: Blob

The blob data.

FunctionCall

A function call from the model.

Fields

function_call: FunctionCall

The function call details.

FunctionResponse

A function response sent back to the model.

Fields

function_response: FunctionResponse

The function response details.

ExecutableCode

Executable code returned by the model.

Fields

executable_code: ExecutableCode

The executable code details.

CodeExecutionResult

Result of code execution.

Fields

code_execution_result: CodeExecutionResult

The code execution result details.

Implementations

impl Part

pub fn text(s: impl Into<String>) -> Part

Create a text part.

Examples

use gemini_genai_rs::protocol::types::Part;

let part = Part::text("Hello, world!");

pub fn thought(s: impl Into<String>) -> Part

Create a thought part.

pub fn inline_data( mime_type: impl Into<String>, data: impl Into<String>, ) -> Part

Create an inline data part (e.g. audio or image blob).

Examples

use gemini_genai_rs::protocol::types::Part;

let audio = Part::inline_data("audio/pcm", "AQIDBA==");
let image = Part::inline_data("image/jpeg", "/9j/4AAQ...");

pub fn function_call(call: FunctionCall) -> Part

Create a function call part.

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<(), Error>

Formats the value using the given formatter.

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

fn deserialize<D>( deserializer: D, ) -> Result<Part, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

One pass over the part’s fields.

#[serde(untagged)] buffered every part into an intermediate tree and then tried each variant in turn, allocating an error for each miss; on an audio part that meant copying the base64 payload twice and failing twice before reaching InlineData. This reads the fields directly and chooses the first variant whose fields are present, the same choice untagged makes for any part the API sends. Unknown fields (such as thoughtSignature) are ignored, as before.

impl PartialEq for Part

fn eq(&self, other: &Part) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Part

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Part