fix(server): preview builds keep their bundled OpenCode 2 compatibility policy (#14368)

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: juliusmarminge

apps/server/src/provider/ModelManifest.test.ts

@@ -11,6 +11,7 @@ import { HttpClient, HttpClientResponse } from "effect/unstable/http";
 import * as ServerConfig from "../config.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import * as ModelManifest from "./ModelManifest.ts";
+import { resolveProviderCompatibility } from "./providerCompatibility.ts";
 
 /**
  * Test policy: this file covers manifest machinery, not manifest contents.
@@ -583,6 +584,62 @@ describe("ModelManifest service", () => {
   );
 });
 
+// TEMPORARY V2 preview stopgap; remove with `withPreviewCompatibility` (#2829).
+describe("compatibility policy by release channel", () => {
+  const OPENCODE = ProviderDriverKind.make("opencode");
+  // Main's OpenCode policy (#14198): stable and nightly have no OpenCode 2 runtime.
+  const remote: ModelManifest.ModelManifestData = {
+    ...REMOTE_MANIFEST,
+    compatibility: [
+      {
+        driver: OPENCODE,
+        t3CodeRange: ">=0.0.42",
+        recommendedRange: ">=1.14.19 <2.0.0",
+        recommendedVersion: "1.14.19",
+        ranges: [
+          { range: ">=2.0.0", status: "broken" },
+          { range: ">=1.14.19 <2.0.0", status: "supported" },
+          { range: "<1.14.19", status: "broken" },
+        ],
+      },
+    ],
+  };
+
+  for (const [channel, t3CodeVersion, expected, openCode2Status] of [
+    [
+      "preview builds keep the bundled policy",
+      "0.0.44-preview.20260929.1",
+      { ...remote, compatibility: ModelManifest.BUNDLED_MODEL_MANIFEST.compatibility },
+      "supported",
+    ],
+    ["stable builds adopt the fetched policy", "0.0.44", remote, "broken"],
+    ["nightly builds adopt the fetched policy", "0.0.44-nightly.20260929.1", remote, "broken"],
+  ] as const) {
+    it.live(channel, () =>
+      Effect.gen(function* () {
+        const openCode2 = (manifest: ModelManifest.ModelManifestData) =>
+          resolveProviderCompatibility(manifest.compatibility, OPENCODE, "2.0.18", t3CodeVersion)
+            ?.status;
+        const refreshed = yield* (yield* ModelManifest.makeForVersion(t3CodeVersion)).refresh;
+        assert.deepStrictEqual(refreshed, expected);
+        assert.strictEqual(openCode2(refreshed), openCode2Status);
+
+        // A restart reads the fetched manifest back from the disk cache.
+        const rebooted = yield* (yield* ModelManifest.makeForVersion(t3CodeVersion)).current;
+        assert.deepStrictEqual(rebooted, expected);
+      }).pipe(
+        Effect.scoped,
+        Effect.provide(
+          serviceLayers({
+            prefix: "model-manifest-channel-compatibility-test",
+            response: () => Response.json(remote),
+          }),
+        ),
+      ),
+    );
+  }
+});
+
 it.effect("caches valid compatibility policies and keeps them after a malformed refresh", () => {
   const remote: ModelManifest.ModelManifestData = {
     ...REMOTE_MANIFEST,

apps/server/src/provider/ModelManifest.ts

@@ -19,6 +19,7 @@ import {
   type ProviderDriverKind,
   type ServerProviderModel,
 } from "@t3tools/contracts";
+import { cliReleaseChannelOf } from "@t3tools/shared/cliRelease";
 import { codexModelFamily } from "@t3tools/shared/model";
 import * as Clock from "effect/Clock";
 import * as Context from "effect/Context";
@@ -30,6 +31,7 @@ import * as Schema from "effect/Schema";
 import * as Semaphore from "effect/Semaphore";
 import { HttpClient, HttpClientResponse } from "effect/unstable/http";
 
+import packageJson from "../../package.json" with { type: "json" };
 import { ServerConfig } from "../config.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import { hasValidClaudeManifestAdapters } from "./ClaudeModelManifest.ts";
@@ -140,6 +142,25 @@ const decodeManifest = Schema.decodeUnknownEffect(ModelManifestSchema);
 export const BUNDLED_MODEL_MANIFEST: ModelManifestData =
   Schema.decodeUnknownSync(ModelManifestSchema)(bundledManifestJson);
 
+/**
+ * TEMPORARY V2 preview stopgap. Revert before V2 merges into main; it is on
+ * #2829's "Revert before merging into main" checklist.
+ *
+ * The fetched manifest is `main`'s, and its compatibility policy is written for
+ * stable and nightly builds, which do not run OpenCode 2. A policy's
+ * `t3CodeRange` cannot single out preview builds because range matching drops
+ * prerelease tags. Preview builds therefore keep the compatibility policy they
+ * shipped with and take everything else from the fetched manifest.
+ */
+function withPreviewCompatibility(
+  manifest: ModelManifestData,
+  t3CodeVersion: string,
+): ModelManifestData {
+  return cliReleaseChannelOf(t3CodeVersion) === "preview"
+    ? { ...manifest, compatibility: BUNDLED_MODEL_MANIFEST.compatibility }
+    : manifest;
+}
+
 /** Epoch millis of the manifest's `updatedAt`, or 0 when absent or unparsable. */
 function manifestUpdatedAtMs(manifest: ModelManifestData): number {
   if (manifest.updatedAt === undefined) return 0;
@@ -336,7 +357,8 @@ const BundledOnlyModelManifest: ModelManifest["Service"] = {
 
 export const layerTest = Layer.succeed(ModelManifest, BundledOnlyModelManifest);
 
-export const make = Effect.gen(function* () {
+/** `make` for a given T3 Code version, so tests can exercise each release channel. */
+export const makeForVersion = Effect.fnUntraced(function* (t3CodeVersion: string) {
   const fileSystem = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const config = yield* ServerConfig;
@@ -369,7 +391,7 @@ export const make = Effect.gen(function* () {
       if (manifestUpdatedAtMs(BUNDLED_MODEL_MANIFEST) > manifestUpdatedAtMs(fromDisk.manifest)) {
         return;
       }
-      manifest = fromDisk.manifest;
+      manifest = withPreviewCompatibility(fromDisk.manifest, t3CodeVersion);
       fetchedAtMs = fromDisk.fetchedAtMs;
     }),
   );
@@ -408,7 +430,7 @@ export const make = Effect.gen(function* () {
       return manifest;
     }
 
-    manifest = fetched;
+    manifest = withPreviewCompatibility(fetched, t3CodeVersion);
     fetchedAtMs = now;
     yield* encodeManifestCache({ fetchedAtMs: now, manifest: fetched }).pipe(
       Effect.flatMap((serialized) => fileSystem.writeFileString(cachePath, serialized)),
@@ -427,4 +449,6 @@ export const make = Effect.gen(function* () {
   });
 });
 
+export const make = makeForVersion(packageJson.version);
+
 export const layer = Layer.effect(ModelManifest, make);

apps/server/src/provider/model-manifest.json

@@ -53,11 +53,11 @@
     {
       "driver": "opencode",
       "t3CodeRange": ">=0.0.42",
-      "recommendedRange": ">=1.14.19 <2.0.0",
-      "recommendedVersion": "1.14.19",
+      "recommendedRange": ">=2.0.18",
       "ranges": [
-        { "range": ">=2.0.0", "status": "broken" },
-        { "range": ">=1.14.19 <2.0.0", "status": "supported" },
+        { "range": ">=2.0.18", "status": "supported" },
+        { "range": ">=2.0.0 <2.0.18", "status": "unsupported" },
+        { "range": ">=1.14.19 <2.0.0", "status": "graceful" },
         { "range": "<1.14.19", "status": "broken" }
       ]
     },

apps/server/src/provider/providerCompatibility.test.ts

@@ -67,6 +67,28 @@ describe("provider compatibility", () => {
     }
   });
 
+  it("supports OpenCode 2 and gives OpenCode 1.x limited support", () => {
+    const opencode = ProviderDriverKind.make("opencode");
+    for (const [version, expected] of [
+      ["2.0.18", "supported"],
+      ["2.1.0", "supported"],
+      // Early OpenCode 2 releases predate the API the adapter was built against.
+      ["2.0.17", "unsupported"],
+      ["2.0.0", "unsupported"],
+      ["1.99.0", "graceful"],
+      ["1.14.19", "graceful"],
+      ["1.14.18", "broken"],
+    ] as const) {
+      const advisory = resolveProviderCompatibility(
+        ModelManifest.BUNDLED_MODEL_MANIFEST.compatibility,
+        opencode,
+        version,
+      );
+      assert.strictEqual(advisory?.status, expected, `OpenCode ${version}`);
+      assert.strictEqual(advisory?.recommendedRange, ">=2.0.18");
+    }
+  });
+
   it("compares Cursor build dates without treating semver prereleases as stable", () => {
     const cursor = ProviderDriverKind.make("cursor");
     const cursorPolicy: ProviderCompatibilityPolicy = {