gproxy-transform 3.0.0-alpha.0

GPROXY v3 pairwise protocol transforms
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 gproxy_protocol::claude;

use crate::TransformError;

use super::ClaudeCollector;

impl ClaudeCollector {
    pub(super) fn apply_delta(
        &mut self,
        index: u64,
        delta: claude::EventDelta,
    ) -> Result<(), TransformError> {
        match delta {
            claude::EventDelta::Known(delta) => match *delta {
                claude::KnownEventDelta::Text { text, .. } => {
                    if let Some(claude::ResponseContentBlock::Text(block)) =
                        self.blocks.get_mut(&index)
                    {
                        block.text.push_str(&text);
                    }
                }
                claude::KnownEventDelta::Thinking { thinking, .. } => {
                    if let Some(claude::ResponseContentBlock::Thinking(block)) =
                        self.blocks.get_mut(&index)
                    {
                        block.thinking.push_str(&thinking);
                    }
                }
                claude::KnownEventDelta::Signature { signature, .. } => {
                    if let Some(claude::ResponseContentBlock::Thinking(block)) =
                        self.blocks.get_mut(&index)
                    {
                        block.signature.get_or_insert_default().push_str(&signature);
                    }
                }
                claude::KnownEventDelta::InputJson { partial_json, .. } => {
                    self.json.entry(index).or_default().push_str(&partial_json);
                }
                claude::KnownEventDelta::Compaction {
                    content,
                    encrypted_content,
                    ..
                } => {
                    if let Some(claude::ResponseContentBlock::Compaction(block)) =
                        self.blocks.get_mut(&index)
                    {
                        block.content.get_or_insert_default().push_str(&content);
                        block.encrypted_content.push_str(&encrypted_content);
                    }
                }
                claude::KnownEventDelta::Citations { .. } => {}
                #[cfg(not(feature = "exhaustive"))]
                _ => {
                    return Err(crate::TransformError::unsupported(
                        "protocol enum",
                        "unrecognized external variant",
                    ));
                }
            },
            claude::EventDelta::Unknown(_) => {}
            #[cfg(not(feature = "exhaustive"))]
            _ => {
                return Err(crate::TransformError::unsupported(
                    "protocol enum",
                    "unrecognized external variant",
                ));
            }
        }
        Ok(())
    }
}