openrouter_api 0.1.6

A Rust client library for the OpenRouter API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use openrouter_api::{OpenRouterClient, utils, ModelGroups, PredefinedModelCoverageProfile};
use openrouter_api::types::chat::Message;
use openrouter_api::models::structured::JsonSchemaConfig;
use serde::{Deserialize, Serialize};
use std::time::Duration;

#[derive(Debug, Serialize, Deserialize)]
struct MovieRecommendation {
    title: String,
    year: u32,
    director: String,
    genre: String,
    description: String,
}

#[tokio::main]
async fn main() -> Result<(), openrouter_api::Error> {
    // Load API key from environment
    let api_key = utils::load_api_key_from_env()?;

    // Initialize client with Model Coverage Profile
    let client = OpenRouterClient::new()
        .with_base_url("https://openrouter.ai/api/v1/")?
        .with_http_referer("https://github.com/your-org/your-repo")
        .with_timeout(Duration::from_secs(60))
        .with_model_coverage_profile(PredefinedModelCoverageProfile::Custom(
            ModelGroups::general()
        ))
        .with_api_key(api_key)?;

    // Create a simple chat message
    let messages = vec![Message {
        role: "user".to_string(),
        content: "Recommend a sci-fi movie from the 1980s".to_string(),
        name: None,
        tool_calls: None,
    }];

    // Define JSON schema for structured output
    let schema = JsonSchemaConfig {
        name: "MovieRecommendation".to_string(),
        strict: true,
        schema: serde_json::from_value(serde_json::json!({
            "type": "object",
            "properties": {
                "title": {"type": "string"},
                "year": {"type": "integer", "minimum": 1980, "maximum": 1989},
                "director": {"type": "string"},
                "genre": {"type": "string"},
                "description": {"type": "string"}
            },
            "required": ["title", "year", "director", "genre", "description"]
        })).unwrap(),
    };

    // Get a structured response
    let structured_api = client.structured()?;
    let movie: MovieRecommendation = structured_api.generate(
        "openai/gpt-4o",
        messages,
        schema
    ).await?;

    println!("Recommended movie: {} ({})", movie.title, movie.year);
    println!("Director: {}", movie.director);
    println!("Genre: {}", movie.genre);
    println!("Description: {}", movie.description);

    Ok(())
}