refactor: extract shared proxy handler, eliminate route duplication

- Extract withRetry() to src/utils/retry.ts (was duplicated 3x)
- Create shared proxy-handler.ts encapsulating acquire/stream/release lifecycle
- Refactor chat.ts, messages.ts, gemini.ts to use shared handler (-264 lines net)
- Convert models.ts from default export to named createModelRoutes()
- Extract GEMINI_STATUS_MAP to types/gemini.ts (was duplicated in error-handler)
- Add SessionManager.destroy() with interval cleanup + unref
- Remove dead captureCookies() method from codex-api.ts
- Add stack trace logging to error handler
- Fix hardcoded localhost in startup message
- Use atomic write-to-temp-then-rename for cookie-jar and account-pool
- Add warning logs for previously silent catch blocks

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

src/auth/account-pool.ts

@@ -402,7 +402,9 @@ export class AccountPool {
       const dir = dirname(ACCOUNTS_FILE);
       if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
       const data: AccountsFile = { accounts: [...this.accounts.values()] };
-      writeFileSync(ACCOUNTS_FILE, JSON.stringify(data, null, 2), "utf-8");
+      const tmpFile = ACCOUNTS_FILE + ".tmp";
+      writeFileSync(tmpFile, JSON.stringify(data, null, 2), "utf-8");
+      renameSync(tmpFile, ACCOUNTS_FILE);
     } catch (err) {
       console.error("[AccountPool] Failed to persist accounts:", err instanceof Error ? err.message : err);
     }
@@ -420,8 +422,8 @@ export class AccountPool {
           }
         }
       }
-    } catch {
-      // corrupt file, start fresh
+    } catch (err) {
+      console.warn("[AccountPool] Failed to load accounts:", err instanceof Error ? err.message : err);
     }
   }
 

src/index.ts

@@ -11,7 +11,7 @@ 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 { createModelRoutes } from "./routes/models.js";
 import { createWebRoutes } from "./routes/web.js";
 import { CookieJar } from "./proxy/cookie-jar.js";
 import { startUpdateChecker, stopUpdateChecker } from "./update-checker.js";
