OpenRouter RS

https://docs.rs/openrouter-rs/latest/openrouter_rs/
Admin
OpenRouter RS is a type-safe, async Rust SDK for the OpenRouter API that provides easy access to...
Tokens:59,894
Snippets:381
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Basic Chat Example

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/index

Provides a fundamental example of sending a chat completion request to the OpenRouter API and receiving a response. It covers client initialization and request building.

```Rust
use openrouter_rs::{OpenRouterClient, api::chat::*};
use openrouter_rs::types::Role;

let client = OpenRouterClient::builder()
    .api_key("your_key")
    .build()?;

let request = ChatCompletionRequest::builder()
    .model("google/gemini-2.5-flash")
    .messages(vec![Message::new(Role::User, "Hello!")])
    .build()?;

let response = client.send_chat_completion(&request).await?;
```

--------------------------------

### Model Discovery Example

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/index

Illustrates how to discover available models through the OpenRouter API. It demonstrates initializing the client and fetching the list of models.

```Rust
use openrouter_rs::OpenRouterClient;

let client = OpenRouterClient::builder()
    .api_key("your_key")
    .build()?;

let models = client.list_models().await?;
println!("Found {} models", models.len());
```

--------------------------------

### OpenRouter Configuration (Rust)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/all

Provides functions for loading OpenRouter configuration, likely from a file or environment variables. This allows for flexible setup of the client.

```Rust
pub fn load_config() -> Result<OpenRouterConfig, OpenRouterError>
```

--------------------------------

### Initialize OpenRouterConfig and Get Models

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/index

Demonstrates how to initialize the OpenRouterConfig with default settings and retrieve the list of resolved models available through the SDK.

```Rust
use openrouter_rs::config::OpenRouterConfig;

let config = OpenRouterConfig::default();
println!("Available models: {:?}", config.get_resolved_models());
```

--------------------------------

### Error Handling Example

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/index

Demonstrates how to handle potential errors when interacting with the OpenRouter API, including rate limit errors and invalid API key errors, using Rust's `Result` and `match`.

```Rust
use openrouter_rs::error::OpenRouterError;

match client.send_chat_completion(&request).await {
    Ok(response) => println!("Success: {:?}", response),
    Err(OpenRouterError::RateLimitExceeded) => {
        println!("Rate limit hit, retrying later...");
    }
    Err(OpenRouterError::InvalidApiKey) => {
        println!("Check your API key configuration");
    }
    Err(e) => println!("Other error: {}", e),
}
```

--------------------------------

### Get Resolved Models Example

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/struct

Shows how to obtain a list of all resolved and enabled model IDs from the OpenRouterConfig. This includes models specified individually and those expanded from presets, with duplicates automatically removed.

```Rust
use openrouter_rs::config::OpenRouterConfig;

let config = OpenRouterConfig::default();
let models = config.get_resolved_models();
assert!(!models.is_empty());
```

--------------------------------

### Add openrouter-rs to Cargo.toml

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/index

This snippet shows how to add the openrouter-rs crate and tokio as dependencies in your Cargo.toml file to get started with the SDK.

```toml
[dependencies]
openrouter-rs = "0.4.5"
tokio = { version = "1", features = ["full"] }
```

--------------------------------

### Reasoning Tokens (Chain-of-Thought) with OpenRouter Rust SDK

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/index

Illustrates how to enable and utilize reasoning tokens for chain-of-thought processing in the OpenRouter API. This example configures the request with high-effort reasoning and a token limit, then prints both the reasoning and the final answer.

```Rust
use openrouter_rs::{OpenRouterClient, api::chat::*, types::{Role, Effort}};

let client = OpenRouterClient::builder()
    .api_key("your_api_key")
    .build()?;

let request = ChatCompletionRequest::builder()
    .model("deepseek/deepseek-r1")
    .messages(vec![Message::new(Role::User, "What's bigger: 9.9 or 9.11?")])
    .reasoning_effort(Effort::High)  // Enable high-effort reasoning
    .reasoning_max_tokens(1000)      // Limit reasoning tokens
    .build()?;

let response = client.send_chat_completion(&request).await?;

println!("Reasoning: {}", response.choices[0].reasoning().unwrap_or(""));
println!("Answer: {}", response.choices[0].content().unwrap_or(""));
```

