muna 0.0.28

Run prediction functions in your Rust apps.
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

/*
*   Muna
*   Copyright © 2026 NatML Inc. All Rights Reserved.
*/

use serde::{Deserialize, Serialize};

use super::Dtype;

/// Prediction parameter.
/// Describes a value that is consumed or produced by a predictor.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Parameter {
    /// Parameter name.
    pub name: String,
    /// Parameter data type.
    #[serde(default)]
    pub dtype: Option<Dtype>,
    /// Parameter description.
    #[serde(default)]
    pub description: Option<String>,
    /// Parameter denotation for specialized data types.
    #[serde(default)]
    pub denotation: Option<String>,
    /// Parameter is optional.
    #[serde(default)]
    pub optional: Option<bool>,
    /// Parameter value choices for enumeration parameters.
    #[serde(default)]
    pub enumeration: Option<Vec<EnumerationMember>>,
    /// Parameter JSON schema (only populated for `list` and `dict` parameters).
    #[serde(default)]
    pub schema: Option<serde_json::Map<String, serde_json::Value>>,
    /// Parameter minimum value.
    #[serde(default)]
    pub min: Option<f64>,
    /// Parameter maximum value.
    #[serde(default)]
    pub max: Option<f64>,
    /// Audio sample rate in Hertz.
    #[serde(default)]
    pub sample_rate: Option<u32>,
    /// Maximum context length in tokens for chat message parameters.
    #[serde(default)]
    pub context_length: Option<u32>,
    /// Batch configuration for list parameters.
    #[serde(default)]
    pub batch: Option<BatchConfig>,
}

/// Enumeration member value.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EnumerationValue {
    String(String),
    Int(i64),
}

/// Prediction parameter enumeration member.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EnumerationMember {
    /// Enumeration member name.
    pub name: String,
    /// Enumeration member value.
    pub value: EnumerationValue,
}

/// Batching mode for a batched parameter.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum BatchMode {
    /// Fixed-size batches: buffer until capacity, then invoke.
    Static,
    /// Variable-size batches up to capacity.
    Dynamic,
    /// Predictor batches internally; callers submit concurrently.
    Continuous,
}

/// Batch configuration for list parameters.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BatchConfig {
    /// Batching mode.
    pub mode: BatchMode,
    /// Batch capacity. Required for `static` and `dynamic` modes.
    #[serde(default, alias = "max_count", alias = "maxCount", skip_serializing_if = "Option::is_none")]
    pub capacity: Option<usize>,
}
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn context_length_round_trips_camel_case() {
        let param: Parameter = serde_json::from_str(r#"{
            "name": "messages",
            "dtype": "list",
            "denotation": "openai.chat.completions.messages",
            "contextLength": 262144
        }"#).unwrap();
        assert_eq!(param.context_length, Some(262_144));
        let json = serde_json::to_value(&param).unwrap();
        assert_eq!(json["contextLength"], 262_144);
    }

    #[test]
    fn context_length_defaults_to_none() {
        let param: Parameter = serde_json::from_str(r#"{ "name": "x", "dtype": "int32" }"#).unwrap();
        assert!(param.context_length.is_none());
    }
}