refactor(agent-mode): drop opencode's hardcoded effort vocabulary

`KNOWN_OPENCODE_EFFORTS` and the trailing-segment branch it gated are
unreachable on every opencode version Copilot will talk to. opencode reports
effort as a sibling `category:"thought_level"` config option and its model ids
carry none, which `applySelection` and `prefetchEffortCatalog` already rely on;
installs below `OPENCODE_MIN_ACP_VERSION` (1.16.0) resolve to `incompatible`,
and both `AgentModelPreloader` and `isBackendInstalled` require `ready`, so an
older binary never spawns or reports a catalog. The suffix branch is also never
reached from persisted state: `opencodeEnabledModelEntries` builds its base id
from the provider mapping, not `wire.decode`, whose only callers are
`translateBackendState` over live agent-reported ids.

Deleting it also removes the reason the vocabulary existed — with no trailing
segment peeled off, an umbrella id like `openrouter/anthropic/claude-3.5-haiku`
can no longer be mis-split, so nothing needs to gate against it. `encode` drops
effort to match, as Claude's codec already does.

Net -68 lines.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: zeroliu

src/agentMode/backends/opencode/descriptor.test.ts

@@ -24,77 +24,42 @@ describe("OpencodeBackendDescriptor.wire.decode", () => {
     });
   });
 
