gproxy-protocol 4.1.14

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::{
    transform::TransformError,
    wire::openai::{chat as c, responses::generate as r},
};

pub(super) fn to_responses(
    input: &c::GenerateContentRequestBody,
    out: &mut r::GenerateContentRequestBody,
) -> Result<(), TransformError> {
    out.prompt_cache_retention = input.prompt_cache_retention.map(|v| {
        v.map(|v| match v {
            c::PromptCacheRetention::InMemory => r::PromptCacheRetention::InMemory,
            c::PromptCacheRetention::TwentyFourHours => r::PromptCacheRetention::TwentyFourHours,
        })
    });
    out.prompt_cache_options = input.prompt_cache_options.as_ref().map(|value| {
        let mut target = r::PromptCacheOptions::builder().build();
        target.mode = value.mode.map(|v| match v {
            c::PromptCacheOptionMode::Implicit => r::PromptCachingMode::Implicit,
            c::PromptCacheOptionMode::Explicit => r::PromptCachingMode::Explicit,
        });
        target.ttl = value.ttl.map(|v| match v {
            c::PromptCacheTtl::ThirtyMinutes => r::PromptCacheTtl::ThirtyMinutes,
        });
        target
    });
    out.moderation = input.moderation.as_ref().map(|value| {
        value.as_ref().map(|value| {
            let mut target = r::ResponseModeration::builder(value.model.clone()).build();
            target.policy = value.policy.as_ref().map(|value| {
                value.as_ref().map(|value| {
                    let mut policy = r::ModerationPolicy::builder().build();
                    policy.input = value.input.as_ref().map(|v| {
                        v.as_ref().map(|v| {
                            r::ModerationPolicyMode::builder(match v.mode {
                                c::ModerationModeType::Score => r::ModerationMode::Score,
                                c::ModerationModeType::Block => r::ModerationMode::Block,
                            })
                            .build()
                        })
                    });
                    policy.output = value.output.as_ref().map(|v| {
                        v.as_ref().map(|v| {
                            r::ModerationPolicyMode::builder(match v.mode {
                                c::ModerationModeType::Score => r::ModerationMode::Score,
                                c::ModerationModeType::Block => r::ModerationMode::Block,
                            })
                            .build()
                        })
                    });
                    policy
                })
            });
            target
        })
    });
    Ok(())
}

pub(super) fn to_chat(
    input: &r::GenerateContentRequestBody,
    out: &mut c::GenerateContentRequestBody,
) -> Result<(), TransformError> {
    if input.prompt_cache_options.as_ref().and_then(|v| v.ttl)
        == Some(r::PromptCacheTtl::TwelveHours)
    {
        return Err(TransformError::unsupported(
            "prompt_cache_options.ttl",
            "Chat Completions has no request-wide 12h cache lifetime",
        ));
    }
    out.prompt_cache_retention = input.prompt_cache_retention.map(|v| {
        v.map(|v| match v {
            r::PromptCacheRetention::InMemory => c::PromptCacheRetention::InMemory,
            r::PromptCacheRetention::TwentyFourHours => c::PromptCacheRetention::TwentyFourHours,
        })
    });
    out.prompt_cache_options = input.prompt_cache_options.as_ref().map(|value| {
        let mut target = c::PromptCacheOptions::builder().build();
        target.mode = value.mode.map(|v| match v {
            r::PromptCachingMode::Implicit => c::PromptCacheOptionMode::Implicit,
            r::PromptCachingMode::Explicit => c::PromptCacheOptionMode::Explicit,
        });
        target.ttl = value.ttl.map(|v| match v {
            r::PromptCacheTtl::ThirtyMinutes => c::PromptCacheTtl::ThirtyMinutes,
            r::PromptCacheTtl::TwelveHours => unreachable!("checked above"),
        });
        target
    });
    out.moderation = input.moderation.as_ref().map(|value| {
        value.as_ref().map(|value| {
            let mut target = c::Moderation::builder(value.model.clone()).build();
            target.policy = value.policy.as_ref().map(|value| {
                value.as_ref().map(|value| {
                    let mut policy = c::ModerationPolicy::builder().build();
                    policy.input = value.input.as_ref().map(|v| {
                        v.as_ref().map(|v| {
                            c::ModerationMode::builder(match v.mode {
                                r::ModerationMode::Score => c::ModerationModeType::Score,
                                r::ModerationMode::Block => c::ModerationModeType::Block,
                            })
                            .build()
                        })
                    });
                    policy.output = value.output.as_ref().map(|v| {
                        v.as_ref().map(|v| {
                            c::ModerationMode::builder(match v.mode {
                                r::ModerationMode::Score => c::ModerationModeType::Score,
                                r::ModerationMode::Block => c::ModerationModeType::Block,
                            })
                            .build()
                        })
                    });
                    policy
                })
            });
            target
        })
    });
    Ok(())
}