Models

Overview

T3Router provides access to multiple AI models from different providers through the t3.chat platform. Each model has different capabilities, speeds, and use cases.

Model Discovery

Use the ModelsClient to discover available models:

use t3router::t3::models::ModelsClient;

let cookies = std::env::var("COOKIES")?;
let session_id = std::env::var("CONVEX_SESSION_ID")?;

let models_client = ModelsClient::new(cookies, session_id);
let models = models_client.get_model_statuses().await?;

for model in models {
    println!("{}: {}", model.name, model.description);
}

Method Signature:

pub fn new(cookies: String, convex_session_id: String) -> Self

pub async fn get_model_statuses(&self) -> Result<Vec<ModelStatus>, Box<dyn std::error::Error>>

Model Types

The ModelsClient returns two types of model information:

ModelStatus

Basic model information:

pub struct ModelStatus {
    pub name: String,
    pub indicator: String,
    pub description: String,
}

ModelInfo

Detailed model information:

pub struct ModelInfo {
    pub id: String,
    pub name: String,
    pub provider: String,
    pub developer: String,
    pub short_description: String,
    pub full_description: String,
    pub requires_pro: bool,
    pub premium: bool,
}

Available Models

T3Router supports models from multiple providers:

Text Generation Models

Google Gemini

gemini-2.5-flash

Google’s state of the art fast model. Best balance of speed and quality.

gemini-2.5-flash-lite

Google’s most cost-efficient model. Fastest response times.

let response = client.send(
    "gemini-2.5-flash-lite",
    Some(Message::new(Type::User, "Hello".to_string())),
    Some(config),
).await?;

Anthropic Claude

claude-3.7

Anthropic’s Claude 3.7 Sonnet. Excellent reasoning and coding.

claude-4-sonnet

Anthropic’s Claude 4 Sonnet. Latest generation model.

let response = client.send(
    "claude-4-sonnet",
    Some(Message::new(Type::User, "Explain quantum computing".to_string())),
    Some(config),
).await?;

OpenAI

gpt-o4-mini

OpenAI’s latest small reasoning model. Good for complex problem-solving.

let response = client.send(
    "gpt-o4-mini",
    Some(Message::new(Type::User, "Solve this logic puzzle...".to_string())),
    Some(config),
).await?;

DeepSeek

deepseek-r1-groq

DeepSeek R1 distilled on Llama. Optimized for reasoning tasks.

let response = client.send(
    "deepseek-r1-groq",
    Some(Message::new(Type::User, "Analyze this data...".to_string())),
    Some(config),
).await?;

Image Generation Models

gpt-image-1

OpenAI’s DALL-E based image generation.

gemini-imagen-4

Google’s Imagen 4 model for high-quality image generation.

use std::path::Path;

let save_path = Path::new("output/robot.png");
let response = client.send_with_image_download(
    "gpt-image-1",
    Some(Message::new(Type::User, "Create a happy robot".to_string())),
    Some(config),
    Some(save_path),
).await?;

Model Selection Guide

Use Case Based Selection

Quick responses and general queries

Use gemini-2.5-flash-lite for fastest responses with good quality.

client.send("gemini-2.5-flash-lite", message, config).await?

Complex reasoning and analysis

Use claude-4-sonnet or gpt-o4-mini for deeper reasoning tasks.

client.send("claude-4-sonnet", message, config).await?

Code generation and debugging

Use claude-3.7 or claude-4-sonnet for excellent coding capabilities.

client.send("claude-3.7", message, config).await?

Image generation

Use gpt-image-1 or gemini-imagen-4 depending on style preferences.

client.send_with_image_download("gemini-imagen-4", message, config, save_path).await?

Cost-sensitive applications

Use gemini-2.5-flash-lite for the most efficient token usage.

client.send("gemini-2.5-flash-lite", message, config).await?

Dynamic Model Discovery

The ModelsClient dynamically fetches model information from t3.chat:

let models_client = ModelsClient::new(cookies, session_id);

// Attempts dynamic discovery from t3.chat chunks
let models = models_client.get_model_statuses().await?;

for model in &models {
    println!("ID: {}", model.name);
    println!("Status: {}", model.indicator);
    println!("Description: {}", model.description);
    println!();
}

Fallback Models

If dynamic discovery fails, the client returns a curated list of known models:

