model-picker

1import type { EngineInterface, PluginOptions, Register } from 'claude-code'
2
3import { EFFORTS, MODELS } from './choices'
4
5/** What this mod last set or adopted, so a reload applies only a pick that changed. */
6type Applied = { model?: string; effort?: string }
7
8type Field = 'model' | 'effort'
9
10/** True while this mod sets the model or effort itself, so its own change is not adopted back. */
11let isApplyingModel = false
12let isApplyingEffort = false
13
14function message(error: unknown): string {
15  return error instanceof Error ? error.message : String(error)
16}
17
18/** The pick a model or effort spelling stands for, or undefined when none does. */
19export function toPick(field: Field, raw: string): string | undefined {
20  const value = raw.trim().toLowerCase()
21  if (field === 'effort') return EFFORTS.includes(value) ? value : undefined
22  if (MODELS.includes(value)) return value
23
24  // A full id or a variant (`claude-opus-5-5`, `opus[1m]`) counts as its family.
25  return MODELS.find(model => model !== 'default' && value.includes(model))
26}
27
28async function readApplied($: EngineInterface): Promise<Applied | undefined> {
29  const value = await $.store.get('applied')
30
31  return value !== null && typeof value === 'object' ? (value as Applied) : undefined
32}
33
34async function setOwnRow($: EngineInterface, field: Field, value: string): Promise<void> {
35  await $.config.set({ key: field === 'model' ? 'model-picker.model' : 'model-picker.effort', value })
36}
37
38/**
39 * The first load takes the session's model and effort as the picks, so
40 * installing the mod changes nothing.
41 */
42async function adoptSession($: EngineInterface, options: PluginOptions): Promise<void> {
43  const [model, effort] = await Promise.all([$.session.model(), $.env.get('CLAUDE_EFFORT')])
44  const applied: Applied = {
45    model: toPick('model', model) ?? String(options['model']),
46    effort: (effort === undefined ? undefined : toPick('effort', effort)) ?? String(options['effort']),
47  }
48  // Stored before the rows change: each change reloads this mod.
49  await $.store.set('applied', applied)
50  if (applied.model !== options['model']) await setOwnRow($, 'model', applied.model ?? '')
51  if (applied.effort !== options['effort']) await setOwnRow($, 'effort', applied.effort ?? '')
52}
53
54/**
55 * Sets the session's model and effort to the picks in `options`, each only
56 * when it differs from what this mod last set: a config change reloads the
57 * mod, and every load runs this again.
58 */
59async function applyPicks($: EngineInterface, options: PluginOptions, applied: Applied): Promise<void> {
60  const model = String(options['model'])
61  const effort = String(options['effort'])
62  const next: Applied = { ...applied }
63
64  if (model !== applied.model) {
65    isApplyingModel = true
66    const result = await $.config.set({ key: 'model', value: model }).finally(() => {
67      isApplyingModel = false
68    })
69    if (result.deny === undefined) {
70      next.model = model
71      $.ui.toast(`modelo → ${model}`)
72    } else {
73      $.ui.toast(`modelo: ${result.deny}`)
74    }
75  }
76
77  if (effort !== applied.effort) {
78    next.effort = effort
79    $.ui.toast(`effort → ${effort}`)
80    isApplyingEffort = true
81    // Queued until the session is idle; nothing here waits on it.
82    void $.command
83      .run({ command: 'effort', args: effort })
84      .catch(error => $.ui.toast(`effort: ${message(error)}`))
85      .finally(() => {
86        isApplyingEffort = false
87      })
88  }
89
90  await $.store.set('applied', next)
91}
92
93/**
94 * Takes a model or effort the person set elsewhere (/model, /effort, /config)
95 * as this mod's pick, so the mods pane shows what the session runs.
96 */
97async function adopt($: EngineInterface, options: PluginOptions, field: Field, raw: string): Promise<void> {
98  const pick = toPick(field, raw)
99  if (pick === undefined) return
100
101  const applied = (await readApplied($)) ?? {}
102  await $.store.set('applied', { ...applied, [field]: pick })
103  if (options[field] !== pick) await setOwnRow($, field, pick)
104}
105
106export const register: Register = (on, options) => {
107  const isEnabled = options['enabled'] !== false
108
109  on('session.start', async ($, e, next) => {
110    const started = await next(e)
111    if (!isEnabled) return started
112
113    // A pick never set or adopted yet (a first load, or a store from before
114    // every field had a pick) takes the session's own instead of changing it.
115    const applied = await readApplied($)
116    if (applied?.model === undefined || applied.effort === undefined) {
117      await adoptSession($, options)
118    } else {
119      await applyPicks($, options, applied)
120    }
121
122    return started
123  })
124
125  on('command.run', { command: 'model' }, async ($, e, next) => {
126    const ran = await next(e)
127    if (isEnabled && !isApplyingModel && e.args.trim() !== '') await adopt($, options, 'model', e.args)
128
129    return ran
130  }).catch(($, e, next) => next(e))
131
132  on('command.run', { command: 'effort' }, async ($, e, next) => {
133    const ran = await next(e)
134    if (isEnabled && !isApplyingEffort && e.args.trim() !== '') await adopt($, options, 'effort', e.args)
135
136    return ran
137  }).catch(($, e, next) => next(e))
138
139  on('config.set', { key: 'model' }, async ($, e, next) => {
140    const set = await next(e)
141    const isOwn = isApplyingModel || (e.origin?.kind === 'plugin' && e.origin.name === 'model-picker')
142    if (isEnabled && !isOwn && set.deny === undefined) await adopt($, options, 'model', String(set.value))
143
144    return set
145  }).catch(($, e, next) => next(e))
146}
147

1/** The `model` option's picks: the base models `/model` offers. */
2export const MODELS: readonly string[] = ['default', 'opus', 'sonnet', 'haiku', 'fable']
3
4/** The `effort` option's picks: the levels `/effort` takes. */
5export const EFFORTS: readonly string[] = ['low', 'medium', 'high', 'xhigh', 'max']
6