OpenRouter Rust SDK

https://docs.rs/openrouter-rs/latest/
Admin
A type-safe, async Rust SDK for the OpenRouter API that provides easy access to 200+ AI models from...
Tokens:286,210
Snippets:2,578
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example: Get Current API Key Info

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

Shows how to build a client with an API key and retrieve its details.

```rust
# use openrouter_rs::OpenRouterClient;
# async fn example() -> Result<(), Box<dyn std::error::Error>> {
let client = OpenRouterClient::builder().api_key("your_api_key").build()?;
let api_key_details = client.get_current_api_key_info().await?;
println!("{:?}", api_key_details);
# Ok(())
# }
```

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

### Tool Builder Example

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

Example of how to build a Tool using the builder pattern.

```APIDOC
## Examples
```rust
use openrouter_rs::types::tool::Tool;
use serde_json::json;

let weather_tool = Tool::builder()
    .name("get_weather")
    .description("Get current weather for a location")
    .parameters(json!({
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City and state"}
        },
        "required": ["location"]
    }))
    .build()?;
```
```

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

### Responses API Example

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/mod.rs.html

Shows how to use the Responses API to get a response, likely for a specific input format. Requires an API key.

```rust
use openrouter_rs::{OpenRouterClient, api::responses::ResponsesRequest};
use serde_json::json;

# async fn example() -> Result<(), Box<dyn std::error::Error>> {
let client = OpenRouterClient::builder().api_key("your_key").build()?;
let request = ResponsesRequest::builder()
    .model("openai/gpt-5")
    .input(json!([{ "role": "user", "content": "Say hello." }]))
    .build()?;
let response = client.responses().create(&request).await?;
println!("{:?}", response.id);
# Ok(())
# }
```

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

### Client Setup with openrouter-rs Builder

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

Illustrates the basic client setup using the `OpenRouterClient::builder()`. This is the recommended way to configure the client, allowing for API key and other runtime settings to be specified.

```rust
use openrouter_rs::OpenRouterClient;

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

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

### Responses API Example

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

Shows how to use the Responses API to get a response based on input.

```APIDOC
## Responses API

### Description
Retrieves a response from the API based on the provided input.

### Method
POST (implied by `client.responses().create()`)

### Endpoint
`/v1/responses` (implied by `client.responses().create()`)

### Parameters
#### Request Body
- **model** (string) - Required - The model to use.
- **input** (JSON value) - Required - The input for the model.

### Request Example
```rust
use openrouter_rs::{OpenRouterClient, api::responses::ResponsesRequest};
use serde_json::json;

let client = OpenRouterClient::builder().api_key("your_key").build()?;
let request = ResponsesRequest::builder()
    .model("openai/gpt-5")
    .input(json!([{ "role": "user", "content": "Say hello." }]))
    .build()?;
let response = client.responses().create(&request).await?;
println!("{:?}", response.id);
```

### Response
#### Success Response (200)
- **id** (string) - The ID of the response.

#### Response Example
(Response structure not detailed in source, example shows printing response ID)
```

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

### Chat Completion Example

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

Demonstrates how to create a chat completion request and get a response from the client.

```APIDOC
## Chat Completion

### Description
Creates a chat completion request and retrieves a response.

### Method
POST (implied by `client.chat().create()`)

### Endpoint
`/v1/chat/completions` (implied by `client.chat().create()`)

### Parameters
#### Request Body
- **model** (string) - Required - The model to use for completion.
- **messages** (array of Message objects) - Required - The messages to send to the model.

### Request Example
```rust
use openrouter_rs::{
    OpenRouterClient,
    api::chat::{ChatCompletionRequest, Message},
    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.chat().create(&request).await?;
println!("{:?}", response.choices[0].content());
```

### Response
#### Success Response (200)
- **choices** (array of Choice objects) - The list of completion choices.

#### Response Example
(Response structure not detailed in source, example shows printing content)
```

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

### Model Discovery Example

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

Demonstrates how to list models by category.

```APIDOC
## Model Discovery

### Description
Lists available models, filterable by category.

### Method
GET (implied by `client.models().list_by_category()`)

### Endpoint
`/v1/models` (implied by `client.models().list_by_category()`)

### Parameters
#### Query Parameters
- **category** (ModelCategory) - Required - The category to filter models by.

### Request Example
```rust
use openrouter_rs::{OpenRouterClient, types::ModelCategory};

let client = OpenRouterClient::builder().api_key("your_key").build()?;
let models = client.models().list_by_category(ModelCategory::Programming).await?;
println!("Found {} models", models.len());
```

### Response
#### Success Response (200)
- **models** (array of Model objects) - A list of models matching the category.

#### Response Example
(Response structure not detailed in source, example shows printing the count of models)
```

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

### Example Implementation of TypedTool

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/types/typed_tool/trait.TypedTool.html

An example demonstrating how to implement the TypedTool trait for a CalculatorParams struct, including defining operations and providing the required name and description.

```APIDOC
## Example Usage

