gproxy-protocol 4.1.2

GPROXY v4 connection modelling, operation declarations, vendor wire types and pairwise conversion
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

//! Pair preparation reuses the declared buffered request mappings and scoped
//! history recovery, then explicitly selects native streaming transport.

mod chat_claude;
mod chat_gemini;
mod chat_responses;
mod claude_gemini;
mod claude_responses;
mod gemini_responses;
mod limits;

use crate::wire::{
    DeclaredFields,
    claude::generate_content as c,
    gemini as g,
    openai::{chat as h, responses as r},
};

pub use chat_gemini::ChatViaGeminiStreamFacts;
pub use claude_gemini::{ClaudeViaGeminiStreamFacts, GeminiViaClaudeStreamFacts};
pub use claude_responses::ResponsesViaClaudeStreamFacts;
pub use gemini_responses::ResponsesViaGeminiStreamFacts;

trait RequestMode: DeclaredFields + Clone {
    fn buffered(self) -> Self;
    fn streaming(self) -> Self;
    fn emit_usage(&self) -> bool {
        true
    }
}

impl RequestMode for h::GenerateContentRequestBody {
    fn buffered(mut self) -> Self {
        self.stream = Some(Some(false));
        self
    }
    fn streaming(mut self) -> Self {
        self.stream = Some(Some(true));
        let mut options = self
            .stream_options
            .take()
            .flatten()
            .unwrap_or_else(|| h::StreamOptions::builder().build())
            .into_declared();
        options.include_usage = Some(true);
        self.stream_options = Some(Some(options));
        self
    }
    fn emit_usage(&self) -> bool {
        if self.stream.flatten() != Some(true) {
            return true;
        }
        self.stream_options
            .as_ref()
            .and_then(Option::as_ref)
            .and_then(|v| v.include_usage)
            == Some(true)
    }
}

impl RequestMode for c::GenerateContentRequestBody {
    fn buffered(mut self) -> Self {
        self.stream = Some(false);
        self
    }
    fn streaming(mut self) -> Self {
        self.stream = Some(true);
        self
    }
}

impl RequestMode for r::GenerateContentRequestBody {
    fn buffered(mut self) -> Self {
        self.stream = Some(Some(false));
        self
    }
    fn streaming(mut self) -> Self {
        self.stream = Some(Some(true));
        self
    }
}

impl RequestMode for g::GenerateContentRequestBody {
    fn buffered(self) -> Self {
        self
    }
    fn streaming(self) -> Self {
        self
    }
}