--------------------------------

### Get API Key Details - openrouter-rs

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/api_keys/index

Retrieves details for a specific API key. A Provisioning API key is necessary to perform this action.

```Rust
/// Returns details about a specific API key. Requires a Provisioning API key.
fn get_api_key(key_id: &str) -> Result<ApiKeyDetails, Error>;
```

--------------------------------

### Use Builder Pattern for ReasoningConfig in OpenRouter Rust SDK

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/index

Illustrates the use of the builder pattern for constructing `ReasoningConfig` objects in the OpenRouter Rust SDK. This example shows setting various parameters like enabled status, effort, max tokens, and exclusion.

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

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

--------------------------------

### Get Current API Key Info - openrouter-rs

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/api_keys/index

Fetches information about the API key associated with the current authentication session.

```Rust
/// Get information on the API key associated with the current authentication session
fn get_current_api_key() -> Result<ApiKeyDetails, Error>;
```

--------------------------------

### Categorize Models in OpenRouter Rust SDK

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/index

Provides examples of using the `ModelCategory` enum in the OpenRouter Rust SDK to filter and organize models by their use cases, such as programming, reasoning, or image generation.

```Rust
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;
```

--------------------------------

### Define Role in OpenRouter Rust SDK

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/index

Demonstrates how to define and use the `Role` enum in the OpenRouter Rust SDK for specifying message roles in conversations. It shows examples for System, User, Assistant, Tool, and Developer roles.

```Rust
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
```

--------------------------------

### Get Default Model Example

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/struct

Demonstrates how to retrieve the default model ID from the OpenRouterConfig. This method is useful for understanding which model will be used by default when no specific model is requested.

```Rust
use openrouter_rs::config::OpenRouterConfig;

let config = OpenRouterConfig::default();
assert_eq!(config.get_default_model(), "deepseek/deepseek-chat-v3-0324:free");
```

--------------------------------

### OpenRouterClientBuilder Methods

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/client/struct

Provides methods for configuring the OpenRouterClient. These methods allow setting the API key, base URL, provisioning key, HTTP referer, X-Title, and configuration, returning a mutable reference to the builder for chaining.

```Rust
pub fn base_url<VALUE: Into<String>>(&mut self, value: VALUE) -> &mut Self
```

```Rust
pub fn api_key<VALUE: Into<String>>(&mut self, value: VALUE) -> &mut Self
```

```Rust
pub fn provisioning_key<VALUE: Into<String>>( &mut self, value: VALUE, ) -> &mut Self
```

```Rust
pub fn http_referer<VALUE: Into<String>>(&mut self, value: VALUE) -> &mut Self
```

```Rust
pub fn x_title<VALUE: Into<String>>(&mut self, value: VALUE) -> &mut Self
```

```Rust
pub fn config<VALUE: Into<OpenRouterConfig>>( &mut self, value: VALUE, ) -> &mut Self
```

--------------------------------

### Rust Example ChatCompletionRequest with Effort

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/enum

Demonstrates how to use the `Effort` enum when building a `ChatCompletionRequest`. This example sets the reasoning effort to `Effort::High` for maximum reasoning depth.

```Rust
use openrouter_rs::types::Effort;
use openrouter_rs::api::chat::ChatCompletionRequest;

let request = ChatCompletionRequest::builder()
    .model("deepseek/deepseek-r1")
    .reasoning_effort(Effort::High)  // Maximum reasoning depth
    // ... other fields
    .build()?;
```

--------------------------------

### Rust: Using Default Configuration

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/index

Demonstrates how to initialize and use the default configuration for the OpenRouter Rust SDK. It shows how to retrieve the default model and a list of all resolved available models based on the default settings.

```rust
use openrouter_rs::config::OpenRouterConfig;

let config = OpenRouterConfig::default();
println!("Default model: {}", config.get_default_model());
println!("Available models: {:?}", config.get_resolved_models());
```

--------------------------------

### Get Output Type

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/struct

Defines the output type of an operation, which should always be `Self` in this context.

```Rust
type Output = T
```

--------------------------------

### OpenRouter Credit Management (Rust)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/all

Functions for retrieving user credits and creating Coinbase charges for purchasing credits. This facilitates managing account balances.

