codex-claude-proxy 1.0.0

package/src/format-converter.js

@@ -0,0 +1,331 @@
+/**
+ * Format Converter
+ * Converts between Anthropic Messages API and OpenAI Responses API format
+ */
+
+import crypto from 'crypto';
+
+function extractSystemPrompt(system) {
+    if (!system) {
+        return undefined;
+    }
+    
+    if (typeof system === 'string') {
+        return system;
+    }
+    
+    if (Array.isArray(system)) {
+        const textParts = system
+            .filter(block => block.type === 'text')
+            .map(block => block.text);
+        return textParts.join('\n\n') || undefined;
+    }
+    
+    return undefined;
+}
+
+/**
+ * Convert Anthropic Messages API request to OpenAI Responses API format
+ */
+export function convertAnthropicToResponsesAPI(anthropicRequest) {
+    const { model, messages, system, tools, tool_choice } = anthropicRequest;
+
+    const instructions = extractSystemPrompt(system);
+
+    const request = {
+        model: model || 'gpt-5.2-codex',
+        input: convertMessagesToInput(messages),
+        tools: tools ? convertAnthropicToolsToOpenAI(tools) : [],
+        tool_choice: tool_choice || 'auto',
+        parallel_tool_calls: true,
+        store: false,
+        stream: true,
+        include: []
+    };
+    
+    if (instructions) {
+        request.instructions = instructions;
+    } else {
+        request.instructions = '';
+    }
+
+    return request;
+}
+
+/**
+ * Convert Anthropic messages to OpenAI Responses API input format
+ */
+function convertMessagesToInput(messages) {
+    if (!Array.isArray(messages)) {
+        return [];
+    }
+
+    const input = [];
+
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            const { textParts, toolResults } = convertUserContent(msg.content);
+            
+            if (textParts.length > 0) {
+                // API accepts: string OR array of {type: 'input_text', text: '...'}
+                const content = textParts.length === 1 
+                    ? textParts[0]  // Use string for single text
+                    : textParts.map(text => ({ type: 'input_text', text }));
+                input.push({
+                    type: 'message',
+                    role: 'user',
+                    content
+                });
+            }
+            
+            for (const result of toolResults) {
+                input.push(result);
+            }
+        } else if (msg.role === 'assistant') {
+            const { textParts, toolCalls } = convertAssistantContentToOpenAI(msg.content);
+            
+            if (textParts.length > 0) {
+                // API accepts: string OR array of {type: 'output_text', text: '...'}
+                const content = textParts.length === 1 
+                    ? textParts[0]  // Use string for single text
+                    : textParts.map(text => ({ type: 'output_text', text }));
+                input.push({
+                    type: 'message',
+                    role: 'assistant',
+                    content
+                });
+            }
+            
+            for (const call of toolCalls) {
+                input.push(call);
+            }
+        }
+    }
+
+    return input;
+}
+
+/**
+ * Convert user content, separating text and tool results
+ */
+function convertUserContent(content) {
+    const textParts = [];
+    const toolResults = [];
+    
+    if (typeof content === 'string') {
+        textParts.push(content);
+    } else if (Array.isArray(content)) {
+        for (const block of content) {
+            if (block.type === 'text') {
+                textParts.push(block.text);
+            } else if (block.type === 'tool_result') {
+                const outputContent = typeof block.content === 'string' 
+                    ? block.content 
+                    : Array.isArray(block.content)
+                        ? block.content.filter(c => c.type === 'text').map(c => c.text).join('\n')
+                        : JSON.stringify(block.content);
+                
+                let callId = block.tool_use_id;
+                if (!callId.startsWith('fc_') && !callId.startsWith('fc')) {
+                    callId = 'fc_' + callId.replace(/^(call_|toolu_)/, '');
+                }
+                
+                toolResults.push({
+                    type: 'function_call_output',
+                    call_id: callId,
+                    output: block.is_error ? `Error: ${outputContent}` : outputContent
+                });
+            }
+        }
+    }
+    
+    return { textParts, toolResults };
+}
+
+/**
+ * Convert Anthropic assistant content to OpenAI format
+ */
+function convertAssistantContentToOpenAI(content) {
+    const textParts = [];
+    const toolCalls = [];
+    
+    if (typeof content === 'string') {
+        textParts.push(content);
+    } else if (Array.isArray(content)) {
+        for (const block of content) {
+            if (block.type === 'text') {
+                textParts.push(block.text);
+            } else if (block.type === 'tool_use') {
+                let callId = block.id;
+                if (!callId.startsWith('fc_') && !callId.startsWith('fc')) {
+                    callId = 'fc_' + callId.replace(/^(call_|toolu_)/, '');
+                }
+                
+                toolCalls.push({
+                    type: 'function_call',
+                    id: callId,
+                    call_id: callId,
+                    name: block.name,
+                    arguments: typeof block.input === 'string' 
+                        ? block.input 
+                        : JSON.stringify(block.input)
+                });
+            }
+        }
+    }
+    
+    return { textParts, toolCalls };
+}
+
+/**
+ * Convert Anthropic tools to OpenAI function format
+ */
+function convertAnthropicToolsToOpenAI(tools) {
+    if (!Array.isArray(tools)) {
+        return [];
+    }
+
+    return tools.map(tool => ({
+        type: 'function',
+        name: tool.name,
+        description: tool.description || '',
+        parameters: sanitizeSchema(tool.input_schema || { type: 'object' })
+    }));
+}
+
+function sanitizeSchema(schema) {
+    if (typeof schema !== 'object' || schema === null) {
+        return { type: 'object' };
+    }
+    
+    const result = {};
+    
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'const') {
+            result.enum = [value];
+            continue;
+        }
+        
+        if ([
+            '$schema', '$id', '$ref', '$defs', '$comment',
+            'additionalItems', 'definitions', 'examples',
+            'minLength', 'maxLength', 'pattern', 'format',
+            'minItems', 'maxItems', 'minimum', 'maximum',
+            'exclusiveMinimum', 'exclusiveMaximum',
+            'allOf', 'anyOf', 'oneOf', 'not'
+        ].includes(key)) {
+            continue;
+        }
+        
+        if (key === 'additionalProperties' && typeof value === 'boolean') {
+            continue;
+        }
+        
+        if (key === 'type' && Array.isArray(value)) {
+            const nonNullTypes = value.filter(t => t !== 'null');
+            result.type = nonNullTypes.length > 0 ? nonNullTypes[0] : 'string';
+            continue;
+        }
+        
+        if (key === 'properties' && value && typeof value === 'object') {
+            result.properties = {};
+            for (const [propKey, propValue] of Object.entries(value)) {
+                result.properties[propKey] = sanitizeSchema(propValue);
+            }
+            continue;
+        }
+        
+        if (key === 'items') {
+            if (Array.isArray(value)) {
+                result.items = value.map(item => sanitizeSchema(item));
+            } else if (typeof value === 'object') {
+                result.items = sanitizeSchema(value);
+            } else {
+                result.items = value;
+            }
+            continue;
+        }
+        
+        if (key === 'required' && Array.isArray(value)) {
+            result.required = value;
+            continue;
+        }
+        
+        if (key === 'enum' && Array.isArray(value)) {
+            result.enum = value;
+            continue;
+        }
+        
+        if (['type', 'description', 'title'].includes(key)) {
+            result[key] = value;
+        }
+    }
+    
+    if (!result.type) {
+        result.type = 'object';
+    }
+    
+    if (result.type === 'object' && !result.properties) {
+        result.properties = {};
+    }
+    
+    return result;
+}
+
+/**
+ * Convert OpenAI Responses API output to Anthropic content blocks
+ */
+export function convertOutputToAnthropic(output) {
+    if (!Array.isArray(output)) {
+        return [{ type: 'text', text: '' }];
+    }
+
+    const content = [];
+    
+    for (const item of output) {
+        if (item.type === 'message') {
+            for (const part of item.content || []) {
+                if (part.type === 'output_text') {
+                    content.push({ type: 'text', text: part.text });
+                }
+            }
+        } else if (item.type === 'function_call') {
+            let input = {};
+            try {
+                input = typeof item.arguments === 'string' 
+                    ? JSON.parse(item.arguments) 
+                    : item.arguments || {};
+            } catch (e) {
+                input = {};
+            }
+            
+            content.push({
+                type: 'tool_use',
+                id: item.call_id || item.id,
+                name: item.name,
+                input: input
+            });
+        } else if (item.type === 'reasoning') {
+            content.push({
+                type: 'thinking',
+                thinking: '',
+                signature: ''
+            });
+        }
+    }
+
+    return content.length > 0 ? content : [{ type: 'text', text: '' }];
+}
+
+/**
+ * Generate Anthropic message ID
+ */
+export function generateMessageId() {
+    return `msg_${crypto.randomBytes(16).toString('hex')}`;
+}
+
+export default {
+    convertAnthropicToResponsesAPI,
+    convertOutputToAnthropic,
+    generateMessageId
+};