-  it("parses 3-segment ids as variants when the suffix is a known effort", () => {
-    expect(decode("anthropic/claude-sonnet-4-5/medium")).toEqual({
-      selection: { baseModelId: "anthropic/claude-sonnet-4-5", effort: "medium" },
-      provider: "anthropic",
-    });
-    expect(decode("openai/gpt-5/minimal")).toEqual({
-      selection: { baseModelId: "openai/gpt-5", effort: "minimal" },
-      provider: "openai",
-    });
-  });
-
-  it("recognizes opencode's full effort vocabulary (none/minimal/low/medium/high/xhigh/max)", () => {
-    // Opencode advertises Anthropic models with `/max` and `/xhigh` and
-    // OpenRouter reasoning models with `/none`. Each must collapse onto
-    // its bare base.
-    for (const effort of ["none", "minimal", "low", "medium", "high", "xhigh", "max"]) {
-      expect(decode(`anthropic/claude-opus-4-7/${effort}`)).toEqual({
-        selection: { baseModelId: "anthropic/claude-opus-4-7", effort },
-        provider: "anthropic",
-      });
-    }
-  });
-
-  it("returns no-effort representation for 3-segment ids whose suffix isn't a known effort", () => {
-    // OpenRouter-style 3-segment ids without an effort suffix — the
-    // trailing segment is part of the model name. The whole id is the
-    // baseModelId; provider is still attributed from the leading segment.
-    expect(decode("openrouter/anthropic/claude-sonnet-4-5")).toEqual({
-      selection: { baseModelId: "openrouter/anthropic/claude-sonnet-4-5", effort: null },
-      provider: "openrouterai",
-    });
+  it("keeps an umbrella provider's id whole, attributing only the leading segment", () => {
+    // `claude-3.5-haiku` and `gpt-5` are part of the model name, not an effort.
+    // opencode reports effort as a separate `thought_level` config option, so no
+    // trailing segment is ever peeled off.
     expect(decode("openrouter/anthropic/claude-3.5-haiku")).toEqual({
       selection: { baseModelId: "openrouter/anthropic/claude-3.5-haiku", effort: null },
       provider: "openrouterai",
     });
-  });
-
-  it("parses 4-segment umbrella ids as variants when the last segment is a known effort", () => {
-    // OpenRouter wraps native ids under `openrouter/`, so its variants
-    // are 4-segment: `openrouter/<sub>/<model>/<effort>`. Without this
-    // case the picker would render seven duplicate rows per OpenRouter
-    // reasoning model.
-    expect(decode("openrouter/anthropic/claude-sonnet-4.5/high")).toEqual({
-      selection: { baseModelId: "openrouter/anthropic/claude-sonnet-4.5", effort: "high" },
-      provider: "openrouterai",
-    });
-    expect(decode("openrouter/anthropic/claude-sonnet-4.5/none")).toEqual({
-      selection: { baseModelId: "openrouter/anthropic/claude-sonnet-4.5", effort: "none" },
+    expect(decode("openrouter/openai/gpt-5")).toEqual({
+      selection: { baseModelId: "openrouter/openai/gpt-5", effort: null },
       provider: "openrouterai",
     });
-    expect(decode("openrouter/openai/gpt-5/xhigh")).toEqual({
-      selection: { baseModelId: "openrouter/openai/gpt-5", effort: "xhigh" },
+    // OpenRouter route variants like `:exacto` live inside the model segment.
+    expect(decode("openrouter/openai/gpt-oss-120b:exacto")).toEqual({
+      selection: { baseModelId: "openrouter/openai/gpt-oss-120b:exacto", effort: null },
       provider: "openrouterai",
     });
-    // OpenRouter route variants like `:exacto` live inside the model
-    // segment — the effort suffix still attaches at the trailing slash.
-    expect(decode("openrouter/openai/gpt-oss-120b:exacto/none")).toEqual({
-      selection: { baseModelId: "openrouter/openai/gpt-oss-120b:exacto", effort: "none" },
-      provider: "openrouterai",
+  });
+
+  it("keeps a trailing segment that reads like an effort, since effort never rides the id", () => {
+    // A model literally named `.../high` would once have been mis-split into a
+    // base model plus an effort. The vocabulary that made that possible is gone.
+    expect(decode("anthropic/claude-sonnet-4-5/high")).toEqual({
+      selection: { baseModelId: "anthropic/claude-sonnet-4-5/high", effort: null },
+      provider: "anthropic",
     });
   });
 
-  it("returns no-effort representation for unparseable shapes (1 segment or unknown trailing segment)", () => {
-    // 1-segment ids have no provider segment to attribute.
+  it("attributes no provider to a single-segment id", () => {
     expect(decode("just-a-name")).toEqual({
       selection: { baseModelId: "just-a-name", effort: null },
       provider: null,
     });
-    // 4+ segment ids whose trailing segment isn't a known effort fall
-    // through to a no-effort representation. The leading segment still
-    // attributes a provider when it maps.
+  });
+
+  it("attributes a provider only when the leading segment maps to a Copilot one", () => {
     expect(decode("anthropic/foo/bar/baz")).toEqual({
       selection: { baseModelId: "anthropic/foo/bar/baz", effort: null },
       provider: "anthropic",
@@ -115,27 +80,22 @@ describe("OpencodeBackendDescriptor.wire.encode", () => {
     );
   });
 
-  it("appends the variant when effort is set", () => {
+  it("drops effort, which opencode carries in its own config option rather than the id", () => {
     expect(encode({ baseModelId: "anthropic/claude-sonnet-4-5", effort: "high" })).toBe(
-      "anthropic/claude-sonnet-4-5/high"
+      "anthropic/claude-sonnet-4-5"
     );
   });
 
   it("round-trips via wire.decode", () => {
     const ids = [
       "anthropic/claude-sonnet-4-5",
-      "anthropic/claude-sonnet-4-5/low",
-      "openai/gpt-5/high",
-      "anthropic/claude-opus-4-7/max",
       "openrouter/anthropic/claude-sonnet-4.5",
-      "openrouter/anthropic/claude-sonnet-4.5/none",
-      "openrouter/anthropic/claude-sonnet-4.5/high",
+      "openrouter/openai/gpt-oss-120b:exacto",
       // Catalog-less BYOK (openai-compatible) — provider id is the synthetic
       // copilot providerId, and the model id may itself contain slashes
       // (LM Studio repo-prefixed ids like `lmstudio-community/Qwen-…-GGUF`).
-      // The trailing segment isn't a known effort, so decode treats the
-      // whole string as `baseModelId` with `effort: null` — and encode
-      // reproduces it verbatim.
+      // decode treats the whole string as `baseModelId`, and encode reproduces
+      // it verbatim.
       "lmstudio-byok-id/lmstudio-community/Qwen2.5-7B-Instruct-GGUF",
       "ollama-byok-id/llama3.2",
     ];

src/agentMode/backends/opencode/descriptor.ts

@@ -50,46 +50,23 @@ const EMPTY_EFFORT_CATALOG: Record<string, EffortOption[]> = Object.freeze({});
 let managerRef: OpencodeBinaryManager | null = null;
 
 /**
- * Effort suffixes opencode appends to model ids. Used to disambiguate
- * genuine effort variants from ids whose trailing segment is part of
- * the model name (e.g. `openrouter/anthropic/claude-3.5-haiku` — the
- * last segment `claude-3.5-haiku` is the model, not an effort).
- */
-const KNOWN_OPENCODE_EFFORTS = new Set([
-  "none",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max",
-]);
-
-/**
- * Wire-format codec for Opencode. Native providers emit
- * `<provider>/<model>[/<effort>]` (3 segments with effort); umbrella
- * providers like OpenRouter emit `<provider>/<sub>/<model>[/<effort>]`
- * (4 segments with effort). The leading segment is always the opencode
- * provider id, mapped onto a Copilot `ChatModelProviders` value via
- * `OPENCODE_PROVIDER_MAP` for picker section grouping. We classify the
- * trailing segment as effort iff it's in the known effort vocabulary —
- * that gates out 3-seg umbrella ids whose last segment is part of the
- * model name (e.g. `openrouter/anthropic/claude-3.5-haiku`).
+ * Wire-format codec for Opencode. A model id is `<provider>/<model>` for native
+ * providers and `<provider>/<sub>/<model>` for umbrella providers like
+ * OpenRouter; the leading segment is always the opencode provider id, mapped
+ * onto a Copilot `ChatModelProviders` value via `OPENCODE_PROVIDER_MAP` for
+ * picker section grouping.
+ *
+ * Effort never rides the id: opencode reports it as a sibling
+ * `category:"thought_level"` config option, scoped to the active model, which
+ * `applySelection` and `prefetchEffortCatalog` read. So `decode` leaves the id
+ * whole — no trailing segment is an effort, and none is guessed.
  */
 const opencodeWire: ModelWireCodec = {
-  encode: (selection: ModelSelection) =>
-    selection.effort ? `${selection.baseModelId}/${selection.effort}` : selection.baseModelId,
+  encode: (selection: ModelSelection) => selection.baseModelId,
   decode: (wireId: string) => {
     if (!wireId) return { selection: { baseModelId: wireId, effort: null }, provider: null };
     const segments = wireId.split("/");
     const provider = segments.length >= 2 ? opencodeProviderToCopilot(segments[0]) : null;
-    const last = segments[segments.length - 1];
-    if (segments.length >= 3 && KNOWN_OPENCODE_EFFORTS.has(last)) {
-      return {
-        selection: { baseModelId: segments.slice(0, -1).join("/"), effort: last },
-        provider,
-      };
-    }
     return { selection: { baseModelId: wireId, effort: null }, provider };
   },
 };
@@ -207,9 +184,7 @@ export const OpencodeBackendDescriptor: BackendDescriptor = {
         ? context.backendReportedCurrent?.baseModelId
         : session.getState()?.model?.current.baseModelId;
       if (currentBase !== selection.baseModelId) {
-        await session.applyModelWireId(
-          opencodeWire.encode({ baseModelId: selection.baseModelId, effort: null })
-        );
+        await session.applyModelWireId(opencodeWire.encode(selection));
       }
       if (selection.effort !== null) {
         const refreshedApply = session.getState()?.model?.apply;
@@ -243,10 +218,7 @@ export const OpencodeBackendDescriptor: BackendDescriptor = {
     // the effort options the refreshed state reports for it.
     if (modelState.apply.kind !== "setConfigOption") return EMPTY_EFFORT_CATALOG;
     const configId = modelState.apply.configId;
-    const originalWire = opencodeWire.encode({
-      baseModelId: modelState.current.baseModelId,
-      effort: null,
-    });
+    const originalWire = opencodeWire.encode(modelState.current);
     const out: Record<string, EffortOption[]> = {};
     try {
       for (const model of enabledModels) {