| /** | |
| * Build the unified `SessionConfigOption[]` surface advertised on | |
| * `session/new` + `session/load` + `session/resume` and refreshed by | |
| * `config_option_update`. | |
| * | |
| * The surface has up to three options: | |
| * - `id: 'model'` (`type: 'select'`, `category: 'model'`) — one row per | |
| * {@link AcpModelEntry}. Thinking is an orthogonal axis (separate toggle). | |
| * - `id: 'thinking'` (`type: 'select'`, `category: 'thought_level'`) — | |
| * appears ONLY when the currently-selected model's catalog row has | |
| * `thinkingSupported === true`; otherwise omitted so the client doesn't | |
| * render a non-actionable toggle. Encoded as a `select` for Zed | |
| * compatibility (its chip strip only renders `select` options; the spec's | |
| * `boolean` arm shows as "Unknown"). The entries adapt to the model's | |
| * declared capability: a model with `supportEfforts` offers `off` plus | |
| * every declared effort level; a boolean model keeps the plain | |
| * `off` / `on` pair. `always_thinking` models drop the `off` entry. | |
| * - `id: 'mode'` (`type: 'select'`, `category: 'mode'`) — the locked | |
| * 4-mode taxonomy ({@link ACP_MODES}). | |
| */ | |
| import type { SessionConfigOption, SessionConfigSelectOption } from '@agentclientprotocol/sdk'; | |
| import { ACP_MODES, type AcpModeId } from './modes'; | |
| import type { AcpModelEntry } from './model-catalog'; | |
| /** | |
| * Project the catalog into the `SessionConfigOption` `model` arm. One option | |
| * row per catalog entry. `currentValue` is the bare model id. | |
| */ | |
| export function buildModelOption( | |
| models: readonly AcpModelEntry[], | |
| currentBaseModelId: string, | |
| ): SessionConfigOption { | |
| const options: SessionConfigSelectOption[] = models.map((model) => ({ | |
| value: model.id, | |
| name: model.name, | |
| ...(model.description !== undefined ? { description: model.description } : {}), | |
| })); | |
| return { | |
| type: 'select', | |
| id: 'model', | |
| name: 'Model', | |
| category: 'model', | |
| currentValue: currentBaseModelId, | |
| options, | |
| }; | |
| } | |
| /** | |
| * Build the `thinking` select. Entries adapt to the model's declared | |
| * capability: with `supportEfforts` the select is `off` plus every declared | |
| * effort level; without them it stays the boolean `off` / `on` pair. | |
| * `alwaysThinking` models drop the `off` entry (thinking cannot be disabled — | |
| * ACP has no "disabled entry" concept). A `currentLevel` not present in the | |
| * entries (e.g. an engine-resolved effort the catalog didn't declare) is | |
| * appended so `currentValue` always stays selectable. | |
| */ | |
| export function buildThinkingOption( | |
| currentLevel: string, | |
| alwaysThinking = false, | |
| supportEfforts?: readonly string[], | |
| ): SessionConfigOption { | |
| const values = supportEfforts !== undefined ? ['off', ...supportEfforts] : ['off', 'on']; | |
| const options: SessionConfigSelectOption[] = values | |
| .filter((value) => !(alwaysThinking && value === 'off')) | |
| .map((value) => ({ value, name: thinkingOptionName(value) })); | |
| if (!options.some((option) => option.value === currentLevel)) { | |
| options.push({ value: currentLevel, name: thinkingOptionName(currentLevel) }); | |
| } | |
| return { | |
| type: 'select', | |
| id: 'thinking', | |
| name: 'Thinking', | |
| category: 'thought_level', | |
| currentValue: currentLevel, | |
| options, | |
| }; | |
| } | |
| /** Display name for a thinking select entry (`off` → `Thinking Off`). */ | |
| function thinkingOptionName(value: string): string { | |
| return `Thinking ${value.charAt(0).toUpperCase()}${value.slice(1)}`; | |
| } | |
| /** | |
| * Project the locked 4-mode taxonomy ({@link ACP_MODES}) into the | |
| * `SessionConfigOption` `mode` arm. Order is preserved (default → plan → auto → | |
| * yolo). | |
| */ | |
| export function buildModeOption(currentModeId: AcpModeId): SessionConfigOption { | |
| const options: SessionConfigSelectOption[] = ACP_MODES.map((mode) => ({ | |
| value: mode.id, | |
| name: mode.name, | |
| description: mode.description, | |
| })); | |
| return { | |
| type: 'select', | |
| id: 'mode', | |
| name: 'Mode', | |
| category: 'mode', | |
| currentValue: currentModeId, | |
| options, | |
| }; | |
| } | |
| /** | |
| * Compose the `SessionConfigOption[]` surface — | |
| * `[modelOption, …(thinkingOption?), modeOption]`. Order is part of the | |
| * contract: ACP clients render options top-to-bottom, model on top of mode. | |
| * | |
| * The thinking toggle only appears when the currently-selected base model is | |
| * `thinkingSupported`; otherwise the snapshot is just `[modelOption, modeOption]`. | |
| * | |
| * Returns a mutable `SessionConfigOption[]` (rather than `readonly`) so the | |
| * value is assignable to the SDK's `NewSessionResponse.configOptions` field, | |
| * which is typed `Array<SessionConfigOption>`. | |
| */ | |
| export function buildSessionConfigOptions( | |
| models: readonly AcpModelEntry[], | |
| currentBaseModelId: string, | |
| currentThinkingLevel: string, | |
| currentModeId: AcpModeId, | |
| ): SessionConfigOption[] { | |
| 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) { | |
| // Always-thinking models render locked-on regardless of the session's | |
| // recorded level — the runtime clamps the same way. | |
| const level = alwaysThinking && currentThinkingLevel === 'off' ? 'on' : currentThinkingLevel; | |
| out.push(buildThinkingOption(level, alwaysThinking, currentModelEntry?.supportEfforts)); | |
| } | |
| out.push(buildModeOption(currentModeId)); | |
| return out; | |
| } | |