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..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-19T23:30:00Z", + "updatedAt": "2026-11-20T00:34:00Z", "compatibility": [ { "driver": "codex", @@ -65,6 +65,7 @@ { "driver": "opencode", "t3CodeRange": ">=0.0.46", + "versionPattern": "^(\\d+\\.\\d+\\.\\d+)(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$", "recommendedRange": ">=2.0.18", "ranges": [ { "range": ">=2.0.18", "status": "supported" }, @@ -107,7 +108,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.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, 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/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/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..6362dd4e73ed2 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,18 +1100,39 @@ it.layer(layerTest)("checkOpenCodeProviderStatus with configured server URL", (i }), ); - it.effect("rejects an unsupported server before loading inventory", () => + it.effect("reports a version the policy rates broken 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.", + 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("reports a failed server connection before loading inventory", () => + Effect.gen(function* () { + 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/status.ts b/packages/provider-opencode/src/server/status.ts index e9776bcefc1d1..f99e2631d59e3 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,21 +859,30 @@ 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) { - 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: `OpenCode v${probed.version} is too old. Upgrade to v${OpenCodeRuntime.MINIMUM_OPENCODE_VERSION} or newer.`, - }, + 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; @@ -910,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", 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-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..76a05fde0b88e 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"; @@ -61,8 +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. -export const MINIMUM_PI_VERSION = "0.84.3"; const decodePiAuthCheck = Schema.decodeUnknownOption( Schema.fromJsonString(Schema.Struct({ reason: Schema.optional(Schema.String) })), @@ -433,6 +436,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 +530,19 @@ 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) { + // 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, + advisory: yield* compatibility(ProviderDriverKind.make("pi"), version), + }); + if (broken !== undefined) { return buildServerProvider({ presentation: PI_PRESENTATION, enabled: piSettings.enabled, @@ -542,7 +553,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,