codex-rotating-proxy 0.1.1 → 0.1.3

package/README.md

@@ -115,28 +115,30 @@ codex-proxy config --cooldown 30       # cooldown minutes
 
 ## Using with opencode
 
-Add the proxy as your OpenAI provider base URL in `~/.config/opencode/opencode.json`:
+The built-in `openai` provider ignores `baseURL` overrides for Codex models. Instead, register the proxy as a custom provider using `@ai-sdk/openai-compatible` in `~/.config/opencode/opencode.json`:
 
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
+  "model": "rotating-openai/gpt-5.3-codex",
   "provider": {
-    "openai": {
+    "rotating-openai": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "Rotating OpenAI",
       "options": {
         "baseURL": "http://localhost:4000/v1"
+      },
+      "models": {
+        "gpt-5.3-codex": {
+          "name": "GPT-5.3 Codex"
+        }
       }
     }
   }
 }
 ```
 
-Then set your model as usual — the proxy forwards whatever model the client requests:
-
-```json
-{
-  "model": "openai/gpt-4o"
-}
-```
+You can add any OpenAI model to the `models` map — the proxy forwards whatever model the client requests.
 
 Start both:
 
@@ -162,7 +164,8 @@ Set the base URL to `http://localhost:4000/v1`. Set the API key to any non-empty
 - **Sticky routing** — stays on one account until it hits a rate limit, then rotates to the next
 - **Auto-rotation** — detects HTTP 429, 402, and quota-related 403 responses
 - **Token refresh** — OAuth tokens are automatically refreshed on 401; no manual re-login needed
-- **Streaming** — full SSE streaming support for chat completions
+- **Chat Completions compatibility** — automatically translates `/v1/chat/completions` requests to the Responses API, so tools that only speak Chat Completions work with Codex models
+- **Streaming** — full SSE streaming support for both chat completions and responses API
 - **Hot reload** — logging in while the proxy is running adds the new account immediately
 - **Zero dependencies** — just Node.js
 

package/dist/login.js

@@ -51,8 +51,9 @@ export async function loginFlow(accountName) {
                     client_id: CLIENT_ID,
                     code_verifier: verifier,
                 });
-                // Step 2: exchange id_token for an OpenAI API key
-                const apiKey = await exchangeForApiKey(tokens.id_token);
+                // Use access_token directly (JWT bearer) — NOT an sk-proj-* API key.
+                // Codex models like gpt-5.3-codex require the JWT access token,
+                // not an exchanged API key.
                 // Parse JWT for display info + account ID
                 const claims = parseJwt(tokens.id_token);
                 const email = claims.email ?? "unknown";