```rust
use openrouter_rs::types::typed_tool::TypedTool;
use serde::{Deserialize, Serialize};
use schemars::JsonSchema;

#[derive(Serialize, Deserialize, JsonSchema)]
pub struct CalculatorParams {
    pub operation: Operation,
    pub a: f64,
    pub b: f64,
}

#[derive(Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "lowercase")]
pub enum Operation {
    Add,
    Subtract,
    Multiply,
    Divide,
}

impl TypedTool for CalculatorParams {
    fn name() -> &'static str {
        "calculator"
    }

    fn description() -> &'static str {
        "Perform basic arithmetic operations"
    }
}
```
```

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

### Example: Create API Key

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

Demonstrates how to initialize the client with a management key and create a new API key with an optional credit limit.

```rust
# use openrouter_rs::OpenRouterClient;
# async fn example() -> Result<(), Box<dyn std::error::Error>> {
let client = OpenRouterClient::builder().management_key("your_management_key").build()?;
let api_key = client.create_api_key("New API Key", Some(100.0)).await?;
println!("{:?}", api_key);
# Ok(())
# }
```

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

### ToolChoice Examples

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

Demonstrates how to instantiate different ToolChoice variants. Use these to configure the model's tool-calling behavior.

```rust
use openrouter_rs::types::tool::ToolChoice;

// Let model decide
let auto = ToolChoice::auto();

// Prevent tool use
let none = ToolChoice::none();

// Require tool use
let required = ToolChoice::required();

// Force specific tool
let specific = ToolChoice::force_tool("get_weather");
```

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

### Model Discovery Example

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/mod.rs.html

Illustrates how to list models by category, specifically for programming-related models. An API key is needed.

```rust
use openrouter_rs::{OpenRouterClient, types::ModelCategory};

# async fn example() -> Result<(), Box<dyn std::error::Error>> {
let client = OpenRouterClient::builder().api_key("your_key").build()?;
let models = client.models().list_by_category(ModelCategory::Programming).await?;
println!("Found {} models", models.len());
# Ok(())
# }
```

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

### Example: Delete API Key

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

Illustrates initializing the client with a management key and deleting an API key by its hash.

```rust
# use openrouter_rs::OpenRouterClient;
# async fn example() -> Result<(), Box<dyn std::error::Error>> {
let client = OpenRouterClient::builder().management_key("your_management_key").build()?;
let success = client.delete_api_key("api_key_hash").await?;
println!("Deletion successful: {}", success);
# Ok(())
# }
```

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

### Chat Completion Example

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/mod.rs.html

Demonstrates how to create a chat completion request using the OpenRouterClient. Ensure you have your API key configured.

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

# async fn example() -> Result<(), Box<dyn std::error::Error>> {
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.chat().create(&request).await?;
println!("{:?}", response.choices[0].content());
# Ok(())
# }
```

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

### ModelsCountData Usage Example

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/discovery/struct.ModelsCountData.html

This example demonstrates how ModelsCountData is used as a response payload for the GET /models/count endpoint.

```APIDOC
## GET /models/count

### Description
Retrieves the total count of available models.

### Response
#### Success Response (200)
- **count** (u64) - The total number of models.

### Response Example
```json
{
  "count": 150
}
```
```

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

### Accessing Audio Client

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

Shows how to get an AudioClient from an OpenRouterClient. This client is used for audio-related operations.

```rust
pub fn audio(&self) -> AudioClient<'_>
```

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

### List Workspaces

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

Lists available workspaces with optional pagination. Corresponds to `GET /workspaces`.

```APIDOC
## list_workspaces

### Description
List workspaces (`GET /workspaces`).

### Method
GET

### Endpoint
/workspaces

### Parameters
#### Query Parameters
- **pagination** (PaginationOptions) - Optional - Options for pagination.

### Response
#### Success Response (200)
- **WorkspaceListResponse** - The response containing a list of workspaces.
```

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

### Create and Exchange Auth Code Example

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

Demonstrates creating an authorization code with PKCE and then exchanging it for an API key. Ensure you have your API key and a callback URL configured.

```rust
use openrouter_rs::{OpenRouterClient, api::auth};
async fn example() -> Result<(), Box<dyn std::error::Error>> {
let client = OpenRouterClient::builder().api_key("your_api_key").build()?;

let create = auth::CreateAuthCodeRequest::builder()
    .callback_url("https://myapp.com/auth/callback")
    .code_challenge("E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM")
    .code_challenge_method(auth::CodeChallengeMethod::S256)
    .build()?;

let auth_code = client.create_auth_code(&create).await?;

let exchanged = client
    .exchange_code_for_api_key(
        &auth_code.id,
        Some("your_pkce_code_verifier"),
        Some(auth::CodeChallengeMethod::S256),
    )
    .await?;

println!("New key: {}", exchanged.key);
Ok(())
}

```

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

### Initialize OpenRouterClient with Builder

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/lib.rs.html

