codex-convert-proxy 0.1.2

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! MiniMax provider implementation.

use crate::providers::trait_::Provider;
use crate::types::chat_api::{ChatRequest, ChatResponse, ChatStreamChunk, Content, MessageRole};

/// MiniMax provider.
///
/// MiniMax specific handling:
/// - Content must be string, not array
/// - Does not support 'developer' role, convert to 'user'
pub struct MiniMaxProvider;

impl Default for MiniMaxProvider {
    fn default() -> Self {
        Self
    }
}

impl MiniMaxProvider {
    pub fn new() -> Self {
        Self
    }
}

impl Provider for MiniMaxProvider {
    fn name(&self) -> &'static str {
        "minimax"
    }

    fn chat_completions_path(&self) -> String {
        // MiniMax URL already includes /v1, so just /chat/completions
        "/chat/completions".to_string()
    }

    fn transform_request(&self, request: &mut ChatRequest) {
        // MiniMax requires content to be a string, not an array
        for message in &mut request.messages {
            if matches!(message.content, Content::Array(_)) {
                let text = message.content.as_text();
                message.content = Content::String(text);
            }
            // MiniMax doesn't support developer role - convert to user
            if message.role == MessageRole::Developer {
                message.role = MessageRole::User;
            }
        }
    }

    fn transform_response(&self, response: &mut ChatResponse) {
        // Ensure content is string
        for choice in &mut response.choices {
            if matches!(choice.message.content, Content::Array(_)) {
                let text = choice.message.content.as_text();
                choice.message.content = Content::String(text);
            }
        }
    }

    fn transform_stream_chunk(&self, chunk: &mut ChatStreamChunk) {
        // Ensure delta content is string
        for choice in &mut chunk.choices {
            if let Some(delta) = &mut choice.delta
                && matches!(delta.content, Some(Content::Array(_)))
                    && let Some(content) = delta.content.take() {
                        let text = content.as_text();
                        if !text.is_empty() {
                            delta.content = Some(Content::String(text));
                        }
                    }
        }
    }

}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::chat_api::{ChatMessage, Content, MessageRole};

    #[test]
    fn test_minimax_flattens_content() {
        let mut request = ChatRequest {
            model: "ab-01".to_string(),
            messages: vec![ChatMessage {
                role: MessageRole::User,
                content: Content::Array(vec![crate::types::chat_api::ContentBlock {
                    block_type: "text".to_string(),
                    text: Some("Hello".to_string()),
                    image_url: None,
                }]),
                name: None,
                annotations: None,
                tool_calls: None,
                tool_call_id: None,
                function_call: None,
                refusal: None,
            }],
            tools: None,
            tool_choice: None,
            stream: Some(false),
            temperature: None,
            max_tokens: None,
            top_p: None,
            user: None,
            stream_options: None,
            frequency_penalty: None,
            presence_penalty: None,
            logit_bias: None,
            logprobs: None,
            top_logprobs: None,
            n: None,
            stop: None,
            response_format: None,
            reasoning_effort: None,
            parallel_tool_calls: None,
            seed: None,
            service_tier: None,
        };

        let provider = MiniMaxProvider;
        provider.transform_request(&mut request);

        let msg = request.messages.first().unwrap();
        assert!(matches!(msg.content, Content::String(_)));
        assert_eq!(msg.content.as_text(), "Hello");
    }
}