gproxy-protocol 4.1.10

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

//! Gemini model controls and metadata projection for cross-dialect conversions.
use crate::{gemini::Part, transform::Report};

pub(crate) fn omitted(part: &Part, report: &mut Report) {
    for (present, field) in [
        (part.media_processing.is_some(), "media_processing"),
        (part.audio_transcription.is_some(), "audio_transcription"),
        (part.speech_metadata.is_some(), "speech_metadata"),
        (
            part.inline_data
                .as_ref()
                .is_some_and(|v| v.display_name.is_some()),
            "inline_data.display_name",
        ),
        (
            part.file_data
                .as_ref()
                .is_some_and(|v| v.display_name.is_some()),
            "file_data.display_name",
        ),
    ] {
        if present {
            report.omitted(field, "Gemini media metadata has no target representation");
        }
    }
}

/// Migration controls apply only to newly converted requests. Native requests
/// retain their wire fields, including fields used by older models.
pub(crate) fn for_model(
    request: &mut crate::gemini::GenerateContentRequestBody,
    model: &str,
    report: &mut Report,
) {
    let model = model.rsplit('/').next().unwrap_or(model);
    let flash_38 = matches!(model, "gemini-3.8-flash" | "gemini-3.7-flash");
    let level_only = flash_38 || model == "gemini-4-argon";
    if !level_only && !matches!(model, "gemini-3.5-flash" | "gemini-3.6-flash") {
        return;
    }
    let Some(config) = &mut request.generation_config else {
        return;
    };
    for (present, field) in [
        (config.temperature.take().is_some(), "temperature"),
        (config.top_p.take().is_some(), "top_p"),
        (config.top_k.take().is_some(), "top_k"),
        (
            flash_38 && config.candidate_count.take().is_some(),
            "candidate_count",
        ),
    ] {
        if present {
            report.omitted(
                field,
                "Target Gemini model no longer supports this generation control",
            );
        }
    }
    if !level_only {
        return;
    }
    if let Some(thinking) = &mut config.thinking_config {
        let budget = thinking.thinking_budget.take();
        if budget.is_some() {
            report.omitted(
                "thinking_budget",
                "Target Gemini model uses thinking_level instead of a token budget",
            );
        }
        if thinking.thinking_level == Some(crate::gemini::ThinkingLevel::Minimal)
            || (thinking.thinking_level.is_none() && budget == Some(0))
        {
            thinking.thinking_level = Some(crate::gemini::ThinkingLevel::Low);
            report.changed(
                "thinking_level",
                "Target Gemini model requires at least low thinking effort",
            );
        }
    }
}

/// Continuation carries opaque upstream state, not portable conversation history.
pub(crate) fn continuation_error() -> crate::transform::TransformError {
    crate::transform::TransformError::unsupported(
        "continuation_token",
        "Gemini long decode requires native continuation; cross-dialect continuation is unsupported",
    )
}