claude-codex-proxy 1.0.0

package/src/direct-api.js

@@ -0,0 +1,214 @@
+/**
+ * Direct API Client
+ * Makes direct HTTP calls to ChatGPT's backend API
+ */
+
+import os from 'os';
+import { convertAnthropicToResponsesAPI, convertOutputToAnthropic, generateMessageId } from './format-converter.js';
+import { streamResponsesAPI, parseResponsesAPIResponse, createResponsesAPIError } from './response-streamer.js';
+import { getServerSettings } from './server-settings.js';
+import { logger } from './utils/logger.js';
+
+const API_URL = 'https://chatgpt.com/backend-api/codex/responses';
+const APP_VERSION = '1.0.5';
+
+function shouldLogRawProxyPayloads() {
+    return getServerSettings().logRawProxyPayloads === true;
+}
+
+function buildOpencodeHeaders(accessToken, accountId, context = {}) {
+    const headers = {
+        'Authorization': `Bearer ${accessToken}`,
+        'ChatGPT-Account-Id': accountId,
+        'Content-Type': 'application/json',
+        'Accept': 'text/event-stream',
+        'originator': 'opencode',
+        'User-Agent': `opencode/${APP_VERSION} (${os.platform()} ${os.release()}; ${os.arch()})`
+    };
+
+    if (context.sessionId) {
+        headers['session-id'] = context.sessionId;
+    }
+
+    return headers;
+}
+
+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;
+}
+
+function getProxyStatusForUpstream(status) {
+    if (status >= 500) return 502;
+    return status || 500;
+}
+
+function createHTTPError(message, status, anthropicErrorType = 'api_error', upstreamStatus = null) {
+    const error = new Error(message);
+    error.status = status;
+    error.anthropicErrorType = anthropicErrorType;
+    if (upstreamStatus !== null) {
+        error.upstreamStatus = upstreamStatus;
+        error.isUpstreamError = true;
+    }
+    return error;
+}
+
+function createUpstreamHTTPError(response, errorText) {
+    const proxyStatus = getProxyStatusForUpstream(response.status);
+    return createHTTPError(`API_ERROR: ${response.status} - ${errorText}`, proxyStatus, 'api_error', response.status);
+}
+
+async function createResponsesAPIStreamResponse(anthropicRequest, accessToken, accountId, accountRotator = null, currentEmail = null, context = {}) {
+    const modelId = anthropicRequest.model;
+    const request = convertAnthropicToResponsesAPI(anthropicRequest);
+    if (shouldLogRawProxyPayloads()) {
+        logger.info('[OpenAI Request]', request);
+    }
+
+    const response = await fetch(API_URL, {
+        method: 'POST',
+        headers: buildOpencodeHeaders(accessToken, accountId, context),
+        body: JSON.stringify(request)
+    });
+
+    if (response.ok) return response;
+
+    const errorText = await response.text();
+    if (shouldLogRawProxyPayloads()) {
+        logger.info('[OpenAI Error]', { status: response.status, body: errorText });
+    }
+
+    if (response.status === 401) {
+        if (accountRotator && currentEmail) {
+            accountRotator.markInvalid(currentEmail, 'Token expired or revoked');
+        }
+        throw createHTTPError('AUTH_EXPIRED: Token expired or revoked. Please re-authenticate.', 401, 'authentication_error', response.status);
+    }
+
+    if (response.status === 429) {
+        const resetMs = parseResetTime(response, errorText);
+        if (accountRotator && currentEmail) {
+            accountRotator.markRateLimited(currentEmail, resetMs, modelId);
+        }
+        const error = createHTTPError(`RATE_LIMITED:${resetMs}:${errorText}`, 429, 'rate_limit_error', response.status);
+        error.resetMs = resetMs;
+        throw error;
+    }
+
+    if (response.status === 403) {
+        if (errorText.includes('challenge') || errorText.includes('cloudflare')) {
+            throw createHTTPError('CLOUDFLARE_BLOCKED: Request blocked by Cloudflare.', 403, 'api_error', response.status);
+        }
+        throw createHTTPError(`FORBIDDEN: ${errorText}`, 403, 'permission_error', response.status);
+    }
+
+    if (response.status === 400) {
+        throw createHTTPError(`INVALID_REQUEST: ${errorText}`, 400, 'invalid_request_error', response.status);
+    }
+
+    throw createUpstreamHTTPError(response, errorText);
+}
+
+/**
+ * Send a streaming request to ChatGPT API
+ */
+export async function* sendMessageStream(anthropicRequest, accessToken, accountId, accountRotator = null, currentEmail = null, context = {}, responseModel = anthropicRequest.model) {
+    const response = await createResponsesAPIStreamResponse(anthropicRequest, accessToken, accountId, accountRotator, currentEmail, context);
+    yield* streamResponsesAPI(response, responseModel);
+}
+
+export async function createMessageStream(anthropicRequest, accessToken, accountId, accountRotator = null, currentEmail = null, context = {}, responseModel = anthropicRequest.model) {
+    const response = await createResponsesAPIStreamResponse(anthropicRequest, accessToken, accountId, accountRotator, currentEmail, context);
+    return streamResponsesAPI(response, responseModel);
+}
+
+/**
+ * Send a non-streaming request to ChatGPT API
+ */
+export async function sendMessage(anthropicRequest, accessToken, accountId, context = {}) {
+    const request = convertAnthropicToResponsesAPI({
+        ...anthropicRequest,
+        stream: false
+    });
+    if (shouldLogRawProxyPayloads()) {
+        logger.info('[OpenAI Request]', request);
+    }
+
+    const response = await fetch(API_URL, {
+        method: 'POST',
+        headers: buildOpencodeHeaders(accessToken, accountId, context),
+        body: JSON.stringify(request)
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        if (shouldLogRawProxyPayloads()) {
+            logger.info('[OpenAI Error]', { status: response.status, body: errorText });
+        }
+
+        if (response.status === 401) {
+            throw createHTTPError('AUTH_EXPIRED: Token expired or revoked. Please re-authenticate.', 401, 'authentication_error', response.status);
+        }
+
+        throw createUpstreamHTTPError(response, errorText);
+    }
+
+    const apiResponse = await parseResponsesAPIResponse(response);
+
+    if (!apiResponse) {
+        throw createResponsesAPIError('Upstream stream ended without response.completed');
+    }
+
+    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 || apiResponse.usage?.input_tokens_details?.cached_tokens || 0
+        }
+    };
+}
+
+export { parseResetTime };
+
+export default {
+    sendMessageStream,
+    createMessageStream,
+    sendMessage,
+    parseResetTime
+};