```Rust
pub fn create_coinbase_charge(client: &OpenRouterClient, charge_request: CoinbaseChargeRequest) -> Result<CoinbaseChargeData, OpenRouterError>
pub fn get_credits(client: &OpenRouterClient) -> Result<CreditsData, OpenRouterError>
```

--------------------------------

### List API Keys - openrouter-rs

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/api_keys/index

Retrieves a list of all API keys associated with the account. Requires a Provisioning API key.

```Rust
/// Returns a list of all API keys associated with the account. Requires a Provisioning API key.
fn list_api_keys() -> Result<Vec<ApiKey>, Error>;
```

--------------------------------

### Any::type_id

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/error/enum

Gets the TypeId of the implementing type. This is part of the Any trait implementation for generic types.

```Rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Get TypeId of a Type

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/struct

Retrieves the `TypeId` of a given type. This is a fundamental operation for runtime type identification in Rust.

```Rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Configuration File Loading and Error Handling

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/error/index

Shows how to load a TOML configuration file and handle specific errors like 'ConfigNotFound' or general 'ConfigError'.

```Rust
use openrouter_rs::{config::load_config, error::OpenRouterError};

match load_config("./config.toml") {
    Ok(config) => println!("Config loaded successfully"),
    Err(OpenRouterError::ConfigNotFound(path)) => {
        println!("Config file not found at: {}", path.display());
        // Use default configuration
    }
    Err(OpenRouterError::ConfigError(msg)) => {
        eprintln!("Invalid configuration: {}", msg);
    }
    Err(e) => eprintln!("Unexpected error: {}", e),
}
```

--------------------------------

### Get Generation Metadata

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/generation/index

Retrieves metadata for a specific generation request. This function is part of the openrouter_rs::api module.

```Rust
/// Returns metadata about a specific generation request
fn get_generation()
```

--------------------------------

### Create API Key - openrouter-rs

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/api_keys/index

Creates a new API key. This function requires a Provisioning API key to be set for authentication.

```Rust
/// Creates a new API key. Requires a Provisioning API key.
fn create_api_key() -> Result<ApiKey, Error>;
```

--------------------------------

### Rust: Get TypeId using Any trait

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Retrieves the `TypeId` of an object implementing the `Any` trait. This is useful for runtime type identification.

```Rust
impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId
```

--------------------------------

### CloneToUninit for CloneToUninit (Nightly)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/chat/struct

An experimental nightly-only API to perform copy-assignment from the instance to uninitialized memory.

```Rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Get User Credits

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/credits/index

Retrieves the total credits purchased and used by the authenticated user. This function is available within the openrouter_rs::api module.

```Rust
get_credits
    Returns the total credits purchased and used for the authenticated user
```

--------------------------------

### Configure Reasoning in OpenRouter Rust SDK

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/index

Shows how to configure advanced reasoning capabilities using `ReasoningConfig` in the OpenRouter Rust SDK. It demonstrates enabling reasoning, setting effort levels, and defining maximum tokens.

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

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

--------------------------------

### OpenRouterClientBuilder Struct

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/client/index

A builder pattern implementation for creating instances of `OpenRouterClient`. This allows for configurable construction of the client, setting various options before instantiation.

```Rust
struct OpenRouterClientBuilder;
```

--------------------------------

### Rust: Loading Custom Configuration

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/index

Illustrates how to load custom SDK configuration from a specified TOML file path. This function allows for external configuration management, overriding default settings.

```rust
use openrouter_rs::config::load_config;

