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.

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>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Part

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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