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
122
123
124
125
126
127

use gproxy_protocol::{claude, openai};

use crate::TransformError;

use super::NativeKind;
use crate::common::native::shape;

pub(crate) fn claude_call(
    id: String,
    input: claude::JsonObject,
    name: String,
    status: openai::ResponseItemLifecycleStatus,
) -> Result<(openai::TypedResponseItem, Option<NativeKind>), TransformError> {
    if name == "bash"
        && let Some(action) = shape::shell_action(&input)
    {
        return Ok((
            openai::TypedResponseItem::ShellCall {
                action,
                call_id: id,
                id: None,
                caller: None,
                environment: None,
                status: Some(status),
                created_by: None,
                rest: Default::default(),
            },
            Some(NativeKind::Shell),
        ));
    }
    if matches!(
        name.as_str(),
        "str_replace_editor" | "str_replace_based_edit_tool"
    ) && let Some(operation) = shape::patch_operation(&input)
    {
        return Ok((
            openai::TypedResponseItem::ApplyPatchCall {
                call_id: id,
                operation,
                status: match status {
                    openai::ResponseItemLifecycleStatus::InProgress => {
                        openai::ResponseApplyPatchCallStatus::InProgress
                    }
                    _ => openai::ResponseApplyPatchCallStatus::Completed,
                },
                id: None,
                caller: None,
                created_by: None,
                rest: Default::default(),
            },
            Some(NativeKind::ApplyPatch),
        ));
    }
    Ok((
        openai::TypedResponseItem::FunctionCall {
            arguments: serde_json::to_string(&input)?,
            call_id: id,
            name,
            id: None,
            caller: None,
            namespace: None,
            async_: None,
            status: Some(status),
            rest: Default::default(),
        },
        None,
    ))
}

pub(crate) fn claude_result(
    block: claude::ToolResultBlock,
    kind: NativeKind,
) -> Result<openai::TypedResponseItem, TransformError> {
    let text = claude_result_text(block.content)?;
    let failed = block.is_error.unwrap_or(false);
    Ok(match kind {
        NativeKind::Shell => openai::TypedResponseItem::ShellCallOutput {
            call_id: block.tool_use_id,
            output: vec![crate::wire!(openai::ShellCallOutputContent {
                outcome: openai::ShellCallOutcome::Exit {
                    exit_code: if failed { 1 } else { 0 },
                    rest: Default::default(),
                },
                stderr: if failed { text.clone() } else { String::new() },
                stdout: if failed { String::new() } else { text },
                created_by: None,
                rest: Default::default(),
            })],
            id: None,
            caller: None,
            max_output_length: None,
            status: Some(openai::ResponseItemLifecycleStatus::Completed),
            created_by: None,
            rest: Default::default(),
        },
        NativeKind::ApplyPatch => openai::TypedResponseItem::ApplyPatchCallOutput {
            call_id: block.tool_use_id,
            status: if failed {
                openai::ResponseApplyPatchCallOutputStatus::Failed
            } else {
                openai::ResponseApplyPatchCallOutputStatus::Completed
            },
            id: None,
            caller: None,
            output: (!text.is_empty()).then_some(text),
            created_by: None,
            rest: Default::default(),
        },
    })
}

fn claude_result_text(
    content: Option<claude::ToolResultContent>,
) -> Result<String, TransformError> {
    Ok(match content {
        None => String::new(),
        Some(claude::ToolResultContent::Text(text)) => text,
        Some(claude::ToolResultContent::Blocks(blocks)) => serde_json::to_string(&blocks)?,
        Some(claude::ToolResultContent::Raw(raw)) => raw.to_string(),
        Some(_) => {
            return Err(TransformError::unsupported(
                "Claude tool result",
                "future result content",
            ));
        }
    })
}