package/src/index.js

@@ -0,0 +1,41 @@
+/**
+ * Codex Claude Proxy
+ * Entry point
+ */
+
+import { startServer } from './server.js';
+import { logger } from './utils/logger.js';
+import { getStatus, ACCOUNTS_FILE } from './account-manager.js';
+
+const PORT = Number(process.env.PORT || 8081);
+
+startServer({ port: PORT });
+
+console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║                 Codex Claude Proxy v2.0.0                    ║
+║                   (Direct API Mode)                          ║
+╠══════════════════════════════════════════════════════════════╣
+║  Server:   http://localhost:${PORT}                          ║
+║  WebUI:    http://localhost:${PORT}                          ║
+║  Health:   http://localhost:${PORT}/health                   ║
+║  Accounts: http://localhost:${PORT}/accounts                 ║
+║  Logs:     http://localhost:${PORT}/api/logs/stream          ║
+╠══════════════════════════════════════════════════════════════╣
+║  Features:                                                   ║
+║    ✓ Native tool calling support                             ║
+║    ✓ Real-time streaming                                     ║
+║    ✓ Multi-account management                                ║
+║    ✓ OpenAI & Anthropic API compatibility                    ║
+╚══════════════════════════════════════════════════════════════╝
+`);
+
+const status = getStatus();
+logger.info(`Accounts: ${status.total} total, Active: ${status.active || 'None'}`);
+
+if (status.total === 0) {
+  logger.warn(`No accounts configured. Open http://localhost:${PORT} to add one.`);
+}
+
+// Expose config path in logs for convenience
+logger.info(`Accounts config: ${ACCOUNTS_FILE}`);

