From 38359fdcee7b235cb4c313c906f938c8d090baa2 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Thu, 19 Nov 2026 15:43:40 -0800 Subject: [PATCH 1/4] refactor(server): OpenCode and Pi read their minimum version from the manifest Provider packages ask the host for a version's compatibility tier, so the OpenCode 1.14.19 and Pi 0.84.3 constants are gone. Pi's policy now rates versions below 0.84.3 broken, matching the error its status check already reported. Co-Authored-By: Claude Fable 5.2 --- apps/server/src/provider/ProviderHostLive.ts | 10 ++++++ apps/server/src/provider/model-manifest.json | 4 +-- .../src/provider/providerCompatibility.ts | 13 +++---- docs/internals/adding-a-provider.md | 2 +- packages/provider-core/package.json | 4 +++ .../provider-core/src/server/ProviderHost.ts | 3 ++ .../provider-core/src/server/compatibility.ts | 23 ++++++++++++ .../src/server/managedProvider.test.ts | 1 + .../OpenCodeRuntime.environment.test.ts | 25 ------------- .../src/server/OpenCodeRuntime.ts | 15 +++----- .../provider-opencode/src/server/driver.ts | 1 + .../src/server/status.test.ts | 36 +++++++++++++++++-- .../provider-opencode/src/server/status.ts | 17 +++++++-- .../src/server/versionProbe.ts | 4 +-- packages/provider-pi/src/server/driver.ts | 10 ++++-- .../provider-pi/src/server/status.test.ts | 17 ++++++--- packages/provider-pi/src/server/status.ts | 20 ++++++++--- .../src/server/textGeneration.test.ts | 13 ++++++- .../provider-pi/src/server/textGeneration.ts | 26 +++++++++----- .../provider-testing/src/TestProviderHost.ts | 6 ++++ 20 files changed, 175 insertions(+), 75 deletions(-) create mode 100644 packages/provider-core/src/server/compatibility.ts diff --git a/apps/server/src/provider/ProviderHostLive.ts b/apps/server/src/provider/ProviderHostLive.ts index 405e2f7100029..8f00468b78d2c 100644 --- a/apps/server/src/provider/ProviderHostLive.ts +++ b/apps/server/src/provider/ProviderHostLive.ts @@ -14,6 +14,7 @@ import * as PortScanner from "../preview/PortScanner.ts"; import * as ServerLifecycleEvents from "../serverLifecycleEvents.ts"; import * as ServerSettings from "../serverSettings.ts"; import * as DocumentText from "./DocumentText.ts"; +import * as ModelManifest from "./ModelManifest.ts"; import * as ProviderCredentialStore from "./ProviderCredentialStore.ts"; export const layer = Layer.effect( @@ -31,7 +32,16 @@ export const layer = Layer.effect( ); // Optional so hosts built without the preview layer still construct. const portDiscovery = yield* Effect.serviceOption(PortScanner.PortDiscovery); + // Optional like the services above; without it the bundled policy still applies. + const manifest = yield* Effect.serviceOption(ModelManifest.ModelManifest); + const currentManifest = Option.match(manifest, { + onNone: () => Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST), + onSome: (service) => service.current, + }); return ProviderHost.ProviderHost.of({ + compatibility: Effect.fn("ProviderHost.compatibility")(function* (driver, version) { + return ModelManifest.providerCompatibility(yield* currentManifest, driver, version); + }), paths: { cwd: config.cwd, baseDir: config.baseDir, diff --git a/apps/server/src/provider/model-manifest.json b/apps/server/src/provider/model-manifest.json index bb2e561e3f3ac..ceabf42adb453 100644 --- a/apps/server/src/provider/model-manifest.json +++ b/apps/server/src/provider/model-manifest.json @@ -1,6 +1,6 @@ { "version": 1, - "updatedAt": "2026-11-19T23:30:00Z", + "updatedAt": "2026-11-19T23:45:00Z", "compatibility": [ { "driver": "codex", @@ -107,7 +107,7 @@ "recommendedRange": ">=1.0.0", "ranges": [ { "range": ">=0.84.3", "status": "supported" }, - { "range": "<0.84.3", "status": "unsupported" } + { "range": "<0.84.3", "status": "broken" } ] }, { diff --git a/apps/server/src/provider/providerCompatibility.ts b/apps/server/src/provider/providerCompatibility.ts index 7d8bed45c7b1c..13cc28c944f7c 100644 --- a/apps/server/src/provider/providerCompatibility.ts +++ b/apps/server/src/provider/providerCompatibility.ts @@ -7,6 +7,7 @@ import { type ServerProvider, type ServerProviderCompatibilityAdvisory, } from "@t3tools/contracts"; +import { brokenVersionDetail } from "@t3tools/provider-core/server/compatibility"; import { satisfiesSemverRange } from "@t3tools/shared/semver"; import * as Schema from "effect/Schema"; import packageJson from "../../package.json" with { type: "json" }; @@ -115,14 +116,10 @@ export function brokenRuntimeError(input: { readonly advisory: ServerProviderCompatibilityAdvisory | undefined; readonly action?: string; }): ProviderSetupError | undefined { - if (input.advisory?.status !== "broken") return undefined; - const target = - input.advisory.recommendedVersion ?? input.advisory.recommendedRange ?? "a newer version"; - return new ProviderSetupError({ - instanceId: input.instanceId, - operation: "runtime", - detail: `${input.name} ${input.version} does not work with this T3 Code release. ${input.action ?? `Update ${input.name}`} to ${target}, then retry.`, - }); + const detail = brokenVersionDetail(input); + return detail === undefined + ? undefined + : new ProviderSetupError({ instanceId: input.instanceId, operation: "runtime", detail }); } export function applyProviderCompatibility( diff --git a/docs/internals/adding-a-provider.md b/docs/internals/adding-a-provider.md index 5bf40a5296049..14ac6db1eb68c 100644 --- a/docs/internals/adding-a-provider.md +++ b/docs/internals/adding-a-provider.md @@ -114,7 +114,7 @@ A provider lives in its own `packages/provider-` package, with the server's replay testkits drive; testkits that need the orchestrator stay in the server. Settings live in `providerInstances`; new providers are off by default. - **Package boundaries.** Server code imports only `@t3tools/provider-core/server/*`, contracts, - and shared. It reaches the server through `ProviderHost` (paths, settings, background demand, + and shared. It reaches the server through `ProviderHost` (paths, settings, background demand, version policy, attachments, stored credentials), never through `apps/server`. Tests use `@t3tools/provider-testing`. - **Server registration:** the driver's entry in [`builtInDrivers.ts`](../../apps/server/src/provider/builtInDrivers.ts). The driver carries its diff --git a/packages/provider-core/package.json b/packages/provider-core/package.json index 3ff646eaa135d..66942a0c95824 100644 --- a/packages/provider-core/package.json +++ b/packages/provider-core/package.json @@ -19,6 +19,10 @@ "types": "./src/server/attachmentPrompt.ts", "import": "./src/server/attachmentPrompt.ts" }, + "./server/compatibility": { + "types": "./src/server/compatibility.ts", + "import": "./src/server/compatibility.ts" + }, "./server/auth": { "types": "./src/server/auth.ts", "import": "./src/server/auth.ts" diff --git a/packages/provider-core/src/server/ProviderHost.ts b/packages/provider-core/src/server/ProviderHost.ts index 6f93df188ea53..05917d7084153 100644 --- a/packages/provider-core/src/server/ProviderHost.ts +++ b/packages/provider-core/src/server/ProviderHost.ts @@ -10,6 +10,7 @@ import type * as Option from "effect/Option"; import type * as Scope from "effect/Scope"; import type * as Stream from "effect/Stream"; +import type { ProviderCompatibilityLookup } from "./compatibility.ts"; import type { ProviderCredentialError } from "./errors.ts"; export interface ProviderHostPaths { @@ -58,5 +59,7 @@ export class ProviderHost extends Context.Service< namespace: string, bindingId: string, ) => Effect.Effect; + /** A driver declares its minimum version in the policy and asks here, not in a constant. */ + readonly compatibility: ProviderCompatibilityLookup; } >()("@t3tools/provider-core/server/ProviderHost") {} diff --git a/packages/provider-core/src/server/compatibility.ts b/packages/provider-core/src/server/compatibility.ts new file mode 100644 index 0000000000000..cb2eeea63219f --- /dev/null +++ b/packages/provider-core/src/server/compatibility.ts @@ -0,0 +1,23 @@ +import type { ProviderDriverKind, ServerProviderCompatibilityAdvisory } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; + +/** Rates a detected provider version against the host's compatibility policy. */ +export type ProviderCompatibilityLookup = ( + driver: ProviderDriverKind, + version: string, +) => Effect.Effect; + +export const noCompatibilityPolicy: ProviderCompatibilityLookup = () => Effect.undefined; + +/** The one message for a version the policy rates `broken`; `action` names how it is updated. */ +export function brokenVersionDetail(input: { + readonly name: string; + readonly version: string; + readonly advisory: ServerProviderCompatibilityAdvisory | undefined; + readonly action?: string; +}): string | undefined { + if (input.advisory?.status !== "broken") return undefined; + const target = + input.advisory.recommendedVersion ?? input.advisory.recommendedRange ?? "a newer version"; + return `${input.name} ${input.version} does not work with this T3 Code release. ${input.action ?? `Update ${input.name}`} to ${target}, then retry.`; +} diff --git a/packages/provider-core/src/server/managedProvider.test.ts b/packages/provider-core/src/server/managedProvider.test.ts index f878b2f44ecca..0eccada27c508 100644 --- a/packages/provider-core/src/server/managedProvider.test.ts +++ b/packages/provider-core/src/server/managedProvider.test.ts @@ -105,6 +105,7 @@ function layerProviderHost(input: { return Layer.succeed( ProviderHost.ProviderHost, ProviderHost.ProviderHost.of({ + compatibility: () => Effect.undefined, paths: { cwd: process.cwd(), baseDir: "/t3", diff --git a/packages/provider-opencode/src/server/OpenCodeRuntime.environment.test.ts b/packages/provider-opencode/src/server/OpenCodeRuntime.environment.test.ts index 8e4663e416511..437ffe5ce318a 100644 --- a/packages/provider-opencode/src/server/OpenCodeRuntime.environment.test.ts +++ b/packages/provider-opencode/src/server/OpenCodeRuntime.environment.test.ts @@ -1,6 +1,3 @@ -import type { OpencodeClient } from "@opencode-ai/sdk/v2"; -import { it as effectIt } from "@effect/vitest"; -import * as Effect from "effect/Effect"; import { describe, expect, it } from "vite-plus/test"; import * as OpenCodeRuntime from "./OpenCodeRuntime.ts"; @@ -28,25 +25,3 @@ describe("resolveOpenCodeServerPassword", () => { ).toBeUndefined(); }); }); - -function makeHealthClient( - result: (options?: { readonly signal?: AbortSignal }) => Promise, -): OpencodeClient { - return { - global: { - health: result, - }, - } as unknown as OpencodeClient; -} - -describe("verifyOpenCodeServerVersion", () => { - effectIt.effect("rejects a server below the supported version", () => - Effect.gen(function* () { - const error = yield* OpenCodeRuntime.verifyOpenCodeServerVersion( - makeHealthClient(() => Promise.resolve({ data: { healthy: true, version: "1.14.18" } })), - ).pipe(Effect.flip); - expect(error).toBeInstanceOf(OpenCodeRuntime.OpenCodeRuntimeError); - expect(error.detail).toContain("v1.14.18 is too old"); - }), - ); -}); diff --git a/packages/provider-opencode/src/server/OpenCodeRuntime.ts b/packages/provider-opencode/src/server/OpenCodeRuntime.ts index ea2d7a7d76cac..d81d8c46fc16f 100644 --- a/packages/provider-opencode/src/server/OpenCodeRuntime.ts +++ b/packages/provider-opencode/src/server/OpenCodeRuntime.ts @@ -37,12 +37,11 @@ import { collectStreamAsString } from "@t3tools/provider-core/server/snapshotPro import * as NetService from "@t3tools/shared/Net"; import { AgentScope } from "@t3tools/shared/AgentScope"; import * as HostProcess from "@t3tools/shared/HostProcess"; -import { compareSemverVersions, parseSemver } from "@t3tools/shared/semver"; +import { parseSemver } from "@t3tools/shared/semver"; import { resolveSpawnCommand } from "@t3tools/shared/shell"; const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); const OPENCODE_EMPTY_CONFIG_CONTENT = "{}"; -export const MINIMUM_OPENCODE_VERSION = "1.14.19"; const OPENCODE_HEALTH_TIMEOUT_MS = 5_000; const OpenCodeHealthSchema = Schema.Struct({ @@ -162,7 +161,7 @@ export const runOpenCodeSdk = ( new OpenCodeRuntimeError({ operation, detail: openCodeRuntimeErrorDetail(cause), cause }), }).pipe(Effect.withSpan(`opencode.${operation}`)); -export const verifyOpenCodeServerVersion = Effect.fn("verifyOpenCodeServerVersion")(function* ( +const verifyOpenCodeServerVersion = Effect.fn("verifyOpenCodeServerVersion")(function* ( client: OpencodeClient, environment?: NodeJS.ProcessEnv, ) { @@ -185,7 +184,7 @@ export const verifyOpenCodeServerVersion = Effect.fn("verifyOpenCodeServerVersio (cause) => new OpenCodeRuntimeError({ operation: "global.health", - detail: `OpenCode server returned an invalid health response. T3 Code requires OpenCode v${MINIMUM_OPENCODE_VERSION} or newer.`, + detail: "OpenCode server returned an invalid health response.", cause, }), ), @@ -193,13 +192,7 @@ export const verifyOpenCodeServerVersion = Effect.fn("verifyOpenCodeServerVersio if (parseSemver(health.version) === null) { return yield* new OpenCodeRuntimeError({ operation: "global.health", - detail: `OpenCode server returned an invalid version. T3 Code requires OpenCode v${MINIMUM_OPENCODE_VERSION} or newer.`, - }); - } - if (compareSemverVersions(health.version, MINIMUM_OPENCODE_VERSION) < 0) { - return yield* new OpenCodeRuntimeError({ - operation: "global.health", - detail: `OpenCode v${health.version} is too old. Upgrade to v${MINIMUM_OPENCODE_VERSION} or newer.`, + detail: "OpenCode server returned an invalid version.", }); } return health.version; diff --git a/packages/provider-opencode/src/server/driver.ts b/packages/provider-opencode/src/server/driver.ts index de5ddb9d60d30..37cedde2e9a18 100644 --- a/packages/provider-opencode/src/server/driver.ts +++ b/packages/provider-opencode/src/server/driver.ts @@ -524,6 +524,7 @@ export const OpenCodeDriver: ProviderDriver< runtimeProbe.refresh, loadOpenCode2Models, processEnv, + host.compatibility, ).pipe( Effect.annotateLogs({ providerInstanceId: instanceId }), Effect.annotateSpans({ providerInstanceId: instanceId }), diff --git a/packages/provider-opencode/src/server/status.test.ts b/packages/provider-opencode/src/server/status.test.ts index 732aa51560822..05901e924451b 100644 --- a/packages/provider-opencode/src/server/status.test.ts +++ b/packages/provider-opencode/src/server/status.test.ts @@ -20,6 +20,7 @@ import { buildProviderOptionSelectionsFromDescriptors } from "@t3tools/shared/mo import { settingsSecretLiteral } from "@t3tools/contracts"; import { OpenCodeSettings } from "../settings.ts"; +import type { ProviderCompatibilityLookup } from "@t3tools/provider-core/server/compatibility"; import * as OpenCodeRuntime from "./OpenCodeRuntime.ts"; import * as OpenCodeServerOwner from "./OpenCodeServerOwner.ts"; import { @@ -507,6 +508,7 @@ const checkProvider = Effect.fn("checkProvider")(function* ( ReadonlyArray, OpenCodeRuntime.OpenCodeRuntimeError > = Effect.succeed([]), + compatibility?: ProviderCompatibilityLookup, ) { return yield* Effect.scoped( Effect.gen(function* () { @@ -520,9 +522,14 @@ const checkProvider = Effect.fn("checkProvider")(function* ( Effect.provideService(HttpClient.HttpClient, server), Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, OpenCodeRuntimeTestDouble), ); - return yield* checkOpenCodeProviderStatus(settings, cwd, probe, openCode2Models).pipe( - Effect.provideService(OpenCodeServerOwner.OpenCodeServerOwner, serverOwner), - ); + return yield* checkOpenCodeProviderStatus( + settings, + cwd, + probe, + openCode2Models, + environment, + compatibility, + ).pipe(Effect.provideService(OpenCodeServerOwner.OpenCodeServerOwner, serverOwner)); }), ); }); @@ -1093,6 +1100,29 @@ it.layer(layerTest)("checkOpenCodeProviderStatus with configured server URL", (i }), ); + it.effect("reports a version the policy rates broken before loading inventory", () => + Effect.gen(function* () { + const snapshot = yield* checkProvider( + makeOpenCodeSettings(), + undefined, + undefined, + undefined, + undefined, + () => + Effect.succeed({ + status: "broken", + message: null, + recommendedVersion: null, + recommendedRange: ">=2.0.18", + }), + ); + + NodeAssert.equal(snapshot.status, "error"); + NodeAssert.match(snapshot.message ?? "", /OpenCode 1\.14\.19 does not work/); + NodeAssert.equal(runtimeMock.state.sdkClientInputs.length, 0); + }), + ); + it.effect("rejects an unsupported server before loading inventory", () => Effect.gen(function* () { runtimeMock.state.connectionError = new Error( diff --git a/packages/provider-opencode/src/server/status.ts b/packages/provider-opencode/src/server/status.ts index e9776bcefc1d1..9b846445d8a10 100644 --- a/packages/provider-opencode/src/server/status.ts +++ b/packages/provider-opencode/src/server/status.ts @@ -1,5 +1,6 @@ import { resolveProviderProbeTimeoutMs } from "@t3tools/provider-core/server/snapshotProbe"; import { + ProviderDriverKind, type ModelCapabilities, type ServerProviderModel, type ServerProviderSkill, @@ -15,7 +16,11 @@ import * as Option from "effect/Option"; import * as Schedule from "effect/Schedule"; import { createModelCapabilities } from "@t3tools/shared/model"; -import { compareSemverVersions } from "@t3tools/shared/semver"; +import { + brokenVersionDetail, + noCompatibilityPolicy, + type ProviderCompatibilityLookup, +} from "@t3tools/provider-core/server/compatibility"; import { buildServerProvider, COMPACT_SLASH_COMMAND, @@ -779,6 +784,7 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu OpenCodeRuntime.OpenCodeRuntimeError >, environment?: NodeJS.ProcessEnv, + compatibility: ProviderCompatibilityLookup = noCompatibilityPolicy, ): Effect.fn.Return< ServerProviderDraft, never, @@ -853,7 +859,12 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu if (probed.generation === "v2") { return yield* checkOpenCode2(openCodeSettings, probed.version, checkedAt, loadOpenCode2Models); } - if (compareSemverVersions(probed.version, OpenCodeRuntime.MINIMUM_OPENCODE_VERSION) < 0) { + const broken = brokenVersionDetail({ + name: "OpenCode", + version: probed.version, + advisory: yield* compatibility(ProviderDriverKind.make("opencode"), probed.version), + }); + if (broken !== undefined) { return buildServerProvider({ presentation: OPENCODE_PRESENTATION, enabled: openCodeSettings.enabled, @@ -864,7 +875,7 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu version: probed.version, status: "error", auth: { status: "unknown" }, - message: `OpenCode v${probed.version} is too old. Upgrade to v${OpenCodeRuntime.MINIMUM_OPENCODE_VERSION} or newer.`, + message: broken, }, }); } diff --git a/packages/provider-opencode/src/server/versionProbe.ts b/packages/provider-opencode/src/server/versionProbe.ts index 705cfe1cabf4e..a87057bd3ea41 100644 --- a/packages/provider-opencode/src/server/versionProbe.ts +++ b/packages/provider-opencode/src/server/versionProbe.ts @@ -88,7 +88,7 @@ export const probeOpenCodeBinary = Effect.fn("probeOpenCodeBinary")(function* ( if (result) return result; return yield* new OpenCodeRuntime.OpenCodeRuntimeError({ operation: "probeOpenCodeBinary", - detail: `Unable to determine OpenCode version from \`opencode --version\` output. T3 Code requires OpenCode v${OpenCodeRuntime.MINIMUM_OPENCODE_VERSION} or newer.`, + detail: "Unable to determine OpenCode version from `opencode --version` output.", }); }); @@ -163,7 +163,7 @@ const probeOpenCodeServer = Effect.fn("probeOpenCodeServer")(function* ( } return yield* new OpenCodeRuntime.OpenCodeRuntimeError({ operation: "probeOpenCodeServer", - detail: `The server did not identify itself as OpenCode. T3 Code requires OpenCode v${OpenCodeRuntime.MINIMUM_OPENCODE_VERSION} or newer.`, + detail: "The server did not identify itself as OpenCode.", }); }); diff --git a/packages/provider-pi/src/server/driver.ts b/packages/provider-pi/src/server/driver.ts index 325b500a35d94..6a9e07bc60fc2 100644 --- a/packages/provider-pi/src/server/driver.ts +++ b/packages/provider-pi/src/server/driver.ts @@ -140,13 +140,19 @@ export const PiDriver: ProviderDriver = { }), ), ); - const textGeneration = yield* makePiTextGeneration(effectiveConfig, processEnv); + const textGeneration = yield* makePiTextGeneration( + effectiveConfig, + processEnv, + host.compatibility, + ); const checkProvider = fileSystem .makeDirectory(probeCwd, { recursive: true }) .pipe( Effect.ignore, - Effect.andThen(checkPiProviderStatus(effectiveConfig, processEnv, probeCwd)), + Effect.andThen( + checkPiProviderStatus(effectiveConfig, processEnv, probeCwd, host.compatibility), + ), Effect.map(stampIdentity), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), ); diff --git a/packages/provider-pi/src/server/status.test.ts b/packages/provider-pi/src/server/status.test.ts index 3c562b461579d..75ab2a89525c5 100644 --- a/packages/provider-pi/src/server/status.test.ts +++ b/packages/provider-pi/src/server/status.test.ts @@ -12,7 +12,7 @@ import * as Stream from "effect/Stream"; import * as ChildProcess from "effect/process/ChildProcess"; import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; -import { checkPiProviderStatus, MINIMUM_PI_VERSION } from "./status.ts"; +import { checkPiProviderStatus } from "./status.ts"; const encoder = new TextEncoder(); const decodeRpcRequest = Schema.decodeSync( @@ -174,15 +174,24 @@ const settings = { customModels: [], } as const; +const BROKEN_ADVISORY = { + status: "broken", + message: null, + recommendedVersion: null, + recommendedRange: ">=1.0.0", +} as const; + describe("PiProvider", () => { - it.effect("requires session-scoped thinking changes", () => + it.effect("reports a version the policy rates broken as an error", () => Effect.gen(function* () { - const snapshot = yield* checkPiProviderStatus(settings).pipe( + const snapshot = yield* checkPiProviderStatus(settings, undefined, undefined, () => + Effect.succeed(BROKEN_ADVISORY), + ).pipe( Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, piProbeSpawner("0.84.2")), ); assert.equal(snapshot.status, "error"); assert.equal(snapshot.version, "0.84.2"); - assert.include(snapshot.message ?? "", `Pi ${MINIMUM_PI_VERSION} or newer`); + assert.include(snapshot.message ?? "", "Pi 0.84.2 does not work"); }).pipe(Effect.provide(NodeServices.layer)), ); diff --git a/packages/provider-pi/src/server/status.ts b/packages/provider-pi/src/server/status.ts index 86a8e63de753c..3d6f969747b3f 100644 --- a/packages/provider-pi/src/server/status.ts +++ b/packages/provider-pi/src/server/status.ts @@ -1,5 +1,6 @@ import { resolveProviderProbeTimeoutMs } from "@t3tools/provider-core/server/snapshotProbe"; import { + ProviderDriverKind, type CustomModelSetting, type ServerProvider, type ServerProviderModel, @@ -7,7 +8,11 @@ import { import type { PiSettings } from "../settings.ts"; import { causeErrorTag } from "@t3tools/shared/observability"; import { resolveSpawnCommand } from "@t3tools/shared/shell"; -import { compareSemverVersions } from "@t3tools/shared/semver"; +import { + brokenVersionDetail, + noCompatibilityPolicy, + type ProviderCompatibilityLookup, +} from "@t3tools/provider-core/server/compatibility"; import * as Cause from "effect/Cause"; import * as DateTime from "effect/DateTime"; import * as Effect from "effect/Effect"; @@ -62,7 +67,6 @@ const VERSION_PROBE_TIMEOUT_MS = 10_000; const PI_RPC_DISCOVERY_TIMEOUT_MS = 30_000; const PI_TEXT_GENERATION_DISCOVERY_TIMEOUT_MS = 5_000; // Earlier releases persist background set_thinking_level requests as the user's global default. -export const MINIMUM_PI_VERSION = "0.84.3"; const decodePiAuthCheck = Schema.decodeUnknownOption( Schema.fromJsonString(Schema.Struct({ reason: Schema.optional(Schema.String) })), @@ -433,6 +437,7 @@ export const checkPiProviderStatus = Effect.fn("checkPiProviderStatus")(function piSettings: PiSettings, environment: NodeJS.ProcessEnv = process.env, cwd?: string, + compatibility: ProviderCompatibilityLookup = noCompatibilityPolicy, ): Effect.fn.Return { const checkedAt = DateTime.formatIso(yield* DateTime.now); const fallbackModels = piModelsFromSettings(piSettings.customModels); @@ -526,12 +531,17 @@ export const checkPiProviderStatus = Effect.fn("checkPiProviderStatus")(function version: null, status: "error", auth: { status: "unknown" }, - message: `T3 Code could not determine the Pi version. Pi ${MINIMUM_PI_VERSION} or newer is required.`, + message: "T3 Code could not determine the Pi version. Update Pi, then refresh its status.", }, }); } - if (compareSemverVersions(version, MINIMUM_PI_VERSION) < 0) { + const broken = brokenVersionDetail({ + name: "Pi", + version, + advisory: yield* compatibility(ProviderDriverKind.make("pi"), version), + }); + if (broken !== undefined) { return buildServerProvider({ presentation: PI_PRESENTATION, enabled: piSettings.enabled, @@ -542,7 +552,7 @@ export const checkPiProviderStatus = Effect.fn("checkPiProviderStatus")(function version, status: "error", auth: { status: "unknown" }, - message: `Pi ${version} is unsupported. Update to Pi ${MINIMUM_PI_VERSION} or newer.`, + message: broken, }, }); } diff --git a/packages/provider-pi/src/server/textGeneration.test.ts b/packages/provider-pi/src/server/textGeneration.test.ts index 6c977eee3cfa7..49e10baef06f2 100644 --- a/packages/provider-pi/src/server/textGeneration.test.ts +++ b/packages/provider-pi/src/server/textGeneration.test.ts @@ -253,6 +253,17 @@ it.effect.each([ const textGeneration = yield* makePiTextGeneration( { enabled: true, binaryPath: "pi", launchArgs: "", customModels: [] }, {}, + (_driver, detected) => + Effect.succeed( + detected === "0.84.2" + ? { + status: "broken" as const, + message: null, + recommendedVersion: null, + recommendedRange: ">=1.0.0", + } + : undefined, + ), ).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, pi.spawner)); const generation = textGeneration.generateCommitMessage({ @@ -268,7 +279,7 @@ it.effect.each([ }); if (version === "0.84.2") { const error = yield* generation.pipe(Effect.flip); - assert.include(error.detail, "Pi 0.84.3 or newer"); + assert.include(error.detail, "Pi 0.84.2 does not work"); assert.deepEqual(pi.received, []); return; } diff --git a/packages/provider-pi/src/server/textGeneration.ts b/packages/provider-pi/src/server/textGeneration.ts index dbc80cdfb4f6f..100dc0cef5892 100644 --- a/packages/provider-pi/src/server/textGeneration.ts +++ b/packages/provider-pi/src/server/textGeneration.ts @@ -4,9 +4,13 @@ import * as Queue from "effect/Queue"; import * as Schema from "effect/Schema"; import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; -import { TextGenerationError } from "@t3tools/contracts"; +import { ProviderDriverKind, TextGenerationError } from "@t3tools/contracts"; import { getModelSelectionStringOptionValue } from "@t3tools/shared/model"; -import { compareSemverVersions } from "@t3tools/shared/semver"; +import { + brokenVersionDetail, + noCompatibilityPolicy, + type ProviderCompatibilityLookup, +} from "@t3tools/provider-core/server/compatibility"; import { parseGenericCliVersion } from "@t3tools/provider-core/server/snapshotProbe"; import type { PiSettings } from "../settings.ts"; @@ -14,7 +18,7 @@ import { makePiRpcConnection, piRecordField, piRecordString, resolvePiModelSlug import { buildPiRpcLaunch, resolvePiLaunchArgs } from "./mcpInjection.ts"; import * as TextGenerationOperations from "@t3tools/provider-core/server/textGenerationOperations"; import { isPiThinkingLevel } from "./modelCapabilities.ts"; -import { MINIMUM_PI_VERSION, runPiVersionCommand } from "./status.ts"; +import { runPiVersionCommand } from "./status.ts"; const PI_TIMEOUT_MS = 180_000; @@ -32,6 +36,7 @@ const piTurnErrorDetail = (errorMessage: string | undefined) => { export const makePiTextGeneration = Effect.fn("makePiTextGeneration")(function* ( piSettings: PiSettings, environment: NodeJS.ProcessEnv = process.env, + compatibility: ProviderCompatibilityLookup = noCompatibilityPolicy, ) { const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; @@ -48,11 +53,16 @@ export const makePiTextGeneration = Effect.fn("makePiTextGeneration")(function* Option.isSome(output) && output.value.code === 0 ? parseGenericCliVersion(`${output.value.stdout}\n${output.value.stderr}`) : null; - if (version === null || compareSemverVersions(version, MINIMUM_PI_VERSION) < 0) { - return yield* new TextGenerationError({ - operation, - detail: `Pi ${MINIMUM_PI_VERSION} or newer is required for text generation thinking options. Update Pi and try again.`, - }); + const broken = + version === null + ? "T3 Code could not determine the Pi version. Update Pi and try again." + : brokenVersionDetail({ + name: "Pi", + version, + advisory: yield* compatibility(ProviderDriverKind.make("pi"), version), + }); + if (broken !== undefined) { + return yield* new TextGenerationError({ operation, detail: broken }); } } diff --git a/packages/provider-testing/src/TestProviderHost.ts b/packages/provider-testing/src/TestProviderHost.ts index 6db6186d7f835..f16f83b40f7b2 100644 --- a/packages/provider-testing/src/TestProviderHost.ts +++ b/packages/provider-testing/src/TestProviderHost.ts @@ -1,4 +1,8 @@ import { DEFAULT_SERVER_SETTINGS, type ServerSettings } from "@t3tools/contracts"; +import { + noCompatibilityPolicy, + type ProviderCompatibilityLookup, +} from "@t3tools/provider-core/server/compatibility"; import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; @@ -13,6 +17,7 @@ export interface TestProviderHostOptions { readonly cwd?: string; readonly settings?: ServerSettings; readonly runBackgroundWork?: boolean; + readonly compatibility?: ProviderCompatibilityLookup; } export class TestProviderHostSettings extends Context.Service< @@ -43,6 +48,7 @@ export const layer = ( const settings = yield* Ref.make(options.settings ?? DEFAULT_SERVER_SETTINGS); const credentials = new Map(); const host = ProviderHost.ProviderHost.of({ + compatibility: options.compatibility ?? noCompatibilityPolicy, paths: { cwd: options.cwd ?? process.cwd(), baseDir, From 8da8b8bbf0456ba852ef5581dd9834c02ff76081 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Thu, 19 Nov 2026 16:11:05 -0800 Subject: [PATCH 2/4] fix(server): OpenCode text generation refuses a version the policy rates broken Text generation never opens a session, so it bypassed the shared gate once the runtime floor was removed. It now asks the host like Pi does. OpenCode prerelease versions are rated by their base version again, and two tests that asserted the removed runtime floor are corrected. Co-Authored-By: Claude Fable 5.2 --- apps/server/src/provider/model-manifest.json | 3 ++- .../src/server/status.test.ts | 8 +++----- .../src/server/textGeneration.test.ts | 20 +++++++++++++------ .../src/server/textGeneration.ts | 17 +++++++++++++++- packages/provider-pi/src/server/status.ts | 3 ++- 5 files changed, 37 insertions(+), 14 deletions(-) diff --git a/apps/server/src/provider/model-manifest.json b/apps/server/src/provider/model-manifest.json index ceabf42adb453..9981e41f526e9 100644 --- a/apps/server/src/provider/model-manifest.json +++ b/apps/server/src/provider/model-manifest.json @@ -1,6 +1,6 @@ { "version": 1, - "updatedAt": "2026-11-19T23:45:00Z", + "updatedAt": "2026-11-20T00:10:00Z", "compatibility": [ { "driver": "codex", @@ -65,6 +65,7 @@ { "driver": "opencode", "t3CodeRange": ">=0.0.46", + "versionPattern": "^(\\d+\\.\\d+\\.\\d+)-[0-9A-Za-z.-]+$", "recommendedRange": ">=2.0.18", "ranges": [ { "range": ">=2.0.18", "status": "supported" }, diff --git a/packages/provider-opencode/src/server/status.test.ts b/packages/provider-opencode/src/server/status.test.ts index 05901e924451b..6362dd4e73ed2 100644 --- a/packages/provider-opencode/src/server/status.test.ts +++ b/packages/provider-opencode/src/server/status.test.ts @@ -1123,18 +1123,16 @@ it.layer(layerTest)("checkOpenCodeProviderStatus with configured server URL", (i }), ); - it.effect("rejects an unsupported server before loading inventory", () => + it.effect("reports a failed server connection before loading inventory", () => Effect.gen(function* () { - runtimeMock.state.connectionError = new Error( - "OpenCode v1.14.18 is too old. Upgrade to v1.14.19 or newer.", - ); + runtimeMock.state.connectionError = new Error("OpenCode server refused the connection."); const snapshot = yield* checkProvider( makeOpenCodeSettings({ serverUrl: "http://127.0.0.1:9999" }), ); NodeAssert.equal(snapshot.status, "error"); NodeAssert.equal(snapshot.models.length, 0); - NodeAssert.match(snapshot.message ?? "", /v1\.14\.18 is too old/); + NodeAssert.match(snapshot.message ?? "", /refused the connection/); NodeAssert.equal(runtimeMock.state.sdkClientInputs.length, 0); }), ); diff --git a/packages/provider-opencode/src/server/textGeneration.test.ts b/packages/provider-opencode/src/server/textGeneration.test.ts index b29e2fb9f86d2..d097e66bf53c4 100644 --- a/packages/provider-opencode/src/server/textGeneration.test.ts +++ b/packages/provider-opencode/src/server/textGeneration.test.ts @@ -15,6 +15,7 @@ import * as TestClock from "effect/testing/TestClock"; import * as NetService from "@t3tools/shared/Net"; import { beforeEach, expect } from "vite-plus/test"; +import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost"; import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost"; import * as OpenCodeRuntime from "./OpenCodeRuntime.ts"; import * as OpenCodeServerOwner from "./OpenCodeServerOwner.ts"; @@ -615,21 +616,28 @@ it.layer(layerOpenCodeTextGenerationExistingServerTest)( ), ); - it.effect("does not create a session when the server version is unsupported", () => + it.effect("does not create a session on a server version the policy rates broken", () => withOpenCodeTextGeneration(EXISTING_SERVER_OPENCODE_SETTINGS, (textGeneration) => Effect.gen(function* () { - runtimeMock.state.connectionError = new Error( - "OpenCode v1.14.18 is too old. Upgrade to v1.14.19 or newer.", - ); - const error = yield* textGeneration .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT) .pipe(Effect.flip); expect(error).toBeInstanceOf(TextGenerationError); - expect(error.message).toContain("v1.14.18 is too old"); + expect(error.message).toContain("OpenCode 1.14.19 does not work"); expect(runtimeMock.state.sessionCreateCalls).toBe(0); }), + ).pipe( + Effect.updateService(ProviderHost.ProviderHost, (host) => ({ + ...host, + compatibility: () => + Effect.succeed({ + status: "broken" as const, + message: null, + recommendedVersion: null, + recommendedRange: ">=2.0.18", + }), + })), ), ); diff --git a/packages/provider-opencode/src/server/textGeneration.ts b/packages/provider-opencode/src/server/textGeneration.ts index bbb02d36e6323..21ff29e968faa 100644 --- a/packages/provider-opencode/src/server/textGeneration.ts +++ b/packages/provider-opencode/src/server/textGeneration.ts @@ -1,7 +1,13 @@ import * as Effect from "effect/Effect"; import * as Schema from "effect/Schema"; -import { NonNegativeInt, settingsSecretLiteral, TextGenerationError } from "@t3tools/contracts"; +import { + NonNegativeInt, + ProviderDriverKind, + settingsSecretLiteral, + TextGenerationError, +} from "@t3tools/contracts"; +import { brokenVersionDetail } from "@t3tools/provider-core/server/compatibility"; import type { OpenCodeSettings } from "../settings.ts"; import { getModelSelectionStringOptionValue } from "@t3tools/shared/model"; @@ -203,6 +209,15 @@ export const makeOpenCodeTextGeneration = Effect.fn("makeOpenCodeTextGeneration" "url" | "serverPassword" | "version" >, ) { + // Text generation does not open a session, so the shared session check never sees it. + const broken = brokenVersionDetail({ + name: "OpenCode", + version: server.version, + advisory: yield* host.compatibility(ProviderDriverKind.make("opencode"), server.version), + }); + if (broken !== undefined) { + return yield* new TextGenerationError({ operation: input.operation, detail: broken }); + } const client = openCodeRuntime.createOpenCodeSdkClient({ baseUrl: server.url, directory: input.cwd, diff --git a/packages/provider-pi/src/server/status.ts b/packages/provider-pi/src/server/status.ts index 3d6f969747b3f..76a05fde0b88e 100644 --- a/packages/provider-pi/src/server/status.ts +++ b/packages/provider-pi/src/server/status.ts @@ -66,7 +66,6 @@ const PI_PRESENTATION = { const VERSION_PROBE_TIMEOUT_MS = 10_000; const PI_RPC_DISCOVERY_TIMEOUT_MS = 30_000; const PI_TEXT_GENERATION_DISCOVERY_TIMEOUT_MS = 5_000; -// Earlier releases persist background set_thinking_level requests as the user's global default. const decodePiAuthCheck = Schema.decodeUnknownOption( Schema.fromJsonString(Schema.Struct({ reason: Schema.optional(Schema.String) })), @@ -536,6 +535,8 @@ export const checkPiProviderStatus = Effect.fn("checkPiProviderStatus")(function }); } + // Stop before discovery: releases the policy rates broken persist background + // set_thinking_level requests as the user's global default. const broken = brokenVersionDetail({ name: "Pi", version, From 52346aa6d913782cbf68f4da2bfd4e864488de79 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Thu, 19 Nov 2026 16:36:39 -0800 Subject: [PATCH 3/4] fix(server): OpenCode versions with build metadata are rated by their base version Co-Authored-By: Claude Fable 5.2 --- apps/server/src/provider/model-manifest.json | 4 ++-- .../src/provider/providerCompatibility.test.ts | 16 ++++++++++++++++ 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/apps/server/src/provider/model-manifest.json b/apps/server/src/provider/model-manifest.json index 9981e41f526e9..6748db955ab9e 100644 --- a/apps/server/src/provider/model-manifest.json +++ b/apps/server/src/provider/model-manifest.json @@ -1,6 +1,6 @@ { "version": 1, - "updatedAt": "2026-11-20T00:10:00Z", + "updatedAt": "2026-11-20T00:34:00Z", "compatibility": [ { "driver": "codex", @@ -65,7 +65,7 @@ { "driver": "opencode", "t3CodeRange": ">=0.0.46", - "versionPattern": "^(\\d+\\.\\d+\\.\\d+)-[0-9A-Za-z.-]+$", + "versionPattern": "^(\\d+\\.\\d+\\.\\d+)(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$", "recommendedRange": ">=2.0.18", "ranges": [ { "range": ">=2.0.18", "status": "supported" }, diff --git a/apps/server/src/provider/providerCompatibility.test.ts b/apps/server/src/provider/providerCompatibility.test.ts index e120aa9cff976..83947bedf9213 100644 --- a/apps/server/src/provider/providerCompatibility.test.ts +++ b/apps/server/src/provider/providerCompatibility.test.ts @@ -73,6 +73,22 @@ describe("provider compatibility", () => { assert.strictEqual(advisory?.status, expected, `OpenCode ${version} on 0.0.45`); assert.strictEqual(advisory?.recommendedVersion, "1.14.19"); } + // The current policy rates a prerelease or build by its base version. + for (const [version, expected] of [ + ["1.13.0-beta.1", "broken"], + ["1.13.0+abc123", "broken"], + ["2.1.0-rc.1", "supported"], + ] as const) { + assert.strictEqual( + resolveProviderCompatibility( + ModelManifest.BUNDLED_MODEL_MANIFEST.compatibility, + opencode, + version, + )?.status, + expected, + `OpenCode ${version}`, + ); + } assert.isUndefined( resolveProviderCompatibility( ModelManifest.BUNDLED_MODEL_MANIFEST.compatibility, From 06605c4957654656271d57b3fd319b61227af361 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Thu, 19 Nov 2026 16:54:01 -0800 Subject: [PATCH 4/4] fix(server): OpenCode sessions and status rate the version the server reports A session opened before any status probe reached an old server with no check, and the status probe rated the CLI's version even when a different server answered. Both now ask the host with the connected server's version. Co-Authored-By: Claude Fable 5.2 --- .../src/server/adapter.test.ts | 32 +++++++++++++ .../provider-opencode/src/server/adapter.ts | 15 +++++++ .../provider-opencode/src/server/status.ts | 45 +++++++++++-------- 3 files changed, 73 insertions(+), 19 deletions(-) diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts index 96e6cd7aa4ae7..2eb62547185e6 100644 --- a/packages/provider-opencode/src/server/adapter.test.ts +++ b/packages/provider-opencode/src/server/adapter.test.ts @@ -184,6 +184,7 @@ const makeOpenCodeRuntimeHarness = Effect.fn("makeOpenCodeRuntimeHarness")(funct connectToOpenCodeServer: () => Effect.succeed({ url: "http://test.invalid", + version: "1.14.19", external: turnSettings.exitCode === undefined, exitCode: turnSettings.exitCode ?? null, }), @@ -192,6 +193,7 @@ const makeOpenCodeRuntimeHarness = Effect.fn("makeOpenCodeRuntimeHarness")(funct Effect.provideService(ProviderHost.ProviderHost, { paths: { cwd: "/workspace" }, resolveAttachmentPath: () => null, + compatibility: () => Effect.undefined, ...host, } as unknown as ProviderHost.ProviderHost["Service"]), ); @@ -3846,6 +3848,7 @@ describe("OpenCodeAdapterV2", () => { Effect.provideService(ProviderHost.ProviderHost, { paths: { cwd: "/workspace" }, resolveAttachmentPath: () => null, + compatibility: () => Effect.undefined, } as unknown as ProviderHost.ProviderHost["Service"]), ); const threadId = ThreadId.make("thread-opencode-admission-race"); @@ -4490,6 +4493,7 @@ describe("OpenCodeAdapterV2", () => { Effect.provideService(ProviderHost.ProviderHost, { paths: { cwd: "/workspace" }, resolveAttachmentPath: () => null, + compatibility: () => Effect.undefined, } as unknown as ProviderHost.ProviderHost["Service"]), ); const threadId = ThreadId.make("thread-opencode-initial-stop"); @@ -5364,3 +5368,31 @@ it.live.each([true, false])("opens an authenticated OpenCode session (external=% ]), ), ); + +it.effect("refuses a session on a server version the policy rates broken", () => + Effect.gen(function* () { + const error = yield* makeOpenCodeRuntimeHarness( + "broken-version", + "ses_broken", + {}, + { + compatibility: () => + Effect.succeed({ + status: "broken" as const, + message: null, + recommendedVersion: null, + recommendedRange: ">=2.0.18", + }), + }, + ).pipe(Effect.flip); + assert.include(JSON.stringify(error), "OpenCode 1.14.19 does not work"); + }).pipe( + Effect.scoped, + Effect.provide([ + NodeServices.layer, + TestProviderHost.layer().pipe(Layer.provide(NodeServices.layer)), + IdAllocator.layer, + McpProviderSessions.layer, + ]), + ), +); diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts index 55d84de3c53b0..e41dc10ec9038 100644 --- a/packages/provider-opencode/src/server/adapter.ts +++ b/packages/provider-opencode/src/server/adapter.ts @@ -30,6 +30,7 @@ import { type OrchestrationV2TurnItem, type PlanId, ProviderDriverKind, + ProviderSetupError, type ProviderInstanceId, type ProviderRequestKind, type ProviderSessionId, @@ -54,6 +55,7 @@ import * as Semaphore from "effect/Semaphore"; import * as Scope from "effect/Scope"; import * as Stream from "effect/Stream"; +import { brokenVersionDetail } from "@t3tools/provider-core/server/compatibility"; import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost"; import { mcpToolPresentation } from "@t3tools/provider-core/server/mcpToolPresentation"; import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions"; @@ -1037,6 +1039,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function return ProviderAdapter.ProviderAdapterV2.of({ instanceId: options.instanceId, driver: OPENCODE_PROVIDER, + checksVersionAtHandshake: true, getCapabilities: Effect.fn("OpencodeAdapter.getCapabilities")(function () { return Effect.succeed(OpenCodeProviderCapabilitiesV2); }), @@ -1056,6 +1059,18 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function : {}), environment: options.environment, }); + const broken = brokenVersionDetail({ + name: "OpenCode", + version: connection.version, + advisory: yield* host.compatibility(OPENCODE_PROVIDER, connection.version), + }); + if (broken !== undefined) { + return yield* new ProviderSetupError({ + instanceId: options.instanceId, + operation: "runtime", + detail: broken, + }); + } const client = runtime.createOpenCodeSdkClient({ baseUrl: connection.url, directory: cwd, diff --git a/packages/provider-opencode/src/server/status.ts b/packages/provider-opencode/src/server/status.ts index 9b846445d8a10..f99e2631d59e3 100644 --- a/packages/provider-opencode/src/server/status.ts +++ b/packages/provider-opencode/src/server/status.ts @@ -859,26 +859,30 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu if (probed.generation === "v2") { return yield* checkOpenCode2(openCodeSettings, probed.version, checkedAt, loadOpenCode2Models); } - const broken = brokenVersionDetail({ - name: "OpenCode", - version: probed.version, - advisory: yield* compatibility(ProviderDriverKind.make("opencode"), probed.version), - }); - if (broken !== undefined) { - return buildServerProvider({ - presentation: OPENCODE_PRESENTATION, - enabled: openCodeSettings.enabled, - checkedAt, - models: providerModelsFromSettings([], customModels, DEFAULT_OPENCODE_MODEL_CAPABILITIES), - probe: { - installed: true, - version: probed.version, - status: "error", - auth: { status: "unknown" }, - message: broken, - }, + const refuseBroken = Effect.fnUntraced(function* (detected: string) { + const broken = brokenVersionDetail({ + name: "OpenCode", + version: detected, + advisory: yield* compatibility(ProviderDriverKind.make("opencode"), detected), }); - } + return broken === undefined + ? undefined + : buildServerProvider({ + presentation: OPENCODE_PRESENTATION, + enabled: openCodeSettings.enabled, + checkedAt, + models: providerModelsFromSettings([], customModels, DEFAULT_OPENCODE_MODEL_CAPABILITIES), + probe: { + installed: true, + version: detected, + status: "error", + auth: { status: "unknown" }, + message: broken, + }, + }); + }); + const refused = yield* refuseBroken(probed.version); + if (refused !== undefined) return refused; const installedVersion = isExternalServer ? {} : { installedVersion: probed.version }; let version = probed.version; @@ -921,6 +925,9 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu ), ), ); + // The server that answered can differ from the CLI the probe ran. + const refusedServer = version === probed.version ? undefined : yield* refuseBroken(version); + if (refusedServer !== undefined) return { ...refusedServer, ...installedVersion }; if (inventoryExit._tag === "Failure") { yield* logDiscoveryFailure({ phase: "inventory",