fix: remove unsupported previous_response_id parameter (#30)

* fix: remove unsupported previous_response_id parameter (#29)

The Codex backend no longer accepts `previous_response_id`.
Sending it causes HTTP 400: "Unsupported parameter: previous_response_id".

Remove the injection logic in proxy-handler and clean up related
dead code across translation functions and session manager.

Closes #29

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

* refactor: remove dead SessionManager (was only used for previous_response_id)

SessionManager, session hashing, and onResponseId session storage
were only used to track previous_response_id across turns. Since the
backend no longer supports this parameter, the entire session system
is dead code. Remove it.

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

---------

Co-authored-by: icebear0828 <icebear0828@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

src/index.ts

@@ -3,7 +3,7 @@ import { serve } from "@hono/node-server";
 import { loadConfig, loadFingerprint, getConfig } from "./config.js";
 import { AccountPool } from "./auth/account-pool.js";
 import { RefreshScheduler } from "./auth/refresh-scheduler.js";
-import { SessionManager } from "./session/manager.js";
+
 import { requestId } from "./middleware/request-id.js";
 import { logger } from "./middleware/logger.js";
 import { errorHandler } from "./middleware/error-handler.js";
@@ -53,7 +53,6 @@ export async function startServer(options?: StartOptions): Promise<ServerHandle>
   // Initialize managers
   const accountPool = new AccountPool();
   const refreshScheduler = new RefreshScheduler(accountPool);
-  const sessionManager = new SessionManager();
   const cookieJar = new CookieJar();
 
   // Create Hono app
@@ -67,9 +66,9 @@ export async function startServer(options?: StartOptions): Promise<ServerHandle>
   // Mount routes
   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 chatRoutes = createChatRoutes(accountPool, cookieJar);
+  const messagesRoutes = createMessagesRoutes(accountPool, cookieJar);
+  const geminiRoutes = createGeminiRoutes(accountPool, cookieJar);
   const webRoutes = createWebRoutes(accountPool);
 
   app.route("/", authRoutes);
@@ -126,7 +125,6 @@ export async function startServer(options?: StartOptions): Promise<ServerHandle>
         stopUpdateChecker();
         stopModelRefresh();
         refreshScheduler.destroy();
-        sessionManager.destroy();
         cookieJar.destroy();
         accountPool.destroy();
         resolve();

src/proxy/codex-api.ts

@@ -32,8 +32,6 @@ export interface CodexResponsesRequest {
   tools?: unknown[];
   /** Optional: tool choice strategy */
   tool_choice?: string | { type: string; name: string };
-  /** Optional: previous response ID for multi-turn */
-  previous_response_id?: string | null;
 }
 
 /** Structured content part for multimodal Codex input. */

src/routes/chat.ts

@@ -1,7 +1,6 @@
 import { Hono } from "hono";
 import { ChatCompletionRequestSchema } from "../types/openai.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 { translateToCodexRequest } from "../translation/openai-to-codex.js";
 import {
@@ -52,7 +51,6 @@ function makeOpenAIFormat(wantReasoning: boolean): FormatAdapter {
 
 export function createChatRoutes(
   accountPool: AccountPool,
-  sessionManager: SessionManager,
   cookieJar?: CookieJar,
 ): Hono {
   const app = new Hono();
@@ -127,18 +125,9 @@ export function createChatRoutes(
     return handleProxyRequest(
       c,
       accountPool,
-      sessionManager,
       cookieJar,
       {
         codexRequest,
-        sessionMessages: req.messages.map((m) => ({
-          role: m.role,
-          content: typeof m.content === "string"
-            ? m.content
-            : m.content == null
-              ? ""
-              : m.content.filter((p) => p.type === "text" && p.text).map((p) => p.text!).join("\n"),
-        })),
         model: codexRequest.model,
         isStreaming: req.stream,
       },

src/routes/gemini.ts

@@ -10,11 +10,9 @@ 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 type { SessionManager } from "../session/manager.js";
 import type { CookieJar } from "../proxy/cookie-jar.js";
 import {
   translateGeminiToCodexRequest,
-  geminiContentsToMessages,
 } from "../translation/gemini-to-codex.js";
 import {
   streamCodexToGemini,
@@ -74,7 +72,6 @@ const GEMINI_FORMAT: FormatAdapter = {
 
 export function createGeminiRoutes(
   accountPool: AccountPool,
-  sessionManager: SessionManager,
   cookieJar?: CookieJar,
 ): Hono {
   const app = new Hono();
@@ -143,12 +140,6 @@ export function createGeminiRoutes(
     }
     const req = validationResult.data;
 
-    // Session lookup for multi-turn
-    const sessionMessages = geminiContentsToMessages(
-      req.contents,
-      req.systemInstruction,
-    );
-
     const codexRequest = translateGeminiToCodexRequest(
       req,
       geminiModel,
@@ -161,11 +152,9 @@ export function createGeminiRoutes(
     return handleProxyRequest(
       c,
       accountPool,
-      sessionManager,
       cookieJar,
       {
         codexRequest,
-        sessionMessages,
         model: geminiModel,
         isStreaming,
       },

src/routes/messages.ts

@@ -8,7 +8,6 @@ import type { StatusCode } from "hono/utils/http-status";
 import { AnthropicMessagesRequestSchema } from "../types/anthropic.js";
 import type { AnthropicErrorBody, AnthropicErrorType } from "../types/anthropic.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 { translateAnthropicToCodexRequest } from "../translation/anthropic-to-codex.js";
 import {
@@ -28,19 +27,6 @@ function makeError(
   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");
-}
-
 function makeAnthropicFormat(wantThinking: boolean): FormatAdapter {
   return {
     tag: "Messages",
@@ -61,7 +47,6 @@ function makeAnthropicFormat(wantThinking: boolean): FormatAdapter {
 
 export function createMessagesRoutes(
   accountPool: AccountPool,
-  sessionManager: SessionManager,
   cookieJar?: CookieJar,
 ): Hono {
   const app = new Hono();
@@ -108,33 +93,15 @@ export function createMessagesRoutes(
     }
     const req = parsed.data;
 
-    // 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 codexRequest = translateAnthropicToCodexRequest(req);
     const wantThinking = req.thinking?.type === "enabled" || req.thinking?.type === "adaptive";
 
     return handleProxyRequest(
       c,
       accountPool,
-      sessionManager,
       cookieJar,
       {
         codexRequest,
-        sessionMessages,
         model: req.model,
         isStreaming: req.stream,
       },

src/routes/shared/proxy-handler.ts

@@ -9,19 +9,16 @@
 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 { EmptyResponseError } from "../../translation/codex-event-extractor.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;
 }
@@ -59,7 +56,6 @@ export interface FormatAdapter {
 export async function handleProxyRequest(
   c: Context,
   accountPool: AccountPool,
-  sessionManager: SessionManager,
   cookieJar: CookieJar | undefined,
   req: ProxyRequest,
   fmt: FormatAdapter,
@@ -76,15 +72,6 @@ export async function handleProxyRequest(
   // Tracks which account the outer catch should release (updated by retry loop)
   let activeEntryId = 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),
@@ -111,7 +98,6 @@ export async function handleProxyRequest(
 
       return stream(c, async (s) => {
         s.onAbort(() => abortController.abort());
-        let sessionTaskId: string | null = null;
         try {
           for await (const chunk of fmt.streamTranslator(
             codexApi,
@@ -120,17 +106,7 @@ export async function handleProxyRequest(
             (u) => {
               usageInfo = u;
             },
-            (respId) => {
-              if (!sessionTaskId) {
-                sessionTaskId = `task-${randomUUID()}`;
-                sessionManager.storeSession(
-                  sessionTaskId,
-                  "turn-1",
-                  req.sessionMessages,
-                );
-              }
-              sessionManager.updateResponseId(sessionTaskId, respId);
-            },
+            () => {},
           )) {
             await s.write(chunk);
           }
@@ -161,15 +137,6 @@ export async function handleProxyRequest(
             currentRawResponse,
             req.model,
           );
-          if (result.responseId) {
-            const taskId = `task-${randomUUID()}`;
-            sessionManager.storeSession(
-              taskId,
-              "turn-1",
-              req.sessionMessages,
-            );
-            sessionManager.updateResponseId(taskId, result.responseId);
-          }
           accountPool.release(currentEntryId, result.usage);
           return c.json(result.response);
         } catch (collectErr) {

src/session/manager.ts

@@ -1,121 +0,0 @@
-import { createHash } from "crypto";
-import { getConfig } from "../config.js";
-
-const MAX_SESSIONS = 10000;
-
-interface Session {
-  taskId: string;
-  turnId: string;
-  messageHash: string;
-  responseId: string | null;
-  createdAt: number;
-}
-
-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;
-    this.cleanupTimer = setInterval(
-      () => this.cleanup(),
-      cleanup_interval_minutes * 60 * 1000,
-    );
-    if (this.cleanupTimer.unref) this.cleanupTimer.unref();
-  }
-
-  destroy(): void {
-    clearInterval(this.cleanupTimer);
-  }
-
-  /**
-   * Hash the message history to create a session key
-   */
-  hashMessages(
-    messages: Array<{ role: string; content: string }>,
-  ): string {
-    const data = JSON.stringify(messages.map((m) => [m.role, m.content]));
-    return createHash("sha256").update(data).digest("hex").slice(0, 32);
-  }
-
-  /**
-   * Find an existing session that matches the message history prefix
-   */
-  findSession(
-    messages: Array<{ role: string; content: string }>,
-  ): Session | null {
-    // Try matching all messages except the last (the new user message)
-    if (messages.length < 2) return null;
-    const prefix = messages.slice(0, -1);
-    const hash = this.hashMessages(prefix);
-
-    for (const session of this.sessions.values()) {
-      if (
-        session.messageHash === hash &&
-        Date.now() - session.createdAt < this.ttlMs
-      ) {
-        return session;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Store a session after task creation
-   */
-  storeSession(
-    taskId: string,
-    turnId: string,
-    messages: Array<{ role: string; content: string }>,
-  ): void {
-    const hash = this.hashMessages(messages);
-    // P2-10: O(1) LRU eviction using Map insertion order
-    if (this.sessions.size >= MAX_SESSIONS) {
-      const oldestKey = this.sessions.keys().next().value;
-      if (oldestKey) this.sessions.delete(oldestKey);
-    }
-    this.sessions.set(taskId, {
-      taskId,
-      turnId,
-      messageHash: hash,
-      responseId: null,
-      createdAt: Date.now(),
-    });
-  }
-
-  /**
-   * Update the response ID for an existing session (for multi-turn previous_response_id)
-   */
-  updateResponseId(taskId: string, responseId: string): void {
-    const session = this.sessions.get(taskId);
-    if (session) session.responseId = responseId;
-  }
-
-  /**
-   * Update turn ID for an existing session
-   */
-  updateTurn(taskId: string, turnId: string): void {
-    const session = this.sessions.get(taskId);
-    if (session) {
-      session.turnId = turnId;
-    }
-  }
-
-  /**
-   * Get session by explicit task ID
-   */
-  getSession(taskId: string): Session | null {
-    return this.sessions.get(taskId) ?? null;
-  }
-
-  private cleanup(): void {
-    const now = Date.now();
-    for (const [key, session] of this.sessions) {
-      if (now - session.createdAt > this.ttlMs) {
-        this.sessions.delete(key);
-      }
-    }
-  }
-}

src/translation/anthropic-to-codex.ts

@@ -151,7 +151,6 @@ function contentToInputItems(
  */
 export function translateAnthropicToCodexRequest(
   req: AnthropicMessagesRequest,
-  previousResponseId?: string | null,
 ): CodexResponsesRequest {
   // Extract system instructions
   let userInstructions: string;
@@ -205,11 +204,6 @@ export function translateAnthropicToCodexRequest(
     request.tool_choice = codexToolChoice;
   }
 
-  // Add previous response ID for multi-turn conversations
-  if (previousResponseId) {
-    request.previous_response_id = previousResponseId;
-  }
-
   // Always request reasoning summary (translation layer filters output on demand)
   const thinkingEffort = mapThinkingToEffort(req.thinking);
   const effort =

src/translation/gemini-to-codex.ts

@@ -161,7 +161,6 @@ export function geminiContentsToMessages(
 export function translateGeminiToCodexRequest(
   req: GeminiGenerateContentRequest,
   geminiModel: string,
-  previousResponseId?: string | null,
 ): CodexResponsesRequest {
   // Extract system instructions
   let userInstructions: string;
@@ -212,11 +211,6 @@ export function translateGeminiToCodexRequest(
     request.tool_choice = codexToolChoice;
   }
 
-  // Add previous response ID for multi-turn conversations
-  if (previousResponseId) {
-    request.previous_response_id = previousResponseId;
-  }
-
   // Always request reasoning summary (translation layer filters output on demand)
   const thinkingEffort = budgetToEffort(
     req.generationConfig?.thinkingConfig?.thinkingBudget,

src/translation/openai-to-codex.ts

@@ -80,7 +80,6 @@ function extractContent(
  */
 export function translateToCodexRequest(
   req: ChatCompletionRequest,
-  previousResponseId?: string | null,
 ): CodexResponsesRequest {
   // Collect system/developer messages as instructions
   const systemMessages = req.messages.filter(
@@ -174,11 +173,6 @@ export function translateToCodexRequest(
     request.tool_choice = codexToolChoice;
   }
 
-  // Add previous response ID for multi-turn conversations
-  if (previousResponseId) {
-    request.previous_response_id = previousResponseId;
-  }
-
   // Always request reasoning summary (translation layer filters output on demand)
   const effort =
     req.reasoning_effort ??