@devries-cameron20 / t3code-1 / commits / 1a42ba1b5f
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

fix(server,web): models stay in the picker after one failed provider check (#39114)

Julius Marminge committed Nov 19, 2026 at 06:33 UTC 1a42ba1b5f377c5e79f77549678441d2e6212afe
8 files changed +218 -18
apps/server/src/provider/AntigravityProvider.test.ts
+62 -13
@@ -16,6 +16,7 @@ import * as Layer from "effect/Layer";
16 import * as Ref from "effect/Ref";
17 import * as Schema from "effect/Schema";
18 import * as Stream from "effect/Stream";
19 +import * as TestClock from "effect/testing/TestClock";
20 import * as EffectAcpErrors from "effect-acp/errors";
21 import type * as EffectAcpSchema from "effect-acp/compat";
22
@@ -112,20 +113,22 @@ const expectedCommands = [
113 { name: "logout", description: "Sign out of Google" },
114 ];
115
115 -const layerTest = ProviderHostLive.layer.pipe(
116 - Layer.provideMerge(
117 - Layer.mock(BackgroundPolicy.BackgroundPolicy)({
118 - shouldRunScopeWork: () => Effect.succeed(false),
119 - }),
120 - ),
121 - Layer.provideMerge(ServerSettings.layerTest()),
122 - Layer.provideMerge(ServerSecretStore.layer),
123 - Layer.provide(
124 - ServerConfig.layerTest(process.cwd(), { prefix: "t3-antigravity-provider-test-" }).pipe(
125 - Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
116 +const makeLayerTest = (runBackgroundWork: boolean) =>
117 + ProviderHostLive.layer.pipe(
118 + Layer.provideMerge(
119 + Layer.mock(BackgroundPolicy.BackgroundPolicy)({
120 + shouldRunScopeWork: () => Effect.succeed(runBackgroundWork),
121 + }),
122 + ),
123 + Layer.provideMerge(ServerSettings.layerTest()),
124 + Layer.provideMerge(ServerSecretStore.layer),
125 + Layer.provide(
126 + ServerConfig.layerTest(process.cwd(), { prefix: "t3-antigravity-provider-test-" }).pipe(
127 + Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
128 + ),
129 ),
127 - ),
128 -);
130 + );
131 +const layerTest = makeLayerTest(false);
132
133 type ProbeError = EffectAcpErrors.AcpError | ProviderSetupError;
134
@@ -824,3 +827,49 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => {
827 }),
828 );
829 });
830 +
831 +it.layer(makeLayerTest(true))("Antigravity periodic health checks", (it) => {
832 + it.effect("rechecks a ready provider after one failed periodic check before publishing it", () =>
833 + Effect.gen(function* () {
834 + const harness = yield* makeHarness();
835 + yield* harness.initialize;
836 + yield* harness.provider.onSessionStarted(started, "/workspace");
837 + expect((yield* harness.provider.snapshot.getSnapshot).status).toBe("ready");
838 + const published = yield* Ref.make<ReadonlyArray<ServerProvider>>([]);
839 + yield* harness.provider.snapshot.streamChanges.pipe(
840 + Stream.runForEach((snapshot) => Ref.update(published, (all) => [...all, snapshot])),
841 + Effect.forkChild,
842 + );
843 + yield* Effect.yieldNow;
844 + yield* Ref.set(
845 + harness.probe,
846 + Effect.fail(EffectAcpErrors.AcpRequestError.internalError("probe failed")),
847 + );
848 +
849 + yield* TestClock.adjust("5 minutes");
850 +
851 + expect((yield* harness.provider.snapshot.getSnapshot).status).toBe("ready");
852 + expect((yield* Ref.get(published)).map((snapshot) => snapshot.status)).not.toContain("error");
853 +
854 + yield* Ref.set(harness.probe, Effect.succeed(initializeResult));
855 + yield* TestClock.adjust("30 seconds");
856 + const failProbe = yield* Deferred.make<void>();
857 + yield* Ref.set(
858 + harness.probe,
859 + Deferred.await(failProbe).pipe(
860 + Effect.andThen(
861 + Effect.fail(EffectAcpErrors.AcpRequestError.internalError("probe failed")),
862 + ),
863 + ),
864 + );
865 + yield* TestClock.adjust("5 minutes");
866 + yield* harness.provider.onSignedOut;
867 + yield* Deferred.succeed(failProbe, undefined);
868 + yield* TestClock.adjust("30 seconds");
869 +
870 + const auth = (yield* Ref.get(published)).map((snapshot) => snapshot.auth.status);
871 + expect(auth.slice(auth.indexOf("unauthenticated"))).not.toContain("authenticated");
872 + expect(auth.at(-1)).toBe("unauthenticated");
873 + }),
874 + );
875 +});
apps/server/src/provider/AntigravityProvider.ts
+12 -2
@@ -25,7 +25,10 @@ import type * as EffectAcpSchema from "effect-acp/compat";
25
26 import type * as AcpSessionRuntime from "@t3tools/provider-acp/server/AcpSessionRuntime";
27 import { acpProviderOptionDescriptors } from "@t3tools/provider-acp/server/sessionConfig";
28 -import { makeManagedServerProvider } from "@t3tools/provider-core/server/managedProvider";
28 +import {
29 + DeferringFailedCheck,
30 + makeManagedServerProvider,
31 +} from "@t3tools/provider-core/server/managedProvider";
32 import {
33 makeManualOnlyProviderMaintenanceCapabilities,
34 type ProviderMaintenanceCapabilities,
@@ -297,7 +300,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
300 const supportsTextGeneration =
301 initialized !== undefined ? yield* options.supportsTextGeneration : false;
302 const updatedAt = DateTime.formatIso(yield* DateTime.now);
300 - const next = yield* SubscriptionRef.updateAndGet(metadata, (state) => {
303 + const applyCheck = (state: AntigravityProviderState) => {
304 if (state.authRevision !== before.authRevision) return state;
305 const { message: _previousMessage, ...draft } = state.draft;
306 const authenticated = draft.auth.status === "authenticated";
@@ -336,6 +339,13 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
339 ...(message ? { message } : {}),
340 },
341 } satisfies AntigravityProviderState;
342 + };
343 + // This state is published as it changes, so a failure the managed provider discards stays out.
344 + const deferFailure = errorMessage !== undefined && (yield* DeferringFailedCheck);
345 + const next = yield* SubscriptionRef.modifySome(metadata, (state) => {
346 + const checked = applyCheck(state);
347 + const stored = deferFailure && state.draft.status === "ready" ? state : checked;
348 + return [checked, stored === state ? Option.none() : Option.some(stored)];
349 });
350 if (initialized !== undefined) yield* refreshUsage();
351 return yield* options.stampIdentity(next.draft);
apps/server/src/provider/ProviderRegistry.test.ts
+53
@@ -1453,6 +1453,58 @@ it.layer(
1453 );
1454 });
1455
1456 + it("marks a ready catalog retained for one failed check", () => {
1457 + const readyProvider = {
1458 + instanceId: ProviderInstanceId.make("codex"),
1459 + driver: ProviderDriverKind.make("codex"),
1460 + status: "ready",
1461 + enabled: true,
1462 + installed: true,
1463 + auth: { status: "authenticated" },
1464 + checkedAt: "2026-10-30T00:00:00.000Z",
1465 + version: "1.0.0",
1466 + models: [{ slug: "gpt-5.5", name: "GPT-5.5", isCustom: false, capabilities: null }],
1467 + slashCommands: [],
1468 + skills: [],
1469 + } as const satisfies ServerProvider;
1470 + const failedProvider = {
1471 + ...readyProvider,
1472 + status: "error",
1473 + auth: { status: "unknown" },
1474 + checkedAt: "2026-10-30T00:01:00.000Z",
1475 + models: [],
1476 + } as const satisfies ServerProvider;
1477 + const merge = ProviderRegistry.mergeProviderSnapshot;
1478 +
1479 + const failedOnce = merge(readyProvider, failedProvider);
1480 + assert.deepStrictEqual(failedOnce.models, [...readyProvider.models]);
1481 + assert.strictEqual(failedOnce.modelsRetained, true);
1482 + assert.strictEqual(merge(failedOnce, failedProvider).modelsRetained, true);
1483 + assert.strictEqual(
1484 + merge(failedOnce, { ...failedProvider, checkedAt: "2026-10-30T00:02:00.000Z" })
1485 + .modelsRetained,
1486 + undefined,
1487 + );
1488 + assert.strictEqual(merge(failedOnce, readyProvider).modelsRetained, undefined);
1489 + const customOnly = {
1490 + ...readyProvider,
1491 + models: [{ slug: "bailian", name: "bailian", isCustom: true, capabilities: null }],
1492 + } satisfies ServerProvider;
1493 + assert.strictEqual(
1494 + merge(customOnly, { ...failedProvider, models: customOnly.models }).modelsRetained,
1495 + true,
1496 + );
1497 + assert.strictEqual(
1498 + merge(readyProvider, { ...failedProvider, installed: false }).modelsRetained,
1499 + undefined,
1500 + );
1501 + assert.strictEqual(
1502 + merge(readyProvider, { ...failedProvider, auth: { status: "unauthenticated" } })
1503 + .modelsRetained,
1504 + undefined,
1505 + );
1506 + });
1507 +
1508 it.each(["kiro", "claudeAgent"] as const)(
1509 "keeps %s models a ready probe can omit",
1510 (driver) => {
@@ -3541,6 +3593,7 @@ it.layer(
3593 withBundledCompatibility({
3594 ...refreshedProvider,
3595 models: [...initialProvider.models],
3596 + modelsRetained: true,
3597 }),
3598 );
3599 }).pipe(Effect.provide(runtimeServices));
apps/server/src/provider/ProviderRegistry.ts
+25
@@ -320,6 +320,23 @@ const carrySavedAntigravityAccount = (
320 return { auth: previousProvider.auth, status };
321 };
322
323 +/** One failed check after a ready one is often transient, so its retained catalog stays offered. */
324 +const retainsReadyCatalog = (
325 + previousProvider: ServerProvider,
326 + nextProvider: ServerProvider,
327 + status: ServerProvider["status"],
328 + models: ServerProvider["models"],
329 +): boolean =>
330 + nextProvider.enabled &&
331 + nextProvider.installed &&
332 + (status === "error" || status === "warning") &&
333 + nextProvider.auth.status !== "unauthenticated" &&
334 + models.length > 0 &&
335 + (previousProvider.status === "ready" ||
336 + // Usage and metadata updates republish the same check.
337 + (previousProvider.modelsRetained === true &&
338 + previousProvider.checkedAt === nextProvider.checkedAt));
339 +
340 export const mergeProviderSnapshot = (
341 previousProvider: ServerProvider | undefined,
342 nextProvider: ServerProvider,
@@ -355,6 +372,14 @@ export const mergeProviderSnapshot = (
372 ...(savedAccount?.status === "ready" ? nextWithoutMessage : nextProvider),
373 ...savedAccount,
374 models,
375 + ...(retainsReadyCatalog(
376 + previousProvider,
377 + nextProvider,
378 + savedAccount?.status ?? nextProvider.status,
379 + models,
380 + )
381 + ? { modelsRetained: true }
382 + : {}),
383 ...(workspaceSnapshots === undefined ? {} : { workspaceSnapshots }),
384 ...(nextProvider.workspaceRescannedAt === undefined &&
385 previousProvider.workspaceRescannedAt !== undefined
apps/web/src/providerInstances.test.ts
+35
@@ -96,6 +96,41 @@ describe("isProviderInstancePickerReady", () => {
96 false,
97 );
98 });
99 +
100 + it("keeps offering the models a refresh retained when the catalog did not arrive in time", () => {
101 + const [entry] = deriveProviderInstanceEntries([
102 + {
103 + ...provider({
104 + provider: ProviderDriverKind.make("codex"),
105 + instanceId: "codex",
106 + status: "warning",
107 + models: [model("gpt-5.5", false, true), model("gpt-5.4")],
108 + }),
109 + message: "Codex did not return its model catalog in time.",
110 + },
111 + ]);
112 +
113 + expect(entry && isProviderInstancePickerReady(entry)).toBe(true);
114 + expect(
115 + entry && isProviderInstancePickerReady({ ...entry, models: [model("bailian", true)] }),
116 + ).toBe(true);
117 + expect(entry && isProviderInstancePickerReady({ ...entry, models: [] })).toBe(false);
118 + });
119 +
120 + it("offers a failed provider's models only while the server marks them retained", () => {
121 + const failed = provider({
122 + provider: ProviderDriverKind.make("codex"),
123 + instanceId: "codex",
124 + status: "error",
125 + models: [model("gpt-5.5", false, true)],
126 + });
127 + const ready = (snapshot: ServerProvider) =>
128 + deriveProviderInstanceEntries([snapshot]).map(isProviderInstancePickerReady)[0];
129 +
130 + expect(ready({ ...failed, modelsRetained: true })).toBe(true);
131 + expect(ready(failed)).toBe(false);
132 + expect(ready({ ...failed, status: "warning", auth: { status: "unknown" } })).toBe(false);
133 + });
134 });
135
136 describe("applyProviderInstanceSettings", () => {
apps/web/src/providerInstances.ts
+17 -2
@@ -52,7 +52,7 @@ export function hasInstanceBadge(entries: ReadonlyArray<ProviderInstanceEntry>):
52 * Disabled instances may retain ready status until reconciliation. A warning still offers
53 * the models of sub-providers that report no problem of their own.
54 */
55 -export function isProviderInstancePickerReady(entry: ProviderInstanceEntry): boolean {
55 +function isProviderInstanceHealthy(entry: ProviderInstanceEntry): boolean {
56 if (!entry.enabled || !entry.isAvailable) return false;
57 if (entry.status === "ready") return true;
58 if (entry.status !== "warning") return false;
@@ -66,6 +66,21 @@ export function isProviderInstancePickerReady(entry: ProviderInstanceEntry): boo
66 );
67 }
68
69 +/** Also true after a check that only failed or ran late: an earlier check's models stay offered. */
70 +export function isProviderInstancePickerReady(entry: ProviderInstanceEntry): boolean {
71 + if (isProviderInstanceHealthy(entry)) return true;
72 + const { subProviders, auth, modelsRetained } = entry.snapshot;
73 + if (!entry.enabled || !entry.isAvailable || subProviders !== undefined) return false;
74 + if (modelsRetained === true) return true;
75 + // The sign-in was confirmed, so the warning is about something else, such as a late catalog.
76 + return (
77 + entry.status === "warning" &&
78 + entry.installed &&
79 + auth.status === "authenticated" &&
80 + entry.models.length > 0
81 + );
82 +}
83 +
84 export function isProviderInstancePickerVisible(entry: ProviderInstanceEntry): boolean {
85 return entry.enabled;
86 }
@@ -240,7 +255,7 @@ export function resolveSelectableProviderInstanceEntry(
255 }
256 }
257 return (
243 - entries.find(isProviderInstancePickerReady) ??
258 + entries.find(isProviderInstanceHealthy) ??
259 entries.find((entry) => isSelectableProviderInstanceEntry(entry) && entry.status !== "error")
260 );
261 }
packages/contracts/src/server.ts
+2
@@ -279,6 +279,8 @@ export const ServerProvider = Schema.Struct({
279 models: Schema.Array(ServerProviderModel),
280 // Pickers group `models` under these, in order, by `subProvider`.
281 subProviders: Schema.optional(Schema.Array(ServerProviderSubProvider)),
282 + // Set for the one failed check that follows a ready one: pickers keep offering `models`.
283 + modelsRetained: Schema.optionalKey(Schema.Boolean),
284 // Kept apart from `models` so clients that predate it never offer them.
285 updateRequiredModels: Schema.optionalKey(Schema.Array(ServerProviderUpdateRequiredModel)),
286 slashCommands: Schema.Array(ServerProviderSlashCommand).pipe(
packages/provider-core/src/server/managedProvider.ts
+12 -1
@@ -4,6 +4,7 @@ import {
4 ServerSettingsError,
5 } from "@t3tools/contracts";
6 import { resolveServerBackgroundActivitySettings } from "@t3tools/shared/backgroundActivitySettings";
7 +import * as Context from "effect/Context";
8 import * as Duration from "effect/Duration";
9 import * as Effect from "effect/Effect";
10 import * as Equal from "effect/Equal";
@@ -44,6 +45,14 @@ function withUsageLimits(
45
46 const FAILED_CHECK_RECHECK_DELAY = "30 seconds";
47
48 +/**
49 + * True inside a `checkProvider` whose failure over a ready provider is discarded for a recheck.
50 + * A provider that also records check results in its own state must leave that failure out of it.
51 + */
52 +export const DeferringFailedCheck = Context.Reference<boolean>("t3/provider/DeferringFailedCheck", {
53 + defaultValue: () => false,
54 +});
55 +
56 export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(function* <
57 Settings,
58 >(input: {
@@ -178,7 +187,9 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(
187
188 // A probe without usage must not erase a report published while its I/O was in flight.
189 const usageBeforeProbe = (yield* Ref.get(snapshotStateRef)).snapshot.usageLimits;
181 - const probedSnapshot = yield* input.checkProvider;
190 + const probedSnapshot = yield* input.checkProvider.pipe(
191 + Effect.provideService(DeferringFailedCheck, options?.deferFailure === true),
192 + );
193 // One failed periodic check over a ready provider is often transient; recheck before showing it.
194 if (
195 options?.deferFailure === true &&