Enum ContentPart 

#[non_exhaustive]
pub enum ContentPart {
    Text {
        text: String,
    },
    Image {
        source: ImageSource,
    },
    Document {
        source: DocumentSource,
    },
    ToolCall(ToolCall),
    ToolResult(ToolResult),
}

One piece of a message.

A message is a sequence of parts rather than a string because a turn can legitimately mix prose, an attachment and the tool exchange that preceded it.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Text

Plain text.

Fields

text: String

The text.

Image

An image. Requires vision.

Fields

source: ImageSource

Where the bytes come from.

Document

A document — a PDF, a spreadsheet, a plain-text attachment. Requires documents, which is declared separately from vision because accepting a PNG says nothing about accepting a PDF.

Fields

source: DocumentSource

Where the bytes come from, and what they are.

ToolCall(ToolCall)

A call the model made (in an assistant message).

ToolResult(ToolResult)

A result the runtime returned (in a tool message).

Implementations

impl ContentPart

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

A text part.

pub fn image_url(url: impl Into<String>) -> Self

An image fetched by the provider from a URL.

pub fn image_base64( media_type: impl Into<String>, data: impl Into<String>, ) -> Self

An inline image.

pub fn inline_bytes(media_type: impl Into<String>, bytes: &[u8]) -> Self

An inline part built from raw bytes, encoded here.

Which of the two it becomes is decided by the media type, because the distinction the provider layer draws is exactly that one: image/* is an image, everything else is a document. A caller holding bytes should not have to know that accepting a PNG says nothing about accepting a PDF — the capability requirements are derived from the part, so the router does that part.

Every inline form in this module takes base64 without a data-URI prefix, which is a rule a caller can only get wrong. So the encoding lives here, beside the contract that asks for it, rather than in every application that has a file.

pub fn document_url( url: impl Into<String>, media_type: impl Into<String>, ) -> Self

A document the provider fetches from a URL, with its media type stated.

pub fn document_base64( media_type: impl Into<String>, data: impl Into<String>, ) -> Self

An inline document.

pub fn as_text(&self) -> Option<&str>

Borrows the text, when this is a text part.

pub fn as_tool_call(&self) -> Option<&ToolCall>

Borrows the call, when this is a tool call.

pub fn as_document(&self) -> Option<&DocumentSource>

Borrows the source, when this is a document part.

pub const fn kind(&self) -> &'static str

Stable snake-case label of the part kind.

Trait Implementations

impl Clone for ContentPart

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ContentPart

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ContentPart

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ContentPart

impl PartialEq for ContentPart

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ContentPart

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ContentPart