Strip previous_response_id for stateless Responses upstreams

open-sse/handlers/chatCore.ts

@@ -24,6 +24,7 @@ import {
   runWithOnPersist,
 } from "../services/tokenRefresh.ts";
 import { createRequestLogger } from "../utils/requestLogger.ts";
+import { applyResponsesPreviousResponseIdPolicy } from "../utils/responsesStatePolicy.ts";
 import { getModelTargetFormat, PROVIDER_ID_TO_ALIAS } from "../config/providerModels.ts";
 import { DEFAULT_THINKING_CLAUDE_SIGNATURE } from "../config/defaultThinkingSignature.ts";
 import {
@@ -3512,6 +3513,14 @@ export async function handleChatCore({
   }
   translatedBody.model = finalModelToUpstream;
 
+  const previousResponseIdPolicy = applyResponsesPreviousResponseIdPolicy(translatedBody, {
+    mode: settings.responsesPreviousResponseIdMode,
+    sourceFormat,
+    targetFormat,
+    credentials,
+  });
+  translatedBody = previousResponseIdPolicy.body as typeof translatedBody;
+
   // #1789: Prevent output_config.effort from overriding effort encoded in model name (Codex)
   if (provider === "codex" || provider?.startsWith("codex")) {
     const hasEffortSuffix = finalModelToUpstream.match(/-(low|medium|high|xhigh)$/i);

open-sse/utils/responsesStatePolicy.ts

@@ -0,0 +1,75 @@
+import { isOpenAIResponsesStoreEnabled } from "@/lib/providers/requestDefaults";
+import {
+  DEFAULT_RESPONSES_PREVIOUS_RESPONSE_ID_MODE,
+  RESPONSES_PREVIOUS_RESPONSE_ID_MODES,
+  type ResponsesPreviousResponseIdMode,
+} from "@/shared/constants/responsesPreviousResponseId";
+import { FORMATS } from "../translator/formats.ts";
+
+type JsonRecord = Record<string, unknown>;
+
+type ApplyResponsesPreviousResponseIdPolicyOptions = {
+  mode: unknown;
+  sourceFormat?: unknown;
+  targetFormat?: unknown;
+  credentials?: unknown;
+};
+
+const MODE_SET = new Set<string>(RESPONSES_PREVIOUS_RESPONSE_ID_MODES);
+
+function toRecord(value: unknown): JsonRecord {
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as JsonRecord) : {};
+}
+
+export function normalizeResponsesPreviousResponseIdMode(
+  value: unknown
+): ResponsesPreviousResponseIdMode {
+  if (typeof value === "string" && MODE_SET.has(value)) {
+    return value as ResponsesPreviousResponseIdMode;
+  }
+  return DEFAULT_RESPONSES_PREVIOUS_RESPONSE_ID_MODE;
+}
+
+export function shouldStripPreviousResponseId({
+  mode,
+  sourceFormat,
+  targetFormat,
+  credentials,
+}: ApplyResponsesPreviousResponseIdPolicyOptions): boolean {
+  const normalizedMode = normalizeResponsesPreviousResponseIdMode(mode);
+  if (normalizedMode === "preserve") return false;
+  if (normalizedMode === "strip") return true;
+
+  const isResponsesSource = sourceFormat === FORMATS.OPENAI_RESPONSES;
+  const isResponsesTarget = targetFormat === FORMATS.OPENAI_RESPONSES;
+  if (!isResponsesSource && !isResponsesTarget) return false;
+
+  // `previous_response_id` is only safe when the upstream actually keeps
+  // Responses state. OmniRoute defaults to stateless upstream calls, so auto
+  // strips unless the connection explicitly opts into OpenAI Responses storage.
+  const providerSpecificData = toRecord(toRecord(credentials).providerSpecificData);
+  return !isOpenAIResponsesStoreEnabled(providerSpecificData);
+}
+
+export function applyResponsesPreviousResponseIdPolicy(
+  body: unknown,
+  options: ApplyResponsesPreviousResponseIdPolicyOptions
+): { body: unknown; stripped: boolean; mode: ResponsesPreviousResponseIdMode } {
+  const mode = normalizeResponsesPreviousResponseIdMode(options.mode);
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return { body, stripped: false, mode };
+  }
+
+  const record = body as JsonRecord;
+  if (!Object.hasOwn(record, "previous_response_id")) {
+    return { body, stripped: false, mode };
+  }
+
+  if (!shouldStripPreviousResponseId({ ...options, mode })) {
+    return { body, stripped: false, mode };
+  }
+
+  const next = { ...record };
+  delete next.previous_response_id;
+  return { body: next, stripped: true, mode };
+}

src/app/(dashboard)/dashboard/settings/ai/page.tsx

@@ -4,6 +4,7 @@ import { useTranslations } from "next-intl";
 import ThinkingBudgetTab from "../components/ThinkingBudgetTab";
 import VisionBridgeSettingsTab from "../components/VisionBridgeSettingsTab";
 import SystemPromptTab from "../components/SystemPromptTab";
+import ResponsesStatePolicyTab from "../components/ResponsesStatePolicyTab";
 import CodexFastTierTab from "../components/CodexFastTierTab";
 import ClaudeFastModeTab from "../components/ClaudeFastModeTab";
 import MemorySkillsTab from "../components/MemorySkillsTab";
@@ -17,6 +18,7 @@ export default function SettingsAiPage() {
       <ThinkingBudgetTab />
       <VisionBridgeSettingsTab />
       <SystemPromptTab />
+      <ResponsesStatePolicyTab />
       <CodexFastTierTab />
       <ClaudeFastModeTab />
       <MemorySkillsTab />

src/app/(dashboard)/dashboard/settings/components/ResponsesStatePolicyTab.tsx

@@ -0,0 +1,120 @@
+"use client";
+
+import { useEffect, useState, useRef } from "react";
+import { useTranslations } from "next-intl";
+import { Card, Select } from "@/shared/components";
+import {
+  DEFAULT_RESPONSES_PREVIOUS_RESPONSE_ID_MODE,
+  RESPONSES_PREVIOUS_RESPONSE_ID_MODES,
+  type ResponsesPreviousResponseIdMode,
+} from "@/shared/constants/responsesPreviousResponseId";
+
+const MODE_SET = new Set<string>(RESPONSES_PREVIOUS_RESPONSE_ID_MODES);
+
+function normalizeMode(value: unknown): ResponsesPreviousResponseIdMode {
+  return typeof value === "string" && MODE_SET.has(value)
+    ? (value as ResponsesPreviousResponseIdMode)
+    : DEFAULT_RESPONSES_PREVIOUS_RESPONSE_ID_MODE;
+}
+
+export default function ResponsesStatePolicyTab() {
+  const [mode, setMode] = useState<ResponsesPreviousResponseIdMode>(
+    DEFAULT_RESPONSES_PREVIOUS_RESPONSE_ID_MODE
+  );
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [status, setStatus] = useState<"" | "saved" | "error">("");
+  const t = useTranslations("settings");
+
+  useEffect(() => {
+    let cancelled = false;
+    fetch("/api/settings")
+      .then((res) => res.json())
+      .then((data) => {
+        if (cancelled) return;
+        setMode(normalizeMode(data?.responsesPreviousResponseIdMode));
+        setLoading(false);
+      })
+      .catch(() => {
+        if (!cancelled) setLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  const save = async (nextMode: ResponsesPreviousResponseIdMode) => {
+    if (saving || loading || nextMode === mode) return;
+    const previousMode = mode;
+    setMode(nextMode);
+    setSaving(true);
+    setStatus("");
+
+    try {
+      const res = await fetch("/api/settings", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ responsesPreviousResponseIdMode: nextMode }),
+      });
+      if (!res.ok) {
+        setMode(previousMode);
+        setStatus("error");
+        return;
+      }
+      setStatus("saved");
+      setTimeout(() => setStatus(""), 2000);
+    } catch {
+      setMode(previousMode);
+      setStatus("error");
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  return (
+    <Card>
+      <div className="flex items-center gap-3 mb-3">
+        <div className="p-2 rounded-lg bg-emerald-500/10 text-emerald-500">
+          <span className="material-symbols-outlined text-[20px]" aria-hidden="true">
+            account_tree
+          </span>
+        </div>
+        <div className="flex-1">
+          <h3 className="text-lg font-semibold">{t("responsesStateTitle")}</h3>
+          <p className="text-sm text-text-muted">{t("responsesStateDesc")}</p>
+        </div>
+        <div className="min-w-[7rem] flex justify-end">
+          {status === "saved" && (
+            <span className="text-xs font-medium text-emerald-500 flex items-center gap-1">
+              <span className="material-symbols-outlined text-[14px]">check_circle</span>{" "}
+              {t("saved")}
+            </span>
+          )}
+          {status === "error" && (
+            <span className="text-xs font-medium text-rose-500 flex items-center gap-1">
+              <span className="material-symbols-outlined text-[14px]">error</span>{" "}
+              {t("responsesStateSaveError")}
+            </span>
+          )}
+        </div>
+      </div>
+
+      <Select
+        label={t("responsesStateModeLabel")}
+        value={mode}
+        disabled={loading || saving}
+        onChange={(e) => save(normalizeMode(e.target.value))}
+        options={[
+          { value: "auto", label: t("responsesStateModeAuto") },
+          { value: "strip", label: t("responsesStateModeStrip") },
+          { value: "preserve", label: t("responsesStateModePreserve") },
+        ]}
+      />
+
+      <p className="mt-4 text-xs text-text-muted/80 flex items-start gap-1.5 leading-relaxed">
+        <span className="material-symbols-outlined text-[14px] mt-0.5">info</span>
+        <span>{t("responsesStateHint")}</span>
+      </p>
+    </Card>
+  );
+}

src/i18n/messages/de.json

@@ -5350,6 +5350,14 @@
     "maxResponseTokensDesc": "__MISSING__:Maximum total tokens allowed in a single response.",
     "modelCooldownsTitle": "Modelle in der Abklingzeit",
     "modelCooldownsEmpty": "Im Moment befinden sich keine Modelle in der Abklingzeit.",
+    "responsesStateTitle": "Responses-State",
+    "responsesStateDesc": "Steuert, wie OmniRoute previous_response_id weiterleitet.",
+    "responsesStateModeLabel": "previous_response_id behandeln",
+    "responsesStateModeAuto": "Auto",
+    "responsesStateModeStrip": "Entfernen",
+    "responsesStateModePreserve": "Beibehalten",
+    "responsesStateHint": "Auto entfernt previous_response_id, außer eine Verbindung aktiviert explizit OpenAI Responses Storage. Entfernen ist am sichersten für zustandslose Clients wie VS Code Custom Endpoint; der Kontext hängt dann davon ab, dass der Client die vollständige Historie sendet.",
+    "responsesStateSaveError": "Responses-State-Einstellung konnte nicht aktualisiert werden",
     "codexFastTierTitle": "Codex Fast Tier",
     "codexFastTierDesc": "service_tier=priority global für OpenAI Codex-Anfragen einfügen.",
     "codexFastTierHint": "Wenn aktiviert, fügt OmniRoute ausgehenden Codex-Anfragen service_tier=priority hinzu, sofern für die Verbindung noch kein Tier festgelegt ist. Der Priority-Tier erfordert einen OpenAI Enterprise API-Schlüssel oder den ChatGPT-Auth-Codex-Pfad; andere Schlüsseltypen erhalten von OpenAI einen tier-bezogenen Fehler. Pro-Verbindung-Einstellungen auf der Codex-Provider-Seite haben Vorrang.",

src/i18n/messages/en.json

@@ -5582,6 +5582,14 @@
     "maxResponseTokensDesc": "Maximum total tokens allowed in a single response.",
     "modelCooldownsTitle": "Models in cooldown",
     "modelCooldownsEmpty": "No models in cooldown right now.",
+    "responsesStateTitle": "Responses State",
+    "responsesStateDesc": "Control how OmniRoute forwards previous_response_id.",
+    "responsesStateModeLabel": "previous_response_id handling",
+    "responsesStateModeAuto": "Auto",
+    "responsesStateModeStrip": "Strip",
+    "responsesStateModePreserve": "Preserve",
+    "responsesStateHint": "Auto strips previous_response_id unless a connection explicitly enables OpenAI Responses storage. Strip is safest for stateless clients such as VS Code Custom Endpoint; context then depends on the client sending full history.",
+    "responsesStateSaveError": "Failed to update Responses state setting",
     "codexFastTierTitle": "Codex Fast Tier",
     "codexFastTierDesc": "Globally inject service_tier=priority for OpenAI Codex requests.",
     "codexFastTierHint": "When enabled, OmniRoute adds service_tier=priority to outbound Codex requests for connections that don't already specify a tier. Priority tier requires an OpenAI Enterprise API key or the ChatGPT-auth Codex path; other key types will receive a tier-related error from OpenAI. Per-connection settings on the Codex provider page take precedence.",

src/lib/db/settings.ts

@@ -9,6 +9,7 @@ import { invalidateDbCache } from "./readCache";
 import { getProxyRegistryGeneration, resolveProxyForScopeFromRegistry } from "./proxies";
 import { getComboModelProvider as getComboEntryProvider } from "@/lib/combos/steps";
 import { requestBodyLimitMbFromEnv } from "@/shared/constants/bodySize";
+import { DEFAULT_RESPONSES_PREVIOUS_RESPONSE_ID_MODE } from "@/shared/constants/responsesPreviousResponseId";
 
 type JsonRecord = Record<string, unknown>;
 type PricingModels = Record<string, JsonRecord>;
@@ -108,6 +109,7 @@ export async function getSettings() {
       supportedModels: ["claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6"],
     },
     codexSessionAffinityTtlMs: 0,
+    responsesPreviousResponseIdMode: DEFAULT_RESPONSES_PREVIOUS_RESPONSE_ID_MODE,
     alwaysPreserveClientCache: "auto",
     idempotencyWindowMs: 5000,
     wsAuth: false,

src/shared/constants/responsesPreviousResponseId.ts

@@ -0,0 +1,5 @@
+export const RESPONSES_PREVIOUS_RESPONSE_ID_MODES = ["auto", "strip", "preserve"] as const;
+
+export type ResponsesPreviousResponseIdMode = (typeof RESPONSES_PREVIOUS_RESPONSE_ID_MODES)[number];
+
+export const DEFAULT_RESPONSES_PREVIOUS_RESPONSE_ID_MODE: ResponsesPreviousResponseIdMode = "auto";

src/shared/validation/settingsSchemas.ts

@@ -10,6 +10,7 @@ import { COMBO_CONFIG_MODES } from "@/shared/constants/comboConfigMode";
 import { MAX_REQUEST_BODY_LIMIT_MB, MIN_REQUEST_BODY_LIMIT_MB } from "@/shared/constants/bodySize";
 import { HIDEABLE_SIDEBAR_ITEM_IDS, SIDEBAR_SECTIONS } from "@/shared/constants/sidebarVisibility";
 import { ACCOUNT_FALLBACK_STRATEGY_VALUES } from "@/shared/constants/routingStrategies";
+import { RESPONSES_PREVIOUS_RESPONSE_ID_MODES } from "@/shared/constants/responsesPreviousResponseId";
 
 const signatureCacheModeValues = ["enabled", "bypass", "bypass-strict"] as const;
 
@@ -69,6 +70,7 @@ export const updateSettingsSchema = z.object({
     })
     .optional(),
   codexSessionAffinityTtlMs: z.number().int().min(0).max(86_400_000).optional(),
+  responsesPreviousResponseIdMode: z.enum(RESPONSES_PREVIOUS_RESPONSE_ID_MODES).optional(),
   // Routing settings (#134)
   fallbackStrategy: z.enum(ACCOUNT_FALLBACK_STRATEGY_VALUES).optional(),
   wildcardAliases: z.array(z.object({ pattern: z.string(), target: z.string() })).optional(),

tests/integration/chat-pipeline.test.ts

@@ -728,6 +728,85 @@ test("chat pipeline applies Codex CLI fingerprint to OAuth responses requests",
   );
 });
 
+test("chat pipeline strips previous_response_id from stateless Codex responses by default", async () => {
+  await seedConnection("codex", {
+    apiKey: "sk-codex-stateless-responses",
+    providerSpecificData: { openaiStoreEnabled: false },
+  });
+  const fetchCalls = [];
+
+  globalThis.fetch = async (url, init: RequestInit = {}) => {
+    fetchCalls.push({
+      url: String(url),
+      headers: toPlainHeaders(init.headers),
+      body: init.body ? JSON.parse(String(init.body)) : null,
+    });
+    return buildOpenAIResponsesSSE({ text: "stateless responses ok", model: "gpt-5.5" });
+  };
+
+  const response = await handleChat(
+    buildRequest({
+      url: "http://localhost/v1/responses",
+      body: {
+        model: "codex/gpt-5.5",
+        stream: false,
+        previous_response_id: "resp_vs_code_prev",
+        input: [
+          {
+            type: "message",
+            role: "user",
+            content: [{ type: "input_text", text: "Second VS Code turn" }],
+          },
+        ],
+      },
+    })
+  );
+
+  await response.json();
+
+  assert.equal(response.status, 200);
+  assert.equal(fetchCalls.length, 1);
+  assert.match(fetchCalls[0].url, /\/responses$/);
+  assert.equal(fetchCalls[0].body.previous_response_id, undefined);
+  assert.equal(fetchCalls[0].body.store, false);
+});
+
+test("chat pipeline preserve mode forwards previous_response_id for responses requests", async () => {
+  await settingsDb.updateSettings({ responsesPreviousResponseIdMode: "preserve" });
+  await seedConnection("codex", {
+    apiKey: "sk-codex-preserve-responses",
+    providerSpecificData: { openaiStoreEnabled: false },
+  });
+  const fetchCalls = [];
+
+  globalThis.fetch = async (url, init: RequestInit = {}) => {
+    fetchCalls.push({
+      url: String(url),
+      headers: toPlainHeaders(init.headers),
+      body: init.body ? JSON.parse(String(init.body)) : null,
+    });
+    return buildOpenAIResponsesSSE({ text: "preserve responses ok", model: "gpt-5.5" });
+  };
+
+  const response = await handleChat(
+    buildRequest({
+      url: "http://localhost/v1/responses",
+      body: {
+        model: "codex/gpt-5.5",
+        stream: false,
+        previous_response_id: "resp_preserved_prev",
+        input: "Second stateful turn",
+      },
+    })
+  );
+
+  await response.json();
+
+  assert.equal(response.status, 200);
+  assert.equal(fetchCalls.length, 1);
+  assert.equal(fetchCalls[0].body.previous_response_id, "resp_preserved_prev");
+});
+
 test("chat pipeline treats Codex /responses/compact as non-streaming JSON", async () => {
   await seedConnection("codex", { apiKey: "sk-codex-compact" });
   const fetchCalls = [];

tests/unit/chatcore-translation-paths.test.ts

@@ -427,7 +427,7 @@ test("chatCore times out upstream execution before provider response headers", a
     const pendingDetail = (await waitFor(
       () =>
         Object.values(getPendingRequests().details[connectionId] || {}).find(
-          (detail: any) => detail?.providerRequest
+          (detail: any) => detail?.providerRequest?.model === "gpt-4o-mini"
         )
     )) as any;
     assert.equal(pendingDetail?.providerRequest?.model, "gpt-4o-mini");