feat: support always-thinking models via supports_thinking_type (#662)

Map the /models three-state supports_thinking_type field ('only' /
'no' / 'both', taking precedence over the legacy supports_reasoning
boolean) onto the existing always_thinking capability:

- oauth: parse the field in both /models parsers; 'only' emits
  always_thinking alongside thinking, 'no' suppresses thinking even
  when supports_reasoning is set, absent falls back to the legacy
  boolean. Default thinking selection is forced on for 'only' (and
  off for 'no') models during login and provider refresh
- TUI: render the thinking control with a fixed On/Off layout — locked
  models show a greyed-out "Off (Unsupported)" segment, and
  non-thinking models mirror the style with "On (Unsupported)"
- agent-core: clamp thinkingLevel at the getter so a stale
  thinking-off config can never reach the request builder, status
  events, or subagent inheritance
- acp-adapter: derive alwaysThinking from capabilities, collapse the
  thinking select to a single locked "on" entry, and ignore off
  requests for locked models while re-emitting the snapshot

Author: liruifengv

apps/kimi-code/src/tui/components/dialogs/model-selector.ts

@@ -259,13 +259,19 @@ export class ModelSelectorComponent extends Container implements Focusable {
       active
         ? currentTheme.boldFg('primary', `[ ${label} ]`)
         : currentTheme.fg('text', `  ${label}  `);
+    // The whole segment is muted, suffix included, so the disabled side reads
+    // as a single greyed-out control rather than a selectable option.
+    const unavailable = (label: string): string =>
+      currentTheme.fg('textMuted', `  ${label} (Unsupported)  `);
 
+    // On stays left and Off right in all three states so the control never
+    // shifts while the cursor moves across models.
     const availability = thinkingAvailability(choice.model);
     if (availability === 'always-on') {
-      return `  ${segment('Always on', true)}`;
+      return `  ${segment('On', true)} ${unavailable('Off')}`;
     }
     if (availability === 'unsupported') {
-      return `  ${segment('Off', true)} ${currentTheme.fg('textMuted', 'unsupported')}`;
+      return `  ${unavailable('On')} ${segment('Off', true)}`;
     }
     const draft = this.draftFor(choice);
     return `  ${segment('On', draft)}  ${segment('Off', !draft)}`;

apps/kimi-code/src/tui/utils/refresh-providers.ts

@@ -182,7 +182,10 @@ function restoreDefaultSelection(
 ): void {
   if (defaultModel === undefined || config.models?.[defaultModel] === undefined) return;
   config.defaultModel = defaultModel;
-  config.defaultThinking = defaultThinking;
+  // A refresh may have just learned that the default model cannot disable
+  // thinking — never restore a stale thinking-off selection onto it.
+  const capabilities = config.models[defaultModel]?.capabilities ?? [];
+  config.defaultThinking = capabilities.includes('always_thinking') ? true : defaultThinking;
 }
 
 // `apply*` may leave `defaultModel` pointing at an alias that no longer exists

apps/kimi-code/test/tui/components/dialogs/model-selector.test.ts

@@ -3,6 +3,7 @@ import { visibleWidth } from '@earendil-works/pi-tui';
 import { describe, expect, it, vi } from 'vitest';
 
 import { ModelSelectorComponent } from '#/tui/components/dialogs/model-selector';
+import { currentTheme } from '#/tui/theme';
 import { darkColors } from '#/tui/theme/colors';
 
 const ANSI = /\[[0-9;]*m/g;
@@ -94,16 +95,60 @@ describe('ModelSelectorComponent', () => {
       onCancel: vi.fn(),
     });
 
-    expect(text(picker)).toContain('[ Always on ]');
+    // Always-on: On selected, Off greyed out with an explanation.
+    const alwaysOut = text(picker);
+    expect(alwaysOut).toContain('[ On ]');
+    expect(alwaysOut).toContain('Off (Unsupported)');
+    expect(alwaysOut).not.toContain('Always on');
     picker.handleInput('\r');
     expect(onSelect).toHaveBeenLastCalledWith({ alias: 'always', thinking: true });
 
+    // Unsupported: Off selected, On greyed out — same style, mirrored.
     picker.handleInput(DOWN);
-    expect(text(picker)).toContain('[ Off ] unsupported');
+    const plainOut = text(picker);
+    expect(plainOut).toContain('On (Unsupported)');
+    expect(plainOut).toContain('[ Off ]');
+    expect(plainOut).not.toContain('] unsupported');
     picker.handleInput('\r');
     expect(onSelect).toHaveBeenLastCalledWith({ alias: 'plain', thinking: false });
   });
 
+  it('ignores Left/Right on always-on and unsupported models', () => {
+    const onSelect = vi.fn();
+    const picker = new ModelSelectorComponent({
+      models: {
+        always: model('Kimi Thinking', ['always_thinking']),
+        plain: model('Kimi Plain', ['tool_use']),
+      },
+      currentValue: 'always',
+      currentThinking: true,
+      onSelect,
+      onCancel: vi.fn(),
+    });
+
+    picker.handleInput(RIGHT);
+    picker.handleInput('\r');
+    expect(onSelect).toHaveBeenLastCalledWith({ alias: 'always', thinking: true });
+
+    picker.handleInput(DOWN);
+    picker.handleInput(LEFT);
+    picker.handleInput('\r');
+    expect(onSelect).toHaveBeenLastCalledWith({ alias: 'plain', thinking: false });
+  });
+
+  it('renders the unavailable thinking segment muted', () => {
+    const picker = new ModelSelectorComponent({
+      models: { always: model('Kimi Thinking', ['always_thinking']) },
+      currentValue: 'always',
+      currentThinking: true,
+      onSelect: vi.fn(),
+      onCancel: vi.fn(),
+    });
+
+    const raw = picker.render(120).join('\n');
+    expect(raw).toContain(currentTheme.fg('textMuted', '  Off (Unsupported)  '));
+  });
+
   it('keeps the thinking draft when moving across models', () => {
     const onSelect = vi.fn();
     const picker = new ModelSelectorComponent({

apps/kimi-code/test/tui/utils/refresh-providers.test.ts

@@ -342,4 +342,61 @@ describe('refreshAllProviderModels', () => {
     expect(host.current().defaultModel).toBe(userAlias);
     expect(host.current().defaultThinking).toBe(false);
   });
+
+  it('forces default thinking on when the refreshed default model cannot disable thinking', async () => {
+    const host = makeRefreshHost({
+      providers: {
+        [KIMI_CODE_PROVIDER_NAME]: {
+          type: 'kimi',
+          apiKey: '',
+          oauth: { storage: 'file', key: 'oauth/kimi-code' },
+        },
+      },
+      models: {
+        'kimi-code/kimi-deep-coder': {
+          provider: KIMI_CODE_PROVIDER_NAME,
+          model: 'kimi-deep-coder',
+          maxContextSize: 262144,
+          capabilities: ['thinking', 'tool_use'],
+        },
+      },
+      defaultModel: 'kimi-code/kimi-deep-coder',
+      defaultThinking: false,
+      telemetry: true,
+    } as unknown as KimiConfig);
+
+    const fetchMock = vi.fn<FetchMock>(
+      async () =>
+        new Response(
+          JSON.stringify({
+            data: [
+              {
+                id: 'kimi-deep-coder',
+                context_length: 262144,
+                supports_reasoning: true,
+                supports_thinking_type: 'only',
+              },
+            ],
+          }),
+          { status: 200, headers: { 'Content-Type': 'application/json' } },
+        ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+
+    const result = await refreshAllProviderModels({
+      getConfig: async () => host.current(),
+      removeProvider: host.removeProvider,
+      setConfig: host.setConfig,
+      resolveOAuthToken: vi.fn(async () => 'oauth-access-token'),
+    });
+
+    expect(result.failed).toEqual([]);
+    expect(host.current().models?.['kimi-code/kimi-deep-coder']?.capabilities).toEqual([
+      'thinking',
+      'always_thinking',
+      'tool_use',
+    ]);
+    expect(host.current().defaultModel).toBe('kimi-code/kimi-deep-coder');
+    expect(host.current().defaultThinking).toBe(true);
+  });
 });

packages/acp-adapter/src/config-options.ts

@@ -96,8 +96,28 @@ export function buildModelOption(
  * currently-selected model has `thinkingSupported === false`, the
  * snapshot omits it entirely (dynamic visibility), so the client never
  * shows a toggle that wouldn't do anything.
+ *
+ * `alwaysThinking` models (declared `always_thinking` capability — the
+ * runtime cannot disable thinking) collapse the select to a single
+ * locked `on` entry: the state stays visible to the client, but there
+ * is no off option to pick. ACP has no "disabled entry" concept, so
+ * omitting `off` is the wire-level equivalent of the TUI's greyed-out
+ * `Off (Unsupported)` segment.
  */
-export function buildThinkingOption(enabled: boolean): SessionConfigOption {
+export function buildThinkingOption(
+  enabled: boolean,
+  alwaysThinking = false,
+): SessionConfigOption {
+  if (alwaysThinking) {
+    return {
+      type: 'select',
+      id: 'thinking',
+      name: 'Thinking',
+      category: 'thought_level',
+      currentValue: 'on',
+      options: [{ value: 'on', name: 'Thinking On' }],
+    };
+  }
   return {
     type: 'select',
     id: 'thinking',
@@ -171,9 +191,12 @@ export async function buildSessionConfigOptions(
   const models = await listModelsFromHarness(harness);
   const currentModelEntry = models.find((m) => m.id === currentBaseModelId);
   const showThinking = currentModelEntry?.thinkingSupported === true;
+  const alwaysThinking = currentModelEntry?.alwaysThinking === true;
   const out: SessionConfigOption[] = [buildModelOption(models, currentBaseModelId)];
   if (showThinking) {
-    out.push(buildThinkingOption(currentThinkingEnabled));
+    // Always-thinking models render locked-on regardless of the session's
+    // recorded toggle state — agent-core clamps the runtime the same way.
+    out.push(buildThinkingOption(alwaysThinking || currentThinkingEnabled, alwaysThinking));
   }
   out.push(buildModeOption(currentModeId));
   return out;

packages/acp-adapter/src/model-catalog.ts

@@ -35,6 +35,8 @@ export interface AcpModelEntry {
   readonly name: string;
   readonly description?: string | undefined;
   readonly thinkingSupported: boolean;
+  /** Declared 'always_thinking' capability — thinking cannot be turned off. */
+  readonly alwaysThinking?: boolean;
 }
 
 /**
@@ -47,13 +49,24 @@ const TOGGLEABLE_THINKING_MODELS = new Set(['kimi-for-coding', 'kimi-code']);
 
 export function deriveThinkingSupported(alias: ModelAlias): boolean {
   const declared = alias.capabilities ?? [];
-  if (declared.includes('thinking')) return true;
+  if (declared.includes('thinking') || declared.includes('always_thinking')) return true;
   const lower = alias.model.toLowerCase();
   if (lower.includes('thinking') || lower.includes('reason')) return true;
   if (TOGGLEABLE_THINKING_MODELS.has(alias.model)) return true;
   return false;
 }
 
+/**
+ * Whether the alias declares the 'always_thinking' capability — the model
+ * cannot run with thinking disabled, so the ACP toggle must lock to on.
+ * Deliberately capability-only: the name heuristics above keep feeding
+ * `thinkingSupported`, but only an explicit (server-derived) declaration
+ * may remove the off option from the client.
+ */
+export function deriveAlwaysThinking(alias: ModelAlias): boolean {
+  return (alias.capabilities ?? []).includes('always_thinking');
+}
+
 /**
  * Project `harness.getConfig().models` into a flat catalog. Returns an
  * empty array when the harness has no models configured, when
@@ -80,6 +93,7 @@ export async function listModelsFromHarness(
       id,
       name: alias.displayName ?? alias.model ?? id,
       thinkingSupported: deriveThinkingSupported(alias),
+      alwaysThinking: deriveAlwaysThinking(alias),
     });
   }
   return out;

packages/acp-adapter/src/session.ts

@@ -37,6 +37,7 @@ import {
   type AcpBuiltinSlashCommandName,
 } from './builtin-commands';
 import { buildSessionConfigOptions } from './config-options';
+import { listModelsFromHarness } from './model-catalog';
 import { acpBlocksToPromptParts } from './convert';
 import {
   acpToolCallId,
@@ -365,13 +366,33 @@ export class AcpSession {
    * carries a fresh snapshot.
    */
   async setThinking(enabled: boolean): Promise<void> {
+    if (!enabled && (await this.currentModelAlwaysThinking())) {
+      // The current model cannot disable thinking (declared
+      // 'always_thinking'); silently ignore the off request — agent-core
+      // clamps the runtime the same way — but still refresh the snapshot
+      // so a stale client toggle snaps back to on.
+      this.currentThinkingEnabledInternal = true;
+      await this.emitConfigOptionUpdate();
+      return;
+    }
     if (typeof this.session.setThinking === 'function') {
       await this.session.setThinking(enabled ? THINKING_ON_LEVEL : THINKING_OFF_LEVEL);
     }
     this.currentThinkingEnabledInternal = enabled;
     await this.emitConfigOptionUpdate();
   }
 
+  /**
+   * Whether the currently-selected model declares 'always_thinking'.
+   * Harness-less adapter unit tests resolve to false — the agent-core
+   * runtime clamp still protects the actual request in that case.
+   */
+  private async currentModelAlwaysThinking(): Promise<boolean> {
+    if (!this.harness) return false;
+    const models = await listModelsFromHarness(this.harness);
+    return models.find((m) => m.id === this.currentModelIdInternal)?.alwaysThinking === true;
+  }
+
   /**
    * Forward an ACP `session/set_mode` request to the underlying SDK
    * session.

packages/acp-adapter/test/_helpers/harness-stubs.ts

@@ -29,18 +29,28 @@ export const UNAUTHED_STATUS = {
  * mirrors what a real config file would carry.
  */
 export function makeModelsMap(
-  entries: ReadonlyArray<{ id: string; name?: string; thinkingSupported?: boolean }>,
+  entries: ReadonlyArray<{
+    id: string;
+    name?: string;
+    thinkingSupported?: boolean;
+    alwaysThinking?: boolean;
+  }>,
 ): Record<string, ModelAlias> {
   const out: Record<string, ModelAlias> = {};
   for (const entry of entries) {
+    const capabilities = entry.alwaysThinking === true
+      ? ['thinking', 'always_thinking']
+      : entry.thinkingSupported === true
+        ? ['thinking']
+        : undefined;
     out[entry.id] = {
       // The fields below are the minimum shape the adapter reads off
       // each alias — `provider`/`max_context_size` are required by the
       // schema but unused by the model catalog, so they're skipped
       // here and the partial-record cast keeps the test stub honest.
       model: entry.id,
       ...(entry.name !== undefined ? { displayName: entry.name } : {}),
-      ...(entry.thinkingSupported === true ? { capabilities: ['thinking'] } : {}),
+      ...(capabilities !== undefined ? { capabilities } : {}),
     } as ModelAlias;
   }
   return out;

packages/acp-adapter/test/config-options.test.ts

@@ -94,6 +94,14 @@ describe('buildThinkingOption', () => {
     if (off.type !== 'select') throw new Error('expected SessionConfigSelect');
     expect(off.currentValue).toBe('off');
   });
+
+  it('collapses to a single locked "on" entry for always-thinking models', () => {
+    const locked = buildThinkingOption(true, true);
+    if (locked.type !== 'select') throw new Error('expected SessionConfigSelect');
+    expect(locked.currentValue).toBe('on');
+    expect(locked.options.map((o) => ('value' in o ? o.value : ''))).toEqual(['on']);
+    expect(locked.options.map((o) => ('name' in o ? o.name : ''))).toEqual(['Thinking On']);
+  });
 });
 
 describe('buildModeOption', () => {
@@ -171,6 +179,24 @@ describe('buildSessionConfigOptions', () => {
     expect(toggle.currentValue).toBe('on');
   });
 
+  it('locks the thinking toggle to on for always-thinking models even when the session state says off', async () => {
+    const { harness } = makeHarnessWithModels([
+      {
+        id: 'kimi-deep',
+        model: 'kimi-deep-coder',
+        displayName: 'Kimi Deep',
+        capabilities: ['thinking', 'always_thinking'],
+      },
+    ]);
+
+    const result = await buildSessionConfigOptions(harness, 'kimi-deep', false, 'default');
+
+    const toggle = result.find((o) => o.id === 'thinking');
+    if (!toggle || toggle.type !== 'select') throw new Error('expected thinking select toggle');
+    expect(toggle.currentValue).toBe('on');
+    expect(toggle.options.map((o) => ('value' in o ? o.value : ''))).toEqual(['on']);
+  });
+
   it('omits the thinking toggle when the current base model id is not in the catalog (defensive)', async () => {
     const { harness } = makeHarnessWithModels([
       { id: 'kimi-coder', model: 'kimi-for-coding', displayName: 'Kimi Coder' },