codex-convert-proxy 0.1.1

A high-performance proxy server that converts between different AI API formats
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

//! Tool conversion utilities for Responses API → Chat API.

use crate::types::chat_api::{ChatTool, ChatToolChoice, ChatToolChoiceMode, FunctionChoice, FunctionDefinition};
use crate::types::response_api::{
    Tool as ResponseTool, ToolChoice as ResponseToolChoice,
    ToolType as ResponseToolType,
};

/// Convert Responses API tools to Chat API tools.
pub fn convert_tools(tools: Vec<ResponseTool>) -> Vec<ChatTool> {
    tools
        .into_iter()
        .filter_map(|t| match t.tool_type {
            ResponseToolType::Function | ResponseToolType::Custom | ResponseToolType::Other => {
                Some(passthrough_tool(t))
            }
            ResponseToolType::WebSearchPreview => Some(builtin_tool(
                t,
                "web_search_preview",
                "Web search tool",
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "query": {
                            "type": "string",
                            "description": "The search query"
                        }
                    },
                    "required": ["query"]
                }),
            )),
            ResponseToolType::CodeInterpreter => Some(builtin_tool(
                t,
                "code_interpreter",
                "Code interpreter tool",
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "code": {
                            "type": "string",
                            "description": "The code to execute"
                        }
                    },
                    "required": ["code"]
                }),
            )),
            ResponseToolType::FileSearch => Some(builtin_tool(
                t,
                "file_search",
                "File search tool",
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "query": {
                            "type": "string",
                            "description": "The search query"
                        }
                    },
                    "required": ["query"]
                }),
            )),
            ResponseToolType::Namespace => None,
        })
        .collect()
}

/// Pass through a tool as-is as a function tool.
fn passthrough_tool(t: ResponseTool) -> ChatTool {
    ChatTool {
        tool_type: "function".to_string(),
        function: FunctionDefinition {
            name: t.name.unwrap_or_default(),
            description: t.description,
            parameters: t.parameters,
        },
    }
}

/// Convert a built-in tool to a function tool with default parameters.
fn builtin_tool(
    t: ResponseTool,
    default_name: &str,
    default_desc: &str,
    param_schema: serde_json::Value,
) -> ChatTool {
    ChatTool {
        tool_type: "function".to_string(),
        function: FunctionDefinition {
            name: t.name.unwrap_or_else(|| default_name.to_string()),
            description: t.description.or_else(|| Some(default_desc.to_string())),
            parameters: Some(param_schema),
        },
    }
}

/// Convert Responses API tool choice to Chat API tool choice.
pub fn convert_tool_choice(choice: ResponseToolChoice) -> ChatToolChoice {
    match choice {
        ResponseToolChoice::Auto => ChatToolChoice::Mode(ChatToolChoiceMode::Auto),
        ResponseToolChoice::None => ChatToolChoice::Mode(ChatToolChoiceMode::None),
        ResponseToolChoice::Required => ChatToolChoice::Mode(ChatToolChoiceMode::Required),
        ResponseToolChoice::Function(f) => ChatToolChoice::Function(FunctionChoice { name: f.name }),
    }
}

/// Check if the tool choice is "none" (no tools).
pub fn is_tool_choice_none(choice: &ChatToolChoice) -> bool {
    match choice {
        ChatToolChoice::Mode(mode) => *mode == ChatToolChoiceMode::None,
        ChatToolChoice::Function(_) => false,
    }
}