@pikoloo/codex-proxy 1.0.6

package/src/direct-api.js

@@ -0,0 +1,164 @@
+/**
+ * Direct API Client
+ * Makes direct HTTP calls to ChatGPT's backend API
+ */
+
+import { convertAnthropicToResponsesAPI, convertOutputToAnthropic, generateMessageId } from './format-converter.js';
+import { streamResponsesAPI, parseResponsesAPIResponse } from './response-streamer.js';
+
+const API_URL = 'https://chatgpt.com/backend-api/codex/responses';
+
+function parseResetTime(response, errorText) {
+    const retryAfter = response.headers?.get?.('retry-after');
+    if (retryAfter) {
+        const seconds = parseInt(retryAfter, 10);
+        if (!isNaN(seconds)) return seconds * 1000;
+    }
+    
+    const ratelimitReset = response.headers?.get?.('x-ratelimit-reset');
+    if (ratelimitReset) {
+        const timestamp = parseInt(ratelimitReset, 10) * 1000;
+        const wait = timestamp - Date.now();
+        if (wait > 0) return wait;
+    }
+    
+    if (errorText) {
+        const delayMatch = errorText.match(/quotaResetDelay[:\s"]+(\d+(?:\.\d+)?)(ms|s)/i);
+        if (delayMatch) {
+            const value = parseFloat(delayMatch[1]);
+            return delayMatch[2] === 's' ? value * 1000 : value;
+        }
+        
+        const secMatch = errorText.match(/retry\s+(?:after\s+)?(\d+)\s*(?:sec|s\b)/i);
+        if (secMatch) {
+            return parseInt(secMatch[1], 10) * 1000;
+        }
+    }
+    
+    return 60000;
+}
+
+/**
+ * Send a streaming request to ChatGPT API
+ */
+export async function* sendMessageStream(anthropicRequest, accessToken, accountId, accountRotator = null, currentEmail = null) {
+    const modelId = anthropicRequest.model;
+    const request = convertAnthropicToResponsesAPI(anthropicRequest);
+    
+    const response = await fetch(API_URL, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'ChatGPT-Account-ID': accountId,
+            'Content-Type': 'application/json',
+            'Accept': 'text/event-stream'
+        },
+        body: JSON.stringify(request)
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        
+        if (response.status === 401) {
+            if (accountRotator && currentEmail) {
+                accountRotator.markInvalid(currentEmail, 'Token expired or revoked');
+            }
+            throw new Error('AUTH_EXPIRED: Token expired or revoked. Please re-authenticate.');
+        }
+        
+        if (response.status === 429) {
+            const resetMs = parseResetTime(response, errorText);
+            if (accountRotator && currentEmail) {
+                accountRotator.markRateLimited(currentEmail, resetMs, modelId);
+            }
+            throw new Error(`RATE_LIMITED:${resetMs}:${errorText}`);
+        }
+        
+        if (response.status === 403) {
+            if (errorText.includes('challenge') || errorText.includes('cloudflare')) {
+                throw new Error('CLOUDFLARE_BLOCKED: Request blocked by Cloudflare.');
+            }
+            throw new Error(`FORBIDDEN: ${errorText}`);
+        }
+        
+        if (response.status === 400) {
+            throw new Error(`INVALID_REQUEST: ${errorText}`);
+        }
+        
+        throw new Error(`API_ERROR: ${response.status} - ${errorText}`);
+    }
+
+    yield* streamResponsesAPI(response, anthropicRequest.model);
+}
+
+/**
+ * Send a non-streaming request to ChatGPT API
+ */
+export async function sendMessage(anthropicRequest, accessToken, accountId) {
+    const request = convertAnthropicToResponsesAPI({
+        ...anthropicRequest,
+        stream: false
+    });
+    
+    const response = await fetch(API_URL, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'ChatGPT-Account-ID': accountId,
+            'Content-Type': 'application/json',
+            'Accept': 'text/event-stream'
+        },
+        body: JSON.stringify(request)
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        
+        if (response.status === 401) {
+            throw new Error('AUTH_EXPIRED: Token expired or revoked. Please re-authenticate.');
+        }
+        
+        throw new Error(`API_ERROR: ${response.status} - ${errorText}`);
+    }
+
+    const apiResponse = await parseResponsesAPIResponse(response);
+    
+    if (!apiResponse) {
+        return {
+            id: generateMessageId(),
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'text', text: '' }],
+            model: anthropicRequest.model,
+            stop_reason: 'end_turn',
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 }
+        };
+    }
+
+    const content = convertOutputToAnthropic(apiResponse.output);
+    const stopReason = content.some(c => c.type === 'tool_use') ? 'tool_use' : 'end_turn';
+
+    return {
+        id: generateMessageId(),
+        type: 'message',
+        role: 'assistant',
+        content: content,
+        model: anthropicRequest.model,
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage: {
+            input_tokens: apiResponse.usage?.input_tokens || 0,
+            output_tokens: apiResponse.usage?.output_tokens || 0,
+            cache_read_input_tokens: apiResponse.usage?.cache_read_input_tokens || 0
+        }
+    };
+}
+
+export { parseResetTime };
+
+export default {
+    sendMessageStream,
+    sendMessage,
+    parseResetTime
+};

