gproxy-protocol 4.1.11

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
91
92
93
94
95
96
97
98
99
100
101
102
103

use super::super::{
    chat_claude::ChatViaClaude, chat_responses::ChatViaResponses, claude_gemini::GeminiViaClaude,
    gemini_responses::GeminiViaResponses, identity_facts::IdentityFacts,
};
use super::*;
use crate::{
    transform::{Converted, Report},
    wire::{
        DeclaredFields,
        claude::generate_content as c,
        gemini as g,
        openai::{chat as h, responses as r},
    },
};
use serde::{Serialize, de::DeserializeOwned};

pub(super) trait Edge {
    type Request: Serialize + DeclaredFields + Clone;
    type Native: Serialize + DeserializeOwned + DeclaredFields + Clone + IdentityFacts;
    type Client: output::Client;
    type Facts;
    fn request(&self) -> &Self::Request;
    fn identities(&self) -> &GenerationIdentity;
    fn report(&self) -> &Report;

    fn convert(
        &mut self,
        native: Self::Native,
        facts: Self::Facts,
    ) -> Result<Converted<Self::Client>, TransformError>;
}

macro_rules! edge {
    ($a:ty,$request:ty,$native:ty,$client:ty,$facts:ty) => {
        impl Edge for $a {
            type Request = $request;
            type Native = $native;
            type Client = $client;
            type Facts = $facts;
            fn request(&self) -> &Self::Request {
                self.target_request()
            }
            fn identities(&self) -> &GenerationIdentity {
                self.identities()
            }
            fn report(&self) -> &Report {
                self.report()
            }
            fn convert(
                &mut self,
                native: Self::Native,
                facts: Self::Facts,
            ) -> Result<Converted<Self::Client>, TransformError> {
                self.convert_response(native, facts)
            }
        }
    };
}
edge!(
    ChatViaClaude,
    c::GenerateContentRequestBody,
    c::GenerateContentResponseBody,
    h::GenerateContentResponseBody,
    crate::transform::generate::claude_chat::ResponseSupplement
);
edge!(
    ChatViaResponses,
    r::GenerateContentRequestBody,
    r::GenerateContentResponseBody,
    h::GenerateContentResponseBody,
    ()
);
edge!(
    GeminiViaClaude,
    c::GenerateContentRequestBody,
    c::GenerateContentResponseBody,
    g::GenerateContentResponseBody,
    crate::transform::generate::claude_gemini::ClaudeGeminiUsageFacts
);

impl Edge for GeminiViaResponses {
    type Request = r::GenerateContentRequestBody;
    type Native = r::GenerateContentResponseBody;
    type Client = g::GenerateContentResponseBody;
    type Facts = crate::transform::generate::gemini_responses::GeminiReplayContext;
    fn request(&self) -> &Self::Request {
        self.target_request()
    }
    fn identities(&self) -> &GenerationIdentity {
        self.identities()
    }
    fn report(&self) -> &Report {
        self.report()
    }

    fn convert(
        &mut self,
        native: Self::Native,
        facts: Self::Facts,
    ) -> Result<Converted<Self::Client>, TransformError> {
        self.convert_response(native, facts)
    }
}