Demonstrates how to build an OpenRouterClient instance using its builder pattern. Requires an API key for authentication.

```rust
use openrouter_rs::OpenRouterClient;

let client = OpenRouterClient::builder()
    .api_key("your_api_key")
    .build()?;
# Ok::<(), openrouter_rs::error::OpenRouterError>(())
```

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

### Example: Adding Multiple Typed Tools

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

Demonstrates adding both weather and calculator tools in a single batch operation. Both `WeatherParams` and `CalculatorParams` must implement `TypedTool`.

```rust
# use openrouter_rs::api::chat::{ChatCompletionRequest, Message};
# use openrouter_rs::types::Role;
# use openrouter_rs::types::typed_tool::TypedTool;
# use serde::{Deserialize, Serialize};
# use schemars::JsonSchema;
# #[derive(Serialize, Deserialize, JsonSchema)]
# struct WeatherParams { location: String }
# impl TypedTool for WeatherParams {
#     fn name() -> &'static str { "get_weather" }
#     fn description() -> &'static str { "Get weather" }
# }
# #[derive(Serialize, Deserialize, JsonSchema)]
# struct CalculatorParams { a: f64, b: f64 }
# impl TypedTool for CalculatorParams {
#     fn name() -> &'static str { "calculator" }
#     fn description() -> &'static str { "Calculate" }
# }

let request = ChatCompletionRequest::builder()
    .model("anthropic/claude-sonnet-4")
    .messages(vec![Message::new(Role::User, "Need weather and calculator help")])
    .typed_tools_batch(&[
        &WeatherParams,
        &CalculatorParams,
    ])
    .build()?;
# Ok::<(), Box<dyn std::error::Error>>(())
```

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

### Count Models

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

Gets the total number of available models. Equivalent to `GET /models/count`.

```APIDOC
## count_models

### Description
Gets the total number of available models.

### Method
`GET`

### Endpoint
`/models/count`

### Parameters
None

### Response
#### Success Response (200)
- `ModelsCountData` (object) - Contains the total count of models.

### Request Example
```rust
let client = OpenRouterClient::new("your_api_key");
let model_count = client.count_models().await;
```

### Response Example
```json
{
  "total": 1000
}
```
```

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

### Get Activity

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

Retrieves endpoint-grouped activity data. This corresponds to the `GET /activity` endpoint.

```APIDOC
## GET /activity

### Description
Get endpoint-grouped activity data.

### Method
GET

### Endpoint
/activity

### Response
#### Success Response (200)
- **activity** (array of ActivityItem) - A list of activity items.
```

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

### Get Workspace

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

Retrieves details for a specific workspace by its ID. Corresponds to `GET /workspaces/{id}`.

```APIDOC
## get_workspace

### Description
Get a workspace (`GET /workspaces/{id}`).

### Method
GET

### Endpoint
/workspaces/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the workspace to retrieve.
```

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

### Default FileInput Initialization

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

Provides a default FileInput instance, typically with all fields set to None. This is useful for starting with an empty configuration.

```rust
fn default() -> FileInput
```

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

### Get Workspace with Client

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/workspaces.rs.html

Internal function to fetch a workspace by ID using a provided HTTP client. It constructs the URL and sends a GET request.

```rust
pub(crate) async fn get_workspace_with_client(
    http_client: &HttpClient,
    base_url: &str,
    management_key: &str,
    id: &str,
) -> Result<Workspace, OpenRouterError> {
    let url = format!("{base_url}/workspaces/{}", encode(id));
    let response = transport_request::with_bearer_auth(
        transport_request::get(http_client, &url),
        management_key,
    )
    .send()
    .await?;

    if response.status().is_success() {
        let payload: ApiResponse<Workspace> = 
            transport_response::parse_json_response(response, "workspace lookup").await?;
        Ok(payload.data)
    } else {
        transport_response::handle_error(response).await?;
        unreachable!()
    }
}
```

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

### Create Video Content

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

Use `ContentPart::video_url` or `ContentPart::input_video` to include video content by URL.

```rust
pub fn video_url(url: impl Into<String>) -> Self {
    Self::VideoUrl {
        video_url: VideoUrl::new(url),
    }
}

pub fn input_video(url: impl Into<String>) -> Self {
    Self::InputVideo {
        video_url: VideoUrl::new(url),
    }
}
```

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

### Create Audio Content

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

Use `ContentPart::input_audio` to include audio data and specify its format.

```rust
pub fn input_audio(data: impl Into<String>, format: impl Into<String>) -> Self {
    Self::InputAudio {
        input_audio: InputAudio::new(data, format),
    }
}
```

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

### Get Guardrail (Public)

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/guardrails.rs.html

Retrieves a specific guardrail by its ID. This public function creates an HTTP client internally. It makes a GET request to the guardrail endpoint using the provided ID.

```rust
pub async fn get_guardrail(
    base_url: &str,
    management_key: &str,
    id: &str,
) -> Result<Guardrail, OpenRouterError> {
    let http_client = crate::transport::new_client()?;
    get_guardrail_with_client(&http_client, base_url, management_key, id).await
}
```

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

