feat: multi-protocol support — Anthropic Messages API + Google Gemini API

Add two new protocol translation layers so the proxy can serve clients
speaking Anthropic (/v1/messages) or Gemini (/v1beta/models/:model:generateContent)
in addition to the existing OpenAI /v1/chat/completions endpoint.
All three protocols translate to the same upstream Codex Responses API.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

config/models.yaml

@@ -74,3 +74,23 @@ aliases:
   codex: "gpt-5.3-codex"
   codex-max: "gpt-5.1-codex-max"
   codex-mini: "gpt-5.1-codex-mini"
+
+  # Anthropic Claude model aliases
+  claude-sonnet-4-20250514: "gpt-5.3-codex"
+  claude-opus-4-20250514: "gpt-5.3-codex"
+  claude-sonnet-4-6: "gpt-5.3-codex"
+  claude-opus-4-6: "gpt-5.3-codex"
+  claude-haiku-4-5: "gpt-5.1-codex-mini"
+  claude-haiku-4-5-20251001: "gpt-5.1-codex-mini"
+  claude-3-5-sonnet-20241022: "gpt-5.3-codex"
+  claude-3-5-haiku-20241022: "gpt-5.1-codex-mini"
+  claude-3-opus-20240229: "gpt-5.3-codex"
+  claude-sonnet: "gpt-5.3-codex"
+  claude-opus: "gpt-5.3-codex"
+  claude-haiku: "gpt-5.1-codex-mini"
+
+  # Google Gemini model aliases
+  gemini-2.5-pro: "gpt-5.3-codex"
+  gemini-2.5-pro-preview: "gpt-5.3-codex"
+  gemini-2.5-flash: "gpt-5.1-codex-mini"
+  gemini-2.0-flash: "gpt-5.1-codex-mini"

src/index.ts

@@ -9,6 +9,8 @@ import { errorHandler } from "./middleware/error-handler.js";
 import { createAuthRoutes } from "./routes/auth.js";
 import { createAccountRoutes } from "./routes/accounts.js";
 import { createChatRoutes } from "./routes/chat.js";
+import { createMessagesRoutes } from "./routes/messages.js";
+import { createGeminiRoutes } from "./routes/gemini.js";
 import modelsApp from "./routes/models.js";
 import { createWebRoutes } from "./routes/web.js";
 import { CookieJar } from "./proxy/cookie-jar.js";
