Struct GenerateContent 

pub struct GenerateContent {
    pub provider: GeminiConfig,
    pub model: String,
    pub cached_content: Option<String>,
    pub thought_replay: ThoughtReplay,
}

Completion wire for unary generateContent and SSE streamGenerateContent. Both modes use GenerateContentDecoder.

Fields

provider: GeminiConfig

The key and the API root.

model: String

The model to address, e.g. GEMINI_2_5_FLASH.

cached_content: Option<String>

Handle of a cachedContents resource every request reads its prefix from. See Self::with_cached_content.

thought_replay: ThoughtReplay

Which thought signatures requests re-send. See ThoughtReplay.

Implementations

impl GenerateContent

pub fn new(provider: GeminiConfig, model: impl Into<String>) -> Self

The wire for model.

pub fn thought_replay(self, replay: ThoughtReplay) -> Self

Re-send thought signatures as replay says. See ThoughtReplay.

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

Use an explicit cachedContents/<id> handle as every request’s prefix. Encoding rejects requests with their own system instruction, tools, or tool choice. See crate::providers::gemini::cached_content for cache ownership.

Trait Implementations

impl Clone for GenerateContent

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 GenerateContent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GenerateContent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for GenerateContent

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

Equality operator ==.

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

Inequality operator !=.

impl ReplayTarget for GenerateContent

fn later_system(&self, _model: &str) -> LaterSystem

Gemini takes system text only in systemInstruction: later system messages fold into the leading one, as pi’s collapseSystemMessages.

fn map_options( &self, request: &CompletionRequest, fields: OptionFields<'_>, ) -> OptionMap

Section 6.4 of the typed-options design, for the Gemini API.

fn api(&self) -> Api

The wire format.

fn provider(&self) -> &str

The provider descriptor name.

fn model(&self) -> &str

The model id the wire addresses.

fn accepts(&self, model: &str) -> Accepts

What model, the model a request addresses on this wire, reads. adapt downgrades everything else, so the encoder never sees it.

fn encodes(&self, _model: &str, media: Media<'_>) -> bool

Whether the encoder carries media to model: its source (data, URL, file id or string), its media type, and where it sits. adapt replaces every part this refuses with a placeholder, or a text document with its text, so the encoder never refuses canonical content. Row H9 of the history conformance suite holds every wire to it. By default every form is carried.

fn normalize_tool_call_id( &self, id: &str, model: &str, _source: Option<&Origin>, ) -> String

The id id takes when a call another model made is sent to model on this wire. source is the call’s origin, None for a hand-built turn. Results answering the call are rewritten to match, and an id another call already took is made distinct.

fn call_id_slot(&self) -> Option<&'static str>

Where a tool call’s id sits in this wire’s call item, as a JSON pointer, when it has one. Replay writes the call’s wire id there, so a replayed item and its result always agree, and a call the provider sent without an id keeps its item only on a wire with a slot.

fn declares_tools(&self, request: &CompletionRequest) -> bool

Whether request declares tools to the provider, in tools, in the tools of its additional_params, or through tools the wire adds. A request that declares none gets its history’s calls and results as text. ToolChoice::None still declares them: the wire sends its own none choice beside the tool history.

fn continues_stored(&self, request: &CompletionRequest) -> bool

Whether request continues a conversation the provider stores, such as one naming a previous interaction. Results before the history’s first turn then answer calls the provider holds, so adapt keeps them.

fn identity(&self, item: &Value) -> Map<String, Value>

The keys of a provider item that survive an edit of its block: an encoder rebuilding the edited block keeps them (Replay::Identity). By default none do.

fn states_finish_reason(&self) -> bool

Whether every reply on this wire states why it stopped. A reply that then names no reason failed (pi’s supportsFinishReason); a wire with no finish vocabulary, such as a local runtime, says false.

fn binds_context(&self, model: &str) -> bool

Whether model binds its provider items to the request’s tools and system prompt, so a turn made under another context replays as if from another model.

fn drops_unbound_items(&self, request: &CompletionRequest) -> bool

Whether request asks the provider to drop an item bound to another context itself (Anthropic’s drop_block), so a turn made under another context replays verbatim rather than as another model’s.

fn route(&self, request: &CompletionRequest) -> Option<&dyn ReplayTarget>

The target request is sent to, for a wire that picks its API per request. Preparing the request and folding its reply both read the target this names, so a turn records the API it was made on. None, the default, is this target.

fn takes_documents(&self) -> bool

Whether the encoder sends a request’s documents itself. Otherwise they join the history as text before it is adapted.

fn needs_next(&self, item: &Value) -> bool

Whether this provider item requires the item after it in its turn (Responses reasoning): when that one is not replayed, neither is this.

fn hosted_pair(&self, item: &Value) -> Option<(Pairing, String)>

The hosted-tool pair this opaque item belongs to: whether it is the use or the result, and the id they share. A use and its result replay only together, in one turn or across the model’s turns. A use still running when the last turn ended (a paused turn, or one whose client call the hosted tool made) replays alone.

fn starts_with_user(&self) -> bool

Whether the wire rejects a conversation whose first message after the system prompt is not a user message. adapt then drops the assistant turns before the first user message, with their results.

fn alternates_roles(&self) -> bool

Whether the wire requires user and assistant messages to alternate. adapt then joins two messages of one role that only system messages separate, which move after them.

fn hosted_needs_tools(&self) -> bool

Whether a hosted tool’s use and result need the request to declare tools. A request that declares none then sends neither.

fn result_parts(&self, model: &str) -> bool

Whether model reads a tool result as several parts. When it reads neither parts nor result images, adapt joins a result’s text parts into one.

fn sends_alone(&self, block: &AssistantContent) -> bool

Whether block on its own makes an assistant message this wire sends. A turn with no such block carries nothing, so adapt drops it and the user messages around it become one. By default every block does.

impl Serialize for GenerateContent

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 GenerateContent

impl<T> Transport<GenerateContent> for Caching<T>

where T: Transport<GenerateContent>,

fn send(&self, payload: Encoded, exchange: Exchange) -> Opening<WireFrame>

Open the reply to one payload. Nothing is sent until the opening is first polled. A payload the transport cannot send in the exchange’s mode fails the opening; a failure after the reply opened is its last frame.

impl Wire for GenerateContent

type Op = Completion

The operation this wire performs.

type Payload = Encoded

What Self::encode produces for the transport to send.

type Frame = WireFrame

One unit of a reply, as the transport delivers it.

type Decoder<'id> = GenerateContentDecoder

The decoder for one of its replies, branded with that reply.

type Reassembler = GenerateContentResponse

What rebuilds a reply’s provider document from its frames when the transport reports no whole document, as for a stream. The driver feeds it every frame and records what it finishes with as raw. A wire whose operation’s decoders record raw themselves names document::Unreassembled; a completion wire cannot, because it does not Serve completions.

fn describe(&self) -> Descriptor<'_>

What the wire says about itself.

fn encode( &self, request: CompletionRequest, mode: Mode, ) -> Result<Encoded, EncodeError>

The request to send. Pure: it may read self, request and mode, and nothing else. A request that cannot be built is an EncodeError, which always reports as a request failure.

fn decoder<'id>(&self) -> Self::Decoder<'id>

A fresh decoder for one reply.

fn reassembler(&self) -> Self::Reassembler

A fresh reassembler for one reply. A wire that picks its API per reply builds the matching one.