Module types

Core Types and Data Structures

This module contains all the core types, enums, and data structures used throughout the OpenRouter SDK. These types provide type-safe representations of API requests, responses, and configuration options.

📋 Type Categories

Request/Response Types (completion)

• Chat Completions: Modern conversational AI request/response structures
• Text Completions: Legacy prompt-based completion types
• Streaming: Types for handling real-time response streams
• Reasoning: Advanced reasoning and chain-of-thought structures

Provider Information (provider)

• Model Metadata: Provider-specific model information
• Capabilities: Model feature and parameter support
• Pricing: Cost information and token usage

Response Formatting (response_format)

• JSON Schema: Structured output formatting
• Content Types: Different response content formats
• Validation: Response format validation rules

🎯 Core Enums

Role

Defines the role of a message in a conversation:

use openrouter_rs::types::Role;

let system_role = Role::System;    // System instructions
let user_role = Role::User;        // User input
let assistant_role = Role::Assistant; // AI response
let tool_role = Role::Tool;        // Tool/function results
let developer_role = Role::Developer; // Developer context

Effort

Specifies reasoning effort levels for chain-of-thought models:

use openrouter_rs::types::Effort;

let high_effort = Effort::High;    // Maximum reasoning depth
let medium_effort = Effort::Medium; // Balanced reasoning
let low_effort = Effort::Low;      // Quick reasoning

🔧 Configuration Types

ReasoningConfig

Configuration for advanced reasoning capabilities:

use openrouter_rs::types::{ReasoningConfig, Effort};

let reasoning = ReasoningConfig::builder()
    .enabled(true)
    .effort(Effort::High)
    .max_tokens(1000)
    .build()?;

ProviderPreferences

Specify preferences for model provider selection:

use openrouter_rs::types::ProviderPreferences;

let prefs = ProviderPreferences {
    allow_fallbacks: true,
    require_parameters: Some(vec!["tools".to_string()]),
    data_collection: Some("deny".to_string()),
};

📊 Model Categories

Categories for filtering and organizing models:

use openrouter_rs::types::ModelCategory;

// Filter models by use case
let programming_models = ModelCategory::Programming;
let reasoning_models = ModelCategory::Reasoning;
let image_models = ModelCategory::Image;

🏗️ Builder Patterns

Most complex types support the builder pattern for ergonomic construction:

use openrouter_rs::types::{ReasoningConfig, Effort};

let config = ReasoningConfig::builder()
    .enabled(true)
    .effort(Effort::High)
    .max_tokens(2000)
    .exclude(false)
    .build()?;

🔄 Serialization Support

All types implement Serialize and Deserialize for JSON compatibility:

use openrouter_rs::types::Role;
use serde_json;

let role = Role::Assistant;
let json = serde_json::to_string(&role)?;
let parsed: Role = serde_json::from_str(&json)?;

🎨 Display Formatting

Common enums implement Display for human-readable output:

use openrouter_rs::types::{Role, Effort};

println!("Role: {}", Role::User);        // "user"
println!("Effort: {}", Effort::High);    // "high"

Re-exports

pub use completion::*;

pub use provider::*;

pub use response_format::*;

Modules

completion

provider

response_format

Structs

ApiResponse

ReasoningConfig

Enums

Effort

Reasoning effort level for chain-of-thought models

ModelCategory

Role

Message role in a conversation

SupportedParameters