let config = load_config("./my_config.toml")?;
```

--------------------------------

### Basic Chat Completion with OpenRouter Rust SDK

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/index

Demonstrates how to create an OpenRouterClient, build a chat completion request with messages and parameters, send the request, and print the response content. It utilizes the builder pattern for client and request construction.

```Rust
use openrouter_rs::{
    OpenRouterClient,
    api::chat::{ChatCompletionRequest, Message},
    types::Role,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create client with builder pattern
    let client = OpenRouterClient::builder()
        .api_key("your_api_key")
        .http_referer("https://yourapp.com")
        .x_title("My App")
        .build()?;

    // Build chat request
    let request = ChatCompletionRequest::builder()
        .model("anthropic/claude-sonnet-4")
        .messages(vec![
            Message::new(Role::System, "You are a helpful assistant"),
            Message::new(Role::User, "Explain Rust ownership in simple terms"),
        ])
        .temperature(0.7)
        .max_tokens(500)
        .build()?;

    // Send request and get response
    let response = client.send_chat_completion(&request).await?;
    println!("Response: {}", response.choices[0].content().unwrap_or(""));

    Ok(())
}
```

--------------------------------

### Get Generation Request Metadata

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/generation/fn

Retrieves metadata for a specific generation request using the OpenRouter API. Requires the base URL, API key, and the generation request ID.

```Rust
pub async fn get_generation(
    base_url: &str,
    api_key: &str,
    id: impl Into<String>,
) -> Result<GenerationData, OpenRouterError>
```

--------------------------------

### Rust: Blanket Implementation of CloneToUninit trait (Nightly)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

This nightly-only experimental API provides `clone_to_uninit` for types that implement Clone, allowing copy-assignment to uninitialized memory.

```Rust
impl<T> CloneToUninit for T
where T: Clone
```

--------------------------------

### OpenRouterClientBuilder Build Method

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/client/struct

The `build` method constructs a new `OpenRouterClient` instance. It returns a `Result` which will be `Ok(OpenRouterClient)` on success or `Err(OpenRouterError)` if any required fields were not initialized.

```Rust
pub fn build(&self) -> Result<OpenRouterClient, OpenRouterError>
```

--------------------------------

### Create Coinbase Charge Request Builder

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/credits/index

Provides a builder pattern for constructing CoinbaseChargeRequest objects, facilitating the creation of cryptocurrency payment charges.

```Rust
struct CoinbaseChargeRequestBuilder
    Builder for `CoinbaseChargeRequest`.
```

--------------------------------

### Rust: Handling OpenRouterError with Pattern Matching

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/error/enum

Demonstrates how to handle different variants of the OpenRouterError enum using pattern matching in Rust. This example shows how to react to specific errors like unauthorized requests, moderation flags, and configuration problems.

```Rust
use openrouter_rs::error::OpenRouterError;
use surf::StatusCode;

// Pattern matching on specific error types
fn handle_error(error: OpenRouterError) {
    match error {
        OpenRouterError::ApiError { code: StatusCode::Unauthorized, .. } => {
            println!("Check your API key");
        }
        OpenRouterError::ModerationError { reasons, .. } => {
            println!("Content flagged for: {:?}", reasons);
        }
        OpenRouterError::ConfigError(msg) => {
            println!("Configuration issue: {}", msg);
        }
        _ => println!("Other error: {}", error),
    }
}
```

--------------------------------

### Chat Completions Request

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/index

Demonstrates how to build a chat completion request using the openrouter-rs library. It includes specifying the model and providing user messages.

```Rust
use openrouter_rs::api::chat::{ChatCompletionRequest, Message};
use openrouter_rs::types::Role;

let request = ChatCompletionRequest::builder()
    .model("anthropic/claude-sonnet-4")
    .messages(vec![Message::new(Role::User, "Hello, world!")])
    .build()?;
```

--------------------------------

### Rust: TOML Configuration Format for Model Presets

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/index

Defines the TOML structure for configuring the OpenRouter SDK, including default models and custom model presets. This format allows users to specify which models or model presets are enabled and to define custom lists of models for each preset.

```toml
default_model = "deepseek/deepseek-chat-v3-0324:free"

[models]
enable = ["preset:programming", "preset:reasoning"]

[models.presets]
programming = [
  "anthropic/claude-sonnet-4",
  "google/gemini-2.5-flash",
  "qwen/qwen3-coder"
]
reasoning = [
  "anthropic/claude-sonnet-4",
  "deepseek/deepseek-r1:free",
  "google/gemini-2.5-pro"
]
```

--------------------------------

### Streaming Responses with OpenRouter Rust SDK

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/index

Shows how to stream responses from the OpenRouter API using the openrouter-rs SDK. It sets up a client, builds a chat request, and iterates over the stream to print the content as it arrives.

```Rust
use futures_util::StreamExt;
use openrouter_rs::{OpenRouterClient, api::chat::*};

let client = OpenRouterClient::builder()
    .api_key("your_api_key")
    .build()?;

let request = ChatCompletionRequest::builder()
    .model("google/gemini-2.5-flash")
    .messages(vec![Message::new(Role::User, "Write a haiku about Rust")])
    .build()?;