package/src/kilo-api.js

@@ -0,0 +1,68 @@
+/**
+ * Kilo API client
+ */
+
+import { convertAnthropicToOpenAIChat, convertOpenAIChatToAnthropic } from './kilo-format-converter.js';
+import { streamOpenAIChat } from './kilo-streamer.js';
+
+const KILO_API_URL = 'https://api.kilo.ai/api/openrouter/chat/completions';
+
+const KILO_HEADERS = {
+    Authorization: 'Bearer anonymous',
+    'User-Agent': 'opencode-kilo-provider',
+    'HTTP-Referer': 'https://kilo.ai'
+};
+
+function buildError(status, message) {
+    const err = new Error(message);
+    err.status = status;
+    return err;
+}
+
+export async function* sendKiloMessageStream(anthropicRequest, targetModel) {
+    const requestBody = convertAnthropicToOpenAIChat(anthropicRequest, targetModel);
+
+    const response = await fetch(KILO_API_URL, {
+        method: 'POST',
+        headers: {
+            ...KILO_HEADERS,
+            'Content-Type': 'application/json',
+            Accept: 'text/event-stream'
+        },
+        body: JSON.stringify(requestBody)
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw buildError(response.status, `KILO_API_ERROR: ${response.status} - ${errorText}`);
+    }
+
+    yield* streamOpenAIChat(response, anthropicRequest.model);
+}
+
+export async function sendKiloMessage(anthropicRequest, targetModel) {
+    const requestBody = convertAnthropicToOpenAIChat({ ...anthropicRequest, stream: false }, targetModel);
+
+    const response = await fetch(KILO_API_URL, {
+        method: 'POST',
+        headers: {
+            ...KILO_HEADERS,
+            'Content-Type': 'application/json',
+            Accept: 'application/json'
+        },
+        body: JSON.stringify({ ...requestBody, stream: false })
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw buildError(response.status, `KILO_API_ERROR: ${response.status} - ${errorText}`);
+    }
+
+    const data = await response.json();
+    return convertOpenAIChatToAnthropic(data);
+}
+
+export default {
+    sendKiloMessageStream,
+    sendKiloMessage
+};

package/src/kilo-format-converter.js

@@ -0,0 +1,270 @@
+/**
+ * Kilo Format Converter
+ * Converts between Anthropic Messages API and OpenAI Chat Completions format
+ */
+
+function extractSystemPrompt(system) {
+    if (!system) return [];
+    if (typeof system === 'string') return [{ role: 'system', content: system }];
+    if (Array.isArray(system)) {
+        const text = system
+            .filter(block => block.type === 'text')
+            .map(block => block.text)
+            .join('\n\n');
+        return text ? [{ role: 'system', content: text }] : [];
+    }
+    return [];
+}
+
+function sanitizeSchema(schema) {
+    if (typeof schema !== 'object' || schema === null) {
+        return { type: 'object' };
+    }
+
+    const result = {};
+
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'const') {
+            result.enum = [value];
+            continue;
+        }
+
+        if ([
+            '$schema', '$id', '$ref', '$defs', '$comment',
+            'additionalItems', 'definitions', 'examples',
+            'minLength', 'maxLength', 'pattern', 'format',
+            'minItems', 'maxItems', 'minimum', 'maximum',
+            'exclusiveMinimum', 'exclusiveMaximum',
+            'allOf', 'anyOf', 'oneOf', 'not'
+        ].includes(key)) {
+            continue;
+        }
+
+        if (key === 'additionalProperties' && typeof value === 'boolean') {
+            continue;
+        }
+
+        if (key === 'type' && Array.isArray(value)) {
+            const nonNullTypes = value.filter(t => t !== 'null');
+            result.type = nonNullTypes.length > 0 ? nonNullTypes[0] : 'string';
+            continue;
+        }
+
+        if (key === 'properties' && value && typeof value === 'object') {
+            result.properties = {};
+            for (const [propKey, propValue] of Object.entries(value)) {
+                result.properties[propKey] = sanitizeSchema(propValue);
+            }
+            continue;
+        }
+
+        if (key === 'items') {
+            if (Array.isArray(value)) {
+                result.items = value.map(item => sanitizeSchema(item));
+            } else if (typeof value === 'object') {
+                result.items = sanitizeSchema(value);
+            } else {
+                result.items = value;
+            }
+            continue;
+        }
+
+        if (key === 'required' && Array.isArray(value)) {
+            result.required = value;
+            continue;
+        }
+
+        if (key === 'enum' && Array.isArray(value)) {
+            result.enum = value;
+            continue;
+        }
+
+        if (['type', 'description', 'title'].includes(key)) {
+            result[key] = value;
+        }
+    }
+
+    if (!result.type) {
+        result.type = 'object';
+    }
+
+    if (result.type === 'object' && !result.properties) {
+        result.properties = {};
+    }
+
+    return result;
+}
+
+function convertTools(tools) {
+    if (!Array.isArray(tools)) return undefined;
+    return tools.map(tool => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description || '',
+            parameters: sanitizeSchema(tool.input_schema || { type: 'object' })
+        }
+    }));
+}
+
+function convertToolChoice(toolChoice) {
+    if (!toolChoice) return undefined;
+    if (typeof toolChoice === 'string') return toolChoice;
+    if (toolChoice.type === 'tool' && toolChoice.name) {
+        return { type: 'function', function: { name: toolChoice.name } };
+    }
+    return undefined;
+}
+
+function normalizeTextBlocks(content) {
+    if (typeof content === 'string') return [content];
+    if (!Array.isArray(content)) return [];
+    return content.filter(block => block.type === 'text').map(block => block.text);
+}
+
+function normalizeToolResultContent(block) {
+    if (typeof block.content === 'string') return block.content;
+    if (Array.isArray(block.content)) {
+        return block.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+    }
+    if (block.content && typeof block.content === 'object') {
+        return JSON.stringify(block.content);
+    }
+    return '';
+}
+
+function convertMessages(messages = []) {
+    const output = [];
+
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            const textParts = normalizeTextBlocks(msg.content);
+            if (textParts.length > 0) {
+                output.push({ role: 'user', content: textParts.join('\n\n') });
+            }
+
+            if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === 'tool_result') {
+                        output.push({
+                            role: 'tool',
+                            tool_call_id: block.tool_use_id,
+                            content: normalizeToolResultContent(block)
+                        });
+                    }
+                }
+            }
+        }
+
+        if (msg.role === 'assistant') {
+            const textParts = normalizeTextBlocks(msg.content);
+            const toolCalls = [];
+
+            if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === 'tool_use') {
+                        toolCalls.push({
+                            id: block.id,
+                            type: 'function',
+                            function: {
+                                name: block.name,
+                                arguments: typeof block.input === 'string'
+                                    ? block.input
+                                    : JSON.stringify(block.input || {})
+                            }
+                        });
+                    }
+                }
+            }
+
+            if (textParts.length > 0 || toolCalls.length > 0) {
+                const message = {
+                    role: 'assistant',
+                    content: textParts.join('\n\n')
+                };
+
+                if (toolCalls.length > 0) {
+                    message.tool_calls = toolCalls;
+                }
+
+                output.push(message);
+            }
+        }
+    }
+
+    return output;
+}
+
+export function convertAnthropicToOpenAIChat(anthropicRequest, targetModel) {
+    const { system, messages, tools, tool_choice, max_tokens, temperature, top_p, stop_sequences, stream } = anthropicRequest;
+
+    const convertedMessages = [
+        ...extractSystemPrompt(system),
+        ...convertMessages(messages || [])
+    ];
+
+    const request = {
+        model: targetModel,
+        messages: convertedMessages,
+        stream: stream !== false
+    };
+
+    if (typeof max_tokens === 'number') request.max_tokens = max_tokens;
+    if (typeof temperature === 'number') request.temperature = temperature;
+    if (typeof top_p === 'number') request.top_p = top_p;
+    if (Array.isArray(stop_sequences) && stop_sequences.length > 0) request.stop = stop_sequences;
+
+    const convertedTools = convertTools(tools);
+    if (convertedTools?.length) request.tools = convertedTools;
+
+    const convertedToolChoice = convertToolChoice(tool_choice);
+    if (convertedToolChoice) request.tool_choice = convertedToolChoice;
+
+    return request;
+}
+
+export function convertOpenAIChatToAnthropic(openAiResponse) {
+    const message = openAiResponse?.choices?.[0]?.message || {};
+    const content = [];
+
+    if (message.content) {
+        content.push({ type: 'text', text: message.content });
+    }
+
+    if (Array.isArray(message.tool_calls)) {
+        for (const call of message.tool_calls) {
+            let input = {};
+            try {
+                input = typeof call.function?.arguments === 'string'
+                    ? JSON.parse(call.function.arguments)
+                    : call.function?.arguments || {};
+            } catch (error) {
+                input = {};
+            }
+
+            content.push({
+                type: 'tool_use',
+                id: call.id,
+                name: call.function?.name || 'unknown',
+                input
+            });
+        }
+    }
+
+    const finishReason = openAiResponse?.choices?.[0]?.finish_reason;
+    const stopReason = finishReason === 'tool_calls' ? 'tool_use' : 'end_turn';
+
+    return {
+        content: content.length > 0 ? content : [{ type: 'text', text: '' }],
+        stopReason,
+        usage: {
+            input_tokens: openAiResponse?.usage?.prompt_tokens || 0,
+            output_tokens: openAiResponse?.usage?.completion_tokens || 0
+        }
+    };
+}
+
+export default {
+    convertAnthropicToOpenAIChat,
+    convertOpenAIChatToAnthropic
+};