gproxy-protocol 4.0.3

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

use super::*;
use base64::Engine as _;

#[derive(Clone)]
pub(crate) enum Media {
    Image {
        url: String,
        detail: Option<source::ImageDetail>,
    },
    Audio {
        url: String,
    },
}

pub(super) fn media(input: &source::GuardianRequestBody) -> Result<Vec<Media>, TransformError> {
    let mut output = Vec::new();
    for entry in &input.input {
        let add_output = |body: &source::FunctionCallOutputBody, output: &mut Vec<Media>| {
            if let source::FunctionCallOutputBody::ContentItems(items) = body {
                for item in items {
                    match item {
                        source::FunctionCallOutputContentItem::InputImage(v) => {
                            output.push(Media::Image {
                                url: v.image_url.clone(),
                                detail: v.detail.clone(),
                            })
                        }
                        source::FunctionCallOutputContentItem::InputAudio(v) => {
                            output.push(Media::Audio {
                                url: v.audio_url.clone(),
                            })
                        }
                        _ => {}
                    }
                }
            }
        };
        match entry {
            source::ClientResponseItem::Message(v) => {
                for item in &v.content {
                    match item {
                        source::ContentItem::InputImage(x) => output.push(Media::Image {
                            url: x.image_url.clone(),
                            detail: x.detail.clone(),
                        }),
                        source::ContentItem::InputAudio(x) => output.push(Media::Audio {
                            url: x.audio_url.clone(),
                        }),
                        _ => {}
                    }
                }
            }
            source::ClientResponseItem::FunctionCallOutput(v) => add_output(&v.output, &mut output),
            source::ClientResponseItem::CustomToolCallOutput(v) => {
                add_output(&v.output, &mut output)
            }
            source::ClientResponseItem::ImageGenerationCall(v) => {
                let bytes = STANDARD.decode(&v.result).map_err(|e| {
                    TransformError::shape("guardian.image_generation.result", e.to_string())
                })?;
                let info = crate::transform::images::inspect_image(&bytes).map_err(|e| {
                    TransformError::shape("guardian.image_generation.result", e.detail())
                })?;
                output.push(Media::Image {
                    url: format!("data:{};base64,{}", info.mime(), v.result),
                    detail: None,
                });
            }
            _ => {}
        }
    }
    Ok(output)
}

pub(super) fn data_uri(value: &str) -> Result<(String, String), TransformError> {
    let (mime, data) = value
        .strip_prefix("data:")
        .and_then(|v| v.split_once(";base64,"))
        .ok_or_else(|| {
            TransformError::missing_metadata(
                "guardian media requires a resolved data URI with MIME",
            )
        })?;
    STANDARD
        .decode(data)
        .map_err(|e| TransformError::shape("guardian.media", e.to_string()))?;
    Ok((mime.into(), data.into()))
}

pub(super) fn detail(value: &Option<source::ImageDetail>) -> r::ImageDetail {
    match value {
        None | Some(source::ImageDetail::Auto) => r::ImageDetail::Auto,
        Some(source::ImageDetail::Low) => r::ImageDetail::Low,
        Some(source::ImageDetail::High) => r::ImageDetail::High,
        Some(source::ImageDetail::Original) => r::ImageDetail::Original,
    }
}

impl Media {
    pub(crate) fn url(&self) -> &str {
        match self {
            Self::Image { url, .. } | Self::Audio { url } => url,
        }
    }
    pub(crate) fn set_url(&mut self, value: String) {
        match self {
            Self::Image { url, .. } | Self::Audio { url } => *url = value,
        }
    }
    pub(crate) fn needs_resolution(&self, target: GuardianTarget) -> bool {
        !self.url().starts_with("data:")
            && (target == GuardianTarget::Gemini
                || matches!(
                    (target, self),
                    (GuardianTarget::OpenAiChat, Self::Audio { .. })
                ))
    }
}