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 &&