package/src/format-converter.js

@@ -0,0 +1,420 @@
+/**
+ * Format Converter
+ * Converts between Anthropic Messages API and OpenAI Responses API format
+ */
+
+import crypto from 'crypto';
+import { cleanCacheControl, processAssistantContent, hasUnsignedThinkingBlocks } from './thinking-utils.js';
+import { getCachedSignature, cacheSignature, cacheThinkingSignature, SIGNATURE_CONSTANTS } from './signature-cache.js';
+import { DEFAULT_OPENAI_MODEL } from './model-mapper.js';
+
+const { MIN_SIGNATURE_LENGTH } = SIGNATURE_CONSTANTS;
+
+/**
+ * Convert Anthropic tool ID to OpenAI fc_ format
+ * Deterministic: strips toolu_/call_ prefix, adds fc_ prefix
+ * @param {string} anthropicId - Original Anthropic tool ID (e.g., toolu_abc123)
+ * @returns {string} OpenAI fc_ format ID (e.g., fc_abc123)
+ */
+function toOpenAIToolId(anthropicId) {
+    if (!anthropicId) return `fc_${crypto.randomBytes(12).toString('hex')}`;
+    if (anthropicId.startsWith('fc_')) return anthropicId;
+
+    // Strip known prefixes and add fc_ prefix
+    const baseId = anthropicId.replace(/^(call_|toolu_)/, '');
+    return `fc_${baseId}`;
+}
+
+/**
+ * Convert OpenAI fc_ ID back to Anthropic toolu_ format
+ * Deterministic: strips fc_ prefix, adds toolu_ prefix
+ * This is the inverse of toOpenAIToolId
+ * @param {string} openAIId - OpenAI fc_ format ID (e.g., fc_abc123)
+ * @returns {string} Anthropic toolu_ format ID (e.g., toolu_abc123)
+ */
+function toAnthropicToolId(openAIId) {
+    if (!openAIId) return `toolu_${crypto.randomBytes(12).toString('hex')}`;
+    if (openAIId.startsWith('toolu_')) return openAIId;
+
+    // Strip fc_ prefix and add toolu_ prefix
+    const baseId = openAIId.replace(/^fc_/, '');
+    return `toolu_${baseId}`;
+}
+
+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;
+
+    // [CRITICAL] Clean cache_control from all messages FIRST
+    // Claude Code CLI sends cache_control fields that the API rejects
+    const cleanedMessages = cleanCacheControl(messages || []);
+
+    const instructions = extractSystemPrompt(system);
+
+    const request = {
+        model: model || DEFAULT_OPENAI_MODEL,
+        input: convertMessagesToInput(cleanedMessages),
+        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') {
+            // Process assistant content: restore signatures, reorder, sanitize
+            let msgContent = msg.content;
+            if (Array.isArray(msgContent)) {
+                msgContent = processAssistantContent(msgContent);
+            }
+            
+            const { textParts, toolCalls } = convertAssistantContentToOpenAI(msgContent);
+            
+            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);
+
+                // Convert to OpenAI fc_ format
+                const callId = toOpenAIToolId(block.tool_use_id);
+
+                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 === 'thinking') {
+                // Handle thinking blocks - they may have signatures we need to cache
+                if (block.signature && block.signature.length >= MIN_SIGNATURE_LENGTH) {
+                    cacheThinkingSignature(block.signature, 'openai');
+                }
+                // For now, we don't include thinking in the output
+                // The API will regenerate thinking as needed
+            } else if (block.type === 'tool_use') {
+                // Convert to OpenAI fc_ format while preserving mapping
+                const openAIId = toOpenAIToolId(block.id);
+
+                // Restore thoughtSignature from cache if missing (Claude Code strips it)
+                let thoughtSignature = block.thoughtSignature;
+                if (!thoughtSignature && block.id) {
+                    thoughtSignature = getCachedSignature(block.id);
+                    if (thoughtSignature) {
+                        console.log(`[FormatConverter] Restored signature from cache for tool: ${block.id}`);
+                    }
+                }
+
+                // Cache the signature for future restoration (keyed by original ID)
+                if (thoughtSignature && thoughtSignature.length >= MIN_SIGNATURE_LENGTH) {
+                    cacheSignature(block.id, thoughtSignature);
+                }
+
+                toolCalls.push({
+                    type: 'function_call',
+                    id: openAIId,
+                    call_id: openAIId,
+                    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 = {};
+            }
+
+            // Convert OpenAI fc_ ID back to original Anthropic ID
+            const openAIId = item.call_id || item.id;
+            const toolId = toAnthropicToolId(openAIId);
+
+            const toolUseBlock = {
+                type: 'tool_use',
+                id: toolId,
+                name: item.name,
+                input: input
+            };
+
+            // Cache signature if present (keyed by original Anthropic ID)
+            if (item.signature && item.signature.length >= MIN_SIGNATURE_LENGTH) {
+                toolUseBlock.thoughtSignature = item.signature;
+                cacheSignature(toolId, item.signature);
+            }
+
+            content.push(toolUseBlock);
+        } else if (item.type === 'reasoning') {
+            const signature = item.signature || '';
+            
+            // Cache thinking signature
+            if (signature && signature.length >= MIN_SIGNATURE_LENGTH) {
+                cacheThinkingSignature(signature, 'openai');
+            }
+            
+            content.push({
+                type: 'thinking',
+                thinking: item.text || item.content || '',
+                signature: signature
+            });
+        }
+    }
+
+    return content.length > 0 ? content : [{ type: 'text', text: '' }];
+}
+
+/**
+ * Generate Anthropic message ID
+ */
+export function generateMessageId() {
+    return `msg_${crypto.randomBytes(16).toString('hex')}`;
+}
+
+export {
+    toOpenAIToolId,
+    toAnthropicToolId
+};
+
+export default {
+    convertAnthropicToResponsesAPI,
+    convertOutputToAnthropic,
+    generateMessageId,
+    toOpenAIToolId,
+    toAnthropicToolId
+};