### Tool::new

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

Create a simple tool with name, description, and parameters.

```APIDOC
### impl Tool

#### pub fn new(name: &str, description: &str, parameters: Value) -> Self
Create a simple tool with name, description, and parameters
```

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

### Get Video Generation Job Status

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

Polls for the status of a specific video generation job using its unique job ID. This function corresponds to the `GET /videos/{jobId}` endpoint.

```APIDOC
## GET /videos/{jobId}

### Description
Poll one video generation job by job id.

### Method
GET

### Endpoint
/videos/{jobId}

### Parameters
#### Path Parameters
- **jobId** (string) - Required - The unique identifier of the video generation job.

### Response
#### Success Response (200)
- **jobId** (string) - The unique identifier for the video generation job.
- **status** (string) - The current status of the job.
- **output** (array of VideoImageUrl) - Optional - A list of URLs for the generated video frames if the job is completed.
- **usage** (VideoGenerationUsage) - Optional - Information about the usage of resources for this job.

#### Response Example
```json
{
  "jobId": "job_abc123",
  "status": "completed",
  "output": [
    { "url": "https://example.com/video_frame_1.png" },
    { "url": "https://example.com/video_frame_2.png" }
  ],
  "usage": {
    "total_credits_charged": 10
  }
}
```
```

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

### get_guardrail

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

Get a guardrail.

```APIDOC
## GET /guardrails/{id}

### Description
Get a guardrail.

### Method
GET

### Endpoint
/guardrails/{id}

### Parameters
#### Path Parameters
- **id** (str) - Required - The ID of the guardrail to retrieve.
```

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

### Example: Adding a Typed Tool for Weather

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

Demonstrates how to add a typed tool for fetching weather information. Requires `WeatherParams` to implement `TypedTool` and `JsonSchema`.

```rust
use openrouter_rs::api::chat::{ChatCompletionRequest, Message};
use openrouter_rs::types::Role;
use openrouter_rs::types::typed_tool::TypedTool;
use serde::{Deserialize, Serialize};
use schemars::JsonSchema;

#[derive(Serialize, Deserialize, JsonSchema)]
struct WeatherParams {
    location: String,
}

impl TypedTool for WeatherParams {
    fn name() -> &'static str { "get_weather" }
    fn description() -> &'static str { "Get weather for location" }
}

let request = ChatCompletionRequest::builder()
    .model("anthropic/claude-sonnet-4")
    .messages(vec![Message::new(Role::User, "What is the weather in Paris?")])
    .typed_tool::<WeatherParams>()
    .build()?;
# Ok::<(), Box<dyn std::error::Error>>(())
```

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

### Accessing Chat Client

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

Provides an example of how to obtain a ChatClient instance from an OpenRouterClient. The ChatClient is used for chat completions and streaming operations.

```rust
pub fn chat(&self) -> ChatClient<'_>
```

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

### VideoUrl::new Constructor

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

Creates a new VideoUrl instance.

```APIDOC
### impl VideoUrl

#### pub fn new(url: impl Into<String>) -> Self
Creates a new VideoUrl instance with the provided URL.
```

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

### get_credits

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

Get credits.

```APIDOC
## GET /credits

### Description
Get credits.

### Method
GET

### Endpoint
/credits

### Response
#### Success Response (200)
- **CreditsData** (object) - Data related to user credits.
```

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

### Create a Tool using Builder

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

Example of creating a tool definition using the builder pattern. This is useful for defining tools with names, descriptions, and parameters for LLM function calling.

```rust
use openrouter_rs::types::tool::Tool;
use serde_json::json;

let weather_tool = Tool::builder()
    .name("get_weather")
    .description("Get current weather for a location")
    .parameters(json!({
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City and state"}
        },
        "required": ["location"]
    }))
    .build()?;
```

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

### get_api_key

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

Get an API key.

```APIDOC
## GET /keys/{hash}

### Description
Get an API key.

### Method
GET

### Endpoint
/keys/{hash}

### Parameters
#### Path Parameters
- **hash** (str) - Required - The hash of the API key to retrieve.
```

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

### get_activity

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

Get endpoint usage activity.

```APIDOC
## GET /activity

### Description
Get endpoint usage activity.

### Method
GET

### Endpoint
/activity

### Parameters
#### Query Parameters
- **date** (str) - Optional - The date for which to retrieve activity.
```

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

### ChatCompletionRequest::messages

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

Gets the messages in this request.

```APIDOC
## ChatCompletionRequest::messages

### Description
Gets the messages in this request.

### Method
`ChatCompletionRequest::messages(&self) -> &[Message]`

### Returns
`&[Message]` - A slice of `Message` objects.
```

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

### Create PaginationOptions Instances

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/types/pagination.rs.html

Provides methods to create `PaginationOptions` instances with specific offset and limit values. Useful for setting pagination parameters.

