opencode-v2

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// The config options the plugin offers, built from the live catalog only
// (`GET /api/provider`, `/api/model`, `/api/model/default`, `/api/agent`).
// There is no list of models, modes or reasoning levels in this plugin: an
// empty catalog is an error the user sees.
import type { ConfigChoice, ConfigOption } from "convergence/protocol";
import { permissionMode } from "../sdk/agent.ts";
import type { Agent, Model, ModelRef, Provider } from "./api.ts";

/// Option ids; also the keys of a session's stored options.
export const OPTION_MODEL = "model";
export const OPTION_AGENT = "agent";
export const OPTION_VARIANT = "variant";

/// Everything the options are built from, read once per workspace.
export interface Catalog {
  providers: readonly Provider[];
  models: readonly Model[];
  defaultModel: ModelRef | null;
  agents: readonly Agent[];
}

/// Display order of reasoning variants, least effort first. Only the order:
/// the names always come from the API. Unknown names follow, alphabetically.
const VARIANT_ORDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];

/// The option value of a model: `<providerID>/<id>`. The id is the
/// catalog entry's own (`gpt-6.1-sol-fast`), not the provider's model name,
/// because two entries can share one provider model.
export const modelValue = (ref: { providerID: string; id: string }) => `${ref.providerID}/${ref.id}`;

/// `<providerID>/<id>` as a model reference; a model id may contain slashes.
export function splitModel(value: unknown): { providerID: string; id: string } | null {
  if (typeof value !== "string") return null;
  const at = value.indexOf("/");
  if (at <= 0 || at === value.length - 1) return null;
  return { providerID: value.slice(0, at), id: value.slice(at + 1) };
}

/// A model's reasoning variants, ordered by effort.
export function variantChoices(model: Model): ConfigChoice[] {
  const rank = (name: string) => {
    const at = VARIANT_ORDER.indexOf(name);
    return at < 0 ? VARIANT_ORDER.length : at;
  };
  return (model.variants ?? [])
    .map((variant) => variant.id)
    .sort((a, b) => rank(a) - rank(b) || a.localeCompare(b))
    .map((id) => ({ value: id, name: id }));
}

/// The models a chat can pick: enabled ones of the providers the server
/// has connected, in the server's order.
export function usableModels(catalog: Catalog): Model[] {
  const connected = new Set(catalog.providers.map((provider) => provider.id));
  return catalog.models.filter((model) => model.enabled !== false && connected.has(model.providerID));
}

/// The catalog entry a stored model value names.
export function findModel(catalog: Catalog, value: unknown): Model | null {
  const ref = splitModel(value);
  if (!ref) return null;
  return catalog.models.find((model) => model.providerID === ref.providerID && model.id === ref.id) ?? null;
}

/// Every option for a workspace: model (grouped by provider), mode (the
/// primary agents), reasoning, and the permission mode. `current` holds the
/// values a chat chose.
export function buildOptions(catalog: Catalog, current: Record<string, unknown> = {}): ConfigOption[] {
  const providerNames = new Map(catalog.providers.map((provider) => [provider.id, provider.name]));
  const models = usableModels(catalog);
  const first = models[0];
  if (!first)
    throw new Error("OpenCode has no connected provider with an enabled model; connect one with `opencode auth login`");
  const choices: ConfigChoice[] = models.map((model) => {
    const levels = variantChoices(model);
    return {
      value: modelValue(model),
      name: model.name,
      group: providerNames.get(model.providerID) ?? model.providerID,
      ...(levels.length ? { reasoningLevels: levels } : {}),
    };
  });
  const stored = current[OPTION_MODEL];
  const fallback = catalog.defaultModel ? modelValue(catalog.defaultModel) : modelValue(first);
  const selected = typeof stored === "string" ? stored : fallback;
  const options: ConfigOption[] = [
    { id: OPTION_MODEL, name: "Model", category: "model", kind: "select", value: selected, choices },
  ];

  const modes: ConfigChoice[] = catalog.agents
    .filter((agent) => !agent.hidden && (agent.mode === "primary" || agent.mode === "all"))
    .map((agent) => ({
      value: agent.id,
      name: agent.name,
      ...(agent.description ? { description: agent.description } : {}),
    }));
  const firstMode = modes[0];
  if (firstMode) {
    const mode = current[OPTION_AGENT];
    options.push({
      id: OPTION_AGENT,
      name: "Mode",
      category: "mode",
      kind: "select",
      value: typeof mode === "string" ? mode : firstMode.value,
      choices: modes,
    });
  }

  // Kept whenever any model has variants, so a draft can switch to a
  // reasoning model before a session exists; `null` is the provider
  // default until the user picks one.
  if (choices.some((choice) => choice.reasoningLevels?.length)) {
    const chosen = choices.find((choice) => choice.value === selected);
    options.push({
      id: OPTION_VARIANT,
      name: "Reasoning",
      category: "reasoning",
      kind: "select",
      value: current[OPTION_VARIANT] ?? null,
      choices: chosen?.reasoningLevels ?? [],
    });
  }

  // OpenCode has no approval reviewer, so Auto is left out rather than
  // offered as another name for Supervised.
  options.push(permissionMode.option(permissionMode.selected(current), false));
  return options;
}

/// The model reference a chat's options ask for, `null` for the server's
/// default. A variant the chosen model does not have is dropped.
export function chosenModel(catalog: Catalog, options: Record<string, unknown>): ModelRef | null {
  const model = findModel(catalog, options[OPTION_MODEL]);
  if (!model) return null;
  const variant = options[OPTION_VARIANT];
  const known = typeof variant === "string" && (model.variants ?? []).some((entry) => entry.id === variant);
  return { providerID: model.providerID, id: model.id, ...(known ? { variant } : {}) };
}

/// The context window of a model, when the catalog names one.
export function contextWindow(catalog: Catalog, ref: { providerID: string; id: string }): number | null {
  const model = catalog.models.find((entry) => entry.providerID === ref.providerID && entry.id === ref.id);
  const context = model?.limit?.context;
  return context && context > 0 ? context : null;
}