litellm-rs 0.4.16

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! AWS Bedrock Provider
//!
//! AWS Bedrock provider for accessing foundation models from AWS.
//! This implementation uses the base infrastructure for HTTP operations
//! and includes AWS SigV4 authentication.

// Core modules
mod client;
mod config;
mod error;
mod model_config;
mod provider;
mod sigv4;
mod transformation;
mod utils;

#[cfg(test)]
mod provider_tests;

// Feature modules
pub mod agents;
pub mod batch;
pub mod chat;
pub mod embeddings;
pub mod guardrails;
pub mod images;
pub mod knowledge_bases;
pub mod streaming;

// Re-export main types for external use
pub use client::BedrockClient;
pub use config::BedrockConfig;
pub use error::BedrockErrorMapper;
pub use model_config::{
    BedrockApiType, BedrockModelFamily, ModelConfig, get_all_model_ids, get_model_config,
    model_supports_capability,
};
pub use provider::BedrockProvider;
pub use sigv4::SigV4Signer;
pub use utils::{
    AWS_REGIONS, AwsAuth, AwsCredentials, CostCalculator, ModelPricing,
    is_model_available_in_region, normalize_bedrock_model_id, validate_region,
};

// Re-export feature modules
pub use chat::{route_chat_request, supports_converse, supports_streaming};
pub use embeddings::execute_embedding;
pub use guardrails::{GuardrailClient, GuardrailConfig, GuardrailSource};
pub use streaming::BedrockStream;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_model_routing() {
        // Test Claude model routing
        let claude_config = get_model_config("anthropic.claude-3-opus-20240229").unwrap();
        assert_eq!(claude_config.family, BedrockModelFamily::Claude);
        assert_eq!(claude_config.api_type, BedrockApiType::Converse);
        assert!(claude_config.supports_streaming);
        assert!(claude_config.supports_function_calling);

        // Test Titan model routing
        let titan_config = get_model_config("amazon.titan-text-express-v1").unwrap();
        assert_eq!(titan_config.family, BedrockModelFamily::TitanText);
        assert_eq!(titan_config.api_type, BedrockApiType::Invoke);
        assert!(titan_config.supports_streaming);
        assert!(!titan_config.supports_function_calling);

        // Test Nova model routing
        let nova_config = get_model_config("amazon.nova-pro-v1:0").unwrap();
        assert_eq!(nova_config.family, BedrockModelFamily::Nova);
        assert_eq!(nova_config.api_type, BedrockApiType::Converse);
        assert!(nova_config.supports_streaming);
        assert!(nova_config.supports_function_calling);

        // Test cost calculation
        assert_eq!(claude_config.input_cost_per_1k, 0.015);
        assert_eq!(claude_config.output_cost_per_1k, 0.075);
    }

    #[test]
    fn test_model_capabilities() {
        assert!(model_supports_capability(
            "anthropic.claude-3-opus-20240229",
            "streaming"
        ));
        assert!(model_supports_capability(
            "anthropic.claude-3-opus-20240229",
            "function_calling"
        ));
        assert!(model_supports_capability(
            "anthropic.claude-3-opus-20240229",
            "multimodal"
        ));

        assert!(!model_supports_capability(
            "amazon.titan-text-express-v1",
            "function_calling"
        ));
        assert!(!model_supports_capability(
            "amazon.titan-text-express-v1",
            "multimodal"
        ));
    }
}