gproxy-transform 2.2.2

Pairwise request/response/stream transforms between the OpenAI, Anthropic Claude, and Google Gemini 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

//! Gemini -> Claude count-token transforms.

use crate::protocol::{claude, gemini};
use crate::transform::{TransformContext, TransformError};

use super::common;

pub fn request(
    input: gemini::CountTokensRequest,
    _: &TransformContext,
) -> Result<claude::CountTokensRequestBody, TransformError> {
    let request = common::split_gemini_count_token_request(input);
    let tool_parts = common::gemini_tools_to_claude(request.tools);

    #[allow(deprecated)]
    Ok(claude::CountTokensRequestBody {
        model: common::gemini_model_string(request.model).into(),
        messages: common::text_to_claude_messages(common::gemini_contents_to_text(
            request.contents,
        )),
        cache_control: None,
        context_management: None,
        diagnostics: None,
        mcp_servers: tool_parts.mcp_servers,
        output_config: common::gemini_generation_to_claude_output_config(
            request.generation_config.as_ref(),
        ),
        output_format: common::gemini_generation_to_claude_output_format(
            request.generation_config.as_ref(),
        ),
        service_tier: common::gemini_service_tier_to_claude(request.service_tier),
        speed: None,
        system: common::text_to_claude_system(
            request.system_instruction.map(common::gemini_content_text),
        ),
        thinking: common::gemini_generation_to_claude_thinking(request.generation_config.as_ref()),
        tool_choice: common::gemini_tool_config_to_claude(request.tool_config),
        tools: tool_parts.tools,
        extra: Default::default(),
    })
}

pub fn response(
    input: gemini::CountTokensResponse,
    _: &TransformContext,
) -> claude::CountTokensResponseBody {
    claude::CountTokensResponseBody {
        input_tokens: input
            .total_tokens
            .map(common::i32_to_u64)
            .unwrap_or_default(),
        context_management: input.cached_content_token_count.map(|cached| {
            claude::CountTokensContextManagement {
                original_input_tokens: Some(common::i32_to_u64(cached)),
                extra: Default::default(),
            }
        }),
        extra: Default::default(),
    }
}