let mut stream = client.stream_chat_completion(&request).await?;

while let Some(result) = stream.next().await {
    if let Ok(response) = result {
        if let Some(content) = response.choices[0].content() {
            print!("{}", content);
        }
    }
}
```

--------------------------------

### Rust: ReasoningConfig with Effort

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/struct

Creates a `ReasoningConfig` instance with a specific effort level. This allows fine-grained control over the reasoning process.

```Rust
pub fn with_effort(effort: Effort) -> Self
```

--------------------------------

### Rust Struct: ProviderPreferences

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

Defines the configuration settings for routing AI provider requests. It includes options for fallbacks, data collection, provider order, ignored providers, quantizations, and sorting.

```Rust
pub struct ProviderPreferences {
    pub allow_fallbacks: Option<bool>,
    pub require_parameters: Option<bool>,
    pub data_collection: Option<DataCollectionPolicy>,
    pub order: Option<Vec<String>>,
    pub ignore: Option<Vec<String>>,
    pub quantizations: Option<Vec<Quantization>>,
    pub sort: Option<ProviderSortBy>,
}
```

--------------------------------

### List Models by Category

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/index

Shows how to retrieve a list of available models filtered by a specific category, such as 'Programming', using the openrouter-rs client.

```Rust
use openrouter_rs::types::ModelCategory;

// Get all models in the programming category
let models = client.list_models_by_category(ModelCategory::Programming).await?;
```

--------------------------------

### OpenRouterConfig Structure

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/struct

Defines the main configuration structure for the OpenRouter SDK. It holds the default model to be used and detailed model configurations, including presets. This structure can be loaded from TOML files or initialized with default values.

```Rust
pub struct OpenRouterConfig {
    pub default_model: String,
    pub models: ModelConfig,
}
```

--------------------------------

### Rust: Implement Sync for ProviderPreferences

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

This implementation allows ProviderPreferences instances to be safely shared between threads.

```Rust
impl Sync for ProviderPreferences
```

--------------------------------

### Rust: ReasoningConfig Default Enabled

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/struct

Creates a new `ReasoningConfig` instance with default enabled settings, typically representing medium effort. This is a convenient constructor for common use cases.

```Rust
pub fn enabled() -> Self
```

--------------------------------

### Default OpenRouterConfig Creation

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/struct

Illustrates the creation of a default OpenRouterConfig. This default configuration includes a specific default model and three presets ('programming', 'reasoning', 'free'), with preset references automatically resolved.

```Rust
use openrouter_rs::config::OpenRouterConfig;

let config = OpenRouterConfig::default();
assert_eq!(config.models.presets.len(), 3);
assert!(config.models.presets.contains_key("programming"));
assert!(config.models.presets.contains_key("reasoning"));
assert!(config.models.presets.contains_key("free"));
```

--------------------------------

### Basic Error Handling with OpenRouterClient

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/error/index

Demonstrates how to handle different types of errors when interacting with the OpenRouter API, such as API errors and network errors, using a match statement.

```Rust
use openrouter_rs::{OpenRouterClient, error::OpenRouterError};

let client = OpenRouterClient::builder()
    .api_key("invalid_key")
    .build()?;

match client.list_models().await {
    Ok(models) => println!("Found {} models", models.len()),
    Err(OpenRouterError::ApiError { code, message }) => {
        eprintln!("API error {}: {}", code, message);
    }
    Err(OpenRouterError::HttpRequest(e)) => {
        eprintln!("Network error: {}", e);
    }
    Err(e) => eprintln!("Other error: {}", e),
}
```

--------------------------------

### Rust: CompletionRequestBuilder - Set Reasoning Config

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Sets the reasoning configuration for the completion request.

```Rust
pub fn reasoning(&mut self, value: ReasoningConfig) -> &mut Self
```

--------------------------------

### OpenRouterClient Struct

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/client/index

Represents the main client for interacting with the OpenRouter API. This struct likely holds configuration and connection details necessary for making requests.

```Rust
struct OpenRouterClient;
```

--------------------------------

### JsonSchemaConfig Struct Documentation

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/response_format/index

Provides details on the JsonSchemaConfig struct, which is used for JSON Schema configuration for structured outputs.

```Rust
/// JSON Schema configuration for structured outputs
struct JsonSchemaConfig;
```

--------------------------------

### Create Coinbase Charge

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/credits/index

Function to create and hydrate a Coinbase Commerce charge for cryptocurrency payments. This function is part of the openrouter_rs::api module.

```Rust
create_coinbase_charge
    Creates and hydrates a Coinbase Commerce charge for cryptocurrency payments