```rust
impl PaginationOptions {
    pub fn new(offset: Option<u32>, limit: Option<u32>) -> Self {
        Self { offset, limit }
    }

    pub fn with_offset(offset: u32) -> Self {
        Self {
            offset: Some(offset),
            limit: None,
        }
    }

    pub fn with_limit(limit: u32) -> Self {
        Self {
            offset: None,
            limit: Some(limit),
        }
    }

    pub fn with_offset_and_limit(offset: u32, limit: u32) -> Self {
        Self {
            offset: Some(offset),
            limit: Some(limit),
        }
    }
}

```

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

### Get Credits with Client

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

Internal function to fetch credit information using a provided HTTP client. It constructs the API URL, sends a GET request with bearer authentication, and parses the JSON response. Handles API errors.

```rust
pub(crate) async fn get_credits_with_client(
    http_client: &HttpClient,
    base_url: &str,
    api_key: &str,
) -> Result<CreditsData, OpenRouterError> {
    let url = format!("{base_url}/credits");

    let response = 
        transport_request::with_bearer_auth(transport_request::get(http_client, &url), api_key)
            .send()
            .await?;

    if response.status().is_success() {
        let credits_response: ApiResponse<_> = 
            transport_response::parse_json_response(response, "credits").await?;
        Ok(credits_response.data)
    } else {
        transport_response::handle_error(response).await?;
        unreachable!()
    }
}
```

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

### Convenience Method for Tool-Aware Streaming

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/types/stream.rs.html

Use the convenience method on the client to directly obtain a tool-aware stream. This simplifies the process of setting up the stream for tool call fragment assembly.

```rust
# async fn example(client: openrouter_rs::OpenRouterClient, request: openrouter_rs::api::chat::ChatCompletionRequest) -> Result<(), Box<dyn std::error::Error>> {
let stream = client.stream_chat_completion_tool_aware(&request).await?;
# Ok(())
# }
```

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

### Get Video Generation Job Status with Client (Rust)

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/videos.rs.html

This internal function polls the status of a video generation job using a provided HTTP client. It constructs the URL with the job ID, sends a GET request, and parses the response.

```rust
pub(crate) async fn get_video_generation_with_client(
    http_client: &HttpClient,
    base_url: &str,
    api_key: &str,
    job_id: &str,
) -> Result<VideoGenerationResponse, OpenRouterError> {
    let url = format!("{base_url}/videos/{}", encode(job_id));
    let response =
        transport_request::with_bearer_auth(transport_request::get(http_client, &url), api_key)
            .send()
            .await?;

    if response.status().is_success() {
        transport_response::parse_json_response(response, "video generation status").await
    } else {

```

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

### Get Guardrail

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/guardrails.rs.html

Retrieves a specific guardrail by its ID.

```APIDOC
## GET /guardrails/{id}

### Description
Retrieves a specific guardrail by its ID.

### Method
GET

### Endpoint
/guardrails/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the guardrail to retrieve.

### Response
#### Success Response (200)
- **Guardrail** - The guardrail object.

### Request Example
```http
GET /guardrails/gr-abc123 HTTP/1.1
Authorization: Bearer YOUR_MANAGEMENT_KEY
Host: api.openrouter.ai
```

### Response Example
```json
{
  "id": "gr-abc123",
  "name": "Profanity Filter",
  "description": "Filters out profane language.",
  "created_at": "2023-10-27T10:00:00Z",
  "updated_at": "2023-10-27T10:00:00Z"
}
```
```

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

### Create Workspace

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/workspaces.rs.html

Creates a new workspace using the provided details. This function initializes a new HTTP client.

```rust
pub async fn create_workspace(
    base_url: &str,
    management_key: &str,
    request: &CreateWorkspaceRequest,
) -> Result<Workspace, OpenRouterError> {
    let http_client = crate::transport::new_client()?;
    create_workspace_with_client(&http_client, base_url, management_key, request).await
}
```

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

### Implement PolicyExt::or

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/auth/struct.AuthResponse.html

Combines two policies, allowing either to return Action::Follow.

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,
```

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

### get_current_api_key_info

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

Get current key session info.

```APIDOC
## GET /key

### Description
Get current key session info.

### Method
GET

### Endpoint
/key

### Response
#### Success Response (200)
- **ApiKeyDetails** (object) - Details of the current API key session.
```

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

### ChatCompletionRequest::tool_choice

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

Gets the tool choice setting.

```APIDOC
## ChatCompletionRequest::tool_choice

### Description
Gets the tool choice setting.

### Method
`ChatCompletionRequest::tool_choice(&self) -> Option<&ToolChoice>`

### Returns
`Option<&ToolChoice>` - An optional `ToolChoice` object.
```

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

### ChatCompletionRequest::tools

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

Gets the tools defined in this request.

```APIDOC
## ChatCompletionRequest::tools

### Description
Gets the tools defined in this request.

### Method
`ChatCompletionRequest::tools(&self) -> Option<&[Tool]>`

