ktxd 0.1.0

A local Responses API compatibility proxy for Codex CLI and Chat Completions backends.
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

use crate::config::{InstructionRole, ModelConfig};
use crate::domain::{CanonicalItem, MessageRole, TaggedItem};
use crate::error::{ProxyError, Result};
use crate::translator::NormalizedTurnInput;
use crate::wire::chat::{
    ChatCompletionRequest, ChatFunctionCall, ChatFunctionTool, ChatMessage, ChatTool, ChatToolCall,
    StreamOptions,
};
use serde_json::{Value, json};

pub fn compile_chat_request(
    model_config: &ModelConfig,
    transcript: &[TaggedItem],
    normalized: &NormalizedTurnInput,
    stream: bool,
) -> Result<ChatCompletionRequest> {
    let mut messages = Vec::new();
    if !normalized.instructions.is_empty() {
        messages.push(ChatMessage {
            role: match model_config.instruction_role {
                InstructionRole::System => "system".to_string(),
                InstructionRole::Developer => "developer".to_string(),
            },
            content: Some(normalized.instructions.clone()),
            tool_call_id: None,
            tool_calls: None,
        });
    }

    for tagged_item in transcript {
        match &tagged_item.item {
            CanonicalItem::Message { role, text } => messages.push(ChatMessage {
                role: match role {
                    MessageRole::User => "user".to_string(),
                    MessageRole::Assistant => "assistant".to_string(),
                },
                content: Some(text.clone()),
                tool_call_id: None,
                tool_calls: None,
            }),
            CanonicalItem::FunctionCall {
                call_id,
                name,
                arguments,
            } => messages.push(ChatMessage {
                role: "assistant".to_string(),
                content: None,
                tool_call_id: None,
                tool_calls: Some(vec![ChatToolCall {
                    index: None,
                    id: call_id.to_string(),
                    tool_type: "function".to_string(),
                    function: ChatFunctionCall {
                        name: name.clone(),
                        arguments: arguments.clone(),
                    },
                }]),
            }),
            CanonicalItem::FunctionCallOutput { call_id, output } => messages.push(ChatMessage {
                role: "tool".to_string(),
                content: Some(output.lower_to_chat_content()),
                tool_call_id: Some(call_id.to_string()),
                tool_calls: None,
            }),
            CanonicalItem::Reasoning { .. } => {}
        }
    }

    Ok(ChatCompletionRequest {
        model: model_config
            .send_model_in_body
            .then(|| model_config.upstream_model.clone()),
        messages,
        tools: compile_tools(&normalized.tools)?,
        tool_choice: compile_tool_choice(&normalized.tool_choice),
        parallel_tool_calls: Some(normalized.parallel_tool_calls),
        stream,
        stream_options: (stream && model_config.include_stream_usage).then_some(StreamOptions {
            include_usage: true,
        }),
    })
}

fn compile_tool_choice(tool_choice: &str) -> Option<Value> {
    if tool_choice.is_empty() {
        None
    } else {
        Some(Value::String(tool_choice.to_string()))
    }
}

fn compile_tools(tools: &[Value]) -> Result<Vec<ChatTool>> {
    let mut compiled = Vec::new();
    for tool in tools {
        let tool_type = tool.get("type").and_then(Value::as_str).unwrap_or_default();
        if tool_type != "function" {
            return Err(ProxyError::UnsupportedTool(tool_type.to_string()));
        }
        let function_value = tool.get("function").unwrap_or(tool);
        let name = function_value
            .get("name")
            .and_then(Value::as_str)
            .ok_or_else(|| ProxyError::UnsupportedTool("function_without_name".to_string()))?;
        let description = function_value
            .get("description")
            .and_then(Value::as_str)
            .map(ToString::to_string);
        let parameters = function_value
            .get("parameters")
            .cloned()
            .unwrap_or_else(|| json!({"type":"object","properties":{}}));
        compiled.push(ChatTool {
            tool_type: "function".to_string(),
            function: ChatFunctionTool {
                name: name.to_string(),
                description,
                parameters,
            },
        });
    }
    Ok(compiled)
}