gproxy-protocol 1.0.20

Wire-format types and cross-protocol transforms for Claude, OpenAI, and Gemini LLM APIs.
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

use crate::gemini::embeddings::response::{GeminiEmbedContentResponse, ResponseBody};
use crate::gemini::embeddings::types::GeminiContentEmbedding;
use crate::gemini::types::{GeminiApiError, GeminiApiErrorResponse, GeminiResponseHeaders};
use crate::openai::embeddings::response::OpenAiEmbeddingsResponse;
use crate::openai::embeddings::types::OpenAiEmbeddingVector;
use crate::transform::utils::TransformError;

fn google_status_from_http(status_code: http::StatusCode) -> Option<String> {
    let status = match status_code.as_u16() {
        400 => "INVALID_ARGUMENT",
        401 => "UNAUTHENTICATED",
        403 => "PERMISSION_DENIED",
        404 => "NOT_FOUND",
        409 => "ABORTED",
        429 => "RESOURCE_EXHAUSTED",
        500 => "INTERNAL",
        503 | 529 => "UNAVAILABLE",
        504 => "DEADLINE_EXCEEDED",
        _ => return None,
    };
    Some(status.to_string())
}

impl TryFrom<OpenAiEmbeddingsResponse> for GeminiEmbedContentResponse {
    type Error = TransformError;

    fn try_from(value: OpenAiEmbeddingsResponse) -> Result<Self, TransformError> {
        Ok(match value {
            OpenAiEmbeddingsResponse::Success {
                stats_code,
                headers,
                body,
            } => {
                let values = body
                    .data
                    .into_iter()
                    .next()
                    .map(|item| match item.embedding {
                        OpenAiEmbeddingVector::FloatArray(values) => values,
                        OpenAiEmbeddingVector::Base64(_) => Vec::new(),
                    })
                    .unwrap_or_default();

                GeminiEmbedContentResponse::Success {
                    stats_code,
                    headers: GeminiResponseHeaders {
                        extra: headers.extra,
                    },
                    body: ResponseBody {
                        embedding: GeminiContentEmbedding {
                            values,
                            shape: None,
                        },
                    },
                }
            }
            OpenAiEmbeddingsResponse::Error {
                stats_code,
                headers,
                body,
            } => GeminiEmbedContentResponse::Error {
                stats_code,
                headers: GeminiResponseHeaders {
                    extra: headers.extra,
                },
                body: GeminiApiErrorResponse {
                    error: GeminiApiError {
                        code: i32::from(stats_code.as_u16()),
                        message: body.error.message,
                        status: google_status_from_http(stats_code),
                        details: None,
                    },
                },
            },
        })
    }
}