```

--------------------------------

### Rust: Implement Unpin for ProviderPreferences

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

This implementation indicates that ProviderPreferences does not require special handling when moving between stack and heap.

```Rust
impl Unpin for ProviderPreferences
```

--------------------------------

### Rust: CompletionRequestBuilder - Default Implementation

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Provides a default instance of CompletionRequestBuilder, initializing it with default values for its fields.

```Rust
fn default() -> Self
```

--------------------------------

### Load Configuration from TOML File (Rust)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/fn

Loads application configuration from a specified TOML file path. If the file is missing, it defaults to a standard configuration. Errors are returned for invalid file content or structure.

```Rust
pub fn load_config(
    config_path: impl AsRef<Path>,
) -> Result<OpenRouterConfig, OpenRouterError>
```

```Rust
use openrouter_rs::config::load_config;

// Load config from file, or use defaults if file doesn't exist
let config = load_config("./openrouter.toml").unwrap();
```

--------------------------------

### OpenRouter Macros (Rust)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/all

Custom macros provided by the openrouter-rs crate, likely for simplifying common coding patterns such as setting optional fields in builders.

```Rust
strip_option_map_setter
strip_option_vec_setter
```

--------------------------------

### OpenRouter Text Completions (Rust)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/all

Enables sending text completion requests to the OpenRouter API. This is used for generating text based on a given prompt.

```Rust
pub fn send_completion_request(client: &OpenRouterClient, request: CompletionRequest) -> Result<CompletionRequest, OpenRouterError>
```

--------------------------------

### Rust: Blanket Implementation of TryFrom trait

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

Provides the `try_from` method for converting U into T, returning a Result, where U implements `Into<T>`.

```Rust
impl<T, U> TryFrom<U> for T
where U: Into<T>
```

--------------------------------

### Rust: CompletionRequestBuilder - Set Prompt

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Sets the prompt for the completion request. Accepts any type that can be converted into a String.

```Rust
pub fn prompt<VALUE: Into<String>>(&mut self, value: VALUE) -> &mut Self
```

--------------------------------

### Rust ChatCompletionRequestBuilder: Enable Reasoning

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/chat/struct

Enables reasoning with default settings (medium effort). This is a convenience method.

```Rust
pub fn enable_reasoning(&mut self) -> &mut Self
```

--------------------------------

### OpenRouter Authentication (Rust)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/all

Handles the authentication process by exchanging a code for an API key. This is a crucial step for establishing a secure connection to the OpenRouter API.

```Rust
pub fn exchange_code_for_api_key(client: &OpenRouterClient, code: &str) -> Result<AuthResponse, OpenRouterError>
```

--------------------------------

### Rust: CompletionRequestBuilder - Clone From Implementation

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Allows for copy-assignment, enabling the state of one CompletionRequestBuilder to be copied into another.

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

--------------------------------

### Rust: Unsafe Clone to Uninit using CloneToUninit trait

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Performs copy-assignment from `self` to an uninitialized memory location. This is a nightly-only experimental API and requires `unsafe`.

```Rust
impl<T> CloneToUninit for T
where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Rust: ReasoningConfig Clone Implementation

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/struct

Implements the `Clone` trait for `ReasoningConfig`, allowing instances to be duplicated. This includes both `clone` and `clone_from` methods.

```Rust
fn clone(&self) -> ReasoningConfig
```

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

--------------------------------

### VZip for VZip

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/chat/struct

Provides a vzip method for types that implement MultiLane.

```Rust
fn vzip(self) -> V
```

--------------------------------

### Rust: Implement Send for ProviderPreferences

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

This implementation allows ProviderPreferences instances to be safely sent across threads.

```Rust
impl Send for ProviderPreferences
```

--------------------------------

### Rust: Blanket Implementation of TryInto trait

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

Provides the `try_into` method for converting T into U, returning a Result, where U implements `TryFrom<T>`.

```Rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>
```

--------------------------------

### Rust: CompletionRequestBuilder - Set Top A

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Sets the top-a sampling parameter. Accepts a f64 value.