### Returns
`Option<&[Tool]>` - An optional slice of `Tool` objects.
```

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

### Create Image Content

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

Use `ContentPart::image_url` to include an image by URL. Add detail with `ContentPart::image_url_with_detail`.

```rust
pub fn image_url(url: impl Into<String>) -> Self {
    Self::ImageUrl {
        image_url: ImageUrl::new(url),
    }
}

pub fn image_url_with_detail(url: impl Into<String>, detail: impl Into<String>) -> Self {
    Self::ImageUrl {
        image_url: ImageUrl::with_detail(url, detail),
    }
}
```

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

### Implement PolicyExt::and

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/auth/struct.AuthResponse.html

Combines two policies, requiring both to return Action::Follow.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,
```

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

### Get Guardrail with Client (Internal)

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/guardrails.rs.html

An internal function to retrieve a specific guardrail by its ID using an existing HTTP client. It constructs the URL with the encoded ID and sends a GET request. Use this when you have an active HTTP client and need to fetch a guardrail.

```rust
pub(crate) async fn get_guardrail_with_client(
    http_client: &HttpClient,
    base_url: &str,
    management_key: &str,
    id: &str,
) -> Result<Guardrail, OpenRouterError> {
    let url = format!("{base_url}/guardrails/{}", encode(id));
    let response = transport_request::with_bearer_auth(
        transport_request::get(http_client, &url),
        management_key,
    )
    .send()
    .await?;

    if response.status().is_success() {
        let payload: ApiResponse<Guardrail> = 
            transport_response::parse_json_response(response, "guardrail lookup").await?;
        Ok(payload.data)
    } else {
        transport_response::handle_error(response).await?;
        unreachable!()
    }
}
```

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

### Create File Content

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

Use `ContentPart::file_data` for file content from data, or `ContentPart::file_id` for files by ID. Optionally specify a filename.

```rust
pub fn file_data(file_data: impl Into<String>) -> Self {
    Self::File {
        file: FileInput::from_data(file_data),
    }
}

pub fn file_data_with_filename(
    file_data: impl Into<String>,
    filename: impl Into<String>,
) -> Self {
    Self::File {
        file: FileInput::from_data(file_data).filename(filename),
    }
}
```

```rust
pub fn file_id(file_id: impl Into<String>) -> Self {
    Self::File {
        file: FileInput::from_id(file_id),
    }
}

pub fn file_id_with_filename(file_id: impl Into<String>, filename: impl Into<String>) -> Self {
    Self::File {
        file: FileInput::from_id(file_id).filename(filename),
    }
}
```

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

### Get Workspace

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/workspaces.rs.html

Retrieves details of a specific workspace by its ID.

```APIDOC
## GET /workspaces/{workspace_id}

### Description
Retrieves the details of a specific workspace using its unique identifier.

### Method
GET

### Endpoint
/workspaces/{workspace_id}

### Parameters
#### Path Parameters
- **workspace_id** (String) - Required - The unique identifier of the workspace to retrieve.

### Response
#### Success Response (200)
- **id** (String) - The unique identifier of the workspace.
- **name** (String) - The name of the workspace.
- **slug** (String) - The unique identifier for the workspace.
- **description** (String) - A description for the workspace.
- **default_text_model** (String) - The default text model to use for this workspace.
- **default_image_model** (String) - The default image model to use for this workspace.
- **default_provider_sort** (String) - The default provider sorting preference.
- **io_logging_api_key_ids** (Array<u64>) - List of API key IDs for I/O logging.
- **io_logging_sampling_rate** (f64) - Sampling rate for I/O logging.
- **is_observability_io_logging_enabled** (Boolean) - Whether I/O logging is enabled for observability.
- **is_observability_broadcast_enabled** (Boolean) - Whether observability broadcast is enabled.
- **is_data_discount_logging_enabled** (Boolean) - Whether data discount logging is enabled.
- **created_at** (String) - Timestamp of creation.
- **updated_at** (String) - Timestamp of last update.
- **created_by** (String) - Identifier of the user who created the workspace.

### Response Example
```json
{
  "id": "ws-123",
  "name": "My Workspace",
  "slug": "my-workspace",
  "description": "This is my primary workspace.",
  "default_text_model": "gpt-3.5-turbo",
  "default_image_model": null,
  "default_provider_sort": "default",
  "io_logging_api_key_ids": [1, 2],
  "io_logging_sampling_rate": 0.5,
  "is_observability_io_logging_enabled": true,
  "is_observability_broadcast_enabled": false,
  "is_data_discount_logging_enabled": true,
  "created_at": "2023-01-01T12:00:00Z",
  "updated_at": "2023-01-01T12:00:00Z",
  "created_by": "user-abc"
}
```
```

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

### Get Guardrail

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

Retrieves a specific guardrail by its unique identifier.

```APIDOC
## GET /guardrails/{id}

### Description
Retrieves a specific guardrail.

### Method
GET

### Endpoint
/guardrails/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the guardrail to retrieve.

### Response
#### Success Response (200)
- **Guardrail** (object) - The guardrail object.

#### Response Example
```json
{
  "example": "response body for Guardrail"
}
```
```

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