@@ -45,11 +47,15 @@ async function main() {
   const authRoutes = createAuthRoutes(accountPool, refreshScheduler);
   const accountRoutes = createAccountRoutes(accountPool, refreshScheduler, cookieJar);
   const chatRoutes = createChatRoutes(accountPool, sessionManager, cookieJar);
+  const messagesRoutes = createMessagesRoutes(accountPool, sessionManager, cookieJar);
+  const geminiRoutes = createGeminiRoutes(accountPool, sessionManager, cookieJar);
   const webRoutes = createWebRoutes(accountPool);
 
   app.route("/", authRoutes);
   app.route("/", accountRoutes);
   app.route("/", chatRoutes);
+  app.route("/", messagesRoutes);
+  app.route("/", geminiRoutes);
   app.route("/", modelsApp);
   app.route("/", webRoutes);
 

src/middleware/error-handler.ts

@@ -1,7 +1,9 @@
 import type { Context, Next } from "hono";
+import type { StatusCode } from "hono/utils/http-status";
 import type { OpenAIErrorBody } from "../types/openai.js";
+import type { AnthropicErrorBody, AnthropicErrorType } from "../types/anthropic.js";
 
-function makeError(
+function makeOpenAIError(
   message: string,
   type: string,
   code: string | null,
@@ -16,6 +18,36 @@ function makeError(
   };
 }
 
+function makeAnthropicError(
+  message: string,
+  errorType: AnthropicErrorType,
+): AnthropicErrorBody {
+  return { type: "error", error: { type: errorType, message } };
+}
+
+interface GeminiErrorBody {
+  error: { code: number; message: string; status: string };
+}
+
+function makeGeminiError(
+  code: number,
+  message: string,
+  status: string,
+): GeminiErrorBody {
+  return { error: { code, message, status } };
+}
+
+const GEMINI_STATUS_MAP: Record<number, string> = {
+  400: "INVALID_ARGUMENT",
+  401: "UNAUTHENTICATED",
+  403: "PERMISSION_DENIED",
+  404: "NOT_FOUND",
+  429: "RESOURCE_EXHAUSTED",
+  500: "INTERNAL",
+  502: "INTERNAL",
+  503: "UNAVAILABLE",
+};
+
 export async function errorHandler(c: Context, next: Next): Promise<void> {
   try {
     await next();
@@ -24,11 +56,51 @@ export async function errorHandler(c: Context, next: Next): Promise<void> {
     console.error("[ErrorHandler]", message);
 
     const status = (err as { status?: number }).status;
+    const path = c.req.path;
+
+    // Anthropic Messages API errors
+    if (path.startsWith("/v1/messages")) {
+      if (status === 401) {
+        c.status(401);
+        return c.json(
+          makeAnthropicError(
+            "Invalid or expired token. Please re-authenticate.",
+            "authentication_error",
+          ),
+        ) as never;
+      }
+      if (status === 429) {
+        c.status(429);
+        return c.json(
+          makeAnthropicError(
+            "Rate limit exceeded. Please try again later.",
+            "rate_limit_error",
+          ),
+        ) as never;
+      }
+      if (status && status >= 500) {
+        c.status(502);
+        return c.json(
+          makeAnthropicError(`Upstream server error: ${message}`, "api_error"),
+        ) as never;
+      }
+      c.status(500);
+      return c.json(makeAnthropicError(message, "api_error")) as never;
+    }
+
+    // Gemini API errors
+    if (path.startsWith("/v1beta/")) {
+      const code = status ?? 500;
+      const geminiStatus = GEMINI_STATUS_MAP[code] ?? "INTERNAL";
+      c.status((code >= 400 && code < 600 ? code : 500) as StatusCode);
+      return c.json(makeGeminiError(code, message, geminiStatus)) as never;
+    }
 
+    // Default: OpenAI-format errors
     if (status === 401) {
       c.status(401);
       return c.json(
-        makeError(
+        makeOpenAIError(
           "Invalid or expired ChatGPT token. Please re-authenticate.",
           "invalid_request_error",
           "invalid_api_key",
@@ -39,7 +111,7 @@ export async function errorHandler(c: Context, next: Next): Promise<void> {
     if (status === 429) {
       c.status(429);
       return c.json(
-        makeError(
+        makeOpenAIError(
           "Rate limit exceeded. Please try again later.",
           "rate_limit_error",
           "rate_limit_exceeded",
@@ -50,7 +122,7 @@ export async function errorHandler(c: Context, next: Next): Promise<void> {
     if (status && status >= 500) {
       c.status(502);
       return c.json(
-        makeError(
+        makeOpenAIError(
           `Upstream server error: ${message}`,
           "server_error",
           "server_error",
@@ -60,7 +132,7 @@ export async function errorHandler(c: Context, next: Next): Promise<void> {
 
     c.status(500);
     return c.json(
-      makeError(message, "server_error", "internal_error"),
+      makeOpenAIError(message, "server_error", "internal_error"),
     ) as never;
   }
 }

src/routes/gemini.ts

@@ -0,0 +1,298 @@
+/**
+ * Google Gemini API route handler.
+ * POST /v1beta/models/{model}:generateContent — non-streaming
+ * POST /v1beta/models/{model}:streamGenerateContent — streaming
+ */
+
+import { Hono } from "hono";
+import type { StatusCode } from "hono/utils/http-status";
+import { stream } from "hono/streaming";
+import { GeminiGenerateContentRequestSchema } from "../types/gemini.js";
+import type { GeminiErrorResponse } from "../types/gemini.js";
+import type { AccountPool } from "../auth/account-pool.js";
+import { CodexApi, CodexApiError } from "../proxy/codex-api.js";
+import { SessionManager } from "../session/manager.js";
+import {
+  translateGeminiToCodexRequest,
+  geminiContentsToMessages,
+} from "../translation/gemini-to-codex.js";
+import {
+  streamCodexToGemini,
+  collectCodexToGeminiResponse,
+  type GeminiUsageInfo,
+} from "../translation/codex-to-gemini.js";
+import { getConfig } from "../config.js";
+import type { CookieJar } from "../proxy/cookie-jar.js";
+import { resolveModelId } from "./models.js";
+
+/** Retry a function on 5xx errors with exponential backoff. */
+async function withRetry<T>(
+  fn: () => Promise<T>,
+  { maxRetries = 2, baseDelayMs = 1000 }: { maxRetries?: number; baseDelayMs?: number } = {},
+): Promise<T> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const isRetryable =
+        err instanceof CodexApiError && err.status >= 500 && err.status < 600;
+      if (!isRetryable || attempt === maxRetries) throw err;
+      const delay = baseDelayMs * Math.pow(2, attempt);
+      console.warn(
+        `[Gemini] Retrying after ${err instanceof CodexApiError ? err.status : "error"} (attempt ${attempt + 1}/${maxRetries}, delay ${delay}ms)`,
+      );
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+}
+
+const GEMINI_STATUS_MAP: Record<number, string> = {
+  400: "INVALID_ARGUMENT",
+  401: "UNAUTHENTICATED",
+  403: "PERMISSION_DENIED",
+  404: "NOT_FOUND",
+  429: "RESOURCE_EXHAUSTED",
+  500: "INTERNAL",
+  502: "INTERNAL",
+  503: "UNAVAILABLE",
+};
+
+function makeError(
+  code: number,
+  message: string,
+  status?: string,
+): GeminiErrorResponse {
+  return {
+    error: {
+      code,
+      message,
+      status: status ?? GEMINI_STATUS_MAP[code] ?? "INTERNAL",
+    },
+  };
+}
+
+/**
+ * Parse model name and action from the URL param.
+ * e.g. "gemini-2.5-pro:generateContent" → { model: "gemini-2.5-pro", action: "generateContent" }
+ */
+function parseModelAction(param: string): {
+  model: string;
+  action: string;
+} | null {
+  const lastColon = param.lastIndexOf(":");
+  if (lastColon <= 0) return null;
+  return {
+    model: param.slice(0, lastColon),
+    action: param.slice(lastColon + 1),
+  };
+}
+
+export function createGeminiRoutes(
+  accountPool: AccountPool,
+  sessionManager: SessionManager,
+  cookieJar?: CookieJar,
+): Hono {
+  const app = new Hono();
+
+  // Handle both generateContent and streamGenerateContent
+  app.post("/v1beta/models/:modelAction", async (c) => {
+    const modelActionParam = c.req.param("modelAction");
+    const parsed = parseModelAction(modelActionParam);
+
+    if (
+      !parsed ||
+      (parsed.action !== "generateContent" &&
+        parsed.action !== "streamGenerateContent")
+    ) {
+      c.status(400);
+      return c.json(
+        makeError(
+          400,
+          `Invalid action. Expected :generateContent or :streamGenerateContent, got: ${modelActionParam}`,
+        ),
+      );
+    }
+
+    const { model: geminiModel, action } = parsed;
+    const isStreaming =
+      action === "streamGenerateContent" ||
+      c.req.query("alt") === "sse";
+
+    // Validate auth — at least one active account
+    if (!accountPool.isAuthenticated()) {
+      c.status(401);
+      return c.json(
+        makeError(401, "Not authenticated. Please login first at /"),
+      );
+    }
+
+    // API key check: query param ?key= or header x-goog-api-key
+    const config = getConfig();
+    if (config.server.proxy_api_key) {
+      const queryKey = c.req.query("key");
+      const headerKey = c.req.header("x-goog-api-key");
+      const authHeader = c.req.header("Authorization");
+      const bearerKey = authHeader?.replace("Bearer ", "");
+      const providedKey = queryKey ?? headerKey ?? bearerKey;
+
+      if (!providedKey || !accountPool.validateProxyApiKey(providedKey)) {
+        c.status(401);
+        return c.json(makeError(401, "Invalid API key"));
+      }
+    }
+
+    // Parse request
+    const body = await c.req.json();
+    const validationResult = GeminiGenerateContentRequestSchema.safeParse(body);
+    if (!validationResult.success) {
+      c.status(400);
+      return c.json(
+        makeError(400, `Invalid request: ${validationResult.error.message}`),
+      );
+    }
+    const req = validationResult.data;
+
+    // Acquire an account from the pool
+    const acquired = accountPool.acquire();
+    if (!acquired) {
+      c.status(503);
+      return c.json(
+        makeError(
+          503,
+          "No available accounts. All accounts are expired or rate-limited.",
+          "UNAVAILABLE",
+        ),
+      );
+    }
+
+    const { entryId, token, accountId } = acquired;
+    const codexApi = new CodexApi(token, accountId, cookieJar, entryId);
+
+    // Session lookup for multi-turn
+    const sessionMessages = geminiContentsToMessages(
+      req.contents,
+      req.systemInstruction,
+    );
+    const existingSession = sessionManager.findSession(sessionMessages);
+    const previousResponseId = existingSession?.responseId ?? null;
+
+    const codexRequest = translateGeminiToCodexRequest(
+      req,
+      geminiModel,
+      previousResponseId,
+    );
+    if (previousResponseId) {
+      console.log(
+        `[Gemini] Account ${entryId} | Multi-turn: previous_response_id=${previousResponseId}`,
+      );
+    }
+    console.log(
+      `[Gemini] Account ${entryId} | Model: ${geminiModel} → ${codexRequest.model} | Codex request:`,
+      JSON.stringify(codexRequest).slice(0, 300),
+    );
+
+    let usageInfo: GeminiUsageInfo | undefined;
+
+    try {
+      const rawResponse = await withRetry(() =>
+        codexApi.createResponse(codexRequest),
+      );
+
+      if (isStreaming) {
+        c.header("Content-Type", "text/event-stream");
+        c.header("Cache-Control", "no-cache");
+        c.header("Connection", "keep-alive");
+
+        return stream(c, async (s) => {
+          let sessionTaskId: string | null = null;
+          try {
+            for await (const chunk of streamCodexToGemini(
+              codexApi,
+              rawResponse,
+              geminiModel,
+              (u) => {
+                usageInfo = u;
+              },
+              (respId) => {
+                if (!sessionTaskId) {
+                  sessionTaskId = `task-${Date.now()}`;
+                  sessionManager.storeSession(
+                    sessionTaskId,
+                    "turn-1",
+                    sessionMessages,
+                  );
+                }
+                sessionManager.updateResponseId(sessionTaskId, respId);
+              },
+            )) {
+              await s.write(chunk);
+            }
+          } finally {
+            accountPool.release(entryId, usageInfo);
+          }
+        });
+      } else {
+        const result = await collectCodexToGeminiResponse(
+          codexApi,
+          rawResponse,
+          geminiModel,
+        );
+        if (result.responseId) {
+          const taskId = `task-${Date.now()}`;
+          sessionManager.storeSession(taskId, "turn-1", sessionMessages);
+          sessionManager.updateResponseId(taskId, result.responseId);
+        }
+        accountPool.release(entryId, result.usage);
+        return c.json(result.response);
+      }
+    } catch (err) {
+      if (err instanceof CodexApiError) {
+        console.error(
+          `[Gemini] Account ${entryId} | Codex API error:`,
+          err.message,
+        );
+        if (err.status === 429) {
+          accountPool.markRateLimited(entryId);
+          c.status(429);
+          return c.json(makeError(429, err.message, "RESOURCE_EXHAUSTED"));
+        }
+        accountPool.release(entryId);
+        const code = (
+          err.status >= 400 && err.status < 600 ? err.status : 502
+        ) as StatusCode;
+        c.status(code);
+        return c.json(makeError(code, err.message));
+      }
+      accountPool.release(entryId);
+      throw err;
+    }
+  });
+
+  // List available Gemini models
+  app.get("/v1beta/models", (c) => {
+    // Import aliases from models.yaml and filter Gemini ones
+    const geminiAliases = [
+      "gemini-2.5-pro",
+      "gemini-2.5-pro-preview",
+      "gemini-2.5-flash",
+      "gemini-2.0-flash",
+    ];
+
+    const models = geminiAliases.map((name) => ({
+      name: `models/${name}`,
+      displayName: name,
+      description: `Proxy alias for ${resolveModelId(name)}`,
+      supportedGenerationMethods: [
+        "generateContent",
+        "streamGenerateContent",
+      ],
+    }));
+
+    return c.json({ models });
+  });
+
+  return app;
+}

src/routes/messages.ts

@@ -0,0 +1,229 @@
+/**
+ * Anthropic Messages API route handler.
+ * POST /v1/messages — compatible with Claude Code CLI and other Anthropic clients.
+ */
+
+import { Hono } from "hono";
+import type { StatusCode } from "hono/utils/http-status";
+import { stream } from "hono/streaming";
+import { AnthropicMessagesRequestSchema } from "../types/anthropic.js";
+import type { AnthropicErrorBody, AnthropicErrorType } from "../types/anthropic.js";
+import type { AccountPool } from "../auth/account-pool.js";
+import { CodexApi, CodexApiError } from "../proxy/codex-api.js";
+import { SessionManager } from "../session/manager.js";
+import { translateAnthropicToCodexRequest } from "../translation/anthropic-to-codex.js";
+import {
+  streamCodexToAnthropic,
+  collectCodexToAnthropicResponse,
+  type AnthropicUsageInfo,
+} from "../translation/codex-to-anthropic.js";
+import { getConfig } from "../config.js";
+import type { CookieJar } from "../proxy/cookie-jar.js";
+
+/** Retry a function on 5xx errors with exponential backoff. */
+async function withRetry<T>(
+  fn: () => Promise<T>,
+  { maxRetries = 2, baseDelayMs = 1000 }: { maxRetries?: number; baseDelayMs?: number } = {},
+): Promise<T> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const isRetryable =
+        err instanceof CodexApiError && err.status >= 500 && err.status < 600;
+      if (!isRetryable || attempt === maxRetries) throw err;
+      const delay = baseDelayMs * Math.pow(2, attempt);
+      console.warn(
+        `[Messages] Retrying after ${err instanceof CodexApiError ? err.status : "error"} (attempt ${attempt + 1}/${maxRetries}, delay ${delay}ms)`,
+      );
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+}
+
+function makeError(
+  type: AnthropicErrorType,
+  message: string,
+): AnthropicErrorBody {
+  return { type: "error", error: { type, message } };
+}
+
+/**
+ * Extract text from Anthropic message content for session hashing.
+ */
+function contentToString(
+  content: string | Array<{ type: string; text?: string }>,
+): string {
+  if (typeof content === "string") return content;
+  return content
+    .filter((b) => b.type === "text" && b.text)
+    .map((b) => b.text!)
+    .join("\n");
+}
+
+export function createMessagesRoutes(
+  accountPool: AccountPool,
+  sessionManager: SessionManager,
+  cookieJar?: CookieJar,
+): Hono {
+  const app = new Hono();
+
+  app.post("/v1/messages", async (c) => {
+    // Validate auth — at least one active account
+    if (!accountPool.isAuthenticated()) {
+      c.status(401);
+      return c.json(
+        makeError("authentication_error", "Not authenticated. Please login first at /"),
+      );
+    }
+
+    // Optional proxy API key check
+    // Anthropic clients use x-api-key header; also accept Bearer token
+    const config = getConfig();
+    if (config.server.proxy_api_key) {
+      const xApiKey = c.req.header("x-api-key");
+      const authHeader = c.req.header("Authorization");
+      const bearerKey = authHeader?.replace("Bearer ", "");
+      const providedKey = xApiKey ?? bearerKey;
+
+      if (!providedKey || !accountPool.validateProxyApiKey(providedKey)) {
+        c.status(401);
+        return c.json(makeError("authentication_error", "Invalid API key"));
+      }
+    }
+
+    // Parse request
+    const body = await c.req.json();
+    const parsed = AnthropicMessagesRequestSchema.safeParse(body);
+    if (!parsed.success) {
+      c.status(400);
+      return c.json(
+        makeError("invalid_request_error", `Invalid request: ${parsed.error.message}`),
+      );
+    }
+    const req = parsed.data;
+
+    // Acquire an account from the pool
+    const acquired = accountPool.acquire();
+    if (!acquired) {
+      c.status(529 as StatusCode);
+      return c.json(
+        makeError(
+          "overloaded_error",
+          "No available accounts. All accounts are expired or rate-limited.",
+        ),
+      );
+    }
+
+    const { entryId, token, accountId } = acquired;
+    const codexApi = new CodexApi(token, accountId, cookieJar, entryId);
+
+    // Build session-compatible messages for multi-turn lookup
+    const sessionMessages: Array<{ role: string; content: string }> = [];
+    if (req.system) {
+      const sysText =
+        typeof req.system === "string"
+          ? req.system
+          : req.system.map((b) => b.text).join("\n");
+      sessionMessages.push({ role: "system", content: sysText });
+    }
+    for (const msg of req.messages) {
+      sessionMessages.push({
+        role: msg.role,
+        content: contentToString(msg.content),
+      });
+    }
+
+    const existingSession = sessionManager.findSession(sessionMessages);
+    const previousResponseId = existingSession?.responseId ?? null;
+    const codexRequest = translateAnthropicToCodexRequest(req, previousResponseId);
+    if (previousResponseId) {
+      console.log(
+        `[Messages] Account ${entryId} | Multi-turn: previous_response_id=${previousResponseId}`,
+      );
+    }
+    console.log(
+      `[Messages] Account ${entryId} | Codex request:`,
+      JSON.stringify(codexRequest).slice(0, 300),
+    );
+
+    let usageInfo: AnthropicUsageInfo | undefined;
+
+    try {
+      const rawResponse = await withRetry(() => codexApi.createResponse(codexRequest));
+
+      if (req.stream) {
+        c.header("Content-Type", "text/event-stream");
+        c.header("Cache-Control", "no-cache");
+        c.header("Connection", "keep-alive");
+
+        return stream(c, async (s) => {
+          let sessionTaskId: string | null = null;
+          try {
+            for await (const chunk of streamCodexToAnthropic(
+              codexApi,
+              rawResponse,
+              req.model, // Echo back the model name the client sent
+              (u) => {
+                usageInfo = u;
+              },
+              (respId) => {
+                if (!sessionTaskId) {
+                  sessionTaskId = `task-${Date.now()}`;
+                  sessionManager.storeSession(
+                    sessionTaskId,
+                    "turn-1",
+                    sessionMessages,
+                  );
+                }
+                sessionManager.updateResponseId(sessionTaskId, respId);
+              },
+            )) {
+              await s.write(chunk);
+            }
+          } finally {
+            accountPool.release(entryId, usageInfo);
+          }
+        });
+      } else {
+        const result = await collectCodexToAnthropicResponse(
+          codexApi,
+          rawResponse,
+          req.model,
+        );
+        if (result.responseId) {
+          const taskId = `task-${Date.now()}`;
+          sessionManager.storeSession(taskId, "turn-1", sessionMessages);
+          sessionManager.updateResponseId(taskId, result.responseId);
+        }
+        accountPool.release(entryId, result.usage);
+        return c.json(result.response);
+      }
+    } catch (err) {
+      if (err instanceof CodexApiError) {
+        console.error(
+          `[Messages] Account ${entryId} | Codex API error:`,
+          err.message,
+        );
+        if (err.status === 429) {
+          accountPool.markRateLimited(entryId);
+          c.status(429);
+          return c.json(makeError("rate_limit_error", err.message));
+        }
+        accountPool.release(entryId);
+        const code = (
+          err.status >= 400 && err.status < 600 ? err.status : 502
+        ) as StatusCode;
+        c.status(code);
+        return c.json(makeError("api_error", err.message));
+      }
+      accountPool.release(entryId);
+      throw err;
+    }
+  });
+
+  return app;
+}

src/translation/anthropic-to-codex.ts

@@ -0,0 +1,128 @@
+/**
+ * Translate Anthropic Messages API request → Codex Responses API request.
+ */
+
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import type { AnthropicMessagesRequest } from "../types/anthropic.js";
+import type {
+  CodexResponsesRequest,
+  CodexInputItem,
+} from "../proxy/codex-api.js";
+import { resolveModelId, getModelInfo } from "../routes/models.js";
+import { getConfig } from "../config.js";
+
+const DESKTOP_CONTEXT = loadDesktopContext();
+
+function loadDesktopContext(): string {
+  try {
+    return readFileSync(
+      resolve(process.cwd(), "config/prompts/desktop-context.md"),
+      "utf-8",
+    );
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Map Anthropic thinking budget_tokens to Codex reasoning effort.
+ */
+function mapThinkingToEffort(
+  thinking: AnthropicMessagesRequest["thinking"],
+): string | undefined {
+  if (!thinking || thinking.type === "disabled") return undefined;
+  const budget = thinking.budget_tokens;
+  if (budget < 2000) return "low";
+  if (budget < 8000) return "medium";
+  if (budget < 20000) return "high";
+  return "xhigh";
+}
+
+/**
+ * Extract text from Anthropic content (string or content block array).
+ */
+function flattenContent(
+  content: string | Array<{ type: string; text?: string }>,
+): string {
+  if (typeof content === "string") return content;
+  return content
+    .filter((b) => b.type === "text" && b.text)
+    .map((b) => b.text!)
+    .join("\n");
+}
+
+/**
+ * Convert an AnthropicMessagesRequest to a CodexResponsesRequest.
+ *
+ * Mapping:
+ *   - system (top-level) → instructions field
+ *   - messages → input array
+ *   - model → resolved model ID
+ *   - thinking → reasoning.effort
+ */
+export function translateAnthropicToCodexRequest(
+  req: AnthropicMessagesRequest,
+  previousResponseId?: string | null,
+): CodexResponsesRequest {
+  // Extract system instructions
+  let userInstructions: string;
+  if (req.system) {
+    if (typeof req.system === "string") {
+      userInstructions = req.system;
+    } else {
+      userInstructions = req.system.map((b) => b.text).join("\n\n");
+    }
+  } else {
+    userInstructions = "You are a helpful assistant.";
+  }
+  const instructions = DESKTOP_CONTEXT
+    ? `${DESKTOP_CONTEXT}\n\n${userInstructions}`
+    : userInstructions;
+
+  // Build input items from messages
+  const input: CodexInputItem[] = [];
+  for (const msg of req.messages) {
+    input.push({
+      role: msg.role as "user" | "assistant",
+      content: flattenContent(msg.content),
+    });
+  }
+
+  // Ensure at least one input message
+  if (input.length === 0) {
+    input.push({ role: "user", content: "" });
+  }
+
+  // Resolve model
+  const modelId = resolveModelId(req.model);
+  const modelInfo = getModelInfo(modelId);
+  const config = getConfig();
+
+  // Build request
+  const request: CodexResponsesRequest = {
+    model: modelId,
+    instructions,
+    input,
+    stream: true,
+    store: false,
+    tools: [],
+  };
+
+  // Add previous response ID for multi-turn conversations
+  if (previousResponseId) {
+    request.previous_response_id = previousResponseId;
+  }
+
+  // Add reasoning effort: thinking param → model default → config default
+  const thinkingEffort = mapThinkingToEffort(req.thinking);
+  const effort =
+    thinkingEffort ??
+    modelInfo?.defaultReasoningEffort ??
+    config.model.default_reasoning_effort;
+  if (effort) {
+    request.reasoning = { effort };
+  }
+
+  return request;
+}

src/translation/codex-to-anthropic.ts

@@ -0,0 +1,191 @@
+/**
+ * Translate Codex Responses API SSE stream → Anthropic Messages API format.
+ *
+ * Codex SSE events:
+ *   response.created → extract response ID
+ *   response.output_text.delta → content_block_delta (text_delta)
+ *   response.completed → content_block_stop + message_delta + message_stop
+ *
+ * Non-streaming: collect all text, return Anthropic message response.
+ */
+
+import { randomUUID } from "crypto";
+import type { CodexApi } from "../proxy/codex-api.js";
+import type {
+  AnthropicMessagesResponse,
+  AnthropicUsage,
+} from "../types/anthropic.js";
+
+export interface AnthropicUsageInfo {
+  input_tokens: number;
+  output_tokens: number;
+}
+
+/** Format an Anthropic SSE event with named event type */
+function formatSSE(eventType: string, data: unknown): string {
+  return `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+/**
+ * Stream Codex Responses API events as Anthropic Messages SSE.
+ * Yields string chunks ready to write to the HTTP response.
+ */
+export async function* streamCodexToAnthropic(
+  codexApi: CodexApi,
+  rawResponse: Response,
+  model: string,
+  onUsage?: (usage: AnthropicUsageInfo) => void,
+  onResponseId?: (id: string) => void,
+): AsyncGenerator<string> {
+  const msgId = `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+  let outputTokens = 0;
+  let inputTokens = 0;
+
+  // 1. message_start
+  yield formatSSE("message_start", {
+    type: "message_start",
+    message: {
+      id: msgId,
+      type: "message",
+      role: "assistant",
+      content: [],
+      model,
+      stop_reason: null,
+      stop_sequence: null,
+      usage: { input_tokens: 0, output_tokens: 0 },
+    },
+  });
+
+  // 2. content_block_start for text block at index 0
+  yield formatSSE("content_block_start", {
+    type: "content_block_start",
+    index: 0,
+    content_block: { type: "text", text: "" },
+  });
+
+  // 3. Process Codex stream events
+  for await (const evt of codexApi.parseStream(rawResponse)) {
+    const data = evt.data as Record<string, unknown>;
+
+    switch (evt.event) {
+      case "response.created":
+      case "response.in_progress": {
+        const resp = data.response as Record<string, unknown> | undefined;
+        if (resp?.id) {
+          onResponseId?.(resp.id as string);
+        }
+        break;
+      }
+
+      case "response.output_text.delta": {
+        const delta = (data.delta as string) ?? "";
+        if (delta) {
+          yield formatSSE("content_block_delta", {
+            type: "content_block_delta",
+            index: 0,
+            delta: { type: "text_delta", text: delta },
+          });
+        }
+        break;
+      }
+
+      case "response.completed": {
+        const resp = data.response as Record<string, unknown> | undefined;
+        if (resp?.usage) {
+          const u = resp.usage as Record<string, number>;
+          inputTokens = u.input_tokens ?? 0;
+          outputTokens = u.output_tokens ?? 0;
+          onUsage?.({ input_tokens: inputTokens, output_tokens: outputTokens });
+        }
+        break;
+      }
+    }
+  }
+
+  // 4. content_block_stop
+  yield formatSSE("content_block_stop", {
+    type: "content_block_stop",
+    index: 0,
+  });
+
+  // 5. message_delta with stop_reason and usage
+  yield formatSSE("message_delta", {
+    type: "message_delta",
+    delta: { stop_reason: "end_turn" },
+    usage: { output_tokens: outputTokens },
+  });
+
+  // 6. message_stop
+  yield formatSSE("message_stop", {
+    type: "message_stop",
+  });
+}
+
+/**
+ * Consume a Codex Responses SSE stream and build a non-streaming
+ * Anthropic Messages response.
+ */
+export async function collectCodexToAnthropicResponse(
+  codexApi: CodexApi,
+  rawResponse: Response,
+  model: string,
+): Promise<{
+  response: AnthropicMessagesResponse;
+  usage: AnthropicUsageInfo;
+  responseId: string | null;
+}> {
+  const id = `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+  let fullText = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let responseId: string | null = null;
+
+  for await (const evt of codexApi.parseStream(rawResponse)) {
+    const data = evt.data as Record<string, unknown>;
+
+    switch (evt.event) {
+      case "response.created":
+      case "response.in_progress": {
+        const resp = data.response as Record<string, unknown> | undefined;
+        if (resp?.id) responseId = resp.id as string;
+        break;
+      }
+
+      case "response.output_text.delta": {
+        fullText += (data.delta as string) ?? "";
+        break;
+      }
+
+      case "response.completed": {
+        const resp = data.response as Record<string, unknown> | undefined;
+        if (resp?.id) responseId = resp.id as string;
+        if (resp?.usage) {
+          const u = resp.usage as Record<string, number>;
+          inputTokens = u.input_tokens ?? 0;
+          outputTokens = u.output_tokens ?? 0;
+        }
+        break;
+      }
+    }
+  }
+
+  const usage: AnthropicUsage = {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+  };
+
+  return {
+    response: {
+      id,
+      type: "message",
+      role: "assistant",
+      content: [{ type: "text", text: fullText }],
+      model,
+      stop_reason: "end_turn",
+      stop_sequence: null,
+      usage,
+    },
+    usage,
+    responseId,
+  };
+}

src/translation/codex-to-gemini.ts

@@ -0,0 +1,181 @@
+/**
+ * Translate Codex Responses API SSE stream → Google Gemini API format.
+ *
+ * Codex SSE events:
+ *   response.created → extract response ID
+ *   response.output_text.delta → streaming candidate with text part
+ *   response.completed → final candidate with finishReason + usageMetadata
+ *
+ * Non-streaming: collect all text, return Gemini generateContent response.
+ */
+
+import type { CodexApi } from "../proxy/codex-api.js";
+import type {
+  GeminiGenerateContentResponse,
+  GeminiUsageMetadata,
+} from "../types/gemini.js";
+
+export interface GeminiUsageInfo {
+  input_tokens: number;
+  output_tokens: number;
+}
+
+/**
+ * Stream Codex Responses API events as Gemini SSE.
+ * Yields string chunks ready to write to the HTTP response.
+ */
+export async function* streamCodexToGemini(
+  codexApi: CodexApi,
+  rawResponse: Response,
+  model: string,
+  onUsage?: (usage: GeminiUsageInfo) => void,
+  onResponseId?: (id: string) => void,
+): AsyncGenerator<string> {
+  let inputTokens = 0;
+  let outputTokens = 0;
+
+  for await (const evt of codexApi.parseStream(rawResponse)) {
+    const data = evt.data as Record<string, unknown>;
+
+    switch (evt.event) {
+      case "response.created":
+      case "response.in_progress": {
+        const resp = data.response as Record<string, unknown> | undefined;
+        if (resp?.id) {
+          onResponseId?.(resp.id as string);
+        }
+        break;
+      }
+
+      case "response.output_text.delta": {
+        const delta = (data.delta as string) ?? "";
+        if (delta) {
+          const chunk: GeminiGenerateContentResponse = {
+            candidates: [
+              {
+                content: {
+                  parts: [{ text: delta }],
+                  role: "model",
+                },
+                index: 0,
+              },
+            ],
+            modelVersion: model,
+          };
+          yield `data: ${JSON.stringify(chunk)}\r\n\r\n`;
+        }
+        break;
+      }
+
+      case "response.completed": {
+        const resp = data.response as Record<string, unknown> | undefined;
+        if (resp?.usage) {
+          const u = resp.usage as Record<string, number>;
+          inputTokens = u.input_tokens ?? 0;
+          outputTokens = u.output_tokens ?? 0;
+          onUsage?.({ input_tokens: inputTokens, output_tokens: outputTokens });
+        }
+
+        // Final chunk with finishReason and usage
+        const finalChunk: GeminiGenerateContentResponse = {
+          candidates: [
+            {
+              content: {
+                parts: [{ text: "" }],
+                role: "model",
+              },
+              finishReason: "STOP",
+              index: 0,
+            },
+          ],
+          usageMetadata: {
+            promptTokenCount: inputTokens,
+            candidatesTokenCount: outputTokens,
+            totalTokenCount: inputTokens + outputTokens,
+          },
+          modelVersion: model,
+        };
+        yield `data: ${JSON.stringify(finalChunk)}\r\n\r\n`;
+        break;
+      }
+    }
+  }
+}
+
+/**
+ * Consume a Codex Responses SSE stream and build a non-streaming
+ * Gemini generateContent response.
+ */
+export async function collectCodexToGeminiResponse(
+  codexApi: CodexApi,
+  rawResponse: Response,
+  model: string,
+): Promise<{
+  response: GeminiGenerateContentResponse;
+  usage: GeminiUsageInfo;
+  responseId: string | null;
+}> {
+  let fullText = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let responseId: string | null = null;
+
+  for await (const evt of codexApi.parseStream(rawResponse)) {
+    const data = evt.data as Record<string, unknown>;
+
+    switch (evt.event) {
+      case "response.created":
+      case "response.in_progress": {
+        const resp = data.response as Record<string, unknown> | undefined;
+        if (resp?.id) responseId = resp.id as string;
+        break;
+      }
+
+      case "response.output_text.delta": {
+        fullText += (data.delta as string) ?? "";
+        break;
+      }
+
+      case "response.completed": {
+        const resp = data.response as Record<string, unknown> | undefined;
+        if (resp?.id) responseId = resp.id as string;
+        if (resp?.usage) {
+          const u = resp.usage as Record<string, number>;
+          inputTokens = u.input_tokens ?? 0;
+          outputTokens = u.output_tokens ?? 0;
+        }
+        break;
+      }
+    }
+  }
+
+  const usage: GeminiUsageInfo = {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+  };
+
+  const usageMetadata: GeminiUsageMetadata = {
+    promptTokenCount: inputTokens,
+    candidatesTokenCount: outputTokens,
+    totalTokenCount: inputTokens + outputTokens,
+  };
+
+  return {
+    response: {
+      candidates: [
+        {
+          content: {
+            parts: [{ text: fullText }],
+            role: "model",
+          },
+          finishReason: "STOP",
+          index: 0,
+        },
+      ],
+      usageMetadata,
+      modelVersion: model,
+    },
+    usage,
+    responseId,
+  };
+}

src/translation/gemini-to-codex.ts

@@ -0,0 +1,151 @@
+/**
+ * Translate Google Gemini generateContent request → Codex Responses API request.
+ */
+
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import type {
+  GeminiGenerateContentRequest,
+  GeminiContent,
+} from "../types/gemini.js";
+import type {
+  CodexResponsesRequest,
+  CodexInputItem,
+} from "../proxy/codex-api.js";
+import { resolveModelId, getModelInfo } from "../routes/models.js";
+import { getConfig } from "../config.js";
+
+const DESKTOP_CONTEXT = loadDesktopContext();
+
+function loadDesktopContext(): string {
+  try {
+    return readFileSync(
+      resolve(process.cwd(), "config/prompts/desktop-context.md"),
+      "utf-8",
+    );
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Map Gemini thinkingBudget to Codex reasoning effort.
+ */
+function budgetToEffort(budget?: number): string | undefined {
+  if (!budget || budget <= 0) return undefined;
+  if (budget < 2000) return "low";
+  if (budget < 8000) return "medium";
+  if (budget < 20000) return "high";
+  return "xhigh";
+}
+
+/**
+ * Extract text from Gemini content parts.
+ */
+function flattenParts(
+  parts: Array<{ text?: string; thought?: boolean }>,
+): string {
+  return parts
+    .filter((p) => p.text && !p.thought)
+    .map((p) => p.text!)
+    .join("\n");
+}
+
+/**
+ * Convert Gemini contents to SessionManager-compatible message format.
+ */
+export function geminiContentsToMessages(
+  contents: GeminiContent[],
+  systemInstruction?: GeminiContent,
+): Array<{ role: string; content: string }> {
+  const messages: Array<{ role: string; content: string }> = [];
+
+  if (systemInstruction) {
+    messages.push({
+      role: "system",
+      content: flattenParts(systemInstruction.parts),
+    });
+  }
+
+  for (const c of contents) {
+    const role = c.role === "model" ? "assistant" : c.role ?? "user";
+    messages.push({ role, content: flattenParts(c.parts) });
+  }
+
+  return messages;
+}
+
+/**
+ * Convert a GeminiGenerateContentRequest to a CodexResponsesRequest.
+ *
+ * Mapping:
+ *   - systemInstruction → instructions field
+ *   - contents → input array (role: "model" → "assistant")
+ *   - model (from URL) → resolved model ID
+ *   - thinkingConfig → reasoning.effort
+ */
+export function translateGeminiToCodexRequest(
+  req: GeminiGenerateContentRequest,
+  geminiModel: string,
+  previousResponseId?: string | null,
+): CodexResponsesRequest {
+  // Extract system instructions
+  let userInstructions: string;
+  if (req.systemInstruction) {
+    userInstructions = flattenParts(req.systemInstruction.parts);
+  } else {
+    userInstructions = "You are a helpful assistant.";
+  }
+  const instructions = DESKTOP_CONTEXT
+    ? `${DESKTOP_CONTEXT}\n\n${userInstructions}`
+    : userInstructions;
+
+  // Build input items from contents
+  const input: CodexInputItem[] = [];
+  for (const content of req.contents) {
+    const role = content.role === "model" ? "assistant" : "user";
+    input.push({
+      role: role as "user" | "assistant",
+      content: flattenParts(content.parts),
+    });
+  }
+
+  // Ensure at least one input message
+  if (input.length === 0) {
+    input.push({ role: "user", content: "" });
+  }
+
+  // Resolve model
+  const modelId = resolveModelId(geminiModel);
+  const modelInfo = getModelInfo(modelId);
+  const config = getConfig();
+
+  // Build request
+  const request: CodexResponsesRequest = {
+    model: modelId,
+    instructions,
+    input,
+    stream: true,
+    store: false,
+    tools: [],
+  };
+
+  // Add previous response ID for multi-turn conversations
+  if (previousResponseId) {
+    request.previous_response_id = previousResponseId;
+  }
+
+  // Add reasoning effort: thinkingBudget → model default → config default
+  const thinkingEffort = budgetToEffort(
+    req.generationConfig?.thinkingConfig?.thinkingBudget,
+  );
+  const effort =
+    thinkingEffort ??
+    modelInfo?.defaultReasoningEffort ??
+    config.model.default_reasoning_effort;
+  if (effort) {
+    request.reasoning = { effort };
+  }
+
+  return request;
+}

src/types/anthropic.ts

@@ -0,0 +1,113 @@
+/**
+ * Anthropic Messages API types for /v1/messages compatibility
+ */
+import { z } from "zod";
+
+// --- Request ---
+
+const AnthropicTextContentSchema = z.object({
+  type: z.literal("text"),
+  text: z.string(),
+});
+
+const AnthropicImageContentSchema = z.object({
+  type: z.literal("image"),
+  source: z.object({
+    type: z.literal("base64"),
+    media_type: z.string(),
+    data: z.string(),
+  }),
+});
+
+const AnthropicContentBlockSchema = z.discriminatedUnion("type", [
+  AnthropicTextContentSchema,
+  AnthropicImageContentSchema,
+]);
+
+const AnthropicContentSchema = z.union([
+  z.string(),
+  z.array(AnthropicContentBlockSchema),
+]);
+
+const AnthropicMessageSchema = z.object({
+  role: z.enum(["user", "assistant"]),
+  content: AnthropicContentSchema,
+});
+
+const AnthropicThinkingEnabledSchema = z.object({
+  type: z.literal("enabled"),
+  budget_tokens: z.number().int().positive(),
+});
+
+const AnthropicThinkingDisabledSchema = z.object({
+  type: z.literal("disabled"),
+});
+
+export const AnthropicMessagesRequestSchema = z.object({
+  model: z.string(),
+  max_tokens: z.number().int().positive(),
+  messages: z.array(AnthropicMessageSchema).min(1),
+  system: z
+    .union([z.string(), z.array(AnthropicTextContentSchema)])
+    .optional(),
+  stream: z.boolean().optional().default(false),
+  temperature: z.number().optional(),
+  top_p: z.number().optional(),
+  top_k: z.number().optional(),
+  stop_sequences: z.array(z.string()).optional(),
+  metadata: z
+    .object({
+      user_id: z.string().optional(),
+    })
+    .optional(),
+  thinking: z
+    .union([AnthropicThinkingEnabledSchema, AnthropicThinkingDisabledSchema])
+    .optional(),
+});
+
+export type AnthropicMessagesRequest = z.infer<
+  typeof AnthropicMessagesRequestSchema
+>;
+
+// --- Response ---
+
+export interface AnthropicContentBlock {
+  type: "text" | "thinking";
+  text?: string;
+  thinking?: string;
+}
+
+export interface AnthropicUsage {
+  input_tokens: number;
+  output_tokens: number;
+}
+
+export interface AnthropicMessagesResponse {
+  id: string;
+  type: "message";
+  role: "assistant";
+  content: AnthropicContentBlock[];
+  model: string;
+  stop_reason: "end_turn" | "max_tokens" | "stop_sequence" | null;
+  stop_sequence: string | null;
+  usage: AnthropicUsage;
+}
+
+// --- Error ---
+
+export type AnthropicErrorType =
+  | "invalid_request_error"
+  | "authentication_error"
+  | "permission_error"
+  | "not_found_error"
+  | "rate_limit_error"
+  | "api_error"
+  | "overloaded_error";
+
+export interface AnthropicErrorBody {
+  type: "error";
+  error: {
+    type: AnthropicErrorType;
+    message: string;
+  };
+}

src/types/gemini.ts

@@ -0,0 +1,73 @@
+/**
+ * Google Gemini API types for generateContent / streamGenerateContent compatibility
+ */
+import { z } from "zod";
+
+// --- Request ---
+
+const GeminiPartSchema = z.object({
+  text: z.string().optional(),
+  thought: z.boolean().optional(),
+});
+
+const GeminiContentSchema = z.object({
+  role: z.enum(["user", "model"]).optional(),
+  parts: z.array(GeminiPartSchema).min(1),
+});
+
+const GeminiThinkingConfigSchema = z.object({
+  thinkingBudget: z.number().optional(),
+});
+
+const GeminiGenerationConfigSchema = z.object({
+  temperature: z.number().optional(),
+  topP: z.number().optional(),
+  topK: z.number().optional(),
+  maxOutputTokens: z.number().optional(),
+  stopSequences: z.array(z.string()).optional(),
+  thinkingConfig: GeminiThinkingConfigSchema.optional(),
+});
+
+export const GeminiGenerateContentRequestSchema = z.object({
+  contents: z.array(GeminiContentSchema).min(1),
+  systemInstruction: GeminiContentSchema.optional(),
+  generationConfig: GeminiGenerationConfigSchema.optional(),
+});
+
+export type GeminiGenerateContentRequest = z.infer<
+  typeof GeminiGenerateContentRequestSchema
+>;
+export type GeminiContent = z.infer<typeof GeminiContentSchema>;
+
+// --- Response ---
+
+export interface GeminiCandidate {
+  content: {
+    parts: Array<{ text: string; thought?: boolean }>;
+    role: "model";
+  };
+  finishReason?: "STOP" | "MAX_TOKENS" | "SAFETY" | "OTHER";
+  index: number;
+}
+
+export interface GeminiUsageMetadata {
+  promptTokenCount: number;
+  candidatesTokenCount: number;
+  totalTokenCount: number;
+}
+
+export interface GeminiGenerateContentResponse {
+  candidates: GeminiCandidate[];
+  usageMetadata?: GeminiUsageMetadata;
+  modelVersion?: string;
+}
+
+// --- Error ---
+
+export interface GeminiErrorResponse {
+  error: {
+    code: number;
+    message: string;
+    status: string;
+  };
+}