claude

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281// Config options (the Rust `options.rs`). The model list and each model's
// effort levels come from `models.json`; the slash commands and which
// toggles exist at all come from the CLI's `initialize` control response.
import * as wire from "./wire.ts";
import type { ConfigOption, ConfigChoice, SlashCommand, Values } from "./types.ts";
import { permissionMode } from "../sdk/agent.ts";
import { manifest as loadManifest, modelMatches, modelValue } from "./models.ts";

export const MODEL = "model";
export const EFFORT = "effort";
export const PERMISSION_MODE = permissionMode.OPTION_ID;
export const THINKING = "thinking";
export const FAST_MODE = "fast_mode";
/// The value that means "leave this to Claude Code", so no flag is passed.
export const DEFAULT = "default";
/// The effort level above `xhigh`: `xhigh` plus standing dynamic-workflow
/// orchestration. The CLI takes it as `--effort ultracode` and as the
/// session setting `ultracode`; it needs a model that offers `xhigh`.
export const ULTRACODE = "ultracode";
/// The effort level ultracode runs at, and needs.
const XHIGH = "xhigh";
/// The mark of the ultracode choice: the `workflow` icon.
const ULTRACODE_ICON =
  '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="8" height="8" x="3" y="3" rx="2"/><path d="M7 11v4a2 2 0 0 0 2 2h4"/><rect width="8" height="8" x="13" y="13" rx="2"/></svg>';

/// The `--permission-mode` value for one of the four shared modes. Claude
/// has its own reviewer, so `auto` is a real mode. The mode is always
/// sent: the composer shows a mode, and it must be the one in force.
export function permissionFlag(mode: string) {
  switch (mode) {
    case permissionMode.AUTO_EDITS:
      return "acceptEdits";
    case permissionMode.AUTO:
      return "auto";
    case permissionMode.FULL:
      return "bypassPermissions";
    default:
      return "default";
  }
}

/// Why fast mode cannot serve, in words the user can act on. The reasons
/// the toggle itself clears, and the ones that pass on their own, give
/// nothing: "unavailable" next to the switch that turns it on is wrong.
export function fastModeNote(reason: string) {
  switch (reason) {
    case "not_first_party":
      return "Only an Anthropic account can use fast mode.";
    case "model_not_allowed":
      return "Your organization does not allow fast mode for this model.";
    case "free":
    case "extra_usage_disabled":
      return "Fast mode needs usage credits.";
    case "network_error":
      return "Fast mode could not be reached.";
    case "disabled_by_env":
      return "Fast mode is switched off on this machine.";
    default:
      return null;
  }
}

const EFFORT_NAMES: Record<string, string> = {
  low: "Low",
  medium: "Medium",
  high: "High",
  xhigh: "Extra high",
  max: "Max",
};

export function effortChoice(level: string): ConfigChoice {
  if (level === ULTRACODE) {
    return {
      value: ULTRACODE,
      name: "Ultracode",
      description: "Extra high effort, and Claude plans dynamic workflows: many agents in parallel.",
      icon: ULTRACODE_ICON,
      // The CLI never persists it either: every workflow costs many
      // agents' worth of tokens, so each chat opts in again.
      transient: true,
    };
  }
  return { value: level, name: EFFORT_NAMES[level] ?? level };
}

/// The `apply_flag_settings` layer for an effort choice, which changes a
/// running session without a restart. Ultracode is a setting of its own,
/// so every other level turns it off again; `null` drops the layer's
/// effort and the CLI falls back to the user's configured level.
export function effortSettings(value: string | null | undefined) {
  if (value === ULTRACODE) return { effortLevel: XHIGH, ultracode: true };
  if (value === DEFAULT || value === "" || value === null || value === undefined)
    return { effortLevel: null, ultracode: false };
  return { effortLevel: value, ultracode: false };
}

/// A string option value, ignoring the "leave it to Claude Code"
/// placeholder.
export function selected(values: Values | null | undefined, id: string) {
  const value = values?.[id];
  return typeof value === "string" && value !== "" && value !== DEFAULT ? value : null;
}

/// A toggle value.
export function toggle(values: Values | null | undefined, id: string, fallback: boolean) {
  const value = values?.[id];
  return typeof value === "boolean" ? value : fallback;
}

/// The parts of the `initialize` control response the plugin uses.
export class Catalog {
  models: wire.Model[];
  commands: wire.Command[];
  fastModeState: string | null;
  fastModeDisabledReason: string | null;
  manifest: ReturnType<typeof loadManifest>;
  workflowsOff: boolean;
  constructor({
    models = [],
    commands = [],
    fastModeState = null,
    fastModeDisabledReason = null,
    manifest = loadManifest(),
    workflowsOff = false,
  }: {
    models?: wire.Model[];
    commands?: wire.Command[];
    fastModeState?: string | null;
    fastModeDisabledReason?: string | null;
    manifest?: ReturnType<typeof loadManifest>;
    workflowsOff?: boolean;
  } = {}) {
    this.models = models;
    this.commands = commands;
    /// `off`, `cooldown` or `on`. Absent on a CLI without fast mode.
    this.fastModeState = fastModeState;
    this.fastModeDisabledReason = fastModeDisabledReason;
    this.manifest = manifest;
    /// The user's settings turn dynamic workflows off: no ultracode.
    this.workflowsOff = workflowsOff;
  }

