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

use super::super::ResponsesUsageFacts;
use crate::{
    transform::TransformError,
    wire::{
        claude::{generate_content as c, stream as s},
        openai::responses as r,
    },
};

#[derive(Default)]
pub(super) struct ClaudeProgress {
    output: i64,
    thinking: Option<i64>,
    thinking_at: Option<i64>,
}

impl ClaudeProgress {
    pub fn start(&mut self, v: &c::Usage) -> Result<(), TransformError> {
        self.observe(
            v.output_tokens,
            v.output_tokens_details
                .as_ref()
                .and_then(Option::as_ref)
                .map(|v| v.thinking_tokens),
            v.output_tokens_details.is_some(),
        )
    }
    pub fn delta(&mut self, v: &s::MessageDeltaUsage) -> Result<(), TransformError> {
        self.observe(
            v.output_tokens,
            v.output_tokens_details
                .as_ref()
                .and_then(Option::as_ref)
                .map(|v| v.thinking_tokens),
            v.output_tokens_details.is_some(),
        )
    }
    fn observe(
        &mut self,
        output: i64,
        thinking: Option<i64>,
        present: bool,
    ) -> Result<(), TransformError> {
        self.output = output;
        if let Some(n) = thinking {
            self.thinking = Some(n);
            self.thinking_at = Some(output);
        } else if present {
            self.thinking_at = None;
        }
        Ok(())
    }
    pub fn finalize(
        &self,
        v: &mut c::Usage,
        _facts: ResponsesUsageFacts,
    ) -> Result<(), TransformError> {
        if self.thinking_at != Some(v.output_tokens) {
            v.output_tokens_details = None;
        }
        Ok(())
    }
}

pub(super) fn claude_tier(tier: Option<r::ServiceTier>) -> Option<Option<c::ResponseServiceTier>> {
    match tier {
        Some(r::ServiceTier::Default) => Some(Some(c::ResponseServiceTier::Standard)),
        Some(r::ServiceTier::Priority) => Some(Some(c::ResponseServiceTier::Priority)),
        _ => None,
    }
}