litellm-rs 0.9.0

A high-performance AI Gateway written in Rust, providing OpenAI-compatible APIs with intelligent routing, load balancing, and enterprise features
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

use chrono::{DateTime, Utc};

use super::{GeminiModelFamily, GeminiModelRegistry, GoogleGeminiApiSurface, ModelInfo};

const FLASH_STANDARD_PRICING_START_UTC: i64 = 1_798_761_600;

pub(crate) fn flash_uses_standard_pricing_at(now: DateTime<Utc>) -> bool {
    now.timestamp() >= FLASH_STANDARD_PRICING_START_UTC
}

impl GeminiModelRegistry {
    /// List model metadata for a concrete Google API surface at the current price tier.
    pub fn list_model_infos_for_surface(&self, surface: GoogleGeminiApiSurface) -> Vec<ModelInfo> {
        self.list_model_infos_for_surface_at(surface, Utc::now())
    }

    pub(crate) fn list_model_infos_for_surface_at(
        &self,
        surface: GoogleGeminiApiSurface,
        now: DateTime<Utc>,
    ) -> Vec<ModelInfo> {
        let mut models = self
            .models
            .values()
            .filter(|spec| surface.includes(spec))
            .map(|spec| {
                let mut info = surface.overlay_model_info(spec);
                if flash_uses_standard_pricing_at(now)
                    && matches!(
                        spec.family,
                        GeminiModelFamily::Gemini36Flash
                            | GeminiModelFamily::Gemini37Flash
                            | GeminiModelFamily::Gemini38Flash
                    )
                {
                    info.input_cost_per_1k_tokens = Some(0.0015);
                    info.output_cost_per_1k_tokens = Some(0.0075);
                    if let Some(standard_cache_storage) = info
                        .metadata
                        .get("google_standard_cache_storage_cost_per_million_token_hour")
                        .cloned()
                    {
                        info.metadata.insert(
                            "google_current_cache_storage_cost_per_million_token_hour".to_string(),
                            standard_cache_storage,
                        );
                    }
                }
                info
            })
            .collect::<Vec<_>>();
        models.sort_by(|left, right| left.id.cmp(&right.id));
        models
    }
}