@@ -60,7 +60,7 @@ async function main() {
   app.route("/", chatRoutes);
   app.route("/", messagesRoutes);
   app.route("/", geminiRoutes);
-  app.route("/", modelsApp);
+  app.route("/", createModelRoutes());
   app.route("/", webRoutes);
 
   // Start server
@@ -86,7 +86,8 @@ async function main() {
     console.log(`  Key:  ${accountPool.getProxyApiKey()}`);
     console.log(`  Pool: ${poolSummary.active} active / ${poolSummary.total} total accounts`);
   } else {
-    console.log(`  Open http://localhost:${port} to login`);
+    const displayHost = host === "0.0.0.0" ? "localhost" : host;
+    console.log(`  Open http://${displayHost}:${port} to login`);
   }
   console.log();
 
@@ -103,6 +104,7 @@ async function main() {
   const shutdown = () => {
     console.log("\n[Shutdown] Cleaning up...");
     stopUpdateChecker();
+    sessionManager.destroy();
     cookieJar.destroy();
     refreshScheduler.destroy();
     accountPool.destroy();

src/middleware/error-handler.ts

@@ -2,6 +2,7 @@ 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";
+import { GEMINI_STATUS_MAP } from "../types/gemini.js";
 
 function makeOpenAIError(
   message: string,
@@ -37,23 +38,12 @@ function makeGeminiError(
   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();
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : "Internal server error";
-    console.error("[ErrorHandler]", message);
+    console.error("[ErrorHandler]", err instanceof Error ? (err.stack ?? message) : message);
 
     const status = (err as { status?: number }).status;
     const path = c.req.path;

src/proxy/codex-api.ts

@@ -88,13 +88,6 @@ export class CodexApi {
     }
   }
 
-  /** Capture Set-Cookie headers from a fetch Response into the jar. */
-  private captureCookies(response: Response): void {
-    if (this.cookieJar && this.entryId) {
-      this.cookieJar.capture(this.entryId, response);
-    }
-  }
-
   /**
    * Execute a POST request via curl subprocess.
    * Returns headers + streaming body as a CurlResponse.

src/proxy/cookie-jar.ts

@@ -11,6 +11,7 @@
 import {
   readFileSync,
   writeFileSync,
+  renameSync,
   existsSync,
   mkdirSync,
 } from "fs";
@@ -159,9 +160,11 @@ export class CookieJar {
       const dir = dirname(COOKIE_FILE);
       if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
       const data = Object.fromEntries(this.cookies);
-      writeFileSync(COOKIE_FILE, JSON.stringify(data, null, 2), "utf-8");
-    } catch {
-      // best-effort
+      const tmpFile = COOKIE_FILE + ".tmp";
+      writeFileSync(tmpFile, JSON.stringify(data, null, 2), "utf-8");
+      renameSync(tmpFile, COOKIE_FILE);
+    } catch (err) {
+      console.warn("[CookieJar] Failed to persist:", err instanceof Error ? err.message : err);
     }
   }
 
@@ -175,8 +178,8 @@ export class CookieJar {
           this.cookies.set(key, val);
         }
       }
-    } catch {
-      // corrupt file, start fresh
+    } catch (err) {
+      console.warn("[CookieJar] Failed to load cookies:", err instanceof Error ? err.message : err);
     }
   }
 

src/routes/chat.ts

@@ -1,42 +1,50 @@
 import { Hono } from "hono";
-import type { StatusCode } from "hono/utils/http-status";
-import { stream } from "hono/streaming";
 import { ChatCompletionRequestSchema } from "../types/openai.js";
 import type { AccountPool } from "../auth/account-pool.js";
-import { CodexApi, CodexApiError } from "../proxy/codex-api.js";
-import { SessionManager } from "../session/manager.js";
+import type { SessionManager } from "../session/manager.js";
+import type { CookieJar } from "../proxy/cookie-jar.js";
 import { translateToCodexRequest } from "../translation/openai-to-codex.js";
 import {
   streamCodexToOpenAI,
   collectCodexResponse,
-  type UsageInfo,
 } from "../translation/codex-to-openai.js";
 import { getConfig } from "../config.js";
-import type { CookieJar } from "../proxy/cookie-jar.js";
+import {
+  handleProxyRequest,
+  type FormatAdapter,
+} from "./shared/proxy-handler.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(
-        `[Chat] 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 OPENAI_FORMAT: FormatAdapter = {
+  tag: "Chat",
+  noAccountStatus: 503,
+  formatNoAccount: () => ({
+    error: {
+      message:
+        "No available accounts. All accounts are expired or rate-limited.",
+      type: "server_error",
+      param: null,
+      code: "no_available_accounts",
+    },
+  }),
+  format429: (msg) => ({
+    error: {
+      message: msg,
+      type: "rate_limit_error",
+      param: null,
+      code: "rate_limit_exceeded",
+    },
+  }),
+  formatError: (_status, msg) => ({
+    error: {
+      message: msg,
+      type: "server_error",
+      param: null,
+      code: "codex_api_error",
+    },
+  }),
+  streamTranslator: streamCodexToOpenAI,
+  collectTranslator: collectCodexResponse,
+};
 
 export function createChatRoutes(
   accountPool: AccountPool,
@@ -46,7 +54,7 @@ export function createChatRoutes(
   const app = new Hono();
 
   app.post("/v1/chat/completions", async (c) => {
-    // Validate auth — at least one active account
+    // Auth check
     if (!accountPool.isAuthenticated()) {
       c.status(401);
       return c.json({
@@ -96,106 +104,21 @@ export function createChatRoutes(
     }
     const req = parsed.data;
 
-    // Acquire an account from the pool
-    const acquired = accountPool.acquire();
-    if (!acquired) {
-      c.status(503);
-      return c.json({
-        error: {
-          message: "No available accounts. All accounts are expired or rate-limited.",
-          type: "server_error",
-          param: null,
-          code: "no_available_accounts",
-        },
-      });
-    }
-
-    const { entryId, token, accountId } = acquired;
-    const codexApi = new CodexApi(token, accountId, cookieJar, entryId);
+    const codexRequest = translateToCodexRequest(req);
 
-    // Find existing session for multi-turn previous_response_id
-    const existingSession = sessionManager.findSession(req.messages);
-    const previousResponseId = existingSession?.responseId ?? null;
-    const codexRequest = translateToCodexRequest(req, previousResponseId);
-    if (previousResponseId) {
-      console.log(`[Chat] Account ${entryId} | Multi-turn: previous_response_id=${previousResponseId}`);
-    }
-    console.log(
-      `[Chat] Account ${entryId} | Codex request:`,
-      JSON.stringify(codexRequest).slice(0, 300),
+    return handleProxyRequest(
+      c,
+      accountPool,
+      sessionManager,
+      cookieJar,
+      {
+        codexRequest,
+        sessionMessages: req.messages,
+        model: codexRequest.model,
+        isStreaming: req.stream,
+      },
+      OPENAI_FORMAT,
     );
-
-    let usageInfo: UsageInfo | 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 streamCodexToOpenAI(
-              codexApi,
-              rawResponse,
-              codexRequest.model,
-              (u) => { usageInfo = u; },
-              (respId) => {
-                if (!sessionTaskId) {
-                  // First call: create session
-                  sessionTaskId = `task-${Date.now()}`;
-                  sessionManager.storeSession(sessionTaskId, "turn-1", req.messages);
-                }
-                sessionManager.updateResponseId(sessionTaskId, respId);
-              },
-            )) {
-              await s.write(chunk);
-            }
-          } finally {
-            accountPool.release(entryId, usageInfo);
-          }
-        });
-      } else {
-        const result = await collectCodexResponse(
-          codexApi,
-          rawResponse,
-          codexRequest.model,
-        );
-        // Store session with responseId for multi-turn
-        if (result.responseId) {
-          const taskId = `task-${Date.now()}`;
-          sessionManager.storeSession(taskId, "turn-1", req.messages);
-          sessionManager.updateResponseId(taskId, result.responseId);
-        }
-        accountPool.release(entryId, result.usage);
-        return c.json(result.response);
-      }
-    } catch (err) {
-      if (err instanceof CodexApiError) {
-        console.error(`[Chat] Account ${entryId} | Codex API error:`, err.message);
-        if (err.status === 429) {
-          // Parse Retry-After if present
-          accountPool.markRateLimited(entryId);
-        } else {
-          accountPool.release(entryId);
-        }
-        const code = (err.status >= 400 && err.status < 600 ? err.status : 502) as StatusCode;
-        c.status(code);
-        return c.json({
-          error: {
-            message: err.message,
-            type: "server_error",
-            param: null,
-            code: "codex_api_error",
-          },
-        });
-      }
-      accountPool.release(entryId);
-      throw err;
-    }
   });
 
   return app;

src/routes/gemini.ts

@@ -6,12 +6,12 @@
 
 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 { GEMINI_STATUS_MAP } from "../types/gemini.js";
+import { GeminiGenerateContentRequestSchema } 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 type { SessionManager } from "../session/manager.js";
+import type { CookieJar } from "../proxy/cookie-jar.js";
 import {
   translateGeminiToCodexRequest,
   geminiContentsToMessages,
@@ -19,46 +19,13 @@ import {
 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",
-};
+import {
+  handleProxyRequest,
+  type FormatAdapter,
+} from "./shared/proxy-handler.js";
 
 function makeError(
   code: number,
@@ -90,6 +57,21 @@ function parseModelAction(param: string): {
   };
 }
 
+const GEMINI_FORMAT: FormatAdapter = {
+  tag: "Gemini",
+  noAccountStatus: 503,
+  formatNoAccount: () =>
+    makeError(
+      503,
+      "No available accounts. All accounts are expired or rate-limited.",
+      "UNAVAILABLE",
+    ),
+  format429: (msg) => makeError(429, msg, "RESOURCE_EXHAUSTED"),
+  formatError: (status, msg) => makeError(status, msg),
+  streamTranslator: streamCodexToGemini,
+  collectTranslator: collectCodexToGeminiResponse,
+};
+
 export function createGeminiRoutes(
   accountPool: AccountPool,
   sessionManager: SessionManager,
@@ -121,7 +103,7 @@ export function createGeminiRoutes(
       action === "streamGenerateContent" ||
       c.req.query("alt") === "sse";
 
-    // Validate auth — at least one active account
+    // Auth check
     if (!accountPool.isAuthenticated()) {
       c.status(401);
       return c.json(
@@ -155,125 +137,38 @@ export function createGeminiRoutes(
     }
     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),
+      `[Gemini] Model: ${geminiModel} → ${codexRequest.model}`,
     );
 
-    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;
-    }
+    return handleProxyRequest(
+      c,
+      accountPool,
+      sessionManager,
+      cookieJar,
+      {
+        codexRequest,
+        sessionMessages,
+        model: geminiModel,
+        isStreaming,
+      },
+      GEMINI_FORMAT,
+    );
   });
 
   // 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",

src/routes/messages.ts

@@ -5,44 +5,21 @@
 
 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 type { SessionManager } from "../session/manager.js";
+import type { CookieJar } from "../proxy/cookie-jar.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;
-}
+import {
+  handleProxyRequest,
+  type FormatAdapter,
+} from "./shared/proxy-handler.js";
 
 function makeError(
   type: AnthropicErrorType,
@@ -64,6 +41,20 @@ function contentToString(
     .join("\n");
 }
 
+const ANTHROPIC_FORMAT: FormatAdapter = {
+  tag: "Messages",
+  noAccountStatus: 529 as StatusCode,
+  formatNoAccount: () =>
+    makeError(
+      "overloaded_error",
+      "No available accounts. All accounts are expired or rate-limited.",
+    ),
+  format429: (msg) => makeError("rate_limit_error", msg),
+  formatError: (_status, msg) => makeError("api_error", msg),
+  streamTranslator: streamCodexToAnthropic,
+  collectTranslator: collectCodexToAnthropicResponse,
+};
+
 export function createMessagesRoutes(
   accountPool: AccountPool,
   sessionManager: SessionManager,
@@ -72,7 +63,7 @@ export function createMessagesRoutes(
   const app = new Hono();
 
   app.post("/v1/messages", async (c) => {
-    // Validate auth — at least one active account
+    // Auth check
     if (!accountPool.isAuthenticated()) {
       c.status(401);
       return c.json(
@@ -80,8 +71,7 @@ export function createMessagesRoutes(
       );
     }
 
-    // Optional proxy API key check
-    // Anthropic clients use x-api-key header; also accept Bearer token
+    // Optional proxy API key check (x-api-key or Bearer token)
     const config = getConfig();
     if (config.server.proxy_api_key) {
       const xApiKey = c.req.header("x-api-key");
@@ -106,21 +96,6 @@ export function createMessagesRoutes(
     }
     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) {
@@ -137,92 +112,21 @@ export function createMessagesRoutes(
       });
     }
 
-    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),
+    const codexRequest = translateAnthropicToCodexRequest(req);
+
+    return handleProxyRequest(
+      c,
+      accountPool,
+      sessionManager,
+      cookieJar,
+      {
+        codexRequest,
+        sessionMessages,
+        model: req.model,
+        isStreaming: req.stream,
+      },
+      ANTHROPIC_FORMAT,
     );
-
-    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/routes/models.ts

@@ -5,8 +5,6 @@ import yaml from "js-yaml";
 import { getConfig } from "../config.js";
 import type { OpenAIModel, OpenAIModelList } from "../types/openai.js";
 
-const app = new Hono();
-
 /**
  * Full model catalog from Codex CLI `model/list`.
  * Each model has reasoning effort levels, description, and capabilities.
@@ -78,60 +76,64 @@ function toOpenAIModel(info: CodexModelInfo): OpenAIModel {
   };
 }
 
-app.get("/v1/models", (c) => {
-  // Include catalog models + aliases as separate entries
-  const models: OpenAIModel[] = MODEL_CATALOG.map(toOpenAIModel);
-  for (const [alias] of Object.entries(MODEL_ALIASES)) {
-    models.push({
-      id: alias,
-      object: "model",
-      created: MODEL_CREATED_TIMESTAMP,
-      owned_by: "openai",
-    });
-  }
-  const response: OpenAIModelList = { object: "list", data: models };
-  return c.json(response);
-});
+export function createModelRoutes(): Hono {
+  const app = new Hono();
+
+  app.get("/v1/models", (c) => {
+    // Include catalog models + aliases as separate entries
+    const models: OpenAIModel[] = MODEL_CATALOG.map(toOpenAIModel);
+    for (const [alias] of Object.entries(MODEL_ALIASES)) {
+      models.push({
+        id: alias,
+        object: "model",
+        created: MODEL_CREATED_TIMESTAMP,
+        owned_by: "openai",
+      });
+    }
+    const response: OpenAIModelList = { object: "list", data: models };
+    return c.json(response);
+  });
 
-app.get("/v1/models/:modelId", (c) => {
-  const modelId = c.req.param("modelId");
+  app.get("/v1/models/:modelId", (c) => {
+    const modelId = c.req.param("modelId");
 
-  // Try direct match
-  const info = MODEL_CATALOG.find((m) => m.id === modelId);
-  if (info) return c.json(toOpenAIModel(info));
+    // Try direct match
+    const info = MODEL_CATALOG.find((m) => m.id === modelId);
+    if (info) return c.json(toOpenAIModel(info));
 
-  // Try alias
-  const resolved = MODEL_ALIASES[modelId];
-  if (resolved) {
+    // Try alias
+    const resolved = MODEL_ALIASES[modelId];
+    if (resolved) {
+      return c.json({
+        id: modelId,
+        object: "model",
+        created: MODEL_CREATED_TIMESTAMP,
+        owned_by: "openai",
+      });
+    }
+
+    c.status(404);
     return c.json({
-      id: modelId,
-      object: "model",
-      created: MODEL_CREATED_TIMESTAMP,
-      owned_by: "openai",
+      error: {
+        message: `Model '${modelId}' not found`,
+        type: "invalid_request_error",
+        param: "model",
+        code: "model_not_found",
+      },
     });
-  }
-
-  c.status(404);
-  return c.json({
-    error: {
-      message: `Model '${modelId}' not found`,
-      type: "invalid_request_error",
-      param: "model",
-      code: "model_not_found",
-    },
   });
-});
-
-// Extended endpoint: model details with reasoning efforts
-app.get("/v1/models/:modelId/info", (c) => {
-  const modelId = c.req.param("modelId");
-  const resolved = MODEL_ALIASES[modelId] ?? modelId;
-  const info = MODEL_CATALOG.find((m) => m.id === resolved);
-  if (!info) {
-    c.status(404);
-    return c.json({ error: `Model '${modelId}' not found` });
-  }
-  return c.json(info);
-});
 
-export default app;
+  // Extended endpoint: model details with reasoning efforts
+  app.get("/v1/models/:modelId/info", (c) => {
+    const modelId = c.req.param("modelId");
+    const resolved = MODEL_ALIASES[modelId] ?? modelId;
+    const info = MODEL_CATALOG.find((m) => m.id === resolved);
+    if (!info) {
+      c.status(404);
+      return c.json({ error: `Model '${modelId}' not found` });
+    }
+    return c.json(info);
+  });
+
+  return app;
+}

src/routes/shared/proxy-handler.ts

@@ -0,0 +1,173 @@
+/**
+ * Shared proxy handler — encapsulates the account acquire → retry → stream/collect → release
+ * lifecycle that is common to all API format routes (OpenAI, Anthropic, Gemini).
+ *
+ * Each route provides its own schema parsing, auth checking, and format adapter.
+ * This handler takes over once a CodexResponsesRequest is prepared.
+ */
+
+import type { Context } from "hono";
+import type { StatusCode } from "hono/utils/http-status";
+import { stream } from "hono/streaming";
+import { randomUUID } from "crypto";
+import { CodexApi, CodexApiError } from "../../proxy/codex-api.js";
+import type { CodexResponsesRequest } from "../../proxy/codex-api.js";
+import type { AccountPool } from "../../auth/account-pool.js";
+import type { SessionManager } from "../../session/manager.js";
+import type { CookieJar } from "../../proxy/cookie-jar.js";
+import { withRetry } from "../../utils/retry.js";
+
+/** Data prepared by each route after parsing and translating the request. */
+export interface ProxyRequest {
+  codexRequest: CodexResponsesRequest;
+  sessionMessages: Array<{ role: string; content: string }>;
+  model: string;
+  isStreaming: boolean;
+}
+
+/** Format-specific adapter provided by each route. */
+export interface FormatAdapter {
+  tag: string;
+  noAccountStatus: StatusCode;
+  formatNoAccount: () => unknown;
+  format429: (message: string) => unknown;
+  formatError: (status: number, message: string) => unknown;
+  streamTranslator: (
+    api: CodexApi,
+    response: Response,
+    model: string,
+    onUsage: (u: { input_tokens: number; output_tokens: number }) => void,
+    onResponseId: (id: string) => void,
+  ) => AsyncGenerator<string>;
+  collectTranslator: (
+    api: CodexApi,
+    response: Response,
+    model: string,
+  ) => Promise<{
+    response: unknown;
+    usage: { input_tokens: number; output_tokens: number };
+    responseId: string | null;
+  }>;
+}
+
+/**
+ * Core shared handler — from account acquire to release.
+ *
+ * Handles: acquire, session lookup, retry, stream/collect, release, error formatting.
+ */
+export async function handleProxyRequest(
+  c: Context,
+  accountPool: AccountPool,
+  sessionManager: SessionManager,
+  cookieJar: CookieJar | undefined,
+  req: ProxyRequest,
+  fmt: FormatAdapter,
+): Promise<Response> {
+  // 1. Acquire account
+  const acquired = accountPool.acquire();
+  if (!acquired) {
+    c.status(fmt.noAccountStatus);
+    return c.json(fmt.formatNoAccount());
+  }
+
+  const { entryId, token, accountId } = acquired;
+  const codexApi = new CodexApi(token, accountId, cookieJar, entryId);
+
+  // 2. Session lookup for multi-turn
+  const existingSession = sessionManager.findSession(req.sessionMessages);
+  const previousResponseId = existingSession?.responseId ?? null;
+  if (previousResponseId) {
+    req.codexRequest.previous_response_id = previousResponseId;
+    console.log(
+      `[${fmt.tag}] Account ${entryId} | Multi-turn: previous_response_id=${previousResponseId}`,
+    );
+  }
+  console.log(
+    `[${fmt.tag}] Account ${entryId} | Codex request:`,
+    JSON.stringify(req.codexRequest).slice(0, 300),
+  );
+
+  let usageInfo: { input_tokens: number; output_tokens: number } | undefined;
+
+  try {
+    // 3. Retry + send to Codex
+    const rawResponse = await withRetry(
+      () => codexApi.createResponse(req.codexRequest),
+      { tag: fmt.tag },
+    );
+
+    // 4. Stream or collect
+    if (req.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 fmt.streamTranslator(
+            codexApi,
+            rawResponse,
+            req.model,
+            (u) => {
+              usageInfo = u;
+            },
+            (respId) => {
+              if (!sessionTaskId) {
+                sessionTaskId = `task-${randomUUID()}`;
+                sessionManager.storeSession(
+                  sessionTaskId,
+                  "turn-1",
+                  req.sessionMessages,
+                );
+              }
+              sessionManager.updateResponseId(sessionTaskId, respId);
+            },
+          )) {
+            await s.write(chunk);
+          }
+        } finally {
+          accountPool.release(entryId, usageInfo);
+        }
+      });
+    } else {
+      const result = await fmt.collectTranslator(
+        codexApi,
+        rawResponse,
+        req.model,
+      );
+      if (result.responseId) {
+        const taskId = `task-${randomUUID()}`;
+        sessionManager.storeSession(
+          taskId,
+          "turn-1",
+          req.sessionMessages,
+        );
+        sessionManager.updateResponseId(taskId, result.responseId);
+      }
+      accountPool.release(entryId, result.usage);
+      return c.json(result.response);
+    }
+  } catch (err) {
+    // 5. Error handling with format-specific responses
+    if (err instanceof CodexApiError) {
+      console.error(
+        `[${fmt.tag}] Account ${entryId} | Codex API error:`,
+        err.message,
+      );
+      if (err.status === 429) {
+        accountPool.markRateLimited(entryId);
+        c.status(429);
+        return c.json(fmt.format429(err.message));
+      }
+      accountPool.release(entryId);
+      const code = (
+        err.status >= 400 && err.status < 600 ? err.status : 502
+      ) as StatusCode;
+      c.status(code);
+      return c.json(fmt.formatError(code, err.message));
+    }
+    accountPool.release(entryId);
+    throw err;
+  }
+}

