fix: per-model threshold lookup and input-aware context limits

ualtinok · ualtinok · commit 4669e1acd41b · 2026-04-19T09:56:26.000+03:00
Three related correctness fixes around per-model execute_threshold_percentage
and context-limit resolution, addressing user-reported issues with GitHub
Copilot models and experimental-mode model variants.

- transform.ts: populate liveModelBySession from message history when empty,
  so the scheduler can resolve per-model thresholds immediately instead of
  waiting for the next message.updated event. Previously, after a plugin
  restart or on the first transform of a session with prior history, the
  map stayed empty and every transform in that window silently used the
  default threshold.

- event-resolvers.ts: progressive key lookup in resolveExecuteThreshold.
  OpenCode's experimental.modes generates derived model IDs like
  'openai/gpt-5.4-fast' from base 'openai/gpt-5.4'. Users may now write
  either form in config; most-specific match wins. Also matches bare model
  IDs (without provider prefix) through the same cascade. +10 tests.

- models-dev-cache.ts: prefer limit.input over limit.context across all
  three resolution sites (models.json file layer, opencode.json custom
  provider overlay, SDK API refresh path). Matches OpenCode's session/
  overflow.ts behavior. Affects 182+ models including every GitHub Copilot
  entry and most gpt-5.x derivations through proxies where limit.input is
  the enforced prompt cap and limit.context is the total window including
  output. Previously we used the larger context number as the denominator,
  so pressure math underestimated real usage. gpt-5.3-codex for example now
  correctly uses 272K instead of 400K as the context limit.

- models-dev-cache.test.ts: test isolation fix — OPENCODE_CONFIG_DIR now
  points at an empty directory per test so user's real opencode.jsonc
  (which may have custom provider limit overrides) does not leak into
  test expectations. +4 tests for the input/context preference logic.
diff --git a/packages/plugin/src/hooks/magic-context/event-resolvers.test.ts b/packages/plugin/src/hooks/magic-context/event-resolvers.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from "bun:test";
 import {
     resolveCacheTtl,
     resolveContextLimit,
+    resolveExecuteThreshold,
     resolveModelKey,
     resolveSessionId,
 } from "./event-resolvers";
@@ -66,6 +67,124 @@ describe("event-resolvers", () => {
         });
     });
 
