diff --git a/src/app/[locale]/settings/config/page.tsx b/src/app/[locale]/settings/config/page.tsx
index 46b992bd0..72cc51a6d 100644
--- a/src/app/[locale]/settings/config/page.tsx
+++ b/src/app/[locale]/settings/config/page.tsx
@@ -61,6 +61,7 @@ async function SettingsConfigContent({ locale }: { locale: string }) {
interceptAnthropicWarmupRequests: settings.interceptAnthropicWarmupRequests,
enableThinkingSignatureRectifier: settings.enableThinkingSignatureRectifier,
enableThinkingBudgetRectifier: settings.enableThinkingBudgetRectifier,
+ enableThinkingEffortConflictRectifier: settings.enableThinkingEffortConflictRectifier,
enableBillingHeaderRectifier: settings.enableBillingHeaderRectifier,
enableResponseInputRectifier: settings.enableResponseInputRectifier,
allowNonConversationEndpointProviderFallback:
diff --git a/src/app/v1/_lib/proxy/forwarder.ts b/src/app/v1/_lib/proxy/forwarder.ts
index a568f0717..523f63a0f 100644
--- a/src/app/v1/_lib/proxy/forwarder.ts
+++ b/src/app/v1/_lib/proxy/forwarder.ts
@@ -96,6 +96,10 @@ import {
detectThinkingBudgetRectifierTrigger,
rectifyThinkingBudget,
} from "./thinking-budget-rectifier";
+import {
+ detectThinkingEffortConflictRectifierTrigger,
+ rectifyThinkingEffortConflict,
+} from "./thinking-effort-conflict-rectifier";
import {
detectThinkingSignatureRectifierTrigger,
rectifyAnthropicRequestMessage,
@@ -225,21 +229,27 @@ type StreamingHedgeAttempt = {
type ReactiveRectifierRetryState = {
thinkingSignatureRetried: boolean;
thinkingBudgetRetried: boolean;
+ thinkingEffortConflictRetried: boolean;
};
+type ReactiveRectifierType =
+ | "thinking_signature_rectifier"
+ | "thinking_budget_rectifier"
+ | "thinking_effort_conflict_rectifier";
+
type ReactiveRectifierResult =
| { matched: false }
| {
matched: true;
applied: false;
reason: "already_retried" | "not_applicable";
- rectifierType: "thinking_signature_rectifier" | "thinking_budget_rectifier";
+ rectifierType: ReactiveRectifierType;
trigger: string;
}
| {
matched: true;
applied: true;
- rectifierType: "thinking_signature_rectifier" | "thinking_budget_rectifier";
+ rectifierType: ReactiveRectifierType;
trigger: string;
requestDetailsBeforeRectify: ReturnType;
};
@@ -762,12 +772,15 @@ function buildRetryFailedChainEntry(
};
}
-function getReactiveRectifierDisplayName(
- rectifierType: "thinking_signature_rectifier" | "thinking_budget_rectifier"
-): string {
- return rectifierType === "thinking_signature_rectifier"
- ? "Thinking signature rectifier"
- : "Thinking budget rectifier";
+function getReactiveRectifierDisplayName(rectifierType: ReactiveRectifierType): string {
+ switch (rectifierType) {
+ case "thinking_signature_rectifier":
+ return "Thinking signature rectifier";
+ case "thinking_budget_rectifier":
+ return "Thinking budget rectifier";
+ case "thinking_effort_conflict_rectifier":
+ return "Thinking effort conflict rectifier";
+ }
}
async function tryApplyReactiveAnthropicRectifier(params: {
@@ -794,6 +807,68 @@ async function tryApplyReactiveAnthropicRectifier(params: {
return { matched: false };
}
+ // 先于签名整流器检测：effort 冲突的错误文案更具体（reasoning_effort/output_config），
+ // 避免被签名整流器的通用 invalid request 兜底吞掉。
+ const effortConflictTrigger = detectThinkingEffortConflictRectifierTrigger(errorMessage);
+ if (effortConflictTrigger) {
+ const settings = await getCachedSystemSettings();
+ const enabled = settings.enableThinkingEffortConflictRectifier ?? true;
+
+ if (!enabled) {
+ return { matched: false };
+ }
+
+ if (params.retryState.thinkingEffortConflictRetried) {
+ return {
+ matched: true,
+ applied: false,
+ reason: "already_retried",
+ rectifierType: "thinking_effort_conflict_rectifier",
+ trigger: effortConflictTrigger,
+ };
+ }
+
+ const requestDetailsBeforeRectify = buildRequestDetails(requestSession);
+ const rectified = rectifyThinkingEffortConflict(
+ requestSession.request.message as Record
+ );
+
+ addSpecialSettingForPersistence(requestSession, persistSession, {
+ type: "thinking_effort_conflict_rectifier",
+ scope: "request",
+ hit: rectified.applied,
+ providerId: provider.id,
+ providerName: provider.name,
+ trigger: effortConflictTrigger,
+ attemptNumber,
+ retryAttemptNumber,
+ removedOutputConfig: rectified.removedOutputConfig,
+ removedReasoningEffort: rectified.removedReasoningEffort,
+ thinkingType: rectified.thinkingType,
+ effort: rectified.effort,
+ });
+ await persistSpecialSettings(persistSession);
+
+ if (!rectified.applied) {
+ return {
+ matched: true,
+ applied: false,
+ reason: "not_applicable",
+ rectifierType: "thinking_effort_conflict_rectifier",
+ trigger: effortConflictTrigger,
+ };
+ }
+
+ params.retryState.thinkingEffortConflictRetried = true;
+ return {
+ matched: true,
+ applied: true,
+ rectifierType: "thinking_effort_conflict_rectifier",
+ trigger: effortConflictTrigger,
+ requestDetailsBeforeRectify,
+ };
+ }
+
const signatureTrigger = detectThinkingSignatureRectifierTrigger(errorMessage);
if (signatureTrigger) {
const settings = await getCachedSystemSettings();
@@ -1094,6 +1169,7 @@ export class ProxyForwarder {
const reactiveRectifierRetryState: ReactiveRectifierRetryState = {
thinkingSignatureRetried: false,
thinkingBudgetRetried: false,
+ thinkingEffortConflictRetried: false,
};
const requestPath = session.requestUrl.pathname;
@@ -4452,6 +4528,7 @@ export class ProxyForwarder {
reactiveRectifierRetryState: {
thinkingSignatureRetried: false,
thinkingBudgetRetried: false,
+ thinkingEffortConflictRetried: false,
},
settled: false,
thresholdTriggered: false,
diff --git a/src/app/v1/_lib/proxy/thinking-effort-conflict-rectifier.test.ts b/src/app/v1/_lib/proxy/thinking-effort-conflict-rectifier.test.ts
new file mode 100644
index 000000000..db01dad57
--- /dev/null
+++ b/src/app/v1/_lib/proxy/thinking-effort-conflict-rectifier.test.ts
@@ -0,0 +1,186 @@
+import { describe, expect, test } from "vitest";
+import {
+ detectThinkingEffortConflictRectifierTrigger,
+ rectifyThinkingEffortConflict,
+} from "./thinking-effort-conflict-rectifier";
+
+describe("detectThinkingEffortConflictRectifierTrigger", () => {
+ test("matches the documented DeepSeek conflict error", () => {
+ expect(
+ detectThinkingEffortConflictRectifierTrigger(
+ "thinking options type cannot be disabled when reasoning_effort is set"
+ )
+ ).toBe("thinking_disabled_with_reasoning_effort");
+ });
+
+ test("matches the error embedded in a proxy upstream envelope", () => {
+ expect(
+ detectThinkingEffortConflictRectifierTrigger(
+ 'Provider deepseek returned 400: Provider returned 400: Bad Request | Upstream: {"error":{"message":"thinking options type cannot be disabled when reasoning_effort is set","type":"invalid_request_error","param":null,"code":"invalid_request_error"}}'
+ )
+ ).toBe("thinking_disabled_with_reasoning_effort");
+ });
+
+ test("matches case and quoting variants", () => {
+ expect(
+ detectThinkingEffortConflictRectifierTrigger(
+ "Thinking options `type` cannot be disabled when `reasoning_effort` is set."
+ )
+ ).toBe("thinking_disabled_with_reasoning_effort");
+ });
+
+ test("matches output_config flavored variants", () => {
+ expect(
+ detectThinkingEffortConflictRectifierTrigger(
+ "thinking cannot be disabled when output_config.effort is set"
+ )
+ ).toBe("thinking_disabled_with_reasoning_effort");
+ });
+
+ test("ignores unrelated errors", () => {
+ expect(detectThinkingEffortConflictRectifierTrigger(null)).toBeNull();
+ expect(detectThinkingEffortConflictRectifierTrigger(undefined)).toBeNull();
+ expect(detectThinkingEffortConflictRectifierTrigger("")).toBeNull();
+ expect(
+ detectThinkingEffortConflictRectifierTrigger("Invalid `signature` in `thinking` block")
+ ).toBeNull();
+ expect(
+ detectThinkingEffortConflictRectifierTrigger(
+ "thinking.enabled.budget_tokens: Input should be greater than or equal to 1024"
+ )
+ ).toBeNull();
+ expect(
+ detectThinkingEffortConflictRectifierTrigger("reasoning_effort must be one of low|medium")
+ ).toBeNull();
+ expect(detectThinkingEffortConflictRectifierTrigger("invalid request: malformed")).toBeNull();
+ });
+});
+
+describe("rectifyThinkingEffortConflict", () => {
+ test("removes output_config when thinking is disabled (Claude Code subagent shape)", () => {
+ const message: Record = {
+ model: "deepseek-v4-pro",
+ thinking: { type: "disabled" },
+ output_config: { effort: "max" },
+ messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+ };
+
+ const result = rectifyThinkingEffortConflict(message);
+
+ expect(result.applied).toBe(true);
+ expect(result.removedOutputConfig).toBe(true);
+ expect(result.removedReasoningEffort).toBe(false);
+ expect(result.thinkingType).toBe("disabled");
+ expect(result.effort).toBe("max");
+ expect("output_config" in message).toBe(false);
+ expect(message.thinking).toEqual({ type: "disabled" });
+ });
+
+ test("strips only effort and preserves sibling keys in output_config", () => {
+ const message: Record = {
+ thinking: { type: "disabled" },
+ output_config: { effort: "max", verbosity: "high", future_flag: true },
+ messages: [],
+ };
+
+ const result = rectifyThinkingEffortConflict(message);
+
+ expect(result.applied).toBe(true);
+ expect(result.removedOutputConfig).toBe(true);
+ expect(result.effort).toBe("max");
+ // Sibling fields must survive; only the conflicting effort carrier is removed.
+ expect(message.output_config).toEqual({ verbosity: "high", future_flag: true });
+ });
+
+ test("drops output_config entirely when effort was its only key", () => {
+ const message: Record = {
+ thinking: { type: "disabled" },
+ output_config: { effort: "max" },
+ messages: [],
+ };
+
+ rectifyThinkingEffortConflict(message);
+
+ expect("output_config" in message).toBe(false);
+ });
+
+ test("removes a top-level reasoning_effort passthrough as well", () => {
+ const message: Record = {
+ thinking: { type: "disabled" },
+ reasoning_effort: "high",
+ messages: [],
+ };
+
+ const result = rectifyThinkingEffortConflict(message);
+
+ expect(result.applied).toBe(true);
+ expect(result.removedOutputConfig).toBe(false);
+ expect(result.removedReasoningEffort).toBe(true);
+ expect(result.effort).toBe("high");
+ expect("reasoning_effort" in message).toBe(false);
+ });
+
+ test("treats a missing thinking field as disabled and strips effort", () => {
+ const message: Record = {
+ output_config: { effort: "medium" },
+ messages: [],
+ };
+
+ const result = rectifyThinkingEffortConflict(message);
+
+ expect(result.applied).toBe(true);
+ expect(result.removedOutputConfig).toBe(true);
+ expect(result.thinkingType).toBeNull();
+ });
+
+ test("does not touch requests with thinking enabled", () => {
+ const message: Record = {
+ thinking: { type: "enabled", budget_tokens: 2048 },
+ output_config: { effort: "max" },
+ };
+
+ const result = rectifyThinkingEffortConflict(message);
+
+ expect(result.applied).toBe(false);
+ expect(message.output_config).toEqual({ effort: "max" });
+ expect(message.thinking).toEqual({ type: "enabled", budget_tokens: 2048 });
+ });
+
+ test("does not touch requests with adaptive thinking", () => {
+ const message: Record = {
+ thinking: { type: "adaptive" },
+ output_config: { effort: "low" },
+ };
+
+ expect(rectifyThinkingEffortConflict(message).applied).toBe(false);
+ expect(message.output_config).toEqual({ effort: "low" });
+ });
+
+ test("is a no-op when no effort fields are present", () => {
+ const message: Record = {
+ thinking: { type: "disabled" },
+ messages: [],
+ };
+
+ const result = rectifyThinkingEffortConflict(message);
+
+ expect(result.applied).toBe(false);
+ expect(result.removedOutputConfig).toBe(false);
+ expect(result.removedReasoningEffort).toBe(false);
+ });
+
+ test("keeps an effort-less output_config in place", () => {
+ const message: Record = {
+ thinking: { type: "disabled" },
+ output_config: { something_else: true },
+ reasoning_effort: "low",
+ };
+
+ const result = rectifyThinkingEffortConflict(message);
+
+ expect(result.applied).toBe(true);
+ expect(result.removedOutputConfig).toBe(false);
+ expect(result.removedReasoningEffort).toBe(true);
+ expect(message.output_config).toEqual({ something_else: true });
+ });
+});
diff --git a/src/app/v1/_lib/proxy/thinking-effort-conflict-rectifier.ts b/src/app/v1/_lib/proxy/thinking-effort-conflict-rectifier.ts
new file mode 100644
index 000000000..a05110c73
--- /dev/null
+++ b/src/app/v1/_lib/proxy/thinking-effort-conflict-rectifier.ts
@@ -0,0 +1,119 @@
+/**
+ * Thinking Effort Conflict Rectifier - Reactive rectifier for strict Anthropic-compatible
+ * providers (DeepSeek, MiMo, ...) that reject `thinking: { type: "disabled" }` combined
+ * with a reasoning-effort field.
+ *
+ * Background (issue #1257): Claude Code v2.1.166+ disables thinking for subagent tasks
+ * but keeps the global `output_config: { effort }` in the payload. The official Anthropic
+ * API ignores the contradiction; DeepSeek's validation rejects it with
+ * "thinking options type cannot be disabled when reasoning_effort is set" (DeepSeek docs:
+ * `output_config` only supports `effort`, which maps to reasoning_effort internally).
+ *
+ * Action: strip the effort fields (`output_config.effort` carrier / top-level
+ * `reasoning_effort`) while keeping thinking disabled, then retry the same provider once.
+ */
+
+export type ThinkingEffortConflictRectifierTrigger = "thinking_disabled_with_reasoning_effort";
+
+export type ThinkingEffortConflictRectifierResult = {
+ applied: boolean;
+ removedOutputConfig: boolean;
+ removedReasoningEffort: boolean;
+ thinkingType: string | null;
+ effort: string | null;
+};
+
+/**
+ * 检测是否需要触发「thinking effort 冲突整流器」
+ *
+ * 注意：不依赖错误规则开关（error rules 可能被用户关闭），仅做字符串匹配。
+ */
+export function detectThinkingEffortConflictRectifierTrigger(
+ errorMessage: string | null | undefined
+): ThinkingEffortConflictRectifierTrigger | null {
+ if (!errorMessage) return null;
+
+ const lower = errorMessage.toLowerCase();
+
+ const mentionsDisableConflict =
+ lower.includes("cannot be disabled") || lower.includes("can not be disabled");
+ if (!mentionsDisableConflict) return null;
+
+ // DeepSeek 原文：thinking options type cannot be disabled when reasoning_effort is set
+ if (lower.includes("reasoning_effort")) {
+ return "thinking_disabled_with_reasoning_effort";
+ }
+
+ // 变体兜底：以 output_config(.effort) 表述同一冲突的上游
+ if (lower.includes("output_config") && lower.includes("thinking")) {
+ return "thinking_disabled_with_reasoning_effort";
+ }
+
+ return null;
+}
+
+/**
+ * 对 Anthropic 请求体做最小侵入整流：
+ * - 仅当 thinking 关闭（或缺省，上游按关闭处理）时生效
+ * - 移除携带 effort 的 output_config 与顶层 reasoning_effort 透传字段
+ * - 保留 thinking 关闭状态（尊重客户端对子 agent 关闭思考的意图）
+ *
+ * 说明：仅在上游报错后、同供应商重试前调用（被动触发），不影响正常请求；
+ * 原地修改 message 对象。
+ */
+export function rectifyThinkingEffortConflict(
+ message: Record
+): ThinkingEffortConflictRectifierResult {
+ const thinking = message.thinking;
+ const thinkingType =
+ thinking && typeof thinking === "object" && !Array.isArray(thinking)
+ ? typeof (thinking as Record).type === "string"
+ ? ((thinking as Record).type as string)
+ : null
+ : null;
+
+ const result: ThinkingEffortConflictRectifierResult = {
+ applied: false,
+ removedOutputConfig: false,
+ removedReasoningEffort: false,
+ thinkingType,
+ effort: null,
+ };
+
+ // thinking 显式启用（enabled/adaptive 等）时不属于该冲突，保持原样
+ const thinkingDisabled = thinkingType === null || thinkingType === "disabled";
+ if (!thinkingDisabled) {
+ return result;
+ }
+
+ const outputConfig = message.output_config;
+ const outputConfigEffort =
+ outputConfig && typeof outputConfig === "object" && !Array.isArray(outputConfig)
+ ? (outputConfig as Record).effort
+ : undefined;
+
+ if (outputConfigEffort !== undefined) {
+ result.effort = typeof outputConfigEffort === "string" ? outputConfigEffort : null;
+ // 仅剥离冲突的 effort 字段，保留 output_config 中的其他配置；若剥离后为空对象则整体移除。
+ const { effort: _removedEffort, ...restOutputConfig } = outputConfig as Record;
+ if (Object.keys(restOutputConfig).length > 0) {
+ message.output_config = restOutputConfig;
+ } else {
+ delete message.output_config;
+ }
+ result.removedOutputConfig = true;
+ result.applied = true;
+ }
+
+ const reasoningEffort = message.reasoning_effort;
+ if (reasoningEffort !== undefined) {
+ if (result.effort === null && typeof reasoningEffort === "string") {
+ result.effort = reasoningEffort;
+ }
+ delete message.reasoning_effort;
+ result.removedReasoningEffort = true;
+ result.applied = true;
+ }
+
+ return result;
+}
diff --git a/src/drizzle/schema.ts b/src/drizzle/schema.ts
index 034c07a1f..ff1a76a2a 100644
--- a/src/drizzle/schema.ts
+++ b/src/drizzle/schema.ts
@@ -804,6 +804,13 @@ export const systemSettings = pgTable('system_settings', {
.notNull()
.default(true),
+ // thinking effort 冲突整流器（默认开启）
+ // 开启后：当 Anthropic 兼容供应商（DeepSeek/MiMo 等）因 thinking 关闭 + reasoning_effort 同时存在
+ // 返回 400 错误时，自动剥离 effort 字段并对同供应商重试一次
+ enableThinkingEffortConflictRectifier: boolean('enable_thinking_effort_conflict_rectifier')
+ .notNull()
+ .default(true),
+
// billing header 整流器（默认开启）
// 开启后：主动移除 Claude Code 客户端注入到 system 提示中的 x-anthropic-billing-header 文本块
enableBillingHeaderRectifier: boolean('enable_billing_header_rectifier')
diff --git a/src/lib/api-client/v1/openapi-types.gen.ts b/src/lib/api-client/v1/openapi-types.gen.ts
index 3b3aba480..b603e42ec 100644
--- a/src/lib/api-client/v1/openapi-types.gen.ts
+++ b/src/lib/api-client/v1/openapi-types.gen.ts
@@ -11655,6 +11655,8 @@ export interface operations {
enableThinkingSignatureRectifier: boolean;
/** @description Whether thinking budget rectifier retries are enabled. */
enableThinkingBudgetRectifier: boolean;
+ /** @description Whether thinking effort conflict rectifier retries are enabled. */
+ enableThinkingEffortConflictRectifier: boolean;
/** @description Whether billing-header rectifier is enabled. */
enableBillingHeaderRectifier: boolean;
/** @description Whether Responses API input rectifier is enabled. */
@@ -11913,6 +11915,8 @@ export interface operations {
enableThinkingSignatureRectifier?: boolean;
/** @description Whether thinking budget rectifier retries are enabled. */
enableThinkingBudgetRectifier?: boolean;
+ /** @description Whether thinking effort conflict rectifier retries are enabled. */
+ enableThinkingEffortConflictRectifier?: boolean;
/** @description Whether billing-header rectifier is enabled. */
enableBillingHeaderRectifier?: boolean;
/** @description Whether Responses API input rectifier is enabled. */
@@ -12044,6 +12048,8 @@ export interface operations {
enableThinkingSignatureRectifier: boolean;
/** @description Whether thinking budget rectifier retries are enabled. */
enableThinkingBudgetRectifier: boolean;
+ /** @description Whether thinking effort conflict rectifier retries are enabled. */
+ enableThinkingEffortConflictRectifier: boolean;
/** @description Whether billing-header rectifier is enabled. */
enableBillingHeaderRectifier: boolean;
/** @description Whether Responses API input rectifier is enabled. */
diff --git a/src/lib/api/v1/schemas/system-config.ts b/src/lib/api/v1/schemas/system-config.ts
index 92dc06ecb..944699f0c 100644
--- a/src/lib/api/v1/schemas/system-config.ts
+++ b/src/lib/api/v1/schemas/system-config.ts
@@ -126,6 +126,9 @@ export const SystemSettingsSchema = z
enableThinkingBudgetRectifier: z
.boolean()
.describe("Whether thinking budget rectifier retries are enabled."),
+ enableThinkingEffortConflictRectifier: z
+ .boolean()
+ .describe("Whether thinking effort conflict rectifier retries are enabled."),
enableBillingHeaderRectifier: z
.boolean()
.describe("Whether billing-header rectifier is enabled."),
diff --git a/src/lib/config/system-settings-cache.ts b/src/lib/config/system-settings-cache.ts
index 232349d56..2b4043460 100644
--- a/src/lib/config/system-settings-cache.ts
+++ b/src/lib/config/system-settings-cache.ts
@@ -41,6 +41,7 @@ const DEFAULT_SETTINGS: Pick<
| "codexPriorityBillingSource"
| "enableThinkingSignatureRectifier"
| "enableThinkingBudgetRectifier"
+ | "enableThinkingEffortConflictRectifier"
| "enableBillingHeaderRectifier"
| "enableResponseInputRectifier"
| "allowNonConversationEndpointProviderFallback"
@@ -60,6 +61,7 @@ const DEFAULT_SETTINGS: Pick<
codexPriorityBillingSource: "requested",
enableThinkingSignatureRectifier: true,
enableThinkingBudgetRectifier: true,
+ enableThinkingEffortConflictRectifier: true,
enableBillingHeaderRectifier: true,
enableResponseInputRectifier: true,
// 安全敏感开关：冷缓存 / DB 读取失败时 fail-closed，避免意外重新开启跨供应商 raw fallback。
@@ -148,6 +150,7 @@ export async function getCachedSystemSettings(): Promise {
interceptAnthropicWarmupRequests: DEFAULT_SETTINGS.interceptAnthropicWarmupRequests,
enableThinkingSignatureRectifier: DEFAULT_SETTINGS.enableThinkingSignatureRectifier,
enableThinkingBudgetRectifier: DEFAULT_SETTINGS.enableThinkingBudgetRectifier,
+ enableThinkingEffortConflictRectifier: DEFAULT_SETTINGS.enableThinkingEffortConflictRectifier,
enableBillingHeaderRectifier: DEFAULT_SETTINGS.enableBillingHeaderRectifier,
enableResponseInputRectifier: DEFAULT_SETTINGS.enableResponseInputRectifier,
allowNonConversationEndpointProviderFallback:
diff --git a/src/lib/utils/special-settings.ts b/src/lib/utils/special-settings.ts
index a5f31c028..09922e741 100644
--- a/src/lib/utils/special-settings.ts
+++ b/src/lib/utils/special-settings.ts
@@ -75,6 +75,19 @@ function buildSettingKey(setting: SpecialSetting): string {
setting.removedRedactedThinkingBlocks,
setting.removedSignatureFields,
]);
+ case "thinking_effort_conflict_rectifier":
+ return JSON.stringify([
+ setting.type,
+ setting.hit,
+ setting.providerId ?? null,
+ setting.trigger,
+ setting.attemptNumber,
+ setting.retryAttemptNumber,
+ setting.removedOutputConfig,
+ setting.removedReasoningEffort,
+ setting.thinkingType,
+ setting.effort,
+ ]);
case "codex_session_id_completion":
return JSON.stringify([
setting.type,
diff --git a/src/lib/validation/schemas.ts b/src/lib/validation/schemas.ts
index 368f564ab..5640440ff 100644
--- a/src/lib/validation/schemas.ts
+++ b/src/lib/validation/schemas.ts
@@ -1005,6 +1005,8 @@ export const UpdateSystemSettingsSchema = z.object({
enableThinkingSignatureRectifier: z.boolean().optional(),
// thinking budget 整流器（可选）
enableThinkingBudgetRectifier: z.boolean().optional(),
+ // thinking effort 冲突整流器（可选）
+ enableThinkingEffortConflictRectifier: z.boolean().optional(),
// billing header 整流器（可选）
enableBillingHeaderRectifier: z.boolean().optional(),
// Response API input 整流器（可选）
diff --git a/src/repository/_shared/transformers.ts b/src/repository/_shared/transformers.ts
index e26969ce0..353b5e5d6 100644
--- a/src/repository/_shared/transformers.ts
+++ b/src/repository/_shared/transformers.ts
@@ -266,6 +266,8 @@ export function toSystemSettings(dbSettings: any): SystemSettings {
interceptAnthropicWarmupRequests: dbSettings?.interceptAnthropicWarmupRequests ?? false,
enableThinkingSignatureRectifier: dbSettings?.enableThinkingSignatureRectifier ?? true,
enableThinkingBudgetRectifier: dbSettings?.enableThinkingBudgetRectifier ?? true,
+ enableThinkingEffortConflictRectifier:
+ dbSettings?.enableThinkingEffortConflictRectifier ?? true,
enableBillingHeaderRectifier: dbSettings?.enableBillingHeaderRectifier ?? true,
enableResponseInputRectifier: dbSettings?.enableResponseInputRectifier ?? true,
allowNonConversationEndpointProviderFallback:
diff --git a/src/repository/system-config.ts b/src/repository/system-config.ts
index ab83f114d..d3f6262b6 100644
--- a/src/repository/system-config.ts
+++ b/src/repository/system-config.ts
@@ -163,6 +163,7 @@ function createFallbackSettings(): SystemSettings {
interceptAnthropicWarmupRequests: false,
enableThinkingSignatureRectifier: true,
enableThinkingBudgetRectifier: true,
+ enableThinkingEffortConflictRectifier: true,
enableBillingHeaderRectifier: true,
enableResponseInputRectifier: true,
allowNonConversationEndpointProviderFallback: true,
@@ -218,6 +219,7 @@ export async function getSystemSettings(): Promise {
interceptAnthropicWarmupRequests: systemSettings.interceptAnthropicWarmupRequests,
enableThinkingSignatureRectifier: systemSettings.enableThinkingSignatureRectifier,
enableThinkingBudgetRectifier: systemSettings.enableThinkingBudgetRectifier,
+ enableThinkingEffortConflictRectifier: systemSettings.enableThinkingEffortConflictRectifier,
enableBillingHeaderRectifier: systemSettings.enableBillingHeaderRectifier,
enableResponseInputRectifier: systemSettings.enableResponseInputRectifier,
allowNonConversationEndpointProviderFallback:
@@ -260,6 +262,7 @@ export async function getSystemSettings(): Promise {
interceptAnthropicWarmupRequests: systemSettings.interceptAnthropicWarmupRequests,
enableThinkingSignatureRectifier: systemSettings.enableThinkingSignatureRectifier,
enableThinkingBudgetRectifier: systemSettings.enableThinkingBudgetRectifier,
+ enableThinkingEffortConflictRectifier: systemSettings.enableThinkingEffortConflictRectifier,
enableBillingHeaderRectifier: systemSettings.enableBillingHeaderRectifier,
enableResponseInputRectifier: systemSettings.enableResponseInputRectifier,
allowNonConversationEndpointProviderFallback:
@@ -302,9 +305,33 @@ export async function getSystemSettings(): Promise {
error,
});
- // 最新降级：移除最近新增的 billHedgeLosers 列。
+ // 最新降级：移除最近新增的 enableThinkingEffortConflictRectifier 列。
+ const {
+ enableThinkingEffortConflictRectifier: _omitEffortConflict,
+ ...selectionWithoutEffortConflict
+ } = fullSelection;
+
+ try {
+ const [row] = await db
+ .select(selectionWithoutEffortConflict)
+ .from(systemSettings)
+ .orderBy(asc(systemSettings.id))
+ .limit(1);
+ return row ?? null;
+ } catch (effortConflictFallbackError) {
+ if (!isUndefinedColumnError(effortConflictFallbackError)) {
+ throw effortConflictFallbackError;
+ }
+
+ logger.warn(
+ "system_settings 表除 enableThinkingEffortConflictRectifier 外仍有列缺失，继续回退到上一代字段集。",
+ { error: effortConflictFallbackError }
+ );
+ }
+
+ // 次新降级：移除 billHedgeLosers 列。
const { billHedgeLosers: _omitBillHedgeLosers, ...selectionWithoutBillHedgeLosers } =
- fullSelection;
+ selectionWithoutEffortConflict;
try {
const [row] = await db
@@ -580,6 +607,7 @@ export async function updateSystemSettings(
interceptAnthropicWarmupRequests: systemSettings.interceptAnthropicWarmupRequests,
enableThinkingSignatureRectifier: systemSettings.enableThinkingSignatureRectifier,
enableThinkingBudgetRectifier: systemSettings.enableThinkingBudgetRectifier,
+ enableThinkingEffortConflictRectifier: systemSettings.enableThinkingEffortConflictRectifier,
enableBillingHeaderRectifier: systemSettings.enableBillingHeaderRectifier,
enableResponseInputRectifier: systemSettings.enableResponseInputRectifier,
allowNonConversationEndpointProviderFallback:
@@ -622,6 +650,7 @@ export async function updateSystemSettings(
interceptAnthropicWarmupRequests: systemSettings.interceptAnthropicWarmupRequests,
enableThinkingSignatureRectifier: systemSettings.enableThinkingSignatureRectifier,
enableThinkingBudgetRectifier: systemSettings.enableThinkingBudgetRectifier,
+ enableThinkingEffortConflictRectifier: systemSettings.enableThinkingEffortConflictRectifier,
enableBillingHeaderRectifier: systemSettings.enableBillingHeaderRectifier,
enableResponseInputRectifier: systemSettings.enableResponseInputRectifier,
enableCodexSessionIdCompletion: systemSettings.enableCodexSessionIdCompletion,
@@ -751,6 +780,11 @@ export async function updateSystemSettings(
updates.enableThinkingBudgetRectifier = payload.enableThinkingBudgetRectifier;
}
+ // thinking effort 冲突整流器开关（如果提供）
+ if (payload.enableThinkingEffortConflictRectifier !== undefined) {
+ updates.enableThinkingEffortConflictRectifier = payload.enableThinkingEffortConflictRectifier;
+ }
+
// billing header 整流器开关（如果提供）
if (payload.enableBillingHeaderRectifier !== undefined) {
updates.enableBillingHeaderRectifier = payload.enableBillingHeaderRectifier;
@@ -846,26 +880,57 @@ export async function updateSystemSettings(
error,
});
- // 最新降级：移除最近新增的 billHedgeLosers 列。
- const { billHedgeLosers: _omitUpdateBillHedgeLosers, ...updatesWithoutBillHedgeLosers } =
- updates;
- const { billHedgeLosers: _omitReturningBillHedgeLosers, ...returningWithoutBillHedgeLosers } =
- fullReturning;
+ // 最新降级：移除最近新增的 enableThinkingEffortConflictRectifier 列。
+ const {
+ enableThinkingEffortConflictRectifier: _omitUpdateEffortConflict,
+ ...updatesWithoutEffortConflict
+ } = updates;
+ const {
+ enableThinkingEffortConflictRectifier: _omitReturningEffortConflict,
+ ...returningWithoutEffortConflict
+ } = fullReturning;
try {
[updated] = await executor
.update(systemSettings)
- .set(updatesWithoutBillHedgeLosers)
+ .set(updatesWithoutEffortConflict)
.where(eq(systemSettings.id, current.id))
- .returning(returningWithoutBillHedgeLosers);
- } catch (billHedgeLosersFallbackError) {
- if (!isUndefinedColumnError(billHedgeLosersFallbackError)) {
- throw billHedgeLosersFallbackError;
+ .returning(returningWithoutEffortConflict);
+ } catch (effortConflictFallbackError) {
+ if (!isUndefinedColumnError(effortConflictFallbackError)) {
+ throw effortConflictFallbackError;
}
- logger.warn("system_settings 表除 billHedgeLosers 外仍有列缺失，继续降级更新。", {
- error: billHedgeLosersFallbackError,
- });
+ logger.warn(
+ "system_settings 表除 enableThinkingEffortConflictRectifier 外仍有列缺失，继续降级更新。",
+ {
+ error: effortConflictFallbackError,
+ }
+ );
+ }
+
+ // 次新降级：移除 billHedgeLosers 列。
+ const { billHedgeLosers: _omitUpdateBillHedgeLosers, ...updatesWithoutBillHedgeLosers } =
+ updatesWithoutEffortConflict;
+ const { billHedgeLosers: _omitReturningBillHedgeLosers, ...returningWithoutBillHedgeLosers } =
+ returningWithoutEffortConflict;
+
+ if (!updated) {
+ try {
+ [updated] = await executor
+ .update(systemSettings)
+ .set(updatesWithoutBillHedgeLosers)
+ .where(eq(systemSettings.id, current.id))
+ .returning(returningWithoutBillHedgeLosers);
+ } catch (billHedgeLosersFallbackError) {
+ if (!isUndefinedColumnError(billHedgeLosersFallbackError)) {
+ throw billHedgeLosersFallbackError;
+ }
+
+ logger.warn("system_settings 表除 billHedgeLosers 外仍有列缺失，继续降级更新。", {
+ error: billHedgeLosersFallbackError,
+ });
+ }
}
// 次新降级：移除 billNonSuccessfulRequests 列。
diff --git a/src/types/special-settings.ts b/src/types/special-settings.ts
index a93b8d1fe..c24bc1930 100644
--- a/src/types/special-settings.ts
+++ b/src/types/special-settings.ts
@@ -11,6 +11,7 @@ export type SpecialSetting =
| GuardInterceptSpecialSetting
| ThinkingSignatureRectifierSpecialSetting
| ThinkingBudgetRectifierSpecialSetting
+ | ThinkingEffortConflictRectifierSpecialSetting
| BillingHeaderRectifierSpecialSetting
| CodexSessionIdCompletionSpecialSetting
| ClaudeMetadataUserIdInjectionSpecialSetting
@@ -148,6 +149,28 @@ export type ThinkingSignatureRectifierSpecialSetting = {
removedSignatureFields: number;
};
+/**
+ * Thinking effort 冲突整流器审计
+ *
+ * 用于记录：当 Anthropic 兼容供应商（如 DeepSeek、MiMo 等）因
+ * thinking 关闭 + reasoning_effort/output_config.effort 同时存在而返回 400 时，
+ * 代理剥离 effort 字段并对同供应商自动重试一次的行为。
+ */
+export type ThinkingEffortConflictRectifierSpecialSetting = {
+ type: "thinking_effort_conflict_rectifier";
+ scope: "request";
+ hit: boolean;
+ providerId: number | null;
+ providerName: string | null;
+ trigger: "thinking_disabled_with_reasoning_effort";
+ attemptNumber: number;
+ retryAttemptNumber: number;
+ removedOutputConfig: boolean;
+ removedReasoningEffort: boolean;
+ thinkingType: string | null;
+ effort: string | null;
+};
+
/**
* Codex Session ID 补全审计
*
diff --git a/src/types/system-config.ts b/src/types/system-config.ts
index e0080a37f..d0d168ed7 100644
--- a/src/types/system-config.ts
+++ b/src/types/system-config.ts
@@ -91,6 +91,11 @@ export interface SystemSettings {
// 目标：当 Anthropic 类型供应商出现 budget_tokens < 1024 错误时，自动整流并重试一次
enableThinkingBudgetRectifier: boolean;
+ // thinking effort 冲突整流器（默认开启）
+ // 目标：当 Anthropic 兼容供应商（DeepSeek/MiMo 等）因 thinking 关闭 + reasoning_effort
+ // 同时存在返回 400 错误时，自动剥离 effort 字段并对同供应商重试一次
+ enableThinkingEffortConflictRectifier: boolean;
+
// billing header 整流器（默认开启）
// 目标：主动移除 Claude Code 客户端注入到 system 提示中的 x-anthropic-billing-header 文本块，
// 防止 Amazon Bedrock 等非原生 Anthropic 上游返回 400 错误
@@ -196,6 +201,9 @@ export interface UpdateSystemSettingsInput {
// thinking budget 整流器（可选）
enableThinkingBudgetRectifier?: boolean;
+ // thinking effort 冲突整流器（可选）
+ enableThinkingEffortConflictRectifier?: boolean;
+
// billing header 整流器（可选）
enableBillingHeaderRectifier?: boolean;
diff --git a/tests/configs/thinking-effort-conflict-rectifier.config.ts b/tests/configs/thinking-effort-conflict-rectifier.config.ts
new file mode 100644
index 000000000..5585c41c1
--- /dev/null
+++ b/tests/configs/thinking-effort-conflict-rectifier.config.ts
@@ -0,0 +1,12 @@
+import { createCoverageConfig } from "../vitest.base";
+
+export default createCoverageConfig({
+ name: "thinking-effort-conflict-rectifier",
+ environment: "node",
+ testFiles: [
+ "src/app/v1/_lib/proxy/thinking-effort-conflict-rectifier.test.ts",
+ "tests/unit/proxy/proxy-forwarder-thinking-effort-conflict-rectifier.test.ts",
+ ],
+ sourceFiles: ["src/app/v1/_lib/proxy/thinking-effort-conflict-rectifier.ts"],
+ thresholds: { lines: 80, functions: 80, branches: 70, statements: 80 },
+});
diff --git a/tests/unit/actions/system-config-thinking-effort-conflict-setting.test.ts b/tests/unit/actions/system-config-thinking-effort-conflict-setting.test.ts
new file mode 100644
index 000000000..c1f980722
--- /dev/null
+++ b/tests/unit/actions/system-config-thinking-effort-conflict-setting.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, test, vi } from "vitest";
+
+vi.mock("server-only", () => ({}));
+
+describe("enableThinkingEffortConflictRectifier system setting", () => {
+ test("defaults to enabled in the DB-row transformer", async () => {
+ const { toSystemSettings } = await import("@/repository/_shared/transformers");
+
+ expect(toSystemSettings(undefined).enableThinkingEffortConflictRectifier).toBe(true);
+ expect(
+ toSystemSettings({ id: 1, siteTitle: "Claude Code Hub" })
+ .enableThinkingEffortConflictRectifier
+ ).toBe(true);
+ expect(
+ toSystemSettings({ id: 1, enableThinkingEffortConflictRectifier: false })
+ .enableThinkingEffortConflictRectifier
+ ).toBe(false);
+ });
+
+ test("is accepted by the settings update validation schema", async () => {
+ const { UpdateSystemSettingsSchema } = await import("@/lib/validation/schemas");
+
+ const parsed = UpdateSystemSettingsSchema.parse({
+ enableThinkingEffortConflictRectifier: false,
+ });
+ expect(parsed.enableThinkingEffortConflictRectifier).toBe(false);
+
+ const empty = UpdateSystemSettingsSchema.parse({});
+ expect(empty.enableThinkingEffortConflictRectifier).toBeUndefined();
+ });
+
+ test("is exposed by the v1 system settings response schema", async () => {
+ const { SystemSettingsSchema } = await import("@/lib/api/v1/schemas/system-config");
+
+ expect(Object.keys(SystemSettingsSchema.shape)).toContain(
+ "enableThinkingEffortConflictRectifier"
+ );
+ });
+});
diff --git a/tests/unit/proxy/proxy-forwarder-thinking-effort-conflict-rectifier.test.ts b/tests/unit/proxy/proxy-forwarder-thinking-effort-conflict-rectifier.test.ts
new file mode 100644
index 000000000..ad5bd8171
--- /dev/null
+++ b/tests/unit/proxy/proxy-forwarder-thinking-effort-conflict-rectifier.test.ts
@@ -0,0 +1,253 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+const mocks = vi.hoisted(() => {
+ return {
+ getCachedSystemSettings: vi.fn(async () => ({
+ enableThinkingEffortConflictRectifier: true,
+ enableHighConcurrencyMode: false,
+ })),
+ recordSuccess: vi.fn(),
+ recordFailure: vi.fn(async () => {}),
+ getCircuitState: vi.fn(() => "closed"),
+ getProviderHealthInfo: vi.fn(async () => ({
+ health: { failureCount: 0 },
+ config: { failureThreshold: 3 },
+ })),
+ updateMessageRequestDetails: vi.fn(async () => {}),
+ storeSessionSpecialSettings: vi.fn(async () => {}),
+ updateSessionBindingSmart: vi.fn(async () => ({
+ updated: true,
+ reason: "first_success",
+ details: "mocked",
+ })),
+ updateSessionProvider: vi.fn(async () => {}),
+ };
+});
+
+vi.mock("@/lib/config", async (importOriginal) => {
+ const actual = await importOriginal();
+ return {
+ ...actual,
+ isHttp2Enabled: vi.fn(async () => false),
+ getCachedSystemSettings: mocks.getCachedSystemSettings,
+ };
+});
+
+vi.mock("@/lib/circuit-breaker", () => ({
+ getCircuitState: mocks.getCircuitState,
+ getProviderHealthInfo: mocks.getProviderHealthInfo,
+ recordFailure: mocks.recordFailure,
+ recordSuccess: mocks.recordSuccess,
+}));
+
+vi.mock("@/repository/message", () => ({
+ updateMessageRequestDetails: mocks.updateMessageRequestDetails,
+}));
+
+vi.mock("@/lib/session-manager", () => ({
+ SessionManager: {
+ storeSessionSpecialSettings: mocks.storeSessionSpecialSettings,
+ updateSessionBindingSmart: mocks.updateSessionBindingSmart,
+ updateSessionProvider: mocks.updateSessionProvider,
+ },
+}));
+
+import { ProxyError } from "@/app/v1/_lib/proxy/errors";
+import { ProxyForwarder } from "@/app/v1/_lib/proxy/forwarder";
+import { ProxySession } from "@/app/v1/_lib/proxy/session";
+import type { Provider } from "@/types/provider";
+
+const DEEPSEEK_CONFLICT_ERROR =
+ 'Provider returned 400: Bad Request | Upstream: {"error":{"message":"thinking options type cannot be disabled when reasoning_effort is set","type":"invalid_request_error","param":null,"code":"invalid_request_error"}}';
+
+function createSession(): ProxySession {
+ const headers = new Headers();
+ const session = Object.create(ProxySession.prototype);
+
+ Object.assign(session, {
+ startTime: Date.now(),
+ method: "POST",
+ requestUrl: new URL("https://example.com/v1/messages"),
+ headers,
+ originalHeaders: new Headers(headers),
+ headerLog: JSON.stringify(Object.fromEntries(headers.entries())),
+ request: {
+ model: "deepseek-v4-pro",
+ log: "",
+ message: {
+ model: "deepseek-v4-pro",
+ thinking: { type: "disabled" },
+ output_config: { effort: "max" },
+ messages: [{ role: "user", content: [{ type: "text", text: "subagent task" }] }],
+ },
+ },
+ userAgent: null,
+ context: null,
+ clientAbortSignal: null,
+ userName: "test-user",
+ authState: { success: true, user: null, key: null, apiKey: null },
+ provider: null,
+ messageContext: { id: 123, createdAt: new Date(), user: { id: 1 }, key: {}, apiKey: "k" },
+ sessionId: null,
+ requestSequence: 1,
+ originalFormat: "claude",
+ providerType: null,
+ originalModelName: null,
+ originalUrlPathname: null,
+ providerChain: [],
+ cacheTtlResolved: null,
+ context1mApplied: false,
+ specialSettings: [],
+ cachedPriceData: undefined,
+ cachedBillingModelSource: undefined,
+ highConcurrencyModeEnabled: false,
+ isHeaderModified: () => false,
+ setHighConcurrencyModeEnabled(enabled: boolean) {
+ this.highConcurrencyModeEnabled = enabled;
+ },
+ shouldPersistSessionDebugArtifacts() {
+ return !this.highConcurrencyModeEnabled;
+ },
+ shouldTrackSessionObservability() {
+ return !this.highConcurrencyModeEnabled;
+ },
+ });
+
+ return session as any;
+}
+
+function createAnthropicProvider(): Provider {
+ return {
+ id: 1,
+ name: "deepseek-anthropic",
+ providerType: "claude",
+ url: "https://api.deepseek.com/anthropic/v1/messages",
+ key: "k",
+ preserveClientIp: false,
+ priority: 0,
+ } as unknown as Provider;
+}
+
+function okResponse(): Response {
+ const body = JSON.stringify({ type: "message", content: [{ type: "text", text: "ok" }] });
+ return new Response(body, {
+ status: 200,
+ headers: { "content-type": "application/json", "content-length": String(body.length) },
+ });
+}
+
+describe("ProxyForwarder - thinking effort conflict rectifier", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.getCachedSystemSettings.mockResolvedValue({
+ enableThinkingEffortConflictRectifier: true,
+ enableHighConcurrencyMode: false,
+ });
+ });
+
+ test("命中 DeepSeek thinking/reasoning_effort 冲突 400 时应剥离 effort 字段并对同供应商重试一次", async () => {
+ const session = createSession();
+ session.setProvider(createAnthropicProvider());
+
+ const doForward = vi.spyOn(ProxyForwarder as any, "doForward");
+
+ doForward.mockImplementationOnce(async () => {
+ throw new ProxyError(DEEPSEEK_CONFLICT_ERROR, 400, {
+ body: "",
+ providerId: 1,
+ providerName: "deepseek-anthropic",
+ });
+ });
+
+ doForward.mockImplementationOnce(async (s: ProxySession) => {
+ const msg = s.request.message as any;
+ expect("output_config" in msg).toBe(false);
+ expect("reasoning_effort" in msg).toBe(false);
+ expect(msg.thinking).toEqual({ type: "disabled" });
+ return okResponse();
+ });
+
+ const response = await ProxyForwarder.send(session);
+
+ expect(response.status).toBe(200);
+ expect(doForward).toHaveBeenCalledTimes(2);
+ expect(session.getProviderChain()?.length).toBeGreaterThanOrEqual(2);
+
+ const special = JSON.stringify(session.getSpecialSettings());
+ expect(special).toContain("thinking_effort_conflict_rectifier");
+ expect(special).not.toContain("thinking_signature_rectifier");
+ expect(mocks.updateMessageRequestDetails).toHaveBeenCalledTimes(1);
+ });
+
+ test("开关关闭时不整流也不重试", async () => {
+ mocks.getCachedSystemSettings.mockResolvedValue({
+ enableThinkingEffortConflictRectifier: false,
+ enableHighConcurrencyMode: false,
+ });
+
+ const session = createSession();
+ session.setProvider(createAnthropicProvider());
+
+ const doForward = vi.spyOn(ProxyForwarder as any, "doForward");
+ doForward.mockImplementation(async () => {
+ throw new ProxyError(DEEPSEEK_CONFLICT_ERROR, 400, {
+ body: "",
+ providerId: 1,
+ providerName: "deepseek-anthropic",
+ });
+ });
+
+ await expect(ProxyForwarder.send(session)).rejects.toThrow();
+
+ // 开关关闭：请求体不被整流（常规重试策略仍可能多次尝试，但都带原始字段）
+ const message = session.request.message as Record;
+ expect(message.output_config).toEqual({ effort: "max" });
+ expect(JSON.stringify(session.getSpecialSettings() ?? [])).not.toContain(
+ "thinking_effort_conflict_rectifier"
+ );
+ expect(doForward.mock.calls.length).toBeGreaterThanOrEqual(1);
+ });
+
+ test("请求体不含冲突字段时记录 not_applicable 且不重试", async () => {
+ const session = createSession();
+ const message = session.request.message as Record;
+ delete message.output_config;
+ (message.thinking as Record).type = "enabled";
+ session.setProvider(createAnthropicProvider());
+
+ const doForward = vi.spyOn(ProxyForwarder as any, "doForward");
+ doForward.mockImplementation(async () => {
+ throw new ProxyError(DEEPSEEK_CONFLICT_ERROR, 400, {
+ body: "",
+ providerId: 1,
+ providerName: "deepseek-anthropic",
+ });
+ });
+
+ await expect(ProxyForwarder.send(session)).rejects.toThrow();
+ expect(doForward).toHaveBeenCalledTimes(1);
+
+ const special = JSON.stringify(session.getSpecialSettings());
+ expect(special).toContain("thinking_effort_conflict_rectifier");
+ expect(special).toContain('"hit":false');
+ });
+
+ test("同一供应商最多整流重试一次（第二次命中不再重试）", async () => {
+ const session = createSession();
+ session.setProvider(createAnthropicProvider());
+
+ const doForward = vi.spyOn(ProxyForwarder as any, "doForward");
+ doForward.mockImplementation(async (s: ProxySession) => {
+ // 即使整流移除了 effort 字段，上游仍持续返回同样错误
+ void s;
+ throw new ProxyError(DEEPSEEK_CONFLICT_ERROR, 400, {
+ body: "",
+ providerId: 1,
+ providerName: "deepseek-anthropic",
+ });
+ });
+
+ await expect(ProxyForwarder.send(session)).rejects.toThrow();
+ expect(doForward).toHaveBeenCalledTimes(2);
+ });
+});
diff --git a/tests/unit/repository/system-config-update-missing-columns.test.ts b/tests/unit/repository/system-config-update-missing-columns.test.ts
index 20aaaa318..addafccb0 100644
--- a/tests/unit/repository/system-config-update-missing-columns.test.ts
+++ b/tests/unit/repository/system-config-update-missing-columns.test.ts
@@ -291,6 +291,63 @@ describe("SystemSettings：数据库缺列时的保存兜底", () => {
vi.useRealTimers();
});
+ test("getSystemSettings 在仅缺 enable_thinking_effort_conflict_rectifier 新列时应降级读取并默认开启", async () => {
+ vi.resetModules();
+
+ const now = new Date("2026-01-04T00:00:00.000Z");
+ vi.useFakeTimers();
+ vi.setSystemTime(now);
+
+ // 第一次 select(fullSelection) 因新列缺失而抛 42703；
+ // 第二次 select(selectionWithoutEffortConflict) 命中——验证新列已加入降级链最外层。
+ const selectMock = vi
+ .fn()
+ .mockReturnValueOnce(createRejectedThenableQuery({ code: "42703" }))
+ .mockReturnValueOnce(
+ createThenableQuery([
+ {
+ id: 1,
+ siteTitle: "Claude Code Hub",
+ allowGlobalUsageView: false,
+ currencyDisplay: "USD",
+ billingModelSource: "original",
+ codexPriorityBillingSource: "requested",
+ enableHttp2: true,
+ enableThinkingSignatureRectifier: true,
+ enableThinkingBudgetRectifier: true,
+ createdAt: now,
+ updatedAt: now,
+ },
+ ])
+ );
+
+ vi.doMock("@/drizzle/db", () => ({
+ db: {
+ select: selectMock,
+ update: vi.fn(() => createThenableQuery([])),
+ insert: vi.fn(() => createThenableQuery([])),
+ execute: vi.fn(async () => ({ count: 0 })),
+ },
+ }));
+
+ const { getSystemSettings } = await import("@/repository/system-config");
+
+ const result = await getSystemSettings();
+
+ // 降级读取成功（未抛错）。
+ expect(selectMock).toHaveBeenCalledTimes(2);
+ expect(result.siteTitle).toBe("Claude Code Hub");
+ expect(result.enableHttp2).toBe(true);
+
+ // 关键回归保护：第二次 select 必须恰好剥离了新列（最外层降级），
+ // 而非旧行为先剥离 billHedgeLosers。若新列未加入降级链最外层，下面两条断言会失败。
+ const secondSelection = selectMock.mock.calls[1]?.[0] as Record;
+ expect(secondSelection).not.toHaveProperty("enableThinkingEffortConflictRectifier");
+ expect(secondSelection).toHaveProperty("billHedgeLosers");
+
+ vi.useRealTimers();
+ });
+
test("getSystemSettings 在缺少新列且无记录时应使用降级插入初始化", async () => {
vi.resetModules();