Struct Part 

pub struct Part {
    pub mime_type: MimeType,
    pub body: PartBody,
    pub name: Option<String>,
    pub deliver: Option<Delivery>,
}

One typed piece of content.

A region entry, a tool output, a user message, a model reply and a final output are each a list of these. Text is a part like any other; its body is inline because its registry row says it is text, and that is the whole difference.

Fields

mime_type: MimeType

The part’s type.

body: PartBody

Its bytes, inline or by reference.

name: Option<String>

A name: the file it came from, the artifact it is, what @name finds.

deliver: Option<Delivery>

How a stored part reaches a model, when the default is not wanted.

Implementations

impl Part

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

A text/plain part.

pub fn inline(mime_type: MimeType, s: impl Into<String>) -> Self

An inline part of any text-family type.

pub fn stored(blob: BlobRef) -> Self

A stored part from its reference.

pub fn named(self, name: impl Into<String>) -> Self

The same part, named.

pub fn delivered(self, deliver: Delivery) -> Self

The same part, with a delivery override.

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

The inline text, if this part carries any.

pub fn blob(&self) -> Option<&BlobRef>

The reference, if this part is stored.

pub fn is_stored(&self) -> bool

Whether this part’s bytes are in the store rather than inline.

pub fn is_named(&self, needle: &str) -> bool

Whether needle, as a model or a person would type it, names this stored part: its exact name, the file name of a path-shaped needle (out/hero.png for hero.png), or at least six characters of its hash in either case. One rule for every tool that takes a part by name, so context_export and submit_output cannot disagree about which part hero means. An inline part is never named.

pub fn tokens(&self, reg: &MimeRegistry) -> usize

What this part costs a region.

A stored part is charged its stand-in, not its native token estimate. In a region a stored blob is only a reference plus the short stand-in line that stands for it in the assembled prompt; the native estimate on the blob ref (a per-byte rule over a multi-megabyte model is millions of tokens) is the cost of sending the bytes to a model that can read them, charged at request-build time. Charged here instead, no reasonably sized region could hold real media at all.

pub fn stand_in(&self) -> String

The text a consumer that cannot take a stored part sees, as rendered at ingest. An inline part’s stand-in is its own text.

pub fn handle(&self) -> Option<String>

The name this part answers to for an @name or tool-argument lookup: its name, else its short hash for a stored 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

Formats the value using the given formatter.

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 Eq for Part

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::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Part