```Rust
pub fn top_a(&mut self, value: f64) -> &mut Self
```

--------------------------------

### Rust: ReasoningConfig with Max Tokens

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/struct

Creates a `ReasoningConfig` instance with a specified maximum token limit. This is useful for controlling the length of generated responses.

```Rust
pub fn with_max_tokens(max_tokens: u32) -> Self
```

--------------------------------

### List Available Models

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/models/index

Fetches a list of all models accessible through the OpenRouter API. This function is part of the `openrouter_rs::api` module.

```Rust
/// Returns a list of models available through the API
fn list_models()
```

--------------------------------

### Rust: Blanket Implementation of From trait

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

Provides the `from` method for any type T, allowing conversion from T to T.

```Rust
impl<T> From<T> for T
```

--------------------------------

### Rust ChatCompletionRequestBuilder: Set Reasoning Configuration

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/chat/struct

Sets the configuration for reasoning. Accepts a ReasoningConfig object.

```Rust
pub fn reasoning(&mut self, value: ReasoningConfig) -> &mut Self
```

--------------------------------

### Clone to Uninitialized Memory (Nightly)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/config/struct

An experimental, nightly-only API that performs copy-assignment from `self` to a raw, uninitialized memory pointer (`dest`). Use with caution.

```Rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Rust: CompletionRequestBuilder - Set Provider Preferences

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Sets provider-specific preferences for the completion request.

```Rust
pub fn provider(&mut self, value: ProviderPreferences) -> &mut Self
```

--------------------------------

### Rust: CompletionRequestBuilder - Clone Implementation

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Provides the ability to clone a CompletionRequestBuilder instance, creating a duplicate of its current state.

```Rust
fn clone(&self) -> CompletionRequestBuilder
```

--------------------------------

### TryInto for TryInto

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/chat/struct

Performs a conversion from type T to U, returning a Result.

```Rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Rust: ReasoningConfig Serialize Implementation

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/struct

Implements the `Serialize` trait from the Serde library for `ReasoningConfig`, enabling it to be serialized into various data formats.

```Rust
fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer
```

--------------------------------

### Create Coinbase Charge in Rust

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/credits/fn

This function creates and hydrates a Coinbase Commerce charge for cryptocurrency payments. It requires the base URL, API key, and a CoinbaseChargeRequest object. The function returns a Result containing either CoinbaseChargeData or an OpenRouterError.

```Rust
pub async fn create_coinbase_charge(
    base_url: &str,
    api_key: &str,
    request: &CoinbaseChargeRequest,
) -> Result<CoinbaseChargeData, OpenRouterError>
```

--------------------------------

### Rust: CompletionRequestBuilder - Set Response Format

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Sets the desired response format for the completion.

```Rust
pub fn response_format(&mut self, value: ResponseFormat) -> &mut Self
```

--------------------------------

### Update API Key - openrouter-rs

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/api_keys/index

Updates an existing API key. This function requires a Provisioning API key for authentication.

```Rust
/// Updates an existing API key. Requires a Provisioning API key.
fn update_api_key(key_id: &str, details: ApiKeyDetails) -> Result<ApiKey, Error>;
```

--------------------------------

### Set Provider Preferences in OpenRouter Rust SDK

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/index

Demonstrates how to set provider preferences for model selection in the OpenRouter Rust SDK using the `ProviderPreferences` struct. This includes allowing fallbacks, requiring specific parameters, and managing data collection.

