import * as CodexErrors from "effect-codex-app-server/errors";
import { vi } from "vite-plus/test";
import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
import * as CodexInstallation from "./CodexInstallation.ts";
import * as CodexManagedTokenBroker from "./CodexManagedTokenBroker.ts";
import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import type { ModelInfo } from "@anthropic-ai/claude-agent-sdk";
import { describe, it, assert, expect } from "@effect/vitest";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as PubSub from "effect/PubSub";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";
import * as Sink from "effect/Sink";
import * as Stream from "effect/Stream";
import * as TestClock from "effect/testing/TestClock";
import {
EnvironmentId,
ClaudeSettings,
CodexSettings,
DEFAULT_SERVER_SETTINGS,
PROVIDER_WORKSPACE_SNAPSHOT_TTL_MS,
ProviderDriverKind,
ProviderInstanceId,
ServerSettings,
ServerSettingsError,
ServerProvider,
type ServerProviderSlashCommand,
type ServerSettings as ContractServerSettings,
} from "@t3tools/contracts";
import { HttpClient, HttpClientResponse } from "effect/http";
import { ChildProcessSpawner } from "effect/process";
import * as HostProcess from "@t3tools/shared/HostProcess";
import { deepMerge } from "@t3tools/shared/Struct";
import { createModelCapabilities } from "@t3tools/shared/model";
import { applyServerSettingsPatch } from "@t3tools/shared/serverSettings";
import { checkCodexProviderStatus, type CodexAppServerProviderSnapshot } from "./CodexProvider.ts";
import { BUNDLED_CLAUDE_MODEL_CATALOG } from "./ClaudeModelCatalog.ts";
import { checkClaudeProviderStatus } from "./ClaudeProvider.ts";
import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
import * as AntigravityInstallation from "./AntigravityInstallation.ts";
import * as ModelManifest from "./ModelManifest.ts";
import { applyProviderCompatibility } from "./providerCompatibility.ts";
import * as ResetCreditCoordinator from "./resetCreditCoordinator.ts";
import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as OpenCodeRuntime from "@t3tools/provider-opencode/server/OpenCodeRuntime";
import * as OpenCodeServerLedger from "@t3tools/provider-opencode/server/OpenCodeServerLedger";
import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
import * as ProviderInstanceRegistryHydration from "./ProviderInstanceRegistryHydration.ts";
import * as PortScanner from "../preview/PortScanner.ts";
import * as ServerConfig from "../config.ts";
import * as ServerSettingsModule from "../serverSettings.ts";
import {
readProviderStatusCache,
resolveProviderStatusCachePath,
writeProviderStatusCache,
} from "./providerStatusCache.ts";
import { COMPACT_SLASH_COMMAND } from "@t3tools/provider-core/server/snapshotProbe";
import type {
ProviderInstance,
ProviderWorkspaceSnapshot,
} from "@t3tools/provider-core/server/driver";
import * as ProviderInstanceRegistry from "./ProviderInstanceRegistry.ts";
import * as ProviderInstanceRegistryMutator from "./ProviderInstanceRegistryMutator.ts";
import * as ProviderRegistry from "./ProviderRegistry.ts";
import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment";
import { makeManualOnlyProviderMaintenanceCapabilities } from "@t3tools/provider-core/server/maintenanceResolver";
vi.mock("@anthropic-ai/claude-agent-sdk", { spy: true });
const decodeServerProvider = Schema.decodeSync(ServerProvider);
const encodeServerProvider = Schema.encodeSync(ServerProvider);
const decodeServerSettings = Schema.decodeSync(ServerSettings);
const encodeServerSettings = Schema.encodeSync(ServerSettings);
const encodedDefaultServerSettings = encodeServerSettings(DEFAULT_SERVER_SETTINGS);
const disabledDefaultSlots = (
...drivers: ReadonlyArray<string>
): ContractServerSettings["providerInstances"] =>
Object.fromEntries(
drivers.map((driver) => [
ProviderInstanceId.make(driver),
{ driver: ProviderDriverKind.make(driver), enabled: false },
]),
);
const defaultClaudeSettings: ClaudeSettings = Schema.decodeSync(ClaudeSettings)({});
const decodeCodexSettings = Schema.decodeSync(CodexSettings);
const defaultCodexSettings: CodexSettings = Schema.decodeSync(CodexSettings)({});
process.env.T3CODE_CURSOR_ENABLED = "1";
const encoder = new TextEncoder();
const TEST_EPOCH = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z");
const withBundledCompatibility = (snapshot: ServerProvider) =>
applyProviderCompatibility(
snapshot,
undefined,
ModelManifest.BUNDLED_MODEL_MANIFEST.compatibility,
);
const layerUnusedMutator = Layer.mock(
ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator,
)({});
const layerTestHttpClient = Layer.succeed(
HttpClient.HttpClient,
HttpClient.make((request) =>
Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ version: "0.0.0" }))),
),
).pipe(Layer.provideMerge(ModelManifest.layerTest));
const layerBackgroundPolicyAlwaysRun = Layer.mock(BackgroundPolicy.BackgroundPolicy)({
reportClientActivity: () => Effect.void,
removeRpcClient: () => Effect.void,
snapshot: Effect.succeed({
hostPower: {
source: "unknown",
idle: "unknown",
idleSeconds: null,
locked: "unknown",
suspended: false,
onBattery: "unknown",
lowPowerMode: "unknown",
thermalState: "unknown",
stale: true,
updatedAt: TEST_EPOCH,
},
leases: [],
activeForegroundLeaseCount: 0,
activeScopeKeys: [],
shouldRunOpportunisticWork: true,
updatedAt: TEST_EPOCH,
}),
shouldRunScopeWork: () => Effect.succeed(true),
shouldRunOpportunisticWork: Effect.succeed(true),
});
function selectDescriptor(
id: string,
label: string,
options: ReadonlyArray<{ id: string; label: string; isDefault?: boolean }>,
) {
return {
id,
label,
type: "select" as const,
options: [...options],
...(options.find((option) => option.isDefault)?.id
? { currentValue: options.find((option) => option.isDefault)?.id }
: {}),
};
}
function booleanDescriptor(id: string, label: string) {
return {
id,
label,
type: "boolean" as const,
};
}
type TestClaudeCapabilities = {
readonly email: string | undefined;
readonly subscriptionType: string | undefined;
readonly tokenSource: string | undefined;
readonly apiKeySource: string | undefined;
readonly apiProvider: string | undefined;
readonly slashCommands: ReadonlyArray<ServerProviderSlashCommand>;
readonly models?: ReadonlyArray<ModelInfo>;
};
function claudeCapabilities(overrides: Partial<TestClaudeCapabilities> = {}) {
return () =>
Effect.succeed({
email: undefined,
subscriptionType: undefined,
tokenSource: undefined,
apiKeySource: undefined,
apiProvider: undefined,
slashCommands: [],
...overrides,
});
}
function mockHandle(result: { stdout: string; stderr: string; code: number }) {
return ChildProcessSpawner.makeHandle({
pid: ChildProcessSpawner.ProcessId(1),
exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(result.code)),
isRunning: Effect.succeed(false),
kill: () => Effect.void,
unref: Effect.succeed(Effect.void),
stdin: Sink.drain,
stdout: Stream.make(encoder.encode(result.stdout)),
stderr: Stream.make(encoder.encode(result.stderr)),
all: Stream.empty,
getInputFd: () => Sink.drain,
getOutputFd: () => Stream.empty,
});
}
function layerMockSpawner(
handler: (args: ReadonlyArray<string>) => {
stdout: string;
stderr: string;
code: number;
},
) {
return Layer.succeed(
ChildProcessSpawner.ChildProcessSpawner,
ChildProcessSpawner.make((command) => {
const cmd = command as unknown as { args: ReadonlyArray<string> };
return Effect.succeed(mockHandle(handler(cmd.args)));
}),
);
}
// A Codex CLI on disk whose `app-server` and `--version` behave as `script` says.
const writeFakeCodexCli = Effect.fn("writeFakeCodexCli")(function* (script: string) {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const directory = yield* fs.makeTempDirectoryScoped({ prefix: "t3-fake-codex-" });
const binaryPath = path.join(directory, "codex");
yield* fs.writeFileString(binaryPath, `#!/bin/sh\n${script}\n`);
yield* fs.chmod(binaryPath, 0o755);
return { directory, binaryPath };
});
// The npm `@openai/codex` 0.1 CLI treats `app-server` as a prompt and exits 1.
const OBSOLETE_CODEX_APP_SERVER = `echo "Missing OpenAI API key." >&2; exit 1`;
const codexModelCapabilities = createModelCapabilities({
optionDescriptors: [
selectDescriptor("reasoningEffort", "Reasoning", [
{ id: "high", label: "High", isDefault: true },
{ id: "low", label: "Low" },
]),
booleanDescriptor("fastMode", "Fast Mode"),
],
}) satisfies NonNullable<ServerProvider["models"][number]["capabilities"]>;
function makeCodexProbeSnapshot(
input: Partial<CodexAppServerProviderSnapshot> = {},
): CodexAppServerProviderSnapshot {
return {
version: "1.0.0",
account: {
account: {
type: "chatgpt",
email: "test@example.com",
planType: "pro",
},
requiresOpenaiAuth: false,
},
models: [
{
slug: "gpt-live-codex",
name: "GPT Live Codex",
isCustom: false,
capabilities: codexModelCapabilities,
},
],
skills: [],
...input,
};
}
function makeMutableServerSettingsService(
initial: ContractServerSettings = DEFAULT_SERVER_SETTINGS,
) {
return Effect.gen(function* () {
const settingsRef = yield* Ref.make(initial);
const changes = yield* PubSub.unbounded<ContractServerSettings>();
return {
start: Effect.void,
ready: Effect.void,
getSettings: Ref.get(settingsRef),
updateSettings: (patch) =>
Effect.gen(function* () {
const current = yield* Ref.get(settingsRef);
const next = applyServerSettingsPatch(current, patch);
encodeServerSettings(next);
yield* Ref.set(settingsRef, next);
yield* PubSub.publish(changes, next);
return next;
}),
updateProviderInstance: (mutation, patch = {}) =>
Effect.gen(function* () {
const current = yield* Ref.get(settingsRef);
const next = ServerSettingsModule.applyProviderInstanceMutation(
applyServerSettingsPatch(current, patch),
mutation,
);
encodeServerSettings(next);
yield* Ref.set(settingsRef, next);
yield* PubSub.publish(changes, next);
return next;
}),
withSettingsSnapshot: (use) => Ref.get(settingsRef).pipe(Effect.flatMap(use)),
get streamChanges() {
return Stream.fromPubSub(changes);
},
get subscribeChanges() {
return PubSub.subscribe(changes).pipe(
Effect.map((subscription) => Stream.fromSubscription(subscription)),
);
},
} satisfies ServerSettingsModule.ServerSettingsService["Service"];
});
}
const awaitPersistedProvider = (
registry: ProviderRegistry.ProviderRegistry["Service"],
checkedAt: string,
) =>
registry.streamChanges.pipe(
Stream.filter((providers) => providers.some((provider) => provider.checkedAt === checkedAt)),
Stream.take(1),
Stream.runDrain,
Effect.forkScoped,
);
const layerTestNodeServices = Layer.mergeAll(
ProviderLatestVersions.layer,
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(CodexManagedTokenBroker.CodexManagedTokenBroker)({
endpoint: Effect.succeed("unused-private-pipe"),
}),
Layer.mock(CodexInstallation.CodexInstallation)({
managedDirectory: "unused-managed-installation",
}),
Layer.mock(ServerSecretStore.ServerSecretStore)({}),
Layer.succeed(ServerEnvironment.ServerEnvironmentIdentity, {
getEnvironmentId: Effect.succeed(EnvironmentId.make("00000000-0000-4000-8000-000000000001")),
}),
// An empty home, so the developer's own Claude settings never reach provider probes.
Layer.effect(
HostProcess.HomeDirectory,
Effect.gen(function* () {
return yield* (yield* FileSystem.FileSystem).makeTempDirectoryScoped();
}),
).pipe(Layer.provide(NodeServices.layer)),
);
it.layer(
Layer.mergeAll(layerTestNodeServices, ServerSettingsModule.layerTest(), layerTestHttpClient),
)("ProviderRegistry", (it) => {
describe("checkCodexProviderStatus", () => {
it.effect("uses the app-server account and model list for provider status", () =>
Effect.gen(function* () {
const status = yield* checkCodexProviderStatus(defaultCodexSettings, () =>
Effect.succeed(
makeCodexProbeSnapshot({
skills: [
{
name: "github:gh-fix-ci",
path: "/Users/test/.codex/skills/gh-fix-ci/SKILL.md",
enabled: true,
displayName: "CI Debug",
shortDescription: "Debug failing GitHub Actions checks",
},
],
}),
),
);
assert.strictEqual(status.status, "ready");
assert.strictEqual(status.installed, true);
assert.strictEqual(status.version, "1.0.0");
assert.strictEqual(status.auth.status, "authenticated");
assert.strictEqual(status.auth.type, "chatgpt");
assert.strictEqual(status.auth.label, "ChatGPT Pro 200 Subscription");
assert.strictEqual(status.auth.email, "test@example.com");
assert.deepStrictEqual(status.setup, { canAuthenticate: false, canInstall: false });
assert.deepStrictEqual(status.models, [
{
slug: "gpt-live-codex",
name: "GPT Live Codex",
isCustom: false,
capabilities: codexModelCapabilities,
},
]);
assert.deepStrictEqual(status.skills, [
{
name: "github:gh-fix-ci",
path: "/Users/test/.codex/skills/gh-fix-ci/SKILL.md",
enabled: true,
displayName: "CI Debug",
shortDescription: "Debug failing GitHub Actions checks",
},
]);
assert.deepStrictEqual(status.slashCommands.slice(1), [
{
name: "goal",
description: "Set a goal Codex keeps working toward until it is done",
input: { hint: "Objective, or pause, resume, clear" },
},
{
name: "feedback",
description: "Send this thread and Codex logs to OpenAI",
input: { hint: "Describe the issue (optional)" },
},
]);
}),
);
it.effect("labels the plan the usage read reports over the cached login plan", () =>
Effect.gen(function* () {
const statusWithUsagePlan = (planType: string | null) =>
checkCodexProviderStatus(defaultCodexSettings, () =>
Effect.succeed(
makeCodexProbeSnapshot({
rateLimits: { snapshot: { planType }, resetCredits: null },
}),
),
);
const downgraded = yield* statusWithUsagePlan("free");
assert.strictEqual(downgraded.auth.label, "ChatGPT Free Subscription");
const unreported = yield* statusWithUsagePlan(null);
assert.strictEqual(unreported.auth.label, "ChatGPT Pro 200 Subscription");
const unknown = yield* statusWithUsagePlan("unknown");
assert.strictEqual(unknown.auth.label, "ChatGPT Pro 200 Subscription");
}),
);
it.effect("returns unauthenticated when app-server requires OpenAI auth", () =>
Effect.gen(function* () {
const status = yield* checkCodexProviderStatus(defaultCodexSettings, () =>
Effect.succeed(
makeCodexProbeSnapshot({
account: {
account: null,
requiresOpenaiAuth: true,
},
}),
),
);
assert.strictEqual(status.status, "error");
assert.strictEqual(status.auth.status, "unauthenticated");
assert.strictEqual(
status.message,
"Codex CLI is not authenticated. Run `codex login` and try again.",
);
assert.deepStrictEqual(status.usageLimits?.unavailable, {
reason: "probeFailed",
message: "Codex CLI is not authenticated. Run `codex login` and try again.",
});
}),
);
it.effect("returns ready with unknown auth when app-server does not require OpenAI auth", () =>
Effect.gen(function* () {
const status = yield* checkCodexProviderStatus(defaultCodexSettings, () =>
Effect.succeed(
makeCodexProbeSnapshot({
account: {
account: null,
requiresOpenaiAuth: false,
},
}),
),
);
assert.strictEqual(status.status, "ready");
assert.strictEqual(status.auth.status, "unknown");
}),
);
it.effect("reads the version of a Codex CLI too old to run app-server (#20351)", () =>
Effect.gen(function* () {
if ((yield* HostProcess.Platform) === "win32") return;
const codexHome = yield* FileSystem.FileSystem.pipe(
Effect.flatMap((fs) => fs.makeTempDirectoryScoped({ prefix: "t3-codex-home-" })),
);
const { binaryPath } = yield* writeFakeCodexCli(
[
`if [ "$1" = "--version" ]; then`,
// The fallback runs with the provider's environment and CODEX_HOME.
` [ "$CODEX_HOME" = "${codexHome}" ] && [ "$FAKE_CODEX_ENV" = "kept" ] || exit 2`,
` echo 0.1.4161006; exit 0`,
`fi`,
OBSOLETE_CODEX_APP_SERVER,
].join("\n"),
);
const settings = decodeCodexSettings({ binaryPath, homePath: codexHome });
const status = yield* checkCodexProviderStatus(settings, undefined, {
...process.env,
FAKE_CODEX_ENV: "kept",
});
assert.strictEqual(status.status, "error");
assert.strictEqual(status.installed, true);
assert.strictEqual(status.version, "0.1.4161006");
assert.match(status.message ?? "", /^Codex app-server provider probe failed: /);
const classified = withBundledCompatibility({
...status,
instanceId: ProviderInstanceId.make("codex"),
driver: ProviderDriverKind.make("codex"),
});
assert.strictEqual(classified.compatibilityAdvisory?.status, "broken");
}),
);
it.effect("keeps a prerelease --version unclassified instead of reading it as stable", () =>
Effect.gen(function* () {
if ((yield* HostProcess.Platform) === "win32") return;
const { binaryPath } = yield* writeFakeCodexCli(
[
`[ "$1" = "--version" ] && { echo "codex-cli 0.159.0-alpha.1"; exit 0; }`,
OBSOLETE_CODEX_APP_SERVER,
].join("\n"),
);
const status = yield* checkCodexProviderStatus(decodeCodexSettings({ binaryPath }));
assert.strictEqual(status.version, "0.159.0-alpha.1");
const classified = withBundledCompatibility({
...status,
instanceId: ProviderInstanceId.make("codex"),
driver: ProviderDriverKind.make("codex"),
});
assert.strictEqual(classified.compatibilityAdvisory?.status, "unknown");
}),
);
it.effect("keeps the probe failure without a version when --version also fails", () =>
Effect.gen(function* () {
if ((yield* HostProcess.Platform) === "win32") return;
const { binaryPath } = yield* writeFakeCodexCli(
[
`[ "$1" = "--version" ] && { echo "codex 0.1.0" >&2; exit 3; }`,
OBSOLETE_CODEX_APP_SERVER,
].join("\n"),
);
const status = yield* checkCodexProviderStatus(decodeCodexSettings({ binaryPath }));
assert.strictEqual(status.status, "error");
assert.strictEqual(status.installed, true);
assert.strictEqual(status.version, null);
assert.match(status.message ?? "", /^Codex app-server provider probe failed: /);
}),
);
it.effect("bounds a hanging Codex --version fallback and releases its process scope", () =>
Effect.gen(function* () {
const started = yield* Deferred.make<void>();
const released = yield* Deferred.make<void>();
const spawner = ChildProcessSpawner.make(() =>
Effect.gen(function* () {
yield* Effect.addFinalizer(() => Deferred.succeed(released, undefined));
return ChildProcessSpawner.makeHandle({
...mockHandle({ stdout: "", stderr: "", code: 0 }),
exitCode: Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)),
});
}),
);
const fiber = yield* checkCodexProviderStatus(defaultCodexSettings, () =>
Effect.fail(new CodexErrors.CodexAppServerProcessExitedError({ code: 1 })),
).pipe(
Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
Effect.forkChild,
);
yield* Deferred.await(started);
yield* TestClock.adjust("4 seconds");
const status = yield* Fiber.join(fiber);
assert.strictEqual(status.version, null);
assert.strictEqual(status.status, "error");
assert.strictEqual(status.installed, true);
assert.match(status.message ?? "", /^Codex app-server provider probe failed: /);
assert.isTrue(yield* Deferred.isDone(released));
}),
);
it.effect("does not run --version when the Codex executable cannot start", () =>
Effect.gen(function* () {
if ((yield* HostProcess.Platform) === "win32") return;
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const { directory, binaryPath } = yield* writeFakeCodexCli(
`touch "$(dirname "$0")/ran"; echo 0.1.4161006`,
);
const status = yield* checkCodexProviderStatus(decodeCodexSettings({ binaryPath }), () =>
Effect.fail(
new CodexErrors.CodexAppServerSpawnError({
command: `${binaryPath} app-server`,
cause: new Error("spawn ENOENT"),
}),
),
);
assert.strictEqual(status.installed, false);
assert.strictEqual(status.version, null);
assert.isFalse(yield* fs.exists(path.join(directory, "ran")));
}),
);
});
describe("ProviderRegistry.layer", () => {
it("stores workspace skills, commands and options without changing machine metadata", () => {
const provider = {
instanceId: ProviderInstanceId.make("codex"),
driver: ProviderDriverKind.make("codex"),
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated" },
checkedAt: "2026-03-25T00:00:00.000Z",
version: "1.0.0",
models: [],
slashCommands: [{ name: "global" }],
skills: [{ name: "global", path: "/global/SKILL.md", enabled: true }],
} satisfies ServerProvider;
const scopedSnapshot = {
...provider,
checkedAt: "2026-03-25T00:01:00.000Z",
slashCommands: [{ name: "project" }],
skills: [{ name: "project", path: "/project/SKILL.md", enabled: true }],
optionDescriptors: [
{
id: "agent",
label: "Agent",
type: "select",
options: [{ id: "readonly", label: "Readonly" }],
},
],
} satisfies ProviderWorkspaceSnapshot;
const result = ProviderRegistry.upsertProviderWorkspaceSnapshot(
provider,
"/project",
scopedSnapshot,
);
assert.deepStrictEqual(result.slashCommands, provider.slashCommands);
assert.deepStrictEqual(result.skills, provider.skills);
assert.strictEqual(result.models, provider.models);
const decoded = decodeServerProvider(encodeServerProvider(result));
assert.deepStrictEqual(decoded.workspaceSnapshots, [
{
cwd: "/project",
checkedAt: scopedSnapshot.checkedAt,
slashCommands: scopedSnapshot.slashCommands,
skills: scopedSnapshot.skills,
optionDescriptors: scopedSnapshot.optionDescriptors,
},
]);
const pendingSnapshot = {
...scopedSnapshot,
slashCommands: [COMPACT_SLASH_COMMAND],
slashCommandsPending: true,
} satisfies ProviderWorkspaceSnapshot;
const partial = ProviderRegistry.upsertProviderWorkspaceSnapshot(
result,
"/project",
pendingSnapshot,
);
assert.deepStrictEqual(partial.workspaceSnapshots?.[0]?.slashCommands, [{ name: "project" }]);
assert.strictEqual(partial.workspaceSnapshots?.[0]?.slashCommandsPending, true);
const otherProject = ProviderRegistry.upsertProviderWorkspaceSnapshot(
partial,
"/other-project",
pendingSnapshot,
);
assert.deepStrictEqual(otherProject.workspaceSnapshots?.[1]?.slashCommands, [
COMPACT_SLASH_COMMAND,
]);
const recovered = ProviderRegistry.upsertProviderWorkspaceSnapshot(partial, "/project", {
...scopedSnapshot,
slashCommands: [COMPACT_SLASH_COMMAND, { name: "replacement" }],
});
assert.deepStrictEqual(recovered.workspaceSnapshots?.[0]?.slashCommands, [
COMPACT_SLASH_COMMAND,
{ name: "replacement" },
]);
assert.strictEqual(recovered.workspaceSnapshots?.[0]?.slashCommandsPending, undefined);
const { optionDescriptors, ...failedSnapshot } = scopedSnapshot;
const firstFailure = ProviderRegistry.upsertProviderWorkspaceSnapshot(
provider,
"/project",
failedSnapshot,
);
assert.strictEqual(
Object.hasOwn(firstFailure.workspaceSnapshots![0]!, "optionDescriptors"),
false,
);
const failedOtherProject = ProviderRegistry.upsertProviderWorkspaceSnapshot(
recovered,
"/other-project",
failedSnapshot,
);
assert.strictEqual(
Object.hasOwn(failedOtherProject.workspaceSnapshots![1]!, "optionDescriptors"),
false,
);
for (const clearedDescriptors of [[], [{ ...optionDescriptors[0]!, options: [] }]]) {
const cleared = ProviderRegistry.upsertProviderWorkspaceSnapshot(recovered, "/project", {
...scopedSnapshot,
optionDescriptors: clearedDescriptors,
});
assert.deepStrictEqual(
cleared.workspaceSnapshots?.[0]?.optionDescriptors,
clearedDescriptors,
);
}
const failedRefresh = ProviderRegistry.upsertProviderWorkspaceSnapshot(
failedOtherProject,
"/project",
failedSnapshot,
);
assert.deepStrictEqual(
failedRefresh.workspaceSnapshots?.[1]?.optionDescriptors,
optionDescriptors,
);
});
it("preserves previously discovered provider models when a refresh returns none", () => {
const previousProvider = {
instanceId: ProviderInstanceId.make("cursor"),
driver: ProviderDriverKind.make("cursor"),
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated" },
checkedAt: "2026-04-14T00:00:00.000Z",
version: "2026.04.09-f2b0fcd",
models: [
{
slug: "claude-opus-4-6",
name: "Opus 4.6",
isCustom: false,
capabilities: createModelCapabilities({
optionDescriptors: [
selectDescriptor("reasoning", "Reasoning", [
{ id: "high", label: "High", isDefault: true },
]),
booleanDescriptor("fastMode", "Fast Mode"),
booleanDescriptor("thinking", "Thinking"),
],
}),
},
],
slashCommands: [{ name: "review", description: "Review changes" }],
skills: [
{
name: "typescript",
description: "TypeScript help",
path: "/skills/typescript/SKILL.md",
enabled: true,
},
],
} as const satisfies ServerProvider;
const refreshedProvider = {
...previousProvider,
checkedAt: "2026-04-14T00:01:00.000Z",
models: [],
slashCommands: [],
skills: [],
} satisfies ServerProvider;
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, refreshedProvider).models,
[...previousProvider.models],
);
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, refreshedProvider).slashCommands,
[],
);
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, refreshedProvider).skills,
[],
);
});
it("does not bring back models the installed CLI is too old to run", () => {
const pendingProvider = {
instanceId: ProviderInstanceId.make("claudeAgent"),
driver: ProviderDriverKind.make("claudeAgent"),
status: "warning",
enabled: true,
installed: false,
auth: { status: "unknown" },
checkedAt: "2026-04-14T00:00:00.000Z",
version: null,
models: [
{ slug: "claude-old", name: "Old", isCustom: false, capabilities: null },
{ slug: "claude-next", name: "Next", isCustom: false, capabilities: null },
],
slashCommands: [],
skills: [],
} as const satisfies ServerProvider;
const probedProvider = {
...pendingProvider,
status: "ready",
installed: true,
auth: { status: "authenticated" },
version: "1.0.0",
models: [pendingProvider.models[0]],
updateRequiredModels: [{ slug: "claude-next", name: "Next", minVersion: "1.1.0" }],
} satisfies ServerProvider;
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(pendingProvider, probedProvider).models,
[...probedProvider.models],
);
});
it("retains ACP Registry models while discovery has not completed", () => {
const previousProvider = {
instanceId: ProviderInstanceId.make("acpRegistry_codex"),
driver: ProviderDriverKind.make("acpRegistry"),
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated" },
checkedAt: "2026-08-13T00:00:00.000Z",
version: "1.2.0",
models: [{ slug: "gpt-5.6-sol", name: "GPT-5.6-Sol", isCustom: false, capabilities: null }],
slashCommands: [],
skills: [],
} as const satisfies ServerProvider;
const checkingProvider = {
...previousProvider,
checkedAt: "2026-08-13T00:01:00.000Z",
auth: { status: "unknown" },
message: "Checking ACP authentication, models, and commands in the background...",
models: [{ slug: "default", name: "Default", isCustom: false, capabilities: null }],
} satisfies ServerProvider;
const confirmedCheckingProvider = {
...checkingProvider,
auth: { status: "authenticated" },
} satisfies ServerProvider;
const failedProbeProvider = {
...checkingProvider,
status: "warning",
message: "ACP discovery failed.",
} satisfies ServerProvider;
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, checkingProvider).models,
[
{ slug: "default", name: "Default", isCustom: false, capabilities: null },
{ slug: "gpt-5.6-sol", name: "GPT-5.6-Sol", isCustom: false, capabilities: null },
],
);
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, confirmedCheckingProvider).models,
[
{ slug: "default", name: "Default", isCustom: false, capabilities: null },
{ slug: "gpt-5.6-sol", name: "GPT-5.6-Sol", isCustom: false, capabilities: null },
],
);
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, failedProbeProvider).models,
[
{ slug: "default", name: "Default", isCustom: false, capabilities: null },
{ slug: "gpt-5.6-sol", name: "GPT-5.6-Sol", isCustom: false, capabilities: null },
],
);
});
it("drops Grok models a completed probe no longer advertises", () => {
const previousProvider = {
instanceId: ProviderInstanceId.make("grok"),
driver: ProviderDriverKind.make("grok"),
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated" },
checkedAt: "2026-09-30T00:00:00.000Z",
version: "1.0.44",
models: [
{ slug: "grok-4.7", name: "Grok 4.7", isCustom: false, capabilities: null },
{ slug: "codexhub-removed", name: "Removed", isCustom: false, capabilities: null },
],
slashCommands: [],
skills: [],
} as const satisfies ServerProvider;
const refreshedProvider = {
...previousProvider,
checkedAt: "2026-09-30T00:01:00.000Z",
models: [previousProvider.models[0]],
} satisfies ServerProvider;
const acpFailedProvider = {
...refreshedProvider,
status: "warning",
message: "Grok CLI is installed but ACP initialize failed.",
} satisfies ServerProvider;
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, refreshedProvider).models,
[previousProvider.models[0]],
);
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, acpFailedProvider).models,
[...previousProvider.models],
);
});
it("retains stale OpenCode models when a refresh fails", () => {
const previousProvider = {
instanceId: ProviderInstanceId.make("opencode"),
driver: ProviderDriverKind.make("opencode"),
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated" },
checkedAt: "2026-07-17T00:00:00.000Z",
version: "1.0.0",
models: [
{
slug: "github/gpt-5",
name: "GPT-5",
subProvider: "GitHub",
isCustom: false,
capabilities: null,
},
],
slashCommands: [{ name: "review", description: "Review changes" }],
skills: [
{
name: "typescript",
description: "TypeScript help",
path: "/skills/typescript/SKILL.md",
enabled: true,
},
],
} as const satisfies ServerProvider;
const refreshedProvider = {
...previousProvider,
status: "error",
auth: { status: "unknown" },
checkedAt: "2026-07-17T00:01:00.000Z",
models: [],
message: "Failed to refresh OpenCode models.",
} satisfies ServerProvider;
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, refreshedProvider).models,
[...previousProvider.models],
);
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, refreshedProvider).slashCommands,
previousProvider.slashCommands,
);
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, refreshedProvider).skills,
previousProvider.skills,
);
});
describe("Pi model inventories", () => {
const defaultModel = {
slug: "default",
name: "Pi default",
isCustom: false,
capabilities: null,
} as const;
const currentModel = {
slug: "openai/gpt-6.1-sol",
name: "GPT-6.1-Sol",
isCustom: false,
capabilities: null,
} as const;
const removedModel = {
slug: "openrouter/google/gemini-2.5-pro",
name: "Google: Gemini 2.5 Pro",
isCustom: false,
capabilities: null,
} as const;
const customModel = {
slug: "custom-model",
name: "Custom model",
isCustom: true,
capabilities: null,
} as const;
const cachedProvider = {
instanceId: ProviderInstanceId.make("pi-personal"),
driver: ProviderDriverKind.make("pi"),
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated", type: "pi" },
checkedAt: "2026-10-03T00:00:00.000Z",
version: "1.0.0",
models: [
defaultModel,
currentModel,
removedModel,
{ ...customModel, slug: "removed-custom" },
],
slashCommands: [],
skills: [],
} satisfies ServerProvider;
const refreshedProvider = {
...cachedProvider,
checkedAt: "2026-10-03T00:01:00.000Z",
models: [defaultModel, currentModel, customModel],
} satisfies ServerProvider;
const pendingProvider = {
...cachedProvider,
status: "warning",
version: null,
auth: { status: "unknown" },
models: [defaultModel, customModel],
} satisfies ServerProvider;
const failedProvider = {
...pendingProvider,
checkedAt: "2026-10-03T00:02:00.000Z",
status: "ready",
version: "1.0.0",
message: "Pi is available, but T3 Code could not refresh its models and commands.",
} satisfies ServerProvider;
it("retains Pi inventories during incomplete probes without restoring removed custom models", () => {
const incompleteProviders = [
pendingProvider,
{ ...pendingProvider, installed: false },
failedProvider,
{ ...failedProvider, status: "error" },
] satisfies ReadonlyArray<ServerProvider>;
for (const provider of incompleteProviders) {
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(cachedProvider, provider).models,
[defaultModel, customModel, currentModel, removedModel],
);
}
});
it("does not restore disconnected Pi models after a later discovery failure", () => {
const afterRemoval = ProviderRegistry.mergeProviderSnapshot(
cachedProvider,
refreshedProvider,
);
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(afterRemoval, failedProvider).models,
[defaultModel, customModel, currentModel],
);
});
it.effect(
"persists Pi inventory removals across failed refreshes and registry restarts",
() =>
Effect.gen(function* () {
const config = yield* ServerConfig.ServerConfig;
const filePath = yield* resolveProviderStatusCachePath({
cacheDir: config.providerStatusCacheDir,
instanceId: cachedProvider.instanceId,
});
yield* writeProviderStatusCache({ filePath, provider: cachedProvider });
const nextProvider = yield* Ref.make<ServerProvider>(refreshedProvider);
const currentProvider = yield* Ref.make<ServerProvider>(pendingProvider);
const instance = {
instanceId: cachedProvider.instanceId,
driverKind: cachedProvider.driver,
continuationIdentity: {
driverKind: cachedProvider.driver,
continuationKey: "pi:instance:pi-personal",
},
displayName: undefined,
enabled: true,
snapshot: {
resolveMaintenance: () =>
Effect.succeed(
makeManualOnlyProviderMaintenanceCapabilities({
provider: cachedProvider.driver,
packageName: null,
}),
),
getSnapshot: Ref.get(currentProvider),
refresh: Ref.get(nextProvider).pipe(
Effect.tap((provider) => Ref.set(currentProvider, provider)),
),
streamChanges: Stream.empty,
applyUsageLimits: () => Effect.void,
},
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
textGeneration: {} as ProviderInstance["textGeneration"],
} satisfies ProviderInstance;
const layerInstanceRegistry = 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),
},
);
const retainedModels = [defaultModel, customModel, currentModel];
for (const restarted of [false, true]) {
yield* Ref.set(currentProvider, pendingProvider);
yield* Effect.gen(function* () {
const registry = yield* ProviderRegistry.ProviderRegistry;
assert.deepStrictEqual(
(yield* registry.getProviders)[0]?.models,
restarted
? retainedModels
: [defaultModel, customModel, currentModel, removedModel],
);
yield* registry.refreshInstance(instance.instanceId);
assert.deepStrictEqual(
(yield* readProviderStatusCache(filePath))?.models,
restarted ? retainedModels : refreshedProvider.models,
);
yield* Ref.set(nextProvider, failedProvider);
const afterFailure = yield* registry.refreshInstance(instance.instanceId);
assert.deepStrictEqual(afterFailure[0]?.models, retainedModels);
assert.deepStrictEqual(
(yield* readProviderStatusCache(filePath))?.models,
retainedModels,
);
}).pipe(
Effect.provide(
ProviderRegistry.layer.pipe(
Layer.provide(layerInstanceRegistry),
Layer.provide(layerUnusedMutator),
),
),
Effect.scoped,
);
}
}).pipe(
Effect.provide(
ServerConfig.layerTest(process.cwd(), {
prefix: "t3-pi-model-cache-",
}).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
),
),
);
});
describe("Codex model inventories", () => {
const cachedProvider = {
instanceId: ProviderInstanceId.make("codex-personal"),
driver: ProviderDriverKind.make("codex"),
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated" },
checkedAt: "2026-09-04T19:00:00.000Z",
version: "0.153.3",
models: ["vega-alpha", "joule-alpha", "kindle-alpha", "ultima-alpha", "solstice-alpha"].map(
(slug) => ({ slug, name: slug, isCustom: false, capabilities: null }),
),
slashCommands: [],
skills: [],
} satisfies ServerProvider;
const customModel = {
slug: "custom-model",
name: "Custom model",
isCustom: true,
capabilities: null,
} as const;
const refreshedProvider = {
...cachedProvider,
checkedAt: "2026-09-04T19:01:00.000Z",
models: [
{ slug: "gpt-6-astra", name: "GPT 6 Astra", isCustom: false, capabilities: null },
cachedProvider.models[0]!,
customModel,
],
} satisfies ServerProvider;
const pendingProvider = {
...cachedProvider,
status: "warning",
installed: false,
auth: { status: "unknown" },
models: [customModel],
} satisfies ServerProvider;
const failedProvider = {
...pendingProvider,
checkedAt: "2026-09-04T19:02:00.000Z",
status: "error",
installed: true,
} satisfies ServerProvider;
it.effect("persists removals across failed refreshes and registry restarts", () =>
Effect.gen(function* () {
const config = yield* ServerConfig.ServerConfig;
const filePath = yield* resolveProviderStatusCachePath({
cacheDir: config.providerStatusCacheDir,
instanceId: cachedProvider.instanceId,
});
yield* writeProviderStatusCache({ filePath, provider: cachedProvider });
const nextProvider = yield* Ref.make<ServerProvider>(refreshedProvider);
const currentProvider = yield* Ref.make<ServerProvider>(pendingProvider);
const instance = {
instanceId: cachedProvider.instanceId,
driverKind: cachedProvider.driver,
continuationIdentity: {
driverKind: cachedProvider.driver,
continuationKey: "codex:instance:codex-personal",
},
displayName: undefined,
enabled: true,
snapshot: {
resolveMaintenance: () =>
Effect.succeed(
makeManualOnlyProviderMaintenanceCapabilities({
provider: cachedProvider.driver,
packageName: null,
}),
),
getSnapshot: Ref.get(currentProvider),
refresh: Ref.get(nextProvider).pipe(
Effect.tap((provider) => Ref.set(currentProvider, provider)),
),
streamChanges: Stream.empty,
applyUsageLimits: () => Effect.void,
},
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
textGeneration: {} as ProviderInstance["textGeneration"],
} satisfies ProviderInstance;
const layerInstanceRegistry = 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),
},
);
const retainedModels = [
customModel,
...refreshedProvider.models.filter((model) => !model.isCustom),
];
for (const restarted of [false, true]) {
yield* Ref.set(currentProvider, pendingProvider);
yield* Effect.gen(function* () {
const registry = yield* ProviderRegistry.ProviderRegistry;
const expectedModels = restarted
? retainedModels
: [customModel, ...cachedProvider.models];
assert.deepStrictEqual((yield* registry.getProviders)[0]?.models, expectedModels);
yield* registry.refreshInstance(instance.instanceId);
assert.deepStrictEqual(
(yield* readProviderStatusCache(filePath))?.models,
restarted ? retainedModels : refreshedProvider.models,
);
yield* Ref.set(nextProvider, failedProvider);
const afterFailure = yield* registry.refreshInstance(instance.instanceId);
assert.deepStrictEqual(afterFailure[0]?.models, retainedModels);
assert.deepStrictEqual(
(yield* readProviderStatusCache(filePath))?.models,
retainedModels,
);
}).pipe(
Effect.provide(
ProviderRegistry.layer.pipe(
Layer.provide(layerInstanceRegistry),
Layer.provide(layerUnusedMutator),
),
),
Effect.scoped,
);
}
}).pipe(
Effect.provide(
ServerConfig.layerTest(process.cwd(), {
prefix: "t3-codex-retired-model-cache-",
}).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
),
),
);
});
describe("Antigravity model inventories", () => {
const previousProvider = {
instanceId: ProviderInstanceId.make("antigravity-personal"),
driver: ProviderDriverKind.make("antigravity"),
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated" },
checkedAt: "2026-09-02T00:00:00.000Z",
version: "0.1.3",
models: [
{
slug: "gemini-3.1-pro-high",
name: "Gemini 3.1 Pro High",
isCustom: false,
capabilities: null,
},
{
slug: "gemini-3-flash",
name: "Gemini 3 Flash",
isCustom: false,
capabilities: null,
},
],
slashCommands: [],
skills: [],
} as const satisfies ServerProvider;
it("clears models after sign-out, disable, uninstall, or an empty successful refresh", () => {
const emptyProvider = {
...previousProvider,
checkedAt: "2026-09-02T00:01:00.000Z",
models: [],
} satisfies ServerProvider;
const clearedProviders = [
{ ...emptyProvider, status: "warning", auth: { status: "unauthenticated" } },
{ ...emptyProvider, status: "error", auth: { status: "unauthenticated" } },
{ ...emptyProvider, status: "disabled", enabled: false },
{ ...emptyProvider, status: "error", enabled: false },
{ ...emptyProvider, status: "error", installed: false, auth: { status: "unknown" } },
emptyProvider,
] satisfies ReadonlyArray<ServerProvider>;
for (const provider of clearedProviders) {
const afterRemoval = ProviderRegistry.mergeProviderSnapshot(previousProvider, provider);
assert.deepStrictEqual(afterRemoval.models, []);
const afterFailure = ProviderRegistry.mergeProviderSnapshot(afterRemoval, {
...emptyProvider,
status: "error",
auth: { status: "unknown" },
});
assert.deepStrictEqual(afterFailure.models, []);
}
});
});
describe("Antigravity saved account", () => {
const signedIn = {
instanceId: ProviderInstanceId.make("antigravity-personal"),
driver: ProviderDriverKind.make("antigravity"),
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated", type: "oauth-personal", label: "Google account" },
checkedAt: "2026-09-05T00:00:00.000Z",
version: "agy_acp_server_1.1.1",
models: [
{
slug: "gemini-3.7-flash-high",
name: "Gemini 3.7 Flash",
isCustom: false,
capabilities: null,
},
],
slashCommands: [{ name: "plan" }],
skills: [],
} as const satisfies ServerProvider;
const uncheckedMessage =
"Antigravity is installed. Google account access is not checked yet.";
const restartProbe = {
...signedIn,
status: "warning",
auth: { status: "unknown" },
checkedAt: "2026-09-05T00:01:00.000Z",
message: uncheckedMessage,
models: [],
} as const satisfies ServerProvider;
it("keeps the saved Google account through restart health checks", () => {
const merged = ProviderRegistry.mergeProviderSnapshot(signedIn, restartProbe);
const { message: _uncheckedMessage, ...probeWithoutMessage } = restartProbe;
assert.deepStrictEqual(merged, {
...probeWithoutMessage,
status: "ready",
auth: signedIn.auth,
models: signedIn.models,
});
assert.equal("message" in merged, false);
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(merged, restartProbe),
merged,
);
});
it("does not invent an account after sign-out, disable, uninstall, or for other providers", () => {
const untouched = [
{ ...restartProbe, auth: { status: "unauthenticated" } },
{ ...restartProbe, status: "disabled", enabled: false },
{ ...restartProbe, status: "error", installed: false },
{ ...restartProbe, driver: ProviderDriverKind.make("codex") },
{ ...restartProbe, auth: { status: "unknown", type: "gemini-api-key" } },
] satisfies ReadonlyArray<ServerProvider>;
for (const next of untouched) {
const merged = ProviderRegistry.mergeProviderSnapshot(signedIn, next);
assert.deepStrictEqual(merged.auth, next.auth);
assert.equal(merged.status, next.status);
assert.equal(merged.message, next.message);
}
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(
{ ...signedIn, auth: { status: "unknown" } },
restartProbe,
).auth,
{ status: "unknown" },
);
assert.equal(
ProviderRegistry.mergeProviderSnapshot(
{ ...signedIn, driver: ProviderDriverKind.make("codex") },
restartProbe,
).auth.status,
"unknown",
);
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(signedIn, {
...restartProbe,
auth: { status: "unknown", type: "oauth-personal" },
}).auth,
signedIn.auth,
);
});
});
it("fills missing capabilities from the previous provider snapshot", () => {
const previousProvider = {
instanceId: ProviderInstanceId.make("cursor"),
driver: ProviderDriverKind.make("cursor"),
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated" },
checkedAt: "2026-04-14T00:00:00.000Z",
version: "2026.04.09-f2b0fcd",
models: [
{
slug: "claude-opus-4-6",
name: "Opus 4.6",
isCustom: false,
capabilities: createModelCapabilities({
optionDescriptors: [
selectDescriptor("reasoning", "Reasoning", [
{ id: "high", label: "High", isDefault: true },
]),
booleanDescriptor("fastMode", "Fast Mode"),
booleanDescriptor("thinking", "Thinking"),
],
}),
},
],
slashCommands: [],
skills: [],
} as const satisfies ServerProvider;
const refreshedProvider = {
...previousProvider,
checkedAt: "2026-04-14T00:01:00.000Z",
models: [
{
slug: "claude-opus-4-6",
name: "Opus 4.6",
isCustom: false,
capabilities: createModelCapabilities({
optionDescriptors: [],
}),
},
],
} satisfies ServerProvider;
assert.deepStrictEqual(
ProviderRegistry.mergeProviderSnapshot(previousProvider, refreshedProvider).models,
[...previousProvider.models],
);
});
it.effect("invalidates model caches only for an explicit model refresh", () =>
Effect.gen(function* () {
const forceRefreshCalls = yield* Ref.make(0);
const makeInstance = (name: string) =>
Effect.gen(function* () {
const driver = ProviderDriverKind.make("codex");
const instanceId = ProviderInstanceId.make(name);
const provider = {
instanceId,
driver,
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated" },
checkedAt: "2026-06-10T00:00:00.000Z",
version: "1.0.0",
models: [],
slashCommands: [],
skills: [],
} as const satisfies ServerProvider;
const invalidations = yield* Ref.make(0);
const maintenanceReads = yield* Ref.make<ReadonlyArray<boolean>>([]);
const instance = {
instanceId,
driverKind: driver,
continuationIdentity: {
driverKind: driver,
continuationKey: `codex:instance:${name}`,
},
displayName: undefined,
enabled: true,
snapshot: {
resolveMaintenance: (options) =>
Ref.update(maintenanceReads, (reads) => [...reads, options?.fresh === true]).pipe(
Effect.as(
makeManualOnlyProviderMaintenanceCapabilities({
provider: driver,
packageName: `${name}-package`,
}),
),
),
getSnapshot: Effect.succeed(provider),
refresh: Effect.succeed(provider),
streamChanges: Stream.empty,
applyUsageLimits: () => Effect.void,
},
invalidateCaches: Ref.update(invalidations, (count) => count + 1),
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
textGeneration: {} as ProviderInstance["textGeneration"],
} satisfies ProviderInstance;
const takeMaintenanceReads = Ref.getAndSet(maintenanceReads, []);
return { instance, invalidations, takeMaintenanceReads };
});
const first = yield* makeInstance("codex_first");
const second = yield* makeInstance("codex_second");
const instances = [first.instance, second.instance];
const layerInstanceRegistry = Layer.succeed(
ProviderInstanceRegistry.ProviderInstanceRegistry,
{
getInstance: (instanceId) =>
Effect.succeed(instances.find((instance) => instance.instanceId === instanceId)),
listInstances: Effect.succeed(instances),
listUnavailable: Effect.succeed([]),
streamChanges: Stream.empty,
subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), PubSub.subscribe),
},
);
const layerModelManifest = Layer.succeed(ModelManifest.ModelManifest, {
current: Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST),
refresh: Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST),
forceRefresh: Ref.update(forceRefreshCalls, (count) => count + 1).pipe(
Effect.as(ModelManifest.BUNDLED_MODEL_MANIFEST),
),
refreshInBackground: Effect.void,
});
const layerLatestVersions = Layer.effect(
ProviderLatestVersions.ProviderLatestVersions,
ProviderLatestVersions.make([
["codex_first-package", "1.0.0"],
["codex_second-package", "1.0.0"],
]),
);
const readCachedVersion = (key: string) =>
ProviderLatestVersions.ProviderLatestVersions.use((latestVersions) =>
latestVersions.cached(key, Effect.succeed("2.0.0")),
);
yield* Effect.gen(function* () {
const registry = yield* ProviderRegistry.ProviderRegistry;
yield* registry.refreshInstance(first.instance.instanceId);
yield* registry.refresh();
assert.strictEqual(yield* Ref.get(forceRefreshCalls), 0);
assert.strictEqual(yield* Ref.get(first.invalidations), 0);
assert.strictEqual(yield* readCachedVersion("codex_first-package"), "1.0.0");
yield* first.takeMaintenanceReads;
yield* registry.invalidateModelCaches({ instanceId: first.instance.instanceId });
// The instance refresh that follows resolves installer metadata fresh itself.
assert.deepStrictEqual(yield* first.takeMaintenanceReads, [false]);
assert.strictEqual(yield* Ref.get(forceRefreshCalls), 1);
assert.strictEqual(yield* Ref.get(first.invalidations), 1);
assert.strictEqual(yield* Ref.get(second.invalidations), 0);
assert.strictEqual(yield* readCachedVersion("codex_first-package"), "2.0.0");
assert.strictEqual(yield* readCachedVersion("codex_second-package"), "1.0.0");
yield* registry.invalidateModelCaches({});
assert.strictEqual(yield* Ref.get(first.invalidations), 2);
assert.strictEqual(yield* Ref.get(second.invalidations), 1);
assert.strictEqual(yield* readCachedVersion("codex_second-package"), "2.0.0");
yield* first.takeMaintenanceReads;
// Only a cached workspace refresh leaves the fresh resolution to this call.
const workspace = { instanceId: first.instance.instanceId, cwd: process.cwd() };
yield* registry.invalidateModelCaches(workspace);
assert.deepStrictEqual(yield* first.takeMaintenanceReads, [true]);
yield* registry.invalidateModelCaches({ ...workspace, fresh: true });
assert.deepStrictEqual(yield* first.takeMaintenanceReads, [false]);
}).pipe(
Effect.provide(
ProviderRegistry.layer.pipe(
Layer.provideMerge(layerInstanceRegistry),
Layer.provideMerge(layerModelManifest),
Layer.provideMerge(layerLatestVersions),
Layer.provide(layerUnusedMutator),
Layer.provideMerge(
ServerConfig.layerTest(process.cwd(), {
prefix: "t3-provider-registry-model-cache-",
}),
),
Layer.provideMerge(NodeServices.layer),
),
),
);
}),
);
it.effect(
"a second request for a cwd being scanned gets its result, even if the first leaves",
() =>
Effect.gen(function* () {
const driver = ProviderDriverKind.make("codex");
const instanceId = ProviderInstanceId.make("codex");
const provider = {
instanceId,
driver,
status: "ready",
enabled: true,
installed: true,
auth: { status: "authenticated" },
checkedAt: "2026-06-10T00:00:00.000Z",
version: "1.0.0",
models: [],
slashCommands: [],
skills: [],
} as const satisfies ServerProvider;
const scanStarted = yield* Deferred.make<void>();
const releaseScan = yield* Deferred.make<void>();
const scans = yield* Ref.make(0);
const instance: ProviderInstance = {
instanceId,
driverKind: driver,
continuationIdentity: { driverKind: driver, continuationKey: "codex:instance:codex" },
displayName: undefined,
enabled: true,
snapshot: {
resolveMaintenance: () =>
Effect.succeed(
makeManualOnlyProviderMaintenanceCapabilities({
provider: driver,
packageName: null,
}),
),
getSnapshot: Effect.succeed(provider),
refresh: Effect.succeed(provider),
streamChanges: Stream.empty,
applyUsageLimits: () => Effect.void,
},
snapshotForCwd: () =>
Ref.update(scans, (count) => count + 1).pipe(
Effect.andThen(Deferred.succeed(scanStarted, undefined)),
Effect.andThen(Deferred.await(releaseScan)),
Effect.as(provider),
),
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
textGeneration: {} as ProviderInstance["textGeneration"],
};
const layerInstanceRegistry = Layer.succeed(
ProviderInstanceRegistry.ProviderInstanceRegistry,
{
getInstance: (requestedId) =>
Effect.succeed(requestedId === instanceId ? instance : undefined),
listInstances: Effect.succeed([instance]),
listUnavailable: Effect.succeed([]),
streamChanges: Stream.empty,
subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), PubSub.subscribe),