fix(thinking): keep explicit session thinkingLevel when runtime downgrades (#87740)

hoobnn · hoobnn · commit fbfbeee4bee2 · 2026-05-29T14:33:02.000+08:00
When a session's stored thinkingLevel is unsupported by the active model, the runtime fell back to a supported level for the turn AND wrote that fallback back onto the persisted session override. Because the persistence condition fired exactly when the stored value was the explicit override, the user's explicit choice (e.g. "high") was permanently reset to the supported level (e.g. "off") after every turn — re-setting it just got clobbered again next turn. Downgrade only the level used for the current turn; never persist the support fallback onto the stored override. The explicit override is the user's intent and must survive turns (so it re-applies if a supporting model is used later). Both the reply path (get-reply-run) and the agent-command path carried the same duplicated write-back; both are fixed. Reported by @TitanBob2026.
diff --git a/src/agents/agent-command.live-model-switch.test.ts b/src/agents/agent-command.live-model-switch.test.ts
@@ -40,6 +40,7 @@ const state = vi.hoisted(() => ({
   persistSessionEntryMock: vi.fn(async (..._args: unknown[]): Promise<unknown> => undefined),
   clearSessionAuthProfileOverrideMock: vi.fn(),
   isThinkingLevelSupportedMock: vi.fn((_args: unknown) => true),
+  resolveSupportedThinkingLevelMock: vi.fn((args: { level?: string }) => args.level),
   resolveThinkingDefaultMock: vi.fn((_args: unknown) => "low"),
   loadManifestModelCatalogMock: vi.fn(() => []),
   buildWorkspaceSkillSnapshotMock: vi.fn((..._args: unknown[]): unknown => ({
@@ -54,6 +55,7 @@ const state = vi.hoisted(() => ({
   sessionEntryMock: undefined as unknown,
   sessionStoreMock: undefined as unknown,
   storePathMock: undefined as string | undefined,
+  persistedThinkingMock: undefined as string | undefined,
 }));
 
 vi.mock("./model-fallback.js", () => ({
@@ -120,7 +122,7 @@ vi.mock("./command/session.js", () => ({
     sessionStore: state.sessionStoreMock,
     storePath: state.storePathMock,
     isNewSession: false,
-    persistedThinking: undefined,
+    persistedThinking: state.persistedThinkingMock,
     persistedVerbose: undefined,
   }),
 }));
@@ -154,7 +156,8 @@ vi.mock("../auto-reply/thinking.js", () => ({
   normalizeThinkLevel: (v?: string) => v || undefined,
   normalizeVerboseLevel: (v?: string) => v || undefined,
   isThinkingLevelSupported: (args: unknown) => state.isThinkingLevelSupportedMock(args),
-  resolveSupportedThinkingLevel: ({ level }: { level?: string }) => level,
+  resolveSupportedThinkingLevel: (args: { level?: string }) =>
+    state.resolveSupportedThinkingLevelMock(args),
   supportsXHighThinking: () => false,
 }));
 
@@ -771,6 +774,8 @@ describe("agentCommand – LiveSessionModelSwitchError retry", () => {
     state.resolveAcpExplicitTurnPolicyErrorMock.mockReturnValue(null);
     state.runtimeConfigMock = undefined;
     state.isThinkingLevelSupportedMock.mockReturnValue(true);
+    state.resolveSupportedThinkingLevelMock.mockImplementation((args) => args.level);
+    state.persistedThinkingMock = undefined;
     state.resolveThinkingDefaultMock.mockReturnValue("low");
     state.resolveAgentSkillsFilterMock.mockReturnValue(undefined);
     state.loadManifestModelCatalogMock.mockReturnValue([]);
@@ -942,6 +947,37 @@ describe("agentCommand – LiveSessionModelSwitchError retry", () => {
     expect(state.updateSessionStoreAfterAgentRunMock).toHaveBeenCalledTimes(1);
   });
 
+  it("preserves an explicit session thinkingLevel override when the level is unsupported", async () => {
+    setupSingleAttemptFallback();
+    state.runAgentAttemptMock.mockResolvedValue(makeSuccessResult("openai", "gpt-5.4"));
+    const sessionEntry: SessionEntry = {
+      sessionId: "session-1",
+      updatedAt: 1,
+      thinkingLevel: "high",
+      skillsSnapshot: { prompt: "", skills: [], version: 0 },
+    };
+    state.sessionEntryMock = sessionEntry;
+    state.sessionStoreMock = { "agent:main:main": sessionEntry };
+    state.storePathMock = "/tmp/openclaw-sessions.json";
+    state.persistedThinkingMock = "high";
+    // The model rejects the stored level, so the turn downgrades at runtime.
+    state.isThinkingLevelSupportedMock.mockReturnValue(false);
+    state.resolveSupportedThinkingLevelMock.mockReturnValue("off");
+
+    await agentCommand({
+      message: "hello",
+      to: "+1234567890",
+    });
+
+    // Runtime downgrade is per-turn; it must not persist the fallback level back
+    // onto the user's explicit stored override.
+    const downgradeWrite = state.persistSessionEntryMock.mock.calls.find((call) => {
+      const entry = (call[0] as { entry?: { thinkingLevel?: string } } | undefined)?.entry;
+      return entry?.thinkingLevel === "off";
+    });
+    expect(downgradeWrite).toBeUndefined();
+  });
+
   it("clears stale flag-only pending final delivery when there is no final payload", async () => {
     setupSingleAttemptFallback();
     state.runAgentAttemptMock.mockResolvedValue(makeEmptyResult("openai", "gpt-5.4"));
diff --git a/src/agents/agent-command.ts b/src/agents/agent-command.ts
@@ -1197,27 +1197,10 @@ async function agentCommandInternal(
         level: resolvedThinkLevel,
         catalog: thinkingCatalog,
       });
-      if (fallbackThinkLevel !== resolvedThinkLevel) {
-        const previousThinkLevel = resolvedThinkLevel;
-        resolvedThinkLevel = fallbackThinkLevel;
-        if (
-          sessionEntry &&
-          sessionStore &&
-          sessionKey &&
-          sessionEntry.thinkingLevel === previousThinkLevel &&
-          !suppressVisibleSessionEffects
-        ) {
-          const entry = sessionEntry;
-          entry.thinkingLevel = fallbackThinkLevel;
-          entry.updatedAt = Date.now();
-          await persistSessionEntry({
-            sessionStore,
-            sessionKey,
-            storePath,
-            entry,
-          });
-        }
-      }
+      // Downgrade only the level used for this turn. The explicit session
+      // override is the user's stored intent; persisting the fallback here would
+      // permanently reset it to the supported level on every turn (#87740).
+      resolvedThinkLevel = fallbackThinkLevel;
     }
     const { resolveSessionTranscriptFile } = await loadTranscriptResolveRuntime();
     let sessionFile: string | undefined;
diff --git a/src/auto-reply/reply/get-reply-run.ts b/src/auto-reply/reply/get-reply-run.ts
@@ -311,9 +311,6 @@ const agentRunnerRuntimeLoader = createLazyImportLoader(() => import("./agent-ru
 const sessionUpdatesRuntimeLoader = createLazyImportLoader(
   () => import("./session-updates.runtime.js"),
 );
-const sessionStoreRuntimeLoader = createLazyImportLoader(
-  () => import("../../config/sessions/store.runtime.js"),
-);
 
 function loadEmbeddedAgentRuntime() {
   return embeddedAgentRuntimeLoader.load();
@@ -327,10 +324,6 @@ function loadSessionUpdatesRuntime() {
   return sessionUpdatesRuntimeLoader.load();
 }
 
-function loadSessionStoreRuntime() {
-  return sessionStoreRuntimeLoader.load();
-}
-
 function stripPromptThinkingDirectives(body: string): string {
   return body
     .split("\n")
@@ -880,26 +873,10 @@ export async function runPreparedReply(
       level: resolvedThinkLevel,
       catalog: thinkingCatalog,
     });
-    if (fallbackThinkLevel !== resolvedThinkLevel) {
-      const previousThinkLevel = resolvedThinkLevel;
-      resolvedThinkLevel = fallbackThinkLevel;
-      if (
-        sessionEntry &&
-        sessionStore &&
-        sessionKey &&
-        sessionEntry.thinkingLevel === previousThinkLevel
-      ) {
-        sessionEntry.thinkingLevel = fallbackThinkLevel;
-        sessionEntry.updatedAt = Date.now();
-        sessionStore[sessionKey] = sessionEntry;
-        if (storePath) {
-          const { updateSessionStore } = await loadSessionStoreRuntime();
-          await updateSessionStore(storePath, (store) => {
-            store[sessionKey] = sessionEntry;
-          });
-        }
-      }
-    }
+    // Downgrade only the level used for this turn. The explicit session override
+    // is the user's stored intent; persisting the fallback here would permanently
+    // reset it to the supported level on every turn (#87740).
+    resolvedThinkLevel = fallbackThinkLevel;
   }
   const internalOpts = opts as InternalGetReplyOptions | undefined;
   const providedReplyOperation = internalOpts?.replyOperation;