src/session/manager.ts

@@ -12,11 +12,20 @@ interface Session {
 export class SessionManager {
   private sessions = new Map<string, Session>();
   private ttlMs: number;
+  private cleanupTimer: ReturnType<typeof setInterval>;
 
   constructor() {
     const { ttl_minutes, cleanup_interval_minutes } = getConfig().session;
     this.ttlMs = ttl_minutes * 60 * 1000;
-    setInterval(() => this.cleanup(), cleanup_interval_minutes * 60 * 1000);
+    this.cleanupTimer = setInterval(
+      () => this.cleanup(),
+      cleanup_interval_minutes * 60 * 1000,
+    );
+    if (this.cleanupTimer.unref) this.cleanupTimer.unref();
+  }
+
+  destroy(): void {
+    clearInterval(this.cleanupTimer);
   }
 
   /**

src/types/gemini.ts

@@ -62,6 +62,19 @@ export interface GeminiGenerateContentResponse {
   modelVersion?: string;
 }
 
+// --- Status map (shared by error-handler and gemini route) ---
+
+export 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",
+};
+
 // --- Error ---
 
 export interface GeminiErrorResponse {

src/utils/retry.ts

@@ -0,0 +1,29 @@
+import { CodexApiError } from "../proxy/codex-api.js";
+
+/** Retry a function on 5xx errors with exponential backoff. */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  {
+    maxRetries = 2,
+    baseDelayMs = 1000,
+    tag = "Proxy",
+  }: { maxRetries?: number; baseDelayMs?: number; tag?: string } = {},
+): 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(
+        `[${tag}] Retrying after ${err instanceof CodexApiError ? err.status : "error"} (attempt ${attempt + 1}/${maxRetries}, delay ${delay}ms)`,
+      );
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+}