+    describe("resolveExecuteThreshold", () => {
+        it("returns direct number config unchanged (after max cap)", () => {
+            expect(resolveExecuteThreshold(50, "openai/gpt-5.4-fast", 65)).toBe(50);
+            expect(resolveExecuteThreshold(50, undefined, 65)).toBe(50);
+        });
+
+        it("caps any resolved value at 80%", () => {
+            expect(resolveExecuteThreshold(95, "openai/gpt-4o", 65)).toBe(80);
+            expect(
+                resolveExecuteThreshold({ default: 95, "openai/gpt-4o": 90 }, "openai/gpt-4o", 65),
+            ).toBe(80);
+        });
+
+        it("prefers exact provider/model key when present", () => {
+            //#given — user wrote the derived key
+            const config = { default: 65, "openai/gpt-5.4-fast": 25 };
+
+            //#when
+            const result = resolveExecuteThreshold(config, "openai/gpt-5.4-fast", 65);
+
+            //#then
+            expect(result).toBe(25);
+        });
+
+        it("falls back to base model key when user wrote base (no derived)", () => {
+            //#given — user wrote base key, runtime is derived (e.g., -fast variant)
+            const config = { default: 65, "openai/gpt-5.4": 25 };
+
+            //#when — modelKey is the derived form
+            const result = resolveExecuteThreshold(config, "openai/gpt-5.4-fast", 65);
+
+            //#then — should match "openai/gpt-5.4" after suffix strip
+            expect(result).toBe(25);
+        });
+
+        it("prefers most-specific match when both derived and base configured", () => {
+            //#given — user wrote BOTH keys, want derived to win
+            const config = {
+                default: 65,
+                "openai/gpt-5.4-fast": 20,
+                "openai/gpt-5.4": 40,
+            };
+
+            //#when
+            const derived = resolveExecuteThreshold(config, "openai/gpt-5.4-fast", 65);
+            const base = resolveExecuteThreshold(config, "openai/gpt-5.4", 65);
+
+            //#then
+            expect(derived).toBe(20);
+            expect(base).toBe(40);
+        });
+
+        it("matches bare model id (no provider prefix) in config", () => {
+            //#given — user wrote just the model id without provider
+            const config = { default: 65, "gpt-5.4-fast": 25 };
+
+            //#when
+            const result = resolveExecuteThreshold(config, "openai/gpt-5.4-fast", 65);
+
+            //#then
+            expect(result).toBe(25);
+        });
+
+        it("matches bare base model id for derived runtime model", () => {
+            //#given
+            const config = { default: 65, "gpt-5.4": 30 };
+
+            //#when
+            const result = resolveExecuteThreshold(config, "openai/gpt-5.4-fast", 65);
+
+            //#then
+            expect(result).toBe(30);
+        });
+
+        it("returns config.default when no keys match", () => {
+            //#given
+            const config = { default: 55, "anthropic/claude-opus-4-6": 40 };
+
+            //#when
+            const result = resolveExecuteThreshold(config, "openai/gpt-4o", 65);
+
+            //#then
+            expect(result).toBe(55);
+        });
+
+        it("returns fallback when config.default absent and no match", () => {
+            //#given
+            const config = { default: 0, "anthropic/claude-opus-4-6": 40 } as unknown as {
+                default: number;
+                [key: string]: number;
+            };
+            // Simulate missing default by deleting
+            // biome-ignore lint/performance/noDelete: test setup requires actual missing key
+            delete (config as Record<string, unknown>).default;
+
+            //#when
+            const result = resolveExecuteThreshold(
+                config as { default: number; [key: string]: number },
+                "openai/gpt-4o",
+                65,
+            );
+
+            //#then
+            expect(result).toBe(65);
+        });
+
+        it("returns config.default when modelKey is undefined", () => {
+            //#given
+            const config = { default: 42, "openai/gpt-5.4-fast": 25 };
+
+            //#when
+            const result = resolveExecuteThreshold(config, undefined, 65);
+
+            //#then — undefined modelKey hits the no-model branch, not the per-model lookup
+            expect(result).toBe(42);
+        });
+    });
+
     describe("resolveModelKey", () => {
         it("returns provider/model when both parts exist", () => {
             expect(resolveModelKey("openai", "gpt-4o")).toBe("openai/gpt-4o");
diff --git a/packages/plugin/src/hooks/magic-context/event-resolvers.ts b/packages/plugin/src/hooks/magic-context/event-resolvers.ts
@@ -47,6 +47,35 @@ export function resolveCacheTtl(cacheTtl: CacheTtlConfig, modelKey: string | und
 
 type ExecuteThresholdConfig = number | { default: number; [modelKey: string]: number };
 
+/**
+ * Yield progressively-less-specific lookup keys for a given `provider/model`.
+ *
+ * OpenCode's `experimental.modes` feature derives model IDs like
+ * `gpt-5.4-fast` from a base model `gpt-5.4`. Users may put EITHER the
+ * derived key OR the base key in their per-model config. This generator
+ * returns keys in specificity order so we pick the most specific match
+ * the user actually wrote:
+ *
+ *   "openai/gpt-5.4-fast"  (exact)
+ *   "gpt-5.4-fast"         (bare, derived)
+ *   "openai/gpt-5.4"       (base, with provider)
+ *   "gpt-5.4"              (base, bare)
+ *   ...etc. stripping one "-segment" at a time
+ */
+function* modelKeyLookupOrder(modelKey: string): Generator<string> {
+    const slash = modelKey.indexOf("/");
+    const provider = slash >= 0 ? modelKey.slice(0, slash) : "";
+    let modelId = slash >= 0 ? modelKey.slice(slash + 1) : modelKey;
+
+    while (modelId.length > 0) {
+        if (provider) yield `${provider}/${modelId}`;
+        yield modelId;
+        const lastDash = modelId.lastIndexOf("-");
+        if (lastDash <= 0) break;
+        modelId = modelId.slice(0, lastDash);
+    }
+}
+
 export function resolveExecuteThreshold(
     config: ExecuteThresholdConfig,
     modelKey: string | undefined,
@@ -57,15 +86,15 @@ export function resolveExecuteThreshold(
 
     if (typeof config === "number") {
         resolved = config;
-    } else if (modelKey && typeof config[modelKey] === "number") {
-        resolved = config[modelKey];
     } else if (modelKey) {
-        const bareModelId = modelKey.split("/").slice(1).join("/");
-        if (bareModelId && typeof config[bareModelId] === "number") {
-            resolved = config[bareModelId];
-        } else {
-            resolved = config.default ?? fallback;
+        let matched: number | undefined;
+        for (const candidate of modelKeyLookupOrder(modelKey)) {
+            if (typeof config[candidate] === "number") {
+                matched = config[candidate];
+                break;
+            }
         }
+        resolved = matched ?? config.default ?? fallback;
     } else {
         resolved = config.default ?? fallback;
     }
diff --git a/packages/plugin/src/hooks/magic-context/transform.ts b/packages/plugin/src/hooks/magic-context/transform.ts
@@ -228,10 +228,17 @@ export function createTransform(deps: TransformDeps) {
             const lastAssistantModel = findLastAssistantModel(messages);
             if (lastAssistantModel) {
                 const knownModel = deps.liveModelBySession.get(sessionId);
-                if (
-                    knownModel &&
-                    (knownModel.providerID !== lastAssistantModel.providerID ||
-                        knownModel.modelID !== lastAssistantModel.modelID)
+                if (!knownModel) {
+                    // No known model yet — populate from message history so the
+                    // scheduler can resolve per-model execute_threshold_percentage
+                    // immediately. Without this, after a plugin restart the map
+                    // stays empty until a new message.updated event fires, and
+                    // any transform in between uses the default threshold even
+                    // for sessions with explicit per-model config.
+                    deps.liveModelBySession.set(sessionId, lastAssistantModel);
+                } else if (
+                    knownModel.providerID !== lastAssistantModel.providerID ||
+                    knownModel.modelID !== lastAssistantModel.modelID
                 ) {
                     sessionLog(
                         sessionId,
diff --git a/packages/plugin/src/shared/models-dev-cache.test.ts b/packages/plugin/src/shared/models-dev-cache.test.ts
@@ -19,11 +19,17 @@ describe("models-dev-cache", () => {
             OPENCODE_MODELS_PATH: process.env.OPENCODE_MODELS_PATH,
             OPENCODE_MODELS_URL: process.env.OPENCODE_MODELS_URL,
             XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
+            OPENCODE_CONFIG_DIR: process.env.OPENCODE_CONFIG_DIR,
         };
-        // Isolate from user environment.
+        // Isolate from user environment — including user's ~/.config/opencode/opencode.jsonc
+        // which may have custom provider limits that would override models.json entries.
         delete process.env.OPENCODE_MODELS_PATH;
         delete process.env.OPENCODE_MODELS_URL;
         process.env.XDG_CACHE_HOME = tempDir;
+        // Point at an empty directory so no opencode.json{c} is read unless the test writes one.
+        const emptyConfigDir = join(tempDir, "config", "opencode");
+        mkdirSync(emptyConfigDir, { recursive: true });
+        process.env.OPENCODE_CONFIG_DIR = emptyConfigDir;
         clearModelsDevCache();
     });
 
@@ -61,6 +67,113 @@ describe("models-dev-cache", () => {
         expect(getModelsDevContextLimit("unknown", "unknown")).toBeUndefined();
     });
 
+    test("prefers limit.input over limit.context when both are present", () => {
+        //#given — GitHub Copilot shape: input is max prompt, context is total window.
+        // Matches real-world github-copilot/gpt-5.3-codex which has
+        //   limit.context = 400000 (total), limit.input = 272000 (max prompt).
+        // Our pressure math must use the input cap; sending a 400K prompt gets rejected.
+        // OpenCode's own session/overflow.ts follows the same rule.
+        const opencodeDir = join(tempDir, "opencode");
+        mkdirSync(opencodeDir, { recursive: true });
+        writeFileSync(
+            join(opencodeDir, "models.json"),
+            JSON.stringify({
+                "github-copilot": {
+                    models: {
+                        "gpt-5.3-codex": { limit: { context: 400000, input: 272000 } },
+                        "claude-opus-4.6": { limit: { context: 144000, input: 128000 } },
+                        // Context-only model (no input) falls back to context.
+                        "legacy-only-context": { limit: { context: 100000 } },
+                    },
+                },
+            }),
+        );
+
+        //#then
+        expect(getModelsDevContextLimit("github-copilot", "gpt-5.3-codex")).toBe(272000);
+        expect(getModelsDevContextLimit("github-copilot", "claude-opus-4.6")).toBe(128000);
+        expect(getModelsDevContextLimit("github-copilot", "legacy-only-context")).toBe(100000);
+    });
+
+    test("derived experimental.modes inherit the effective (input) limit", () => {
+        //#given — parent has input < context; derived modes should inherit input, not context
+        const opencodeDir = join(tempDir, "opencode");
+        mkdirSync(opencodeDir, { recursive: true });
+        writeFileSync(
+            join(opencodeDir, "models.json"),
+            JSON.stringify({
+                openai: {
+                    models: {
+                        "gpt-5.4": {
+                            limit: { context: 1050000, input: 922000 },
+                            experimental: { modes: { fast: {}, mini: {} } },
+                        },
+                    },
+                },
+            }),
+        );
+
+        //#then
+        expect(getModelsDevContextLimit("openai", "gpt-5.4")).toBe(922000);
+        expect(getModelsDevContextLimit("openai", "gpt-5.4-fast")).toBe(922000);
+        expect(getModelsDevContextLimit("openai", "gpt-5.4-mini")).toBe(922000);
+    });
+
+    test("custom opencode.json provider overlay uses limit.input preferentially", () => {
+        //#given — user defines a proxy provider in opencode.json with input < context
+        const opencodeDir = join(tempDir, "opencode");
+        mkdirSync(opencodeDir, { recursive: true });
+        const configDir = join(tempDir, "config", "opencode");
+        mkdirSync(configDir, { recursive: true });
+        writeFileSync(
+            join(configDir, "opencode.json"),
+            JSON.stringify({
+                provider: {
+                    "my-proxy": {
+                        models: {
+                            "split-model": { limit: { context: 400000, input: 200000 } },
+                        },
+                    },
+                },
+            }),
+        );
+        process.env.OPENCODE_CONFIG_DIR = configDir;
+        clearModelsDevCache();
+
+        //#then
+        expect(getModelsDevContextLimit("my-proxy", "split-model")).toBe(200000);
+
+        // Cleanup: restore env (afterEach also handles this, but we added a new var)
+        delete process.env.OPENCODE_CONFIG_DIR;
+    });
+
+    test("API cache uses limit.input preferentially", async () => {
+        //#given — API response shape mirrors file layer
+        const mockClient = {
+            config: {
+                providers: async () => ({
+                    data: {
+                        providers: [
+                            {
+                                id: "github-copilot",
+                                models: {
+                                    "gpt-5.3-codex": {
+                                        limit: { context: 400000, input: 272000 },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                }),
+            },
+        };
+        // @ts-expect-error mock narrow shape
+        await refreshModelLimitsFromApi(mockClient);
+
+        //#then
+        expect(getModelsDevContextLimit("github-copilot", "gpt-5.3-codex")).toBe(272000);
+    });
+
     test("expands experimental.modes into derived model IDs with parent context", () => {
         const opencodeDir = join(tempDir, "opencode");
         mkdirSync(opencodeDir, { recursive: true });
diff --git a/packages/plugin/src/shared/models-dev-cache.ts b/packages/plugin/src/shared/models-dev-cache.ts
