ort_openrouter_cli/input/
to_json.rs

1//! ort: Open Router CLI
2//! https://github.com/grahamking/ort
3//!
4//! MIT License
5//! Copyright (c) 2025 Graham King
6
7extern crate alloc;
8use alloc::string::String;
9
10use crate::{ErrorKind, Message, OrtResult, PromptOpts, Write, ort_error};
11
12/// Build the POST body
13/// The system and user prompts must already by in messages.
14pub fn build_body(idx: usize, opts: &PromptOpts, messages: &[Message]) -> OrtResult<String> {
15    let capacity: u32 = 1024 + messages.iter().map(|m| m.size()).sum::<u32>();
16    let mut string_buf = String::with_capacity(capacity as usize);
17    let mut w = unsafe { string_buf.as_mut_vec() };
18
19    w.write_str("{\"stream\": true, \"usage\": {\"include\": true}, \"model\": ")?;
20    write_json_str(&mut w, opts.models.get(idx).expect("Missing model"))?;
21
22    if opts.priority.is_some() || opts.provider.is_some() {
23        w.write_str(", \"provider\": {")?;
24        let mut is_first = true;
25        if let Some(p) = opts.priority {
26            w.write_str("\"sort\":")?;
27            write_json_str_simple(&mut w, p.as_str())?;
28            is_first = false;
29        }
30        if let Some(pr) = &opts.provider {
31            if !is_first {
32                w.write_str(", ")?;
33            }
34            w.write_str("\"order\": [")?;
35            write_json_str(&mut w, pr)?;
36            w.write_char(']')?;
37        }
38        w.write_char('}')?;
39    }
40
41    w.write_str(", \"reasoning\": ")?;
42    match &opts.reasoning {
43        // No -r and nothing in config file
44        None => {
45            w.write_str("{\"enabled\": false}")?;
46        }
47        // cli "-r off" or config file '"enabled": false'
48        Some(r_cfg) if !r_cfg.enabled => {
49            w.write_str("{\"enabled\": false}")?;
50        }
51        // Reasoning on
52        Some(r_cfg) => match (r_cfg.effort, r_cfg.tokens) {
53            (Some(effort), _) => {
54                w.write_str("{\"exclude\": false, \"enabled\": true, \"effort\":")?;
55                write_json_str_simple(&mut w, effort.as_str())?;
56                w.write_char('}')?;
57            }
58            (_, Some(tokens)) => {
59                w.write_str("{\"exclude\": false, \"enabled\": true, \"max_tokens\":")?;
60                write_u32(&mut w, tokens)?;
61                w.write_char('}')?;
62            }
63            _ => unreachable!("Reasoning effort and tokens cannot both be null"),
64        },
65    };
66
67    w.write_str(", \"messages\":")?;
68    Message::write_json_array(messages, &mut w)?;
69
70    w.write_char('}')?;
71
72    Ok(string_buf)
73}
74
75impl PromptOpts {
76    pub fn to_json_writer<W: Write>(&self, writer: &mut W) -> OrtResult<()> {
77        let w = writer;
78
79        w.write_char('{')?;
80        let mut first = true;
81
82        if let Some(ref v) = self.prompt {
83            if !first {
84                w.write_char(',')?;
85            } else {
86                first = false;
87            }
88            w.write_str("\"prompt\":")?;
89            write_json_str(w, v)?;
90        }
91        // TODO: consider multi-model
92        if let Some(v) = self.models.first() {
93            if !first {
94                w.write_char(',')?;
95            } else {
96                first = false;
97            }
98            w.write_str("\"model\":")?;
99            write_json_str(w, v)?;
100        }
101        if let Some(ref v) = self.provider {
102            if !first {
103                w.write_char(',')?;
104            } else {
105                first = false;
106            }
107            w.write_str("\"provider\":")?;
108            write_json_str(w, v)?;
109        }
110        if let Some(ref v) = self.system {
111            if !first {
112                w.write_char(',')?;
113            } else {
114                first = false;
115            }
116            w.write_str("\"system\":")?;
117            write_json_str(w, v)?;
118        }
119        if let Some(ref p) = self.priority {
120            if !first {
121                w.write_char(',')?;
122            } else {
123                first = false;
124            }
125            w.write_str("\"priority\":")?;
126            write_json_str_simple(w, p.as_str())?;
127        }
128        if let Some(ref rc) = self.reasoning {
129            if !first {
130                w.write_char(',')?;
131            } else {
132                first = false;
133            }
134            w.write_str("\"reasoning\":{")?;
135            // always include enabled
136            w.write_str("\"enabled\":")?;
137            write_bool(w, rc.enabled)?;
138            if let Some(ref eff) = rc.effort {
139                w.write_str(",\"effort\":")?;
140                write_json_str_simple(w, eff.as_str())?;
141            }
142            if let Some(tokens) = rc.tokens {
143                w.write_str(",\"tokens\":")?;
144                write_u32(w, tokens)?;
145            }
146            w.write_char('}')?;
147        }
148        if let Some(show) = self.show_reasoning {
149            if !first {
150                w.write_char(',')?;
151            } else {
152                first = false;
153            }
154            w.write_str("\"show_reasoning\":")?;
155            write_bool(w, show)?;
156        }
157        if let Some(quiet) = self.quiet {
158            if !first {
159                w.write_char(',')?;
160            } else {
161                //first = false;
162            }
163            w.write_str("\"quiet\":")?;
164            write_bool(w, quiet)?;
165        }
166
167        // merge_config
168        w.write_char(',')?;
169        w.write_str("\"merge_config\":")?;
170        write_bool(w, self.merge_config)?;
171
172        w.write_char('}')?;
173        Ok(())
174    }
175}
176
177const HEX: &[u8; 16] = b"0123456789ABCDEF";
178
179fn write_bool<W: Write>(w: &mut W, v: bool) -> OrtResult<usize> {
180    if v {
181        w.write_str("true")
182    } else {
183        w.write_str("false")
184    }
185}
186
187fn write_u32<W: Write>(w: &mut W, mut n: u32) -> OrtResult<usize> {
188    if n == 0 {
189        return w.write_str("0");
190    }
191    let mut buf = [0u8; 10];
192    let mut i = buf.len();
193    while n > 0 {
194        i -= 1;
195        buf[i] = b'0' + (n % 10) as u8;
196        n /= 10;
197    }
198    w.write(&buf[i..])
199}
200
201impl Message {
202    pub fn write_json_array<W: Write>(msgs: &[Message], w: &mut W) -> OrtResult<()> {
203        w.write_char('[')?;
204        for (i, msg) in msgs.iter().enumerate() {
205            if i != 0 {
206                w.write_char(',')?;
207            }
208            write_json(msg, w)?;
209        }
210        w.write_char(']')?;
211        Ok(())
212    }
213}
214
215pub fn write_json<W: Write>(data: &Message, w: &mut W) -> OrtResult<()> {
216    w.write_str("{\"role\":")?;
217    write_json_str_simple(w, data.role.as_str())?;
218    match (&data.content, &data.reasoning) {
219        (Some(_), Some(_)) | (None, None) => {
220            return Err(ort_error(
221                ErrorKind::InvalidMessageSchema,
222                "Message must have exactly one of 'content' or 'reasoning'.",
223            ));
224        }
225        (Some(content), _) => {
226            w.write_str(",\"content\":")?;
227            write_json_str(w, content)?;
228        }
229        (_, Some(reasoning)) => {
230            w.write_str(",\"reasoning\":")?;
231            write_json_str(w, reasoning)?;
232        }
233    }
234    w.write_char('}')?;
235    Ok(())
236}
237
238/// No escapes or special characters, just write the bytes
239pub(crate) fn write_json_str_simple<W: Write>(w: &mut W, s: &str) -> OrtResult<()> {
240    w.write_char('"')?;
241    w.write_str(s)?;
242    w.write_char('"')?;
243    Ok(())
244}
245
246// Writes a JSON string (with surrounding quotes) with proper escaping, no allocations.
247fn write_json_str<W: Write>(w: &mut W, s: &str) -> OrtResult<()> {
248    w.write_char('"')?;
249    write_encoded_bytes(w, s.as_bytes())?;
250    w.write_char('"')?;
251
252    Ok(())
253}
254
255pub fn write_encoded_bytes<W: Write>(w: &mut W, bytes: &[u8]) -> OrtResult<()> {
256    let mut start = 0;
257
258    for i in 0..bytes.len() {
259        let b = bytes[i];
260        let esc = match b {
261            b'"' => Some(b"\\\""), // as &[u8]),
262            b'\\' => Some(b"\\\\"),
263            b'\n' => Some(b"\\n"),
264            b'\r' => Some(b"\\r"),
265            b'\t' => Some(b"\\t"),
266            0x08 => Some(b"\\b"),
267            0x0C => Some(b"\\f"),
268            0x00..=0x1F => None, // will use \u00XX
269            _ => continue,
270        };
271
272        if start < i {
273            w.write(&bytes[start..i])?;
274        }
275
276        if let Some(e) = esc {
277            w.write(e)?;
278        } else {
279            // Generic control char: \u00XX
280            let mut buf = [0u8; 6];
281            buf[0] = b'\\';
282            buf[1] = b'u';
283            buf[2] = b'0';
284            buf[3] = b'0';
285            buf[4] = HEX[((b >> 4) & 0xF) as usize];
286            buf[5] = HEX[(b & 0xF) as usize];
287            w.write(&buf)?;
288        }
289
290        start = i + 1;
291    }
292
293    if start < bytes.len() {
294        w.write(&bytes[start..])?;
295    }
296    Ok(())
297}
298
299#[cfg(test)]
300mod tests {
301    extern crate alloc;
302    use alloc::string::ToString;
303    use alloc::vec;
304
305    use super::*;
306    use crate::ReasoningConfig;
307
308    #[test]
309    fn test_build_body() {
310        let opts = PromptOpts {
311            prompt: None,
312            models: vec!["google/gemma-3n-e4b-it:free".to_string()],
313            provider: Some("google-ai-studio".to_string()),
314            system: Some("System prompt here".to_string()),
315            priority: None,
316            reasoning: Some(ReasoningConfig::off()),
317            show_reasoning: Some(false),
318            quiet: None,
319            merge_config: false,
320        };
321        let messages = vec![
322            Message::user("Hello".to_string()),
323            Message::assistant("Hello there!".to_string()),
324        ];
325        let got = match build_body(0, &opts, &messages) {
326            Ok(got) => got,
327            Err(err) => {
328                panic!("{}", err.as_string());
329            }
330        };
331
332        let expected = r#"{"stream": true, "usage": {"include": true}, "model": "google/gemma-3n-e4b-it:free", "provider": {"order": ["google-ai-studio"]}, "reasoning": {"enabled": false}, "messages":[{"role":"user","content":"Hello"},{"role":"assistant","content":"Hello there!"}]}"#;
333
334        assert_eq!(got, expected);
335    }
336}
ort_openrouter_cli/input/to_json.rs

ort_openrouter_cli/input/
to_json.rs
