Struct TypedModel 

pub struct TypedModel<'c, T> { /* private fields */ }

Type-safe wrapper for GenerativeModel guaranteeing response type T.

This type enforces schema contracts through Rust’s type system while maintaining compatibility with Google’s Generative AI API. Use when:

• You need structured output from the model
• Response schema stability is critical
• You want compile-time validation of response handling

Example

use google_ai_rs::{Client, GenerativeModel, AsSchema};

#[derive(AsSchema)]
struct Recipe {
    name: String,
    ingredients: Vec<String>,
}

let client = Client::new(auth).await?;
let model = client.typed_model::<Recipe>("gemini-pro");

Implementations

impl<'c, T> TypedModel<'c, T>

where T: AsSchema,

pub fn new(client: &'c Client, name: &str) -> Self

Creates a new typed model configured to return responses of type T.

Arguments

• client: Authenticated API client.
• name: Model name (e.g., “gemini-pro”).

pub async fn generate_typed_content<I>( &self, contents: I, ) -> Result<TypedResponse<T>, Error>

where I: TryIntoContents + Send, T: TryFromCandidates + Send,

Generates content with full response metadata.

This method clones the model configuration and returns a TypedResponse, containing both the parsed T and the raw API response.

Example

let model = TypedModel::<StockAnalysis>::new(&client, "gemini-pro");
let analysis: TypedResponse<StockAnalysis> = model.generate_typed_content((
    "Analyze NVDA stock performance",
    "Consider PE ratio and recent earnings"
)).await?;
println!("Analysis: {:?}", analysis.t);
println!("Token Usage: {:?}", analysis.raw.usage_metadata);

pub async fn generate_typed_content_consuming<I>( self, contents: I, ) -> Result<TypedResponse<T>, Error>

where I: TryIntoContents + Send, T: TryFromCandidates + Send,

Generates content with metadata, consuming the model instance.

An efficient alternative to generate_typed_content that avoids cloning the model configuration, useful for one-shot requests.

pub async fn generate_content<I>(&self, contents: I) -> Result<T, Error>

where I: TryIntoContents + Send, T: TryFromCandidates + Send,

Generates content and parses it directly into type T.

This is the primary method for most users wanting type-safe responses. It handles all the details of requesting structured JSON and deserializing it into your specified Rust type. It clones the model configuration to allow reuse.

Serde Integration

When the serde feature is enabled, any type implementing serde::Deserialize automatically works with this method. Just define your response structure and let the library handle parsing.

Example: Simple JSON Response

#[derive(AsSchema, Deserialize)]
struct StoryResponse {
    title: String,
    length: usize,
    tags: Vec<String>,
}

let model = TypedModel::<StoryResponse>::new(&client, "gemini-pro");
let story = model.generate_content("Write a short story about a robot astronaut").await?;

println!("{} ({} words)", story.title, story.length);

Example: Multi-part Input

#[derive(AsSchema, Deserialize)]
struct Analysis { safety_rating: u8 }

let model = TypedModel::<Analysis>::new(&client, "gemini-pro-vision");
let analysis = model.generate_content((
    "Analyze this scene safety:",
    Part::blob("image/jpeg", image_data),
    "Consider vehicles, pedestrians, and weather"
)).await?;

Errors

Returns an error if API communication fails or if the response cannot be parsed into type T.

pub async fn generate_content_consuming<I>( self, contents: I, ) -> Result<T, Error>

where I: TryIntoContents + Send, T: TryFromCandidates + Send,

pub fn into_inner(self) -> GenerativeModel<'c>

Consumes the TypedModel, returning the underlying GenerativeModel.

The returned GenerativeModel will retain the response schema configuration that was set for type T.

pub unsafe fn from_inner_unchecked(inner: GenerativeModel<'c>) -> Self

Creates a TypedModel from a GenerativeModel without validation.

This is an advanced-use method that assumes the provided GenerativeModel has already been configured with a response schema that is compatible with T.

Safety

The caller must ensure that inner.generation_config.response_schema is Some and that its schema corresponds exactly to the schema of type T. Failure to uphold this invariant will likely result in API errors or deserialization failures.

Methods from Deref<Target = GenerativeModel<'c>>

pub fn start_chat(&self) -> Session<'_>

Starts a new chat session with empty history

pub async fn generate_content<T>( &self, contents: T, ) -> Result<GenerateContentResponse, Error>

where T: TryIntoContents,

Generates content from flexible input types.

This method clones the model’s configuration for the request, allowing the original GenerativeModel instance to be reused.

Example

use google_ai_rs::Part;

// Simple text generation
let response = model.generate_content("Hello world!").await?;

// Multi-part content
model.generate_content((
    "What's in this image?",
    Part::blob("image/jpeg", image_data)
)).await?;

Errors

Returns Error::Service for model errors or Error::Net for transport failures.

pub async fn typed_generate_content<I, T>( &self, contents: I, ) -> Result<T, Error>

where I: TryIntoContents + Send, T: AsSchema + TryFromCandidates + Send,

A convenience method to generate a structured response of type T.

This method internally converts the GenerativeModel to a TypedModel<T>, makes the request, and returns the parsed result directly. It clones the model configuration for the request.

For repeated calls with the same target type, it may be more efficient to create a TypedModel instance directly.

pub async fn generate_typed_content<I, T>( &self, contents: I, ) -> Result<TypedResponse<T>, Error>

where I: TryIntoContents + Send, T: AsSchema + TryFromCandidates + Send,

A convenience method to generate a structured response with metadata.

Similar to typed_generate_content, but returns a TypedResponse<T> which includes both the parsed data and the raw API response metadata.

pub async fn stream_generate_content<T>( &self, contents: T, ) -> Result<ResponseStream, Error>

where T: TryIntoContents,

Generates a streaming response from flexible input.

This method clones the model’s configuration for the request, allowing the original GenerativeModel instance to be reused.

Example

let mut stream = model.stream_generate_content("Tell me a story.").await?;
while let Some(chunk) = stream.next().await? {
    // Process streaming response
}

Errors

Returns Error::Service for model errors or Error::Net for transport failures.

pub async fn count_tokens<T>( &self, contents: T, ) -> Result<CountTokensResponse, Error>

where T: TryIntoContents,

Estimates token usage for given content

Useful for cost estimation and validation before full generation

Arguments

• parts - Content input that can be converted to parts

Example

let token_count = model.count_tokens(content).await?;
println!("Estimated cost: ${}", token_count.total() * COST_PER_TOKEN);

pub async fn info(&self) -> Result<Info, Error>

info returns information about the model.

Info::Tuned if the current model is a fine-tuned one, otherwise Info::Model.

pub fn full_name(&self) -> &str

Returns the full identifier of the model, including any models/ prefix.

pub fn with_cloned_instruction<I: IntoContent>(&self, instruction: I) -> Self

Creates a copy with new system instructions

Trait Implementations

impl<T> Clone for TypedModel<'_, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for TypedModel<'_, T>

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

Formats the value using the given formatter.

impl<'c, T> Deref for TypedModel<'c, T>

type Target = GenerativeModel<'c>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'c, T> From<GenerativeModel<'c>> for TypedModel<'c, T>

where T: AsSchema,

fn from(value: GenerativeModel<'c>) -> Self

Converts to this type from the input type.