gemini-2.5-flash
gemini-2.5-flash-lite
claude-3.7
claude-4-sonnet
gpt-o4-mini
deepseek-r1-groq

Model Naming Conventions

Model names in T3Router follow these patterns:

Provider prefix: gemini-, claude-, gpt-, deepseek-
Version/generation: 2.5, 3.7, 4, r1
Variant: -flash, -lite, -sonnet, -mini
Special suffixes: -groq (for Groq-hosted models), -image-1 (for image models)

Examples:

gemini-2.5-flash-lite → Google Gemini 2.5, Flash variant, Lite version
claude-4-sonnet → Anthropic Claude 4, Sonnet variant
deepseek-r1-groq → DeepSeek R1, hosted on Groq

Switching Models in Conversations

You can use different models within the same conversation:

use t3router::t3::message::ContentType;

client.new_conversation();

// Use Claude for text explanation
let response1 = client.send(
    "claude-4-sonnet",
    Some(Message::new(Type::User, "Explain impressionist art".to_string())),
    Some(config.clone()),
).await?;

// Use Imagen for image generation in same thread
let response2 = client.send(
    "gemini-imagen-4",
    Some(Message::new(Type::User, "Create an impressionist landscape".to_string())),
    Some(config.clone()),
).await?;

if matches!(response2.content_type, ContentType::Image) {
    println!("Generated image based on explanation!");
}

Model Configuration

Some models support additional configuration through the Config struct:

use t3router::t3::config::{Config, ReasoningEffort};

let mut config = Config::new();
config.reasoning_effort = ReasoningEffort::High;
config.include_search = true;

let response = client.send(
    "claude-4-sonnet",
    Some(message),
    Some(config),
).await?;

See the Configuration guide for more details.

Best Practices

Test different models for your use case

Different models excel at different tasks. Benchmark a few models with your specific use case to find the best fit.

Use lite/mini models for prototyping

Start with gemini-2.5-flash-lite during development for faster iteration, then switch to more capable models for production.

Match model to content type

Use text models for text, image models for images. Don’t attempt image generation with text-only models.

Keep fallback models in mind

If a specific model fails or is unavailable, have a fallback model ready in your error handling logic.

Error Handling

let model = "claude-4-sonnet";

match client.send(model, message, config).await {
    Ok(response) => {
        println!("Success with {}: {}", model, response.content);
    },
    Err(e) => {
        eprintln!("Error with {}: {}", model, e);
        // Try fallback model
        let fallback = "gemini-2.5-flash-lite";
        let response = client.send(fallback, message, config).await?;
        println!("Fallback to {}: {}", fallback, response.content);
    }
}

Client - Learn how to use the Client
Messages - Understanding message types
Configuration - Configure model behavior

Get Started

Core Concepts

Guides

Examples

Overview

Model Discovery

Model Types

ModelStatus

ModelInfo

Available Models

Text Generation Models

Google Gemini

gemini-2.5-flash

gemini-2.5-flash-lite

Anthropic Claude

claude-3.7

claude-4-sonnet

OpenAI

gpt-o4-mini

DeepSeek

deepseek-r1-groq

Image Generation Models

gpt-image-1

gemini-imagen-4

Model Selection Guide

Use Case Based Selection

Dynamic Model Discovery

Fallback Models

Model Naming Conventions

Switching Models in Conversations

Model Configuration

Best Practices

Error Handling

​Overview

​Model Discovery

​Model Types

​ModelStatus

​ModelInfo

​Available Models

​Text Generation Models

​Google Gemini

gemini-2.5-flash

gemini-2.5-flash-lite

​Anthropic Claude

claude-3.7

claude-4-sonnet

​OpenAI

gpt-o4-mini

​DeepSeek

deepseek-r1-groq

​Image Generation Models

gpt-image-1

gemini-imagen-4

​Model Selection Guide

​Use Case Based Selection

​Dynamic Model Discovery

​Fallback Models

​Model Naming Conventions

​Switching Models in Conversations

​Model Configuration

​Best Practices

​Error Handling

​Related

Overview

Model Discovery

Model Types

ModelStatus

ModelInfo

Available Models

Text Generation Models

Google Gemini

Anthropic Claude

OpenAI

DeepSeek

Image Generation Models

Model Selection Guide

Use Case Based Selection

Dynamic Model Discovery

Fallback Models

Model Naming Conventions

Switching Models in Conversations

Model Configuration

Best Practices

Error Handling

Related