### Test Tool Creation with Builder Pattern

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/types/tool.rs.html

Demonstrates the usage of the `Tool::builder()` for creating a tool instance. This is useful for setting tool properties programmatically and verifying their values.

```rust
let tool = Tool::builder()
    .name("test_function")
    .description("A test function")
    .parameters(json!({"type": "object"}))
    .build()
    .unwrap();

assert_eq!(tool.tool_type, "function");
assert_eq!(tool.function.name, "test_function");
assert_eq!(tool.function.description, "A test function");
```

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

### Policy 'And' Implementation

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/workspaces/struct.CreateWorkspaceRequest.html

Combines two policies, requiring both to return Action::Follow.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

```

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

### ChatCompletionRequest::parallel_tool_calls

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

Gets the parallel tool calls setting.

```APIDOC
## ChatCompletionRequest::parallel_tool_calls

### Description
Gets the parallel tool calls setting.

### Method
`ChatCompletionRequest::parallel_tool_calls(&self) -> Option<bool>`

### Returns
`Option<bool>` - An optional boolean indicating if parallel tool calls are enabled.
```

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

### VideoFrameImage::new Constructor

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/videos/struct.VideoFrameImage.html

Creates a new VideoFrameImage instance.

```APIDOC
## impl VideoFrameImage

### pub fn new(url: impl Into<String>, frame_type: impl Into<String>) -> Self

Creates a new `VideoFrameImage` with the specified URL and frame type.
```

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

### Get Credits

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

Retrieves the current credit balance of the authenticated account.

```APIDOC
## Get Credits

### Description
Fetches the current available credit balance for the account associated with the API key.

### Method
GET

### Endpoint
`/credits`

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- `CreditsData` (object) - Contains the user's credit balance information.

#### Response Example
```json
{
  "total_credits": 5000.0,
  "used_credits": 1500.0,
  "remaining_credits": 3500.0
}
```
```

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

### Create Input Video ContentPart

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/chat/enum.ContentPart.html

Constructs a legacy video input content part from a URL. Prefer `video_url` for new implementations.

```rust
pub fn input_video(url: impl Into<String>) -> Self
```

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

### Get Guardrail by ID

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/api/guardrails.rs.html

Retrieves a specific guardrail by its unique identifier.

```APIDOC
## GET /guardrails/{id}

### Description
Retrieves a specific guardrail by its ID.

### Method
GET

### Endpoint
/guardrails/{id}

### Parameters
#### Path Parameters
- **id** (String) - Required - The unique identifier of the guardrail.

### Response
#### Success Response (200)
- **Guardrail** (Guardrail) - The requested guardrail object.
```

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

### OpenRouterClient Builder

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

Demonstrates how to create a new OpenRouterClient instance using its builder pattern. The build method can return a Result, indicating potential errors during client construction.

```rust
let mut client = OpenRouterClient::builder().build()?;
```

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

### List ZDR Endpoints

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

Previews ZDR-compatible endpoints. Equivalent to `GET /endpoints/zdr`.

```APIDOC
## list_zdr_endpoints

### Description
Previews ZDR-compatible endpoints.

### Method
`GET`

### Endpoint
`/endpoints/zdr`

### Parameters
None

### Response
#### Success Response (200)
- `Vec<PublicEndpoint>` (array) - A list of public ZDR endpoint objects.

### Request Example
```rust
let client = OpenRouterClient::new("your_api_key");
let zdr_endpoints = client.list_zdr_endpoints().await;
```

### Response Example
```json
[
  {
    "id": "zdr-endpoint-id",
    "name": "ZDR Endpoint Name"
  }
]
```
```

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

### Basic Error Handling with OpenRouterClient

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

Demonstrates how to build an OpenRouter client and handle potential errors when listing available models. It shows specific matching for API and network errors.

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

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

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

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

### Get Credits

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

Retrieves the total credits purchased and used for the authenticated user.

```APIDOC
## GET /credits

### Description
Returns the total credits purchased and used for the authenticated user.

### Method
GET

### Endpoint
/credits

### Response
#### Success Response (200)
- **total_credits** (f64) - The total amount of credits purchased.
- **total_usage** (f64) - The total amount of credits used.

#### Response Example
```json
{
  "total_credits": 1000.0,
  "total_usage": 250.5
}
```
```

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

### Get All Model Categories

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

Retrieves a vector containing all possible ModelCategory variants.

```APIDOC
## Method: ModelCategory::all

### Description
Returns a `Vec<ModelCategory>` containing all defined model categories.

### Signature
```rust
pub fn all() -> Vec<ModelCategory>
```
```

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

### Create ReasoningConfig with Default Enabled Settings

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

Initializes a new ReasoningConfig with default enabled settings, including medium effort. Useful for starting with a standard configuration.

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

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

### Get Available Model Count

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

Retrieves the total count of available models.

```APIDOC
## GET /models/count