```Rust
use openrouter_rs::types::ProviderPreferences;

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

--------------------------------

### OpenRouter Chat Completions (Rust)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/all

Provides functionality to send and stream chat completion requests to the OpenRouter API. This allows for conversational AI interactions.

```Rust
pub fn send_chat_completion(client: &OpenRouterClient, request: ChatCompletionRequest) -> Result<ChatCompletionRequest, OpenRouterError>
pub fn stream_chat_completion(client: &OpenRouterClient, request: ChatCompletionRequest) -> Result<impl futures_util::Stream<Item = Result<ChatCompletionRequest, OpenRouterError>>, OpenRouterError>
```

--------------------------------

### Rust: Blanket Implementation of Instrument trait (2)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

Provides `instrument` and `in_current_span` methods for any type T, enabling instrumentation with spans. This appears to be a duplicate entry.

```Rust
impl<T> Instrument for T
```

--------------------------------

### OpenRouterClientBuilder Structure

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/client/struct

Defines the structure of the OpenRouterClientBuilder, which is used to construct an OpenRouterClient. It includes private fields and is designed for a fluent building experience.

```Rust
pub struct OpenRouterClientBuilder { /* private fields */ }
```

--------------------------------

### Rust: CompletionRequestBuilder - Set Min P

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Sets the minimum probability for nucleus sampling. Accepts a f64 value.

```Rust
pub fn min_p(&mut self, value: f64) -> &mut Self
```

--------------------------------

### Rust: Blanket Implementation of Any trait

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

Provides the `type_id` method for any type T that is 'static and ?Sized, allowing runtime type identification.

```Rust
impl<T> Any for T
where T: 'static + ?Sized
```

--------------------------------

### OpenRouter API Key Management (Rust)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/all

Functions for creating, retrieving, updating, and deleting API keys within the OpenRouter API. These operations are essential for authenticating requests to the service.

```Rust
pub fn create_api_key(client: &OpenRouterClient) -> Result<ApiKey, OpenRouterError>
pub fn delete_api_key(client: &OpenRouterClient, key_id: &str) -> Result<(), OpenRouterError>
pub fn get_api_key(client: &OpenRouterClient, key_id: &str) -> Result<ApiKey, OpenRouterError>
pub fn get_current_api_key(client: &OpenRouterClient) -> Result<ApiKey, OpenRouterError>
pub fn list_api_keys(client: &OpenRouterClient) -> Result<Vec<ApiKey>, OpenRouterError>
pub fn update_api_key(client: &OpenRouterClient, key_id: &str, new_key_data: ApiKey) -> Result<ApiKey, OpenRouterError>
```

--------------------------------

### Rust: Blanket Implementation of VZip trait

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/provider/struct

Provides the `vzip` method for types T where V implements `MultiLane<T>`, likely for vector zipping operations.

```Rust
impl<V, T> VZip<V> for T
where V: MultiLane<T>
```

--------------------------------

### Strip Option Map Setter Macro

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/client/index

A macro likely used within the `openrouter-rs` crate to simplify the process of setting optional map values in a builder pattern, potentially handling `None` values gracefully.

```Rust
macro_rules! strip_option_map_setter {
    // ... macro definition ...
}
```

--------------------------------

### Rust: CompletionRequestBuilder - Set Temperature

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Sets the temperature for sampling, controlling randomness. Accepts a f64 value.

```Rust
pub fn temperature(&mut self, value: f64) -> &mut Self
```

--------------------------------

### Rust: Implement TryFrom<U> for T

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/client/struct

Shows the implementation of `TryFrom<U>` for `T`, where `U` implements `Into<T>`. It defines an `Error` type and a `try_from` method for fallible conversions.

```Rust
impl<T, U> TryFrom<U> for T
where U: Into<T>
```

--------------------------------

### OpenRouterClientBuilder Clone Implementation

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/client/struct

Implements the `Clone` trait for `OpenRouterClientBuilder`, allowing for the creation of a duplicate builder instance. It includes both `clone` and `clone_from` methods.

```Rust
fn clone(&self) -> OpenRouterClientBuilder
```

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

--------------------------------

### Rust: Implement WithSubscriber for T (Method 2)

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/client/struct

This is a duplicate entry for the `WithSubscriber` trait, demonstrating the same functionality as the previous entry. It allows attaching subscribers using `with_subscriber` or `with_current_subscriber`.

```Rust
impl<T> WithSubscriber for T
where S: Into<Dispatch>
```

--------------------------------

### Instrument for Instrument

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/chat/struct

Instruments the instance with a provided Span, returning an Instrumented wrapper.

```Rust
fn instrument(self, span: Span) -> Instrumented<Self>
```

--------------------------------

### Rust: CompletionRequestBuilder - Set Top K

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/completion/struct

Sets the top-k sampling parameter. Accepts a u32 value.

```Rust
pub fn top_k(&mut self, value: u32) -> &mut Self
```

--------------------------------

### WithSubscriber for WithSubscriber

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/chat/struct

Attaches a Subscriber to the instance, returning a WithDispatch wrapper.

```Rust
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
```
Tokens:
Raw