package/src/index.js

@@ -0,0 +1,46 @@
+/**
+ * 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);
+const HOST = process.env.HOST || '127.0.0.1';
+
+startServer({ port: PORT, host: HOST });
+
+console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║                 Codex Claude Proxy v1.0.6                    ║
+║                   (Direct API Mode)                          ║
+╠══════════════════════════════════════════════════════════════╣
+║  Server:   http://${HOST}:${PORT}                          ║
+║  WebUI:    http://${HOST}:${PORT}                          ║
+║  Health:   http://${HOST}:${PORT}/health                   ║
+║  Accounts: http://${HOST}:${PORT}/accounts                 ║
+║  Logs:     http://${HOST}:${PORT}/api/logs/stream          ║
+╠══════════════════════════════════════════════════════════════╣
+║  Features:                                                   ║
+║    ✓ Native tool calling support                             ║
+║    ✓ Real-time streaming                                     ║
+║    ✓ Multi-account management                                ║
+║    ✓ OpenAI & Anthropic API compatibility                    ║
+╠══════════════════════════════════════════════════════════════╣
+║  Support:                                                    ║
+║    ★ Give it a star on GitHub!                               ║
+║    https://github.com/surajmandalcell/codex-proxy            ║
+╚══════════════════════════════════════════════════════════════╝
+`);
+
+const status = getStatus();
+logger.info(`Accounts: ${status.total} total, Active: ${status.active || 'None'}`);
+
+if (status.total === 0) {
+  logger.warn(`No accounts configured. Open http://${HOST}:${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
+};