fix(context-limit): tag-suffix fallback + take-larger across cache layers (issue #117)

Reported as >1000% context for ollama-cloud models. Two real root causes, both
in getModelsDevContextLimit:

1. Tag-suffix mismatch (deterministic): ollama invokes cloud models with a tag
   (deepseek-v4-pro:cloud) while models.dev stores them tag-less
   (deepseek-v4-pro). Exact-only match missed → fell to the 128k default → wrong
   pressure denominator. Now: exact match first (never collapses a legitimately
   tagged model like gemma3:27b), then retry with the last :tag stripped.

2. Wrong live-API value overriding the correct file value (intermittent): the
   apiCache (from /config/providers) had absolute priority, so ollama reporting
   its tiny default num_ctx (e.g. 8k) for a 1M-window cloud model overrode the
   correct models.dev value. Now: when BOTH layers know the model, take the
   LARGER limit. Providers never under-report their real window; a genuinely
   smaller real limit is still captured via the overflow-detection path
   (detectedContextLimit), not here.

Verified against live models.json: ollama-cloud/deepseek-v4-pro is stored
tag-less at context 1048576. +4 tests.

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

packages/plugin/src/shared/models-dev-cache.test.ts

@@ -238,7 +238,7 @@ describe("models-dev-cache", () => {
         expect(getModelsDevContextLimit("anthropic", "claude-4")).toBeUndefined();
     });
 
-    test("API cache takes priority over file cache", async () => {
+    test("takes the larger limit when both layers know the model (API larger)", async () => {
         // Seed file layer with one value.
         const opencodeDir = join(tempDir, "opencode");
         mkdirSync(opencodeDir, { recursive: true });
@@ -252,7 +252,7 @@ describe("models-dev-cache", () => {
         // Sanity: file layer returns 100000 before API refresh.
         expect(getModelsDevContextLimit("anthropic", "claude-4")).toBe(100000);
 
-        // Mock client providing DIFFERENT value via API.
+        // Mock client providing a LARGER value via API.
         const mockClient = {
             config: {
                 providers: async () => ({
@@ -271,14 +271,78 @@ describe("models-dev-cache", () => {
         };
         await refreshModelLimitsFromApi(mockClient);
 
-        // API value wins.
+        // Larger (API) value wins.
         expect(getModelsDevContextLimit("anthropic", "claude-4")).toBe(1000000);
 
         const state = getModelsDevCacheState();
         expect(state.apiLoaded).toBe(true);
         expect(state.apiCount).toBe(1);
     });
 
+    test("file value wins when the live API reports a smaller (wrong) limit (issue #117)", async () => {
+        // The ollama-cloud scenario: models.dev has the correct large window, but
+        // ollama reports its tiny default num_ctx via the live /config/providers
+        // API. The larger, correct file value must win so pressure isn't bogus.
+        const opencodeDir = join(tempDir, "opencode");
+        mkdirSync(opencodeDir, { recursive: true });
+        writeFileSync(
+            join(opencodeDir, "models.json"),
+            JSON.stringify({
+                "ollama-cloud": {
+                    models: { "deepseek-v4-pro": { limit: { context: 1048576 } } },
+                },
+            }),
+        );
+
+        const mockClient = {
+            config: {
+                providers: async () => ({
+                    data: {
+                        providers: [
+                            {
+                                id: "ollama-cloud",
+                                models: {
+                                    // Bogus tiny default num_ctx from ollama.
+                                    "deepseek-v4-pro": { limit: { context: 8192 } },
+                                },
+                            },
+                        ],
+                    },
+                }),
+            },
+        };
+        await refreshModelLimitsFromApi(mockClient);
+
+        // Larger (file/models.dev) value wins, not the tiny live-API value.
+        expect(getModelsDevContextLimit("ollama-cloud", "deepseek-v4-pro")).toBe(1048576);
+    });
+
+    test("matches a tagged ollama model against its tag-less models.dev entry (issue #117)", () => {
+        // ollama invokes cloud models with a tag (deepseek-v4-pro:cloud) while
+        // models.dev stores them tag-less (deepseek-v4-pro).
+        const opencodeDir = join(tempDir, "opencode");
+        mkdirSync(opencodeDir, { recursive: true });
+        writeFileSync(
+            join(opencodeDir, "models.json"),
+            JSON.stringify({
+                "ollama-cloud": {
+                    models: {
+                        "deepseek-v4-pro": { limit: { context: 1048576 } },
+                        // A legitimately-tagged model must still match exactly.
+                        "gemma3:27b": { limit: { context: 131072 } },
+                    },
+                },
+            }),
+        );
+
+        // Tagged invocation falls back to the tag-less entry.
+        expect(getModelsDevContextLimit("ollama-cloud", "deepseek-v4-pro:cloud")).toBe(1048576);
+        // Exact tagged match still wins (no wrongful collapse).
+        expect(getModelsDevContextLimit("ollama-cloud", "gemma3:27b")).toBe(131072);
+        // Unknown tagged model with no tag-less base stays undefined.
+        expect(getModelsDevContextLimit("ollama-cloud", "nonexistent:cloud")).toBeUndefined();
+    });
+
     test("refreshModelLimitsFromApi tolerates empty/malformed responses", async () => {
         // Undefined data.
         await refreshModelLimitsFromApi({

packages/plugin/src/shared/models-dev-cache.ts

@@ -298,19 +298,58 @@ export async function refreshModelLimitsFromApi(client: OpencodeClientLike): Pro
  * Returns `undefined` if neither layer knows the model.
  */
 export function getModelsDevContextLimit(providerID: string, modelID: string): number | undefined {
-    const key = `${providerID}/${modelID}`;
-
-    if (apiCache) {
-        const fromApi = apiCache.get(key)?.limit;
-        if (typeof fromApi === "number") return fromApi;
-    }
-
     const now = Date.now();
     if (!fileCache || now - fileLastAttempt > RELOAD_INTERVAL_MS) {
         fileLastAttempt = now;
         fileCache = loadModelsDevMetadataFromFile();
     }
-    return fileCache.get(key)?.limit;
+
+    const fromApi = lookupLimitWithTagFallback(apiCache, providerID, modelID);
+    const fromFile = lookupLimitWithTagFallback(fileCache, providerID, modelID);
+
+    // When BOTH layers know the model, take the LARGER limit. Providers never
+    // under-report their real window, so a suspiciously small value — e.g.
+    // ollama reporting its default `num_ctx` (4k/8k) for a cloud model via the
+    // live `/config/providers` API — must not override the correct, larger
+    // models.dev value. A genuinely smaller real limit (provider actually
+    // rejects at N) is captured separately via the overflow-detection path
+    // (detectedContextLimit), not here. (issue #117)
+    if (typeof fromApi === "number" && typeof fromFile === "number") {
+        return Math.max(fromApi, fromFile);
+    }
+    return fromApi ?? fromFile;
+}
+
+/**
+ * Look up a model's limit in one cache layer, with an ollama-style tag-suffix
+ * fallback.
+ *
+ * models.dev stores some models WITH a colon tag (e.g. `gemma3:27b`,
+ * `deepseek-v3.1:671b`) and ollama-cloud base models WITHOUT one
+ * (`deepseek-v4-pro`). But ollama invokes cloud models with a tag at runtime
+ * (`deepseek-v4-pro:cloud`), so OpenCode reports the tagged id. An exact-only
+ * match therefore misses → falls back to the 128k default → wrong pressure
+ * denominator (issue #117).
+ *
+ * Strategy: exact match first (never collapses a legitimately-tagged model),
+ * then retry once with the last `:tag` segment stripped.
+ */
+function lookupLimitWithTagFallback(
+    cache: Map<string, CachedModelMetadata> | null,
+    providerID: string,
+    modelID: string,
+): number | undefined {
+    if (!cache) return undefined;
+    const exact = cache.get(`${providerID}/${modelID}`)?.limit;
+    if (typeof exact === "number") return exact;
+
+    const colonIdx = modelID.lastIndexOf(":");
+    if (colonIdx > 0) {
+        const baseModel = modelID.slice(0, colonIdx);
+        const fallback = cache.get(`${providerID}/${baseModel}`)?.limit;
+        if (typeof fallback === "number") return fallback;
+    }
+    return undefined;
 }
 
 /** Clear in-memory caches (for testing). */