import { assert, describe, it } from "@effect/vitest";
import { ProviderDriverKind, ProviderInstanceId, type ServerProvider } from "@t3tools/contracts";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as Deferred from "effect/Deferred";
import * as Fiber from "effect/Fiber";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as PubSub from "effect/PubSub";
import * as Ref from "effect/Ref";
import * as Stream from "effect/Stream";
import * as ServerConfig from "../config.ts";
import * as ModelManifest from "./ModelManifest.ts";
import * as ProviderRegistry from "./ProviderRegistry.ts";
import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
import * as ProviderInstanceRegistry from "./ProviderInstanceRegistry.ts";
import * as ProviderInstanceRegistryMutator from "./ProviderInstanceRegistryMutator.ts";
import type { ProviderInstance } from "@t3tools/provider-core/server/driver";
import { makeManualOnlyProviderMaintenanceCapabilities } from "@t3tools/provider-core/server/maintenanceResolver";
import * as Schema from "effect/Schema";
import {
applyProviderCompatibility,
ProviderCompatibilityPolicy,
resolveProviderCompatibility,
} from "./providerCompatibility.ts";
import { resolveAntigravityReleaseAsset } from "./antigravityRelease.ts";
import bundledManifest from "./model-manifest.json" with { type: "json" };
const decodeCompatibilityPolicies = Schema.decodeUnknownSync(
Schema.Array(ProviderCompatibilityPolicy),
);
const driver = ProviderDriverKind.make("codex");
const policy: ProviderCompatibilityPolicy = {
driver,
t3CodeRange: ">=0.0.0",
recommendedVersion: "2.0.0",
recommendedRange: ">=2.0.0 <3.0.0",
ranges: [
{ range: "<1.0.0", status: "broken" },
{ range: ">=1.0.0 <1.5.0", status: "unsupported" },
{ range: ">=1.5.0 <2.0.0", status: "graceful" },
{ range: ">=2.0.0 <3.0.0", status: "supported" },
],
};
const provider: ServerProvider = {
driver,
instanceId: ProviderInstanceId.make("codex-work"),
enabled: true,
installed: true,
version: "0.9.0",
status: "error",
message: "Authentication failed",
checkedAt: "2026-09-22T00:00:00Z",
auth: { status: "unauthenticated" },
models: [],
skills: [],
slashCommands: [],
};
describe("provider compatibility", () => {
it("keeps releases before V2 on the OpenCode 1 policy they shipped with", () => {
// Older builds fetch main's manifest; their V1 orchestrator cannot drive OpenCode 2.
const opencode = ProviderDriverKind.make("opencode");
for (const [version, expected] of [
["1.14.19", "supported"],
["2.0.18", "broken"],
["1.14.18", "broken"],
] as const) {
const advisory = resolveProviderCompatibility(
ModelManifest.BUNDLED_MODEL_MANIFEST.compatibility,
opencode,
version,
"0.0.45",
);
assert.strictEqual(advisory?.status, expected, `OpenCode ${version} on 0.0.45`);
assert.strictEqual(advisory?.recommendedVersion, "1.14.19");
}
assert.isUndefined(
resolveProviderCompatibility(
ModelManifest.BUNDLED_MODEL_MANIFEST.compatibility,
ProviderDriverKind.make("pi"),
"1.0.0",
"0.0.45",
),
);
});
it("compares Cursor build dates without treating semver prereleases as stable", () => {
const cursor = ProviderDriverKind.make("cursor");
const cursorPolicy: ProviderCompatibilityPolicy = {
driver: cursor,
t3CodeRange: policy.t3CodeRange,
ranges: [
{ range: "<2026.05.09", status: "unsupported" },
{ range: ">=2026.05.09", status: "supported" },
],
};
for (const [version, expected] of [
["2026.05.08-a1b2c3d", "unsupported"],
["2026.05.09-a1b2c3d", "supported"],
["2026.09.22-f2b0fcd", "supported"],
["2026.05.09", "supported"],
["2026.05.09-beta.1", "unknown"],
] as const) {
assert.strictEqual(
resolveProviderCompatibility([cursorPolicy], cursor, version)?.status,
expected,
);
}
assert.strictEqual(
resolveProviderCompatibility([policy], driver, "2.0.0-a1b2c3d")?.status,
"unknown",
);
});
it("recognizes Antigravity semver release tags while keeping dated candidates unknown", () => {
const antigravity = ProviderDriverKind.make("antigravity");
const taggedPolicy = {
...policy,
driver: antigravity,
ranges: [{ range: "=2.0.0", status: "supported" as const }],
};
for (const [version, expected] of [
["agy_acp_server_2.0.0", "supported"],
["2.0.0", "supported"],
["agy_acp_server_2.0.1", "unknown"],
["agy_acp_server_2.0.0-beta.1", "unknown"],
["agy_acp_server_20260818_01_RC01", "unknown"],
] as const) {
assert.strictEqual(
resolveProviderCompatibility([taggedPolicy], antigravity, version)?.status,
expected,
);
}
});
it.each([
["darwin", "arm64"],
["win32", "x64"],
] as const)(
"supports the managed Antigravity runtime for %s-%s in the bundled manifest",
(platform, arch) => {
const policies = decodeCompatibilityPolicies(bundledManifest.compatibility);
const release = resolveAntigravityReleaseAsset(platform, arch);
assert.strictEqual(
resolveProviderCompatibility(
policies,
ProviderDriverKind.make("antigravity"),
`agy_acp_server_${release?.version}`,
)?.status,
"supported",
);
},
);
it("classifies boundaries and treats unlisted versions and release tags as unknown", () => {
for (const [version, expected] of [
["0.9.9", "broken"],
["1.0.0", "unsupported"],
["1.5.0", "graceful"],
["2.0.0", "supported"],
["v2.0.0", "supported"],
["3.0.0", "unknown"],
["2.0.0-beta.1", "unknown"],
["agy_acp_server_20260818_01_RC01", "unknown"],
[null, "unknown"],
] as const) {
assert.strictEqual(resolveProviderCompatibility([policy], driver, version)?.status, expected);
}
});
it("applies policies only within their T3 Code version range", () => {
const scopedPolicy = { ...policy, t3CodeRange: ">=0.0.42 <0.1.0" };
for (const version of ["0.0.42", "0.0.45"]) {
assert.strictEqual(
resolveProviderCompatibility([scopedPolicy], driver, "0.9.0", version)?.status,
"broken",
);
}
for (const version of ["0.0.41", "0.1.0"]) {
assert.isUndefined(resolveProviderCompatibility([scopedPolicy], driver, "0.9.0", version));
}
});
it("relaxes remote policy without losing probe errors, and falls back when a policy is omitted", () => {
const broken = applyProviderCompatibility(provider, [], [policy]);
assert.strictEqual(broken.compatibilityAdvisory?.status, "broken");
const relaxed = { ...policy, ranges: [{ range: ">=0.0.0", status: "supported" as const }] };
const supported = applyProviderCompatibility(broken, [relaxed], [policy]);
assert.strictEqual(supported.compatibilityAdvisory?.status, "supported");
assert.strictEqual(supported.status, "error");
assert.strictEqual(supported.message, "Authentication failed");
assert.strictEqual(
applyProviderCompatibility(supported, [{ ...policy, t3CodeRange: "<0.0.0" }], [policy])
.compatibilityAdvisory?.status,
"broken",
);
const removed = applyProviderCompatibility(supported, [], []);
assert.isUndefined(removed.compatibilityAdvisory);
assert.strictEqual(removed.status, "error");
assert.strictEqual(removed.message, "Authentication failed");
assert.isUndefined(
applyProviderCompatibility({ ...broken, enabled: false }, [], [policy]).compatibilityAdvisory,
);
assert.isUndefined(
applyProviderCompatibility({ ...broken, installed: false }, [], [policy])
.compatibilityAdvisory,
);
});
it("rejects invalid ranges and recommendations outside the first supported match", () => {
const decode = Schema.decodeUnknownSync(ProviderCompatibilityPolicy);
assert.doesNotThrow(() => decode(policy));
const prefixed = decode({
...policy,
t3CodeRange: ">=v0.0.42 <v0.1",
recommendedRange: "^v2",
ranges: [{ range: ">=v2.0 <v3", status: "supported" }],
});
assert.strictEqual(
resolveProviderCompatibility([prefixed], driver, "2.0.0", "0.0.45")?.status,
"supported",
);
assert.strictEqual(
resolveProviderCompatibility([prefixed], driver, "3.0.0", "0.0.45")?.status,
"unknown",
);
for (const invalid of [
{ ...policy, t3CodeRange: "*" },
{ ...policy, recommendedVersion: "3.0.0" },
{ ...policy, ranges: [{ range: ">=2.0.0 garbage", status: "supported" }] },
{ ...policy, recommendedVersion: "2.0.0; echo unsafe" },
{ ...policy, ranges: [{ range: ">=0.0.0", status: "broken" }, ...policy.ranges] },
])
assert.throws(() => decode(invalid));
});
});
it.effect("a remote policy refresh preserves a newer health result on the registry stream", () =>
Effect.gen(function* () {
const started = yield* Deferred.make<void>();
const release = yield* Deferred.make<void>();
const health = yield* Ref.make<ServerProvider>({
...provider,
status: "ready" as ServerProvider["status"],
message: "Healthy",
});
const manifest = yield* Ref.make<ModelManifest.ModelManifestData>({
version: 1,
currentModels: {},
compatibility: [policy],
});
const instance: ProviderInstance = {
instanceId: provider.instanceId,
driverKind: driver,
enabled: true,
displayName: undefined,
continuationIdentity: { driverKind: driver, continuationKey: "test-codex" },
snapshot: {
getSnapshot: Ref.get(health),
refresh: Ref.get(health),
streamChanges: Stream.empty,
applyUsageLimits: () => Effect.void,
resolveMaintenance: () =>
Effect.succeed(
makeManualOnlyProviderMaintenanceCapabilities({ provider: driver, packageName: null }),
),
},
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
textGeneration: {} as ProviderInstance["textGeneration"],
};
const refresh = Deferred.succeed(started, undefined).pipe(
Effect.andThen(Deferred.await(release)),
Effect.andThen(
Ref.updateAndGet(manifest, (current) => ({
...current,
compatibility: [
{ ...policy, ranges: [{ range: ">=0.0.0", status: "supported" as const }] },
],
})),
),
);
const layerDependencies = Layer.mergeAll(
ProviderLatestVersions.layer,
Layer.succeed(ModelManifest.ModelManifest, {
current: Ref.get(manifest),
refresh,
forceRefresh: refresh,
refreshInBackground: Effect.void,
}),
Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, {
getInstance: (id) => Effect.succeed(id === instance.instanceId ? instance : undefined),
listInstances: Effect.succeed([instance]),
listUnavailable: Effect.succeed([]),
streamChanges: Stream.empty,
subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), PubSub.subscribe),
}),
ServerConfig.layerTest(process.cwd(), { prefix: "compatibility-registry-test" }).pipe(
Layer.provideMerge(NodeServices.layer),
),
);
yield* Effect.gen(function* () {
const registry = yield* ProviderRegistry.ProviderRegistry;
yield* Deferred.await(started);
assert.strictEqual(
(yield* registry.getProviders)[0]?.compatibilityAdvisory?.status,
"broken",
);
yield* Ref.set(health, provider);
const latestHealth = yield* registry.refreshInstance(provider.instanceId);
assert.strictEqual(latestHealth[0]?.message, "Authentication failed");
const supported = yield* Stream.toPull(
registry.streamChanges.pipe(
Stream.filter((snapshots) => snapshots[0]?.compatibilityAdvisory?.status === "supported"),
),
);
const subscribed = yield* supported.pipe(Effect.forkScoped({ startImmediately: true }));
yield* Deferred.succeed(release, undefined);
const updated = (yield* Fiber.join(subscribed))[0]?.[0];
assert.strictEqual(updated?.compatibilityAdvisory?.status, "supported");
assert.strictEqual(updated?.status, "error");
assert.strictEqual(updated?.message, "Authentication failed");
}).pipe(
Effect.provide(
ProviderRegistry.layer.pipe(
Layer.provide(layerDependencies),
Layer.provide(
Layer.mock(ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator)({}),
),
),
),
);
}).pipe(Effect.scoped),
);