onwards 0.16.1

A flexible LLM proxy library
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Embeddings API schemas
//!
//! These schemas match the OpenAI Embeddings API specification.
//! See: https://platform.openai.com/docs/api-reference/embeddings

use serde::{Deserialize, Serialize};

/// Request body for POST /v1/embeddings
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmbeddingsRequest {
    /// The model to use for embeddings
    pub model: String,

    /// Input text to embed - can be a string or array of strings
    pub input: EmbeddingInput,

    /// Encoding format for the embeddings
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encoding_format: Option<String>,

    /// Number of dimensions for the embedding (for models that support it)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dimensions: Option<u32>,

    /// User identifier for abuse tracking
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
}

/// Input for embeddings - string, array of strings, or array of token arrays
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EmbeddingInput {
    Single(String),
    Multiple(Vec<String>),
    Tokens(Vec<Vec<u32>>),
}

/// Response from POST /v1/embeddings
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmbeddingsResponse {
    pub object: String,
    pub data: Vec<EmbeddingData>,
    pub model: String,
    pub usage: EmbeddingsUsage,
}

/// A single embedding result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmbeddingData {
    pub object: String,
    pub embedding: Embedding,
    pub index: u32,
}

/// Embedding values - can be floats or base64 encoded
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Embedding {
    Float(Vec<f32>),
    Base64(String),
}

/// Usage information for embeddings
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmbeddingsUsage {
    pub prompt_tokens: u32,
    pub total_tokens: u32,
}

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

    #[test]
    fn test_deserialize_simple_request() {
        let json = r#"{
            "model": "text-embedding-3-small",
            "input": "Hello, world!"
        }"#;

        let request: EmbeddingsRequest = serde_json::from_str(json).unwrap();
        assert_eq!(request.model, "text-embedding-3-small");
        assert!(matches!(request.input, EmbeddingInput::Single(_)));
    }

    #[test]
    fn test_deserialize_multiple_inputs() {
        let json = r#"{
            "model": "text-embedding-3-small",
            "input": ["Hello", "World"]
        }"#;

        let request: EmbeddingsRequest = serde_json::from_str(json).unwrap();
        assert!(matches!(request.input, EmbeddingInput::Multiple(_)));
    }

    #[test]
    fn test_deserialize_with_options() {
        let json = r#"{
            "model": "text-embedding-3-small",
            "input": "Hello",
            "encoding_format": "float",
            "dimensions": 256
        }"#;

        let request: EmbeddingsRequest = serde_json::from_str(json).unwrap();
        assert_eq!(request.encoding_format, Some("float".to_string()));
        assert_eq!(request.dimensions, Some(256));
    }

    #[test]
    fn test_serialize_response() {
        let response = EmbeddingsResponse {
            object: "list".to_string(),
            data: vec![EmbeddingData {
                object: "embedding".to_string(),
                embedding: Embedding::Float(vec![0.1, 0.2, 0.3]),
                index: 0,
            }],
            model: "text-embedding-3-small".to_string(),
            usage: EmbeddingsUsage {
                prompt_tokens: 5,
                total_tokens: 5,
            },
        };

        let json = serde_json::to_string(&response).unwrap();
        assert!(json.contains("text-embedding-3-small"));
    }
}