### Description
Get the total count of available models.

### Method
GET

### Endpoint
/models/count

### Response
#### Success Response (200)
- **model_count_data** (ModelsCountData) - Data containing the model count.

#### Response Example
```json
{
  "model_count_data": {
    "total": 0
  }
}
```
```

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

### Basic Chat Completion with openrouter-rs

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

Demonstrates creating an OpenRouter client, building a chat completion request, and sending it to the API. Ensure you replace 'your_api_key' and provide a valid HTTP referer and app categories.

```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")
        .app_categories(["cli-agent"])
        .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.chat().create(&request).await?;
    println!("Response: {}", response.choices[0].content().unwrap_or(""));

    Ok(())
}
```

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

### UserModel

Source: https://docs.rs/openrouter-rs/latest/openrouter_rs/api/discovery/struct.UserModel.html

Represents a user's model payload returned by `GET /models/user`.

```APIDOC
## Struct UserModel

Model payload returned by `GET /models/user`.

### Fields
- `id`: String
- `canonical_slug`: String
- `hugging_face_id`: Option<String>
- `name`: String
- `created`: f64
- `description`: Option<String>
- `pricing`: PublicPricing
- `context_length`: Option<f64>
- `architecture`: ModelArchitecture
- `top_provider`: TopProviderInfo
- `per_request_limits`: Option<PerRequestLimits>
- `supported_parameters`: Vec<String>
- `default_parameters`: Option<Value>
- `expiration_date`: Option<String>
- `extra`: HashMap<String, Value>
```

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

### Parse Tool Arguments Example

Source: https://docs.rs/openrouter-rs/latest/src/openrouter_rs/types/completion.rs.html

Demonstrates how to parse tool call arguments into a typed struct using the `parse_params` method. Requires the `schemars` crate for JSON schema generation and `serde` for deserialization.

```rust
impl ToolCall {
    /// Parse tool arguments into typed parameters
    ///
    /// # Examples
    ///
    /// ```rust
    /// use openrouter_rs::types::{ToolCall, completion::FunctionCall};
    /// use openrouter_rs::types::typed_tool::TypedTool;
    /// use serde::{Deserialize, Serialize};
    /// use schemars::JsonSchema;
    ///
    /// #[derive(Serialize, Deserialize, JsonSchema)]
    /// struct WeatherParams {
    ///     location: String,
    /// }
    ///
    /// impl TypedTool for WeatherParams {
    ///     fn name() -> &'static str { "get_weather" }
    ///     fn description() -> &'static str { "Get weather" }
    /// }
    ///
    /// let tool_call = ToolCall {
    ///     id: "call_123".to_string(),
    ///     type_: "function".to_string(),
    ///     function: FunctionCall {
    ///         name: "get_weather".to_string(),
    ///         arguments: r#"{"location":"Paris"}"#.to_string(),
    ///     },
    ///     index: None,
    /// };
    ///
    /// let params: WeatherParams = tool_call.parse_params()?;
    /// # Ok::<(), openrouter_rs::error::OpenRouterError>(())
    /// ```
    pub fn parse_params<T>(&self) -> Result<T, crate::error::OpenRouterError>
    where

```

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

### List Providers

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

Lists all available providers. This corresponds to the `GET /providers` endpoint.

```APIDOC
## GET /providers

### Description
List all available providers.

### Method
GET

### Endpoint
/providers

### Response
#### Success Response (200)
- **providers** (array of Provider) - A list of provider information.
```

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

### OpenRouterClient Builder

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

Demonstrates how to build an OpenRouterClient instance using its builder pattern. You can configure base URL, API keys, and other client-specific settings.

```APIDOC
## OpenRouterClient Builder

### Description
Use the `builder()` method to create a new `OpenRouterClient`. You can configure various aspects of the client, such as the base URL, API key, management key, HTTP referer, and X-Title.

### Method
`OpenRouterClient::builder()`

### Example
```rust
use openrouter_rs::OpenRouterClient;

let client = OpenRouterClient::builder()
    .base_url("https://openrouter.ai/api/v1")
    .api_key("your_api_key")
    .build()?;
```
```

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

### Get Activity

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

Retrieves activity logs for endpoint usage, optionally filtered by date.

```APIDOC
## Get Activity

### Description
Fetches a log of API usage activity. You can filter the activity by a specific date.

### Method
GET

### Endpoint
`/activity`

### Parameters
#### Path Parameters
None

#### Query Parameters
- `date` (string) - Optional - The date to filter activity logs for, typically in `YYYY-MM-DD` format.

### Request Example
None

### Response
#### Success Response (200)
- `Vec<ActivityItem>` (array) - A list of activity log items.

#### Response Example
```json
[
  {
    "endpoint": "/v1/chat/completions",
    "method": "POST",
    "timestamp": "2023-10-27T13:00:00Z",
    "user_id": "user_xyz789"
  }
]
```
```
Tokens:
Raw