  static fromResponse(response: wire.CatalogResponse) {
    const text = (key: string) => (typeof response?.[key] === "string" ? response[key] : null);
    return new Catalog({
      models: Array.isArray(response?.models) ? response.models : [],
      commands: Array.isArray(response?.commands) ? response.commands : [],
      fastModeState: text("fast_mode_state"),
      fastModeDisabledReason: text("fast_mode_disabled_reason"),
    });
  }

  slashCommands() {
    return this.commands
      .filter((command) => typeof command?.name === "string")
      .map((command) => {
        const out: SlashCommand = {
          name: command.name ?? "",
          description: typeof command.description === "string" ? command.description : "",
          source: "agent",
        };
        if (typeof command.argumentHint === "string" && command.argumentHint) out.inputHint = command.argumentHint;
        return out;
      });
  }

  /// A model's effort levels, with ultracode after them when the model can
  /// run it: the CLI accepts ultracode for any model and silently runs
  /// without workflows where `xhigh` is missing.
  modelEfforts(levels: string[]) {
    const out = [...levels];
    if (!this.workflowsOff && out.includes(XHIGH)) out.push(ULTRACODE);
    return out;
  }

  /// Effort levels offered by any model, in the list's order.
  effortLevels() {
    const levels: string[] = [];
    for (const model of this.manifest.models) {
      for (const level of this.modelEfforts(model.effort)) if (!levels.includes(level)) levels.push(level);
    }
    return levels;
  }

  /// Whether any model the account can run declares a capability.
  anyModel(capability: "supportsAdaptiveThinking" | "supportsFastMode") {
    return this.models.some((model) => model?.[capability] === true);
  }

  /// One choice per model in `models.json`, the 1M context variant where
  /// the model has one. The CLI's own values (`opus`, `opus[1m]`,
  /// `default`) become aliases of the model they resolve to, so a chat
  /// that stored one keeps its model.
  modelChoices() {
    return this.manifest.models.map((model) => {
      const value = modelValue(model);
      const aliases = this.models
        .filter((cli) => typeof cli?.resolvedModel === "string" && modelMatches(model, cli.resolvedModel))
        .map((cli) => cli.value)
        .filter((alias) => typeof alias === "string");
      if (model.slug !== value) aliases.push(model.slug);
      const choice: ConfigChoice = { value, name: model.name };
      const levels = this.modelEfforts(model.effort).map(effortChoice);
      if (levels.length) choice.reasoningLevels = levels;
      if (aliases.length) choice.aliases = aliases;
      return choice;
    });
  }

  /// The full option snapshot with `values` applied on top of the
  /// catalog's own defaults.
  options(values: Values = {}): ConfigOption[] {
    const chosen = (id: string, fallback: string) => (typeof values?.[id] === "string" ? values[id] : fallback);
    const defaultModel = this.manifest.models.find((model) => model.slug === this.manifest.default);
    const options: ConfigOption[] = [
      {
        id: MODEL,
        name: "Model",
        category: "model",
        kind: "select",
        value: chosen(MODEL, defaultModel ? modelValue(defaultModel) : DEFAULT),
        choices: this.modelChoices(),
      },
      {
        id: EFFORT,
        name: "Effort",
        description: "Reasoning effort. Ultracode adds dynamic workflows.",
        category: "reasoning",
        kind: "select",
        value: chosen(EFFORT, DEFAULT),
        choices: [
          { value: DEFAULT, name: "Default", description: "Let Claude Code pick the effort for the model." },
          ...this.effortLevels().map(effortChoice),
        ],
      },
      // The CLI's own `current_permission_mode` is deliberately not
      // adopted: the host reads an unset option as Supervised, so a
      // session that silently ran looser would do more than the composer
      // says.
      permissionMode.option(permissionMode.selected(values), true),
    ];
    // A toggle is only offered when the CLI proves it exists: a model that
    // declares the capability, and for fast mode a CLI that reports its
    // state at all.
    if (this.anyModel("supportsAdaptiveThinking")) {
      options.push({
        id: THINKING,
        name: "Thinking",
        description: "Let the model think before answering. Applied when the session starts.",
        category: "reasoning",
        kind: "toggle",
        value: toggle(values, THINKING, true),
        choices: [],
      });
    }
    if (this.fastModeState !== null && this.anyModel("supportsFastMode")) {
      const option: ConfigOption = {
        id: FAST_MODE,
        name: "Fast mode",
        category: "speed",
        kind: "toggle",
        value: toggle(values, FAST_MODE, false),
        choices: [],
      };
      const note = this.fastModeDisabledReason !== null ? fastModeNote(this.fastModeDisabledReason) : null;
      if (note) option.description = note;
      options.push(option);
    }
    return options;
  }
}

/// The choice a stored value selects: the one with that value, or the one
/// that lists it as an alias (the host's `ConfigOption::choice_for`).
export function choiceFor(option: ConfigOption, value: string) {
  return (
    (option.choices ?? []).find((choice) => choice.value === value) ??
    (option.choices ?? []).find((choice) => (choice.aliases ?? []).includes(value)) ??
    null
  );
}