feat(tui): cycle thinking effort with shift-tab

Author: elkaix

apps/pythinker-code/src/tui/constant/tips.ts

@@ -44,6 +44,6 @@ export const ALL_TIPS: readonly ToolbarTip[] = [
   { text: '/help: show commands' },
   { text: '/compact compresses context when it gets long', priority: 2 },
   { text: 'ctrl-o to hide or reveal tool output switching between a clean chat view and full execution details', priority: 2 },
-  { text: 'shift-tab to Plan mode to review the approach before Pythinker edits files.', priority: 2 },
+  { text: '/plan to review the approach before Pythinker edits files.', priority: 2 },
   { text: '/model: switch model', priority: 2 },
 ];

apps/pythinker-code/src/tui/controllers/editor-keyboard.ts

@@ -1,6 +1,11 @@
 import { readFile } from 'node:fs/promises';
 
-import type { FileMeta, PythinkerHarness, Session } from '@pymodel/pythinker-code-sdk';
+import type {
+  FileMeta,
+  PythinkerHarness,
+  Session,
+  ThinkingEffort,
+} from '@pymodel/pythinker-code-sdk';
 import { compressImageForModel } from '@pymodel/pythinker-code-sdk';
 
 import {
@@ -11,6 +16,7 @@ import {
 import { parseImageMeta } from '#/utils/image/image-mime';
 import { editInExternalEditor, resolveEditorCommand } from '#/utils/process/external-editor';
 
+import { segmentsFor } from '../components/dialogs/model-selector';
 import {
   CTRL_C_HINT,
   CTRL_D_HINT,
@@ -28,7 +34,13 @@ import type {
 } from '../utils/image-attachment-store';
 import { extractMediaAttachments, imageExtensionForMime } from '../utils/image-placeholder';
 import { extractInlineSkillActivations } from '../utils/inline-skill-tokens';
-import type { PendingExit, QueuedMessage, SteerInputItem } from '../types';
+import { thinkingEffortToConfig } from '../utils/thinking-config';
+import type {
+  AppState,
+  PendingExit,
+  QueuedMessage,
+  SteerInputItem,
+} from '../types';
 import type { TUIState } from '../tui-state';
 import type { BtwPanelController } from './btw-panel';
 
@@ -63,6 +75,8 @@ export interface EditorKeyboardHost {
   releaseStagingMedia(mediaAttachmentIds: readonly number[]): void;
   recallLastQueued(): QueuedMessage | undefined;
   showError(msg: string): void;
+  showNotice(title: string, detail?: string): void;
+  setAppState(patch: Partial<AppState>): void;
   track(event: string, props?: Record<string, unknown>): void;
   updateEditorBorderHighlight(text?: string): void;
   /** `undefined` means the input cannot be a `/goal` command (clear without measuring). */
@@ -76,7 +90,6 @@ export interface EditorKeyboardHost {
   openUndoSelector(): void;
   stop(exitCode?: number): Promise<void>;
   ensureSession(): Promise<Session | undefined>;
-  handlePlanToggle(next: boolean): void;
   handleInputModeChange(mode: 'prompt' | 'bash'): void;
   clearQueuedMessages(): void;
   setExternalEditorRunning(running: boolean): void;
@@ -256,25 +269,7 @@ export class EditorKeyboardController {
     };
 
     editor.onShiftTab = () => {
-      const togglePlan = (): void => {
-        const next = !host.state.appState.planMode;
-        host.track('shortcut_plan_toggle', { enabled: next });
-        host.track('shortcut_mode_switch', { to_mode: next ? 'plan' : 'agent' });
-        host.handlePlanToggle(next);
-      };
-      if (host.session === undefined) {
-        if (!host.engineV2) {
-          host.showError(NO_ACTIVE_SESSION_MESSAGE);
-          return;
-        }
-        // v2 session-less: lazy-create the session, then toggle — the same
-        // path /plan takes.
-        void host.ensureSession().then((session) => {
-          if (session !== undefined) togglePlan();
-        });
-        return;
-      }
-      togglePlan();
+      void this.cycleThinkingEffort();
     };
 
     editor.onInputModeChange = (mode) => {
@@ -532,6 +527,73 @@ export class EditorKeyboardController {
     void this.host.session?.cancel();
   }
 
+  /** Shift-Tab: cycle the thinking effort to the current model's next level (wraps). */
+  private async cycleThinkingEffort(): Promise<void> {
+    const { host } = this;
+    if (host.state.appState.streamingPhase !== 'idle' || host.state.appState.isCompacting) {
+      host.showError('Cannot change thinking effort while streaming — press Esc or Ctrl-C first.');
+      return;
+    }
+    const alias = host.state.appState.model;
+    if (alias.trim().length === 0) {
+      host.showError(LLM_NOT_SET_MESSAGE);
+      return;
+    }
+    const model = host.state.appState.availableModels[alias];
+    if (model === undefined) {
+      host.showError('No model selected. Run /model to select one first.');
+      return;
+    }
+    const levels = segmentsFor(model);
+    if (levels.length <= 1) {
+      host.showNotice(`${alias} does not offer selectable thinking effort levels.`);
+      return;
+    }
+    const prev = host.state.appState.thinkingEffort;
+    const currentIndex = levels.indexOf(prev);
+    // An out-of-list live effort (e.g. a provider-specific value) restarts the
+    // cycle from the off entry when offered, else from the first level.
+    const startIndex = currentIndex !== -1 ? currentIndex + 1 : Math.max(0, levels.indexOf('off'));
+    const next = levels[startIndex % levels.length] ?? levels[0]!;
+    if (host.session !== undefined) {
+      try {
+        await host.session.setThinking(next);
+      } catch (error) {
+        host.showError(`Failed to set thinking effort: ${formatErrorMessage(error)}`);
+        return;
+      }
+    } else if (!host.engineV2) {
+      host.showError(NO_ACTIVE_SESSION_MESSAGE);
+      return;
+    }
+    // v2 session-less: carry the choice into the first lazy-created session,
+    // the same way a session-only Alt+S choice is applied on creation.
+    const patch: Partial<AppState> = { thinkingEffort: next };
+    if (host.session === undefined) patch.lazySessionThinking = next;
+    host.setAppState(patch);
+    host.track('thinking_toggle', { enabled: next !== 'off', effort: next, from: prev });
+    // No transcript notice: the footer already shows the new level live, and
+    // rapid cycling would stack a line per keypress in the chat history.
+    await this.persistDefaultEffort(alias, model, next);
+  }
+
+  /** Best-effort persist of the cycled effort as the config default. */
+  private async persistDefaultEffort(
+    alias: string,
+    model: Parameters<typeof segmentsFor>[0],
+    effort: ThinkingEffort,
+  ): Promise<void> {
+    const harness = this.host.harness;
+    if (harness === undefined || alias !== this.host.state.appState.model) return;
+    try {
+      await harness.setConfig({ thinking: thinkingEffortToConfig(effort, model.supportEfforts) });
+    } catch (error) {
+      this.host.showError(
+        `Thinking effort set to ${effort}, but failed to save default: ${formatErrorMessage(error)}`,
+      );
+    }
+  }
+
   private cancelCurrentCompaction(): void {
     const session = this.host.session;
     if (session === undefined) return;

apps/pythinker-code/test/tui/controllers/editor-keyboard.test.ts

@@ -383,84 +383,180 @@ describe('EditorKeyboardController input changes', () => {
   });
 });
 
-describe('EditorKeyboardController Shift-Tab plan toggle', () => {
-  function createShiftTabHarness(options: { sessionless?: boolean; engineV2?: boolean } = {}) {
+describe('EditorKeyboardController Shift-Tab effort cycle', () => {
+  function createEffortHarness(
+    options: {
+      supportEfforts?: string[];
+      capabilities?: string[];
+      thinkingEffort?: string;
+      streamingPhase?: string;
+      sessionless?: boolean;
+      engineV2?: boolean;
+      setThinkingError?: Error;
+    } = {},
+  ) {
     const editor: Record<string, ((...args: never[]) => unknown) | undefined> = {
       setHistoryFilter: vi.fn() as unknown as (...args: never[]) => unknown,
     };
-    const handlePlanToggle = vi.fn();
+    const setThinking = vi.fn(async () => {});
+    if (options.setThinkingError !== undefined) {
+      setThinking.mockRejectedValue(options.setThinkingError);
+    }
+    const setConfig = vi.fn(async () => {});
     const track = vi.fn();
     const showError = vi.fn();
-    const ensureSession = vi.fn(async (): Promise<{ id: string } | undefined> => ({ id: 'ses-lazy' }));
+    const showNotice = vi.fn();
+    const appState: Record<string, unknown> = {
+      streamingPhase: options.streamingPhase ?? 'idle',
+      isCompacting: false,
+      model: 'kimi-k2',
+      thinkingEffort: options.thinkingEffort ?? 'off',
+      availableModels: {
+        'kimi-k2':
+          options.supportEfforts === undefined
+            ? {
+                provider: 'managed:pythinker-code',
+                model: 'kimi-k2',
+                maxContextSize: 262144,
+                capabilities: options.capabilities ?? ['thinking'],
+              }
+            : {
+                provider: 'managed:pythinker-code',
+                model: 'kimi-k2',
+                maxContextSize: 262144,
+                supportEfforts: options.supportEfforts,
+              },
+      },
+    };
+    const statePatches: Array<Record<string, unknown>> = [];
     const host = {
       state: {
         editor,
         activeDialog: null,
-        appState: { streamingPhase: 'idle', isCompacting: false, planMode: false },
+        appState,
         footer: { setTransientHint: vi.fn() },
         ui: { requestRender: vi.fn() },
       },
-      session: options.sessionless ? undefined : { cancel: vi.fn(async () => {}) },
+      session:
+        options.sessionless === true
+          ? undefined
+          : { cancel: vi.fn(async () => {}), setThinking },
       engineV2: options.engineV2 ?? false,
-      ensureSession,
-      handlePlanToggle,
+      harness: { setConfig },
+      // Merge like the real host so successive presses read fresh effort.
+      setAppState: (patch: Record<string, unknown>) => {
+        Object.assign(appState, patch);
+        statePatches.push(patch);
+      },
       track,
       showError,
+      showNotice,
       btwPanelController: { cancelRunning: vi.fn(), closeOrCancel: vi.fn() },
     } as unknown as EditorKeyboardHost;
 
     new EditorKeyboardController(host, undefined as unknown as ImageAttachmentStore).install();
     const onShiftTab = editor['onShiftTab'] as unknown as () => void;
-    return { onShiftTab, handlePlanToggle, track, showError, ensureSession };
+    return { onShiftTab, setThinking, setConfig, track, showError, showNotice, statePatches };
   }
 
-  it('toggles plan mode directly with an active session', () => {
-    const { onShiftTab, handlePlanToggle, ensureSession } = createShiftTabHarness();
+  async function settle(): Promise<void> {
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+  }
 
-    onShiftTab();
+  it('cycles off → low → high → max → off and persists the default', async () => {
+    const h = createEffortHarness({ supportEfforts: ['low', 'high', 'max'] });
+    const press = async (): Promise<unknown> => {
+      h.onShiftTab();
+      await settle();
+      return h.statePatches.at(-1)?.['thinkingEffort'];
+    };
 
-    expect(ensureSession).not.toHaveBeenCalled();
-    expect(handlePlanToggle).toHaveBeenCalledWith(true);
+    await expect(press()).resolves.toBe('low');
+    expect(h.setThinking).toHaveBeenCalledWith('low');
+    expect(h.setConfig).toHaveBeenCalledWith({ thinking: { enabled: true, effort: 'low' } });
+
+    await expect(press()).resolves.toBe('high');
+    await expect(press()).resolves.toBe('max');
+    // The top declared level never becomes the stored default effort.
+    expect(h.setConfig).toHaveBeenLastCalledWith({ thinking: { enabled: true } });
+
+    await expect(press()).resolves.toBe('off');
+    expect(h.setConfig).toHaveBeenLastCalledWith({ thinking: { enabled: false } });
+    expect(h.track).toHaveBeenLastCalledWith('thinking_toggle', {
+      enabled: false,
+      effort: 'off',
+      from: 'max',
+    });
   });
 
-  it('reports no active session on v1 when session-less', () => {
-    const { onShiftTab, showError, handlePlanToggle } = createShiftTabHarness({
-      sessionless: true,
+  it('refuses to cycle while a turn is streaming', async () => {
+    const h = createEffortHarness({
+      supportEfforts: ['low', 'high'],
+      streamingPhase: 'composing',
     });
 
-    onShiftTab();
+    h.onShiftTab();
+    await settle();
+
+    expect(h.showError).toHaveBeenCalledWith(
+      'Cannot change thinking effort while streaming — press Esc or Ctrl-C first.',
+    );
+    expect(h.setThinking).not.toHaveBeenCalled();
+  });
+
+  it('reports no active session on v1 when session-less', async () => {
+    const h = createEffortHarness({ supportEfforts: ['low', 'high'], sessionless: true });
+
+    h.onShiftTab();
+    await settle();
 
-    expect(showError).toHaveBeenCalledWith(NO_ACTIVE_SESSION_MESSAGE);
-    expect(handlePlanToggle).not.toHaveBeenCalled();
+    expect(h.showError).toHaveBeenCalledWith(NO_ACTIVE_SESSION_MESSAGE);
+    expect(h.statePatches).toEqual([]);
   });
 
-  it('lazy-creates the session before toggling on v2 when session-less', async () => {
-    const { onShiftTab, ensureSession, handlePlanToggle, track } = createShiftTabHarness({
+  it('carries the cycled effort into the lazy v2 session when session-less', async () => {
+    const h = createEffortHarness({
+      supportEfforts: ['low', 'high'],
       sessionless: true,
       engineV2: true,
     });
 
-    onShiftTab();
-    expect(handlePlanToggle).not.toHaveBeenCalled();
+    h.onShiftTab();
+    await settle();
 
-    await vi.waitFor(() => {
-      expect(handlePlanToggle).toHaveBeenCalledWith(true);
+    expect(h.setThinking).not.toHaveBeenCalled();
+    expect(h.statePatches.at(-1)).toMatchObject({
+      thinkingEffort: 'low',
+      lazySessionThinking: 'low',
     });
-    expect(ensureSession).toHaveBeenCalledOnce();
-    expect(track).toHaveBeenCalledWith('shortcut_plan_toggle', { enabled: true });
+    expect(h.showError).not.toHaveBeenCalled();
   });
 
-  it('does not toggle when the lazy creation fails on v2', async () => {
-    const { onShiftTab, ensureSession, handlePlanToggle } = createShiftTabHarness({
-      sessionless: true,
-      engineV2: true,
+  it('notifies when the model offers no selectable levels', async () => {
+    const h = createEffortHarness({ capabilities: ['always_thinking'] });
+
+    h.onShiftTab();
+    await settle();
+
+    expect(h.showNotice).toHaveBeenCalledWith(
+      'kimi-k2 does not offer selectable thinking effort levels.',
+    );
+    expect(h.setThinking).not.toHaveBeenCalled();
+  });
+
+  it('surfaces a setThinking failure without changing state', async () => {
+    const h = createEffortHarness({
+      supportEfforts: ['low', 'high'],
+      setThinkingError: new Error('boom'),
     });
-    ensureSession.mockResolvedValue(undefined);
 
-    onShiftTab();
-    await new Promise((resolve) => setImmediate(resolve));
+    h.onShiftTab();
+    await settle();
 
-    expect(handlePlanToggle).not.toHaveBeenCalled();
+    expect(h.showError).toHaveBeenCalledWith('Failed to set thinking effort: boom');
+    expect(h.statePatches).toEqual([]);
+    expect(h.setConfig).not.toHaveBeenCalled();
   });
 });