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
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
119
120
121

use gproxy_protocol::{claude, openai};

use crate::TransformError;

use super::{ClaudeCall, execution, hosted};

pub(crate) fn openai_call(
    item: openai::TypedResponseItem,
) -> Result<Option<ClaudeCall>, TransformError> {
    Ok(match item {
        openai::TypedResponseItem::LocalShellCall {
            id,
            action,
            call_id,
            ..
        } => Some(execution::local_shell(id, action, call_id)?),
        openai::TypedResponseItem::ShellCall {
            action,
            call_id,
            id,
            environment,
            ..
        } => Some(execution::shell(action, call_id, id, environment)?),
        openai::TypedResponseItem::ApplyPatchCall {
            call_id,
            operation,
            id,
            ..
        } => Some(execution::apply_patch(call_id, operation, id)?),
        openai::TypedResponseItem::ComputerCall {
            id,
            call_id,
            action,
            actions,
            ..
        } => Some(execution::computer(id, call_id, action, actions)?),
        openai::TypedResponseItem::WebSearchCall { id, action, .. } => {
            Some(hosted::web_search(id, action)?)
        }
        openai::TypedResponseItem::CodeInterpreterCall {
            id,
            code,
            container_id,
            ..
        } => Some(hosted::code_interpreter(id, code, container_id)),
        openai::TypedResponseItem::ToolSearchCall {
            arguments,
            id,
            call_id,
            execution,
            ..
        } => Some(hosted::tool_search(arguments, id, call_id, execution)?),
        openai::TypedResponseItem::McpCall {
            id,
            arguments,
            name,
            ..
        } => Some(hosted::mcp(id, arguments, name)?),
        openai::TypedResponseItem::Program {
            id,
            call_id,
            code,
            fingerprint,
            ..
        } => Some(hosted::program(id, call_id, code, fingerprint)),
        openai::TypedResponseItem::FileSearchCall { .. }
        | openai::TypedResponseItem::ComputerCallOutput { .. }
        | openai::TypedResponseItem::FunctionCall { .. }
        | openai::TypedResponseItem::FunctionCallOutput { .. }
        | openai::TypedResponseItem::ToolSearchOutput { .. }
        | openai::TypedResponseItem::AdditionalTools { .. }
        | openai::TypedResponseItem::Reasoning { .. }
        | openai::TypedResponseItem::Compaction { .. }
        | openai::TypedResponseItem::ImageGenerationCall { .. }
        | openai::TypedResponseItem::LocalShellCallOutput { .. }
        | openai::TypedResponseItem::ShellCallOutput { .. }
        | openai::TypedResponseItem::ApplyPatchCallOutput { .. }
        | openai::TypedResponseItem::McpListTools { .. }
        | openai::TypedResponseItem::McpApprovalRequest { .. }
        | openai::TypedResponseItem::McpApprovalResponse { .. }
        | openai::TypedResponseItem::CustomToolCall { .. }
        | openai::TypedResponseItem::CustomToolCallOutput { .. }
        | openai::TypedResponseItem::ProgramOutput { .. }
        | openai::TypedResponseItem::MultiAgentCall { .. }
        | openai::TypedResponseItem::MultiAgentCallOutput { .. }
        | openai::TypedResponseItem::AgentMessage { .. }
        | openai::TypedResponseItem::ConfigurationUpdate { .. }
        | openai::TypedResponseItem::CompactionTrigger { .. }
        | openai::TypedResponseItem::ItemReference { .. } => None,
        #[cfg(not(feature = "exhaustive"))]
        _ => {
            return Err(crate::TransformError::unsupported(
                "protocol enum",
                "unrecognized external variant",
            ));
        }
    })
}

pub(crate) fn request_block(call: ClaudeCall) -> claude::ContentBlockParam {
    claude::ContentBlockParam::ToolUse(crate::wire!(claude::ToolUseBlock {
        id: call.id,
        input: call.input,
        name: call.name,
        type_: claude::ToolUseBlockType::ToolUse,
        cache_control: None,
        caller: None,
        rest: Default::default(),
    }))
}

pub(crate) fn response_block(call: ClaudeCall) -> claude::ResponseContentBlock {
    claude::ResponseContentBlock::ToolUse(crate::wire!(claude::ResponseToolUseBlock {
        id: call.id,
        input: call.input,
        name: call.name,
        type_: claude::ToolUseBlockType::ToolUse,
        caller: None,
        rest: Default::default(),
    }))
}