@@ -61,7 +62,7 @@ export async function loginFlow(accountName) {
                 const name = accountName || email.split("@")[0];
                 addAccount({
                     name,
-                    token: apiKey,
+                    token: tokens.access_token,
                     refreshToken: tokens.refresh_token,
                     accountId,
                     addedAt: new Date().toISOString(),
@@ -115,14 +116,13 @@ export async function refreshAccount(account) {
             refresh_token: account.refreshToken,
             scope: REFRESH_SCOPES,
         });
-        const apiKey = await exchangeForApiKey(tokens.id_token);
         addAccount({
             ...account,
-            token: apiKey,
+            token: tokens.access_token,
             refreshToken: tokens.refresh_token,
             lastRefresh: new Date().toISOString(),
         });
-        return apiKey;
+        return tokens.access_token;
     }
     catch {
         return null;

package/dist/server.js

@@ -4,6 +4,7 @@ import { type as osType, release, arch } from "node:os";
 import { getAccounts, getSettings, writePid, removePid } from "./config.js";
 import { refreshAccount } from "./login.js";
 import { AccountPool, log } from "./pool.js";
+import { chatToResponsesRequest, responsesToChatResponse, createStreamTranslator } from "./translate.js";
 const ROTATE_ON = new Set([429, 402]);
 const STRIP_REQ = new Set([
     "host", "authorization", "connection", "content-length",
@@ -79,6 +80,29 @@ export function startProxy() {
         for await (const chunk of req)
             chunks.push(chunk);
         let body = chunks.length > 0 ? Buffer.concat(chunks) : null;
+        // ── Detect chat completions → responses translation ─────
+        const isChatCompletions = url.pathname === "/v1/chat/completions" && req.method === "POST";
+        let targetPath = url.pathname;
+        let targetBase = upstream;
+        let parsedBody = null;
+        let isStreaming = false;
+        if (isChatCompletions && body) {
+            try {
+                parsedBody = JSON.parse(body.toString("utf-8"));
+                isStreaming = !!parsedBody.stream;
+                const translated = chatToResponsesRequest(parsedBody);
+                log("cyan", `↔ translating chat/completions → responses (stream=${isStreaming})`);
+                log("cyan", `  request: ${JSON.stringify(translated).slice(0, 200)}`);
+                body = Buffer.from(JSON.stringify(translated));
+                // Codex models (gpt-5.x-codex) use ChatGPT backend, not api.openai.com
+                targetBase = "https://chatgpt.com/backend-api";
+                targetPath = "/codex/responses";
+            }
+            catch (err) {
+                log("red", `✗ failed to parse/translate body: ${err}`);
+                // fall through with original body
+            }
+        }
         // ── Forward headers ───────────────────────────────────────
         const fwdHeaders = {};
         for (const [k, v] of Object.entries(req.headers)) {
@@ -91,8 +115,8 @@ export function startProxy() {
             const entry = pool.getNext();
             if (!entry)
                 break;
-            const target = `${upstream}${url.pathname}${url.search}`;
-            log("cyan", `→ ${req.method} ${url.pathname} via ${entry.name}`);
+            const target = `${targetBase}${targetPath}${url.search}`;
+            log("cyan", `→ ${req.method} ${targetPath} via ${entry.name}`);
             // Inner loop: try once, and if 401 + refreshable, refresh and retry
             let currentToken = entry.account.token;
             for (let retry = 0; retry < 2; retry++) {
@@ -103,6 +127,7 @@ export function startProxy() {
                             ...fwdHeaders,
                             ...codexHeaders(entry.account),
                             authorization: `Bearer ${currentToken}`,
+                            "accept-encoding": "identity",
                             ...(body ? { "content-length": String(body.byteLength) } : {}),
                         },
                         body,
@@ -141,8 +166,84 @@ export function startProxy() {
                         forward(res, 403, fetchRes.headers, text);
                         return;
                     }
-                    // ── Stream response back ──────────────────────────
                     log("green", `✓ ${fetchRes.status}`);
+                    // ── Translate response if chat completions ─────────
+                    if (isChatCompletions && parsedBody) {
+                        if (isStreaming) {
+                            // Streaming: translate Responses SSE → Chat Completions SSE
+                            res.writeHead(200, {
+                                "content-type": "text/event-stream",
+                                "cache-control": "no-cache",
+                                "connection": "keep-alive",
+                            });
+                            const translator = createStreamTranslator(parsedBody.model);
+                            const reader = fetchRes.body.getReader();
+                            const decoder = new TextDecoder();
+                            let buffer = "";
+                            let emittedCount = 0;
+                            try {
+                                while (true) {
+                                    const { done, value } = await reader.read();
+                                    if (done)
+                                        break;
+                                    const raw = decoder.decode(value, { stream: true });
+                                    if (emittedCount === 0)
+                                        log("cyan", `  upstream first chunk: ${raw.slice(0, 300).replace(/\n/g, "\\n")}`);
+                                    buffer += raw;
+                                    const lines = buffer.split("\n");
+                                    buffer = lines.pop() ?? "";
+                                    for (const line of lines) {
+                                        const trimmed = line.trim();
+                                        if (!trimmed)
+                                            continue;
+                                        const translated = translator.feed(trimmed);
+                                        for (const out of translated) {
+                                            if (emittedCount < 3)
+                                                log("cyan", `  emit[${emittedCount}]: ${out.slice(0, 200).replace(/\n/g, "\\n")}`);
+                                            res.write(out);
+                                            emittedCount++;
+                                        }
+                                    }
+                                }
+                                // Process remaining buffer
+                                if (buffer.trim()) {
+                                    const translated = translator.feed(buffer.trim());
+                                    for (const out of translated) {
+                                        res.write(out);
+                                        emittedCount++;
+                                    }
+                                }
+                                const flushed = translator.flush();
+                                for (const out of flushed) {
+                                    res.write(out);
+                                    emittedCount++;
+                                }
+                            }
+                            catch (err) {
+                                log("red", `  stream error: ${err}`);
+                            }
+                            log("cyan", `  stream done, emitted ${emittedCount} chunks`);
+                            res.end();
+                        }
+                        else {
+                            // Non-streaming: buffer full response and translate
+                            const text = await fetchRes.text();
+                            log("cyan", `  upstream response: ${text.slice(0, 300)}`);
+                            try {
+                                const respBody = JSON.parse(text);
+                                const translated = responsesToChatResponse(respBody, parsedBody.model);
+                                log("cyan", `  translated: ${JSON.stringify(translated).slice(0, 300)}`);
+                                json(res, 200, translated);
+                            }
+                            catch {
+                                // Can't parse — forward raw
+                                res.writeHead(fetchRes.status, { "content-type": "application/json" });
+                                res.end(text);
+                            }
+                        }
+                        return;
+                    }
+                    // ── Pass-through (non-translated) ─────────────────
                     const resHeaders = {};
                     fetchRes.headers.forEach((v, k) => {
                         if (!STRIP_RES.has(k.toLowerCase()))

package/dist/translate.js

@@ -0,0 +1,276 @@
+// ── Chat Completions ↔ Responses API translation layer ─────────────
+// ── Request: Chat Completions → Responses ──────────────────────────
+export function chatToResponsesRequest(body) {
+    const out = { model: body.model };
+    // Extract system message → instructions
+    const messages = body.messages ?? [];
+    const systemMsgs = messages.filter((m) => m.role === "system");
+    const nonSystem = messages.filter((m) => m.role !== "system");
+    if (systemMsgs.length > 0) {
+        out.instructions = systemMsgs
+            .map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content))
+            .join("\n");
+    }
+    // Convert messages → input
+    out.input = [];
+    for (const msg of nonSystem) {
+        if (msg.role === "user") {
+            out.input.push({ role: "user", content: convertInputContent(msg.content) });
+        }
+        else if (msg.role === "assistant") {
+            // Text part as a message item
+            if (msg.content) {
+                out.input.push({
+                    type: "message",
+                    role: "assistant",
+                    status: "completed",
+                    content: [{ type: "output_text", text: msg.content, annotations: [] }],
+                });
+            }
+            // Tool calls as separate function_call items
+            if (msg.tool_calls) {
+                for (const tc of msg.tool_calls) {
+                    out.input.push({
+                        type: "function_call",
+                        call_id: tc.id,
+                        name: tc.function.name,
+                        arguments: tc.function.arguments,
+                    });
+                }
+            }
+        }
+        else if (msg.role === "tool") {
+            out.input.push({
+                type: "function_call_output",
+                call_id: msg.tool_call_id,
+                output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+            });
+        }
+    }
+    // Simple field mappings
+    if (body.stream !== undefined)
+        out.stream = body.stream;
+    if (body.temperature !== undefined)
+        out.temperature = body.temperature;
+    if (body.top_p !== undefined)
+        out.top_p = body.top_p;
+    // Note: ChatGPT backend doesn't support max_output_tokens, skip it
+    if (body.stop !== undefined)
+        out.stop = body.stop;
+    if (body.frequency_penalty !== undefined)
+        out.frequency_penalty = body.frequency_penalty;
+    if (body.presence_penalty !== undefined)
+        out.presence_penalty = body.presence_penalty;
+    if (body.user !== undefined)
+        out.user = body.user;
+    if (body.parallel_tool_calls !== undefined)
+        out.parallel_tool_calls = body.parallel_tool_calls;
+    out.store = false; // ChatGPT backend requires store=false
+    if (body.metadata !== undefined)
+        out.metadata = body.metadata;
+    // reasoning_effort
+    if (body.reasoning_effort !== undefined) {
+        out.reasoning = { effort: body.reasoning_effort };
+    }
+    // response_format → text.format
+    if (body.response_format) {
+        out.text = { format: body.response_format };
+    }
+    // tools: unwrap function wrapper
+    if (body.tools) {
+        out.tools = body.tools.map((t) => {
+            if (t.type === "function" && t.function) {
+                return { type: "function", ...t.function };
+            }
+            return t;
+        });
+    }
+    // tool_choice: translate object form
+    if (body.tool_choice !== undefined) {
+        if (typeof body.tool_choice === "object" && body.tool_choice.function) {
+            out.tool_choice = { type: "function", name: body.tool_choice.function.name };
+        }
+        else {
+            out.tool_choice = body.tool_choice;
+        }
+    }
+    return out;
+}
+function convertInputContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return content;
+    return content.map((part) => {
+        if (part.type === "text")
+            return { type: "input_text", text: part.text };
+        if (part.type === "image_url")
+            return { type: "input_image", image_url: part.image_url.url ?? part.image_url };
+        return part;
+    });
+}
+// ── Response: Responses → Chat Completions (non-streaming) ─────────
+export function responsesToChatResponse(resp, model) {
+    const output = resp.output ?? [];
+    let textContent = "";
+    const toolCalls = [];
+    for (const item of output) {
+        if (item.type === "message" && item.content) {
+            for (const part of item.content) {
+                if (part.type === "output_text")
+                    textContent += part.text;
+            }
+        }
+        else if (item.type === "function_call") {
+            toolCalls.push({
+                id: item.call_id,
+                type: "function",
+                function: { name: item.name, arguments: item.arguments },
+            });
+        }
+    }
+    const finishReason = toolCalls.length > 0 ? "tool_calls" :
+        resp.status === "completed" ? "stop" :
+            resp.status === "incomplete" ? "length" : "stop";
+    const message = { role: "assistant", content: textContent || null };
+    if (toolCalls.length > 0)
+        message.tool_calls = toolCalls;
+    return {
+        id: resp.id?.replace(/^resp_/, "chatcmpl-") ?? "chatcmpl-proxy",
+        object: "chat.completion",
+        created: Math.floor(resp.created_at ?? Date.now() / 1000),
+        model: resp.model ?? model,
+        choices: [{ index: 0, message, finish_reason: finishReason, logprobs: null }],
+        usage: resp.usage ? {
+            prompt_tokens: resp.usage.input_tokens ?? 0,
+            completion_tokens: resp.usage.output_tokens ?? 0,
+            total_tokens: resp.usage.total_tokens ?? 0,
+        } : undefined,
+    };
+}
+export function createStreamTranslator(model) {
+    const id = `chatcmpl-${Date.now()}`;
+    let sentRole = false;
+    let sentDone = false;
+    let toolCallIndex = -1;
+    const toolCallIds = new Map(); // item_id → index
+    function chunk(delta, finishReason = null) {
+        return `data: ${JSON.stringify({
+            id,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [{ index: 0, delta, finish_reason: finishReason }],
+        })}\n\n`;
+    }
+    function usageChunk(usage) {
+        return `data: ${JSON.stringify({
+            id,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [],
+            usage: {
+                prompt_tokens: usage.input_tokens ?? 0,
+                completion_tokens: usage.output_tokens ?? 0,
+                total_tokens: usage.total_tokens ?? 0,
+            },
+        })}\n\n`;
+    }
+    return {
+        feed(line) {
+            if (!line.startsWith("data: "))
+                return [];
+            const jsonStr = line.slice(6).trim();
+            if (!jsonStr || jsonStr === "[DONE]")
+                return [];
+            let event;
+            try {
+                event = JSON.parse(jsonStr);
+            }
+            catch {
+                return [];
+            }
+            const results = [];
+            const type = event.type;
+            if (type === "response.output_item.added") {
+                // Role announcement on first message
+                if (event.item?.type === "message" && !sentRole) {
+                    sentRole = true;
+                    results.push(chunk({ role: "assistant", content: "" }));
+                }
+                // Function call start
+                if (event.item?.type === "function_call") {
+                    toolCallIndex++;
+                    toolCallIds.set(event.item.id, toolCallIndex);
+                    results.push(chunk({
+                        tool_calls: [{
+                                index: toolCallIndex,
+                                id: event.item.call_id,
+                                type: "function",
+                                function: { name: event.item.name, arguments: "" },
+                            }],
+                    }));
+                }
+            }
+            else if (type === "response.output_text.delta") {
+                if (!sentRole) {
+                    sentRole = true;
+                    results.push(chunk({ role: "assistant", content: "" }));
+                }
+                results.push(chunk({ content: event.delta }));
+            }
+            else if (type === "response.function_call_arguments.delta") {
+                const idx = toolCallIds.get(event.item_id) ?? 0;
+                results.push(chunk({
+                    tool_calls: [{ index: idx, function: { arguments: event.delta } }],
+                }));
+            }
+            else if (type === "response.completed") {
+                const resp = event.response;
+                const hasFnCalls = (resp?.output ?? []).some((o) => o.type === "function_call");
+                const finishReason = hasFnCalls ? "tool_calls" :
+                    resp?.status === "incomplete" ? "length" : "stop";
+                results.push(chunk({}, finishReason));
+                if (resp?.usage)
+                    results.push(usageChunk(resp.usage));
+                results.push("data: [DONE]\n\n");
+            }
+            else if (type === "error") {
+                // Forward API errors as Chat Completions error format
+                const err = event.error ?? {};
+                results.push(`data: ${JSON.stringify({
+                    error: {
+                        message: err.message ?? "Unknown error",
+                        type: err.type ?? "api_error",
+                        code: err.code ?? null,
+                    },
+                })}\n\n`);
+                results.push("data: [DONE]\n\n");
+            }
+            else if (type === "response.failed") {
+                const resp = event.response;
+                const err = resp?.error ?? {};
+                if (!sentDone) {
+                    results.push(`data: ${JSON.stringify({
+                        error: {
+                            message: err.message ?? "Response failed",
+                            type: "api_error",
+                            code: err.code ?? null,
+                        },
+                    })}\n\n`);
+                    results.push("data: [DONE]\n\n");
+                }
+            }
+            if (results.some(r => r.includes("[DONE]")))
+                sentDone = true;
+            return results;
+        },
+        flush() {
+            // If stream ended without a proper termination, send [DONE]
+            if (!sentDone)
+                return ["data: [DONE]\n\n"];
+            return [];
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-rotating-proxy",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "OpenAI API proxy that rotates between multiple accounts when rate limits hit",
   "type": "module",
   "bin": {