The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 22, 22:00 UTC
fix(server): retain Codex authentication when discovery times out (#20537)
Co-authored-by: Julius Marminge <julius0216@outlook.com>
Scott Norteman committed
Oct 20, 2026 at 01:33 UTC
09548f614528ecebe5b16e2280d6d608754eb91f
4 files changed
+322
-53
apps/server/src/provider/CodexProvider.test.ts
+226
-1
@@ -1,6 +1,23 @@
1
+import * as NodeServices from "@effect/platform-node/NodeServices";
2
import { assert, it } from "@effect/vitest";
3
+import { CodexSettings } from "@t3tools/contracts";
4
+import * as DateTime from "effect/DateTime";
5
+import * as Deferred from "effect/Deferred";
6
+import * as Effect from "effect/Effect";
7
+import * as Fiber from "effect/Fiber";
8
+import * as FileSystem from "effect/FileSystem";
9
+import * as Queue from "effect/Queue";
10
+import * as Schema from "effect/Schema";
11
+import * as Sink from "effect/Sink";
12
+import * as Stream from "effect/Stream";
13
+import * as TestClock from "effect/testing/TestClock";
14
+import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
15
3
-import { applyPreferredCodexDefaultModel, mapCodexModelCapabilities } from "./CodexProvider.ts";
16
+import {
17
+ applyPreferredCodexDefaultModel,
18
+ checkCodexProviderStatus,
19
+ mapCodexModelCapabilities,
20
+} from "./CodexProvider.ts";
21
22
it("maps current Codex model capability fields", () => {
23
const capabilities = mapCodexModelCapabilities({
@@ -171,3 +188,211 @@ it("ignores custom models that shadow a preferred slug", () => {
188
189
assert.deepStrictEqual(models.find((model) => model.isDefault)?.slug, "gpt-5.4");
190
});
191
+
192
+const decodeCodexSettings = Schema.decodeSync(CodexSettings);
193
+const decodeRequest = Schema.decodeUnknownSync(
194
+ Schema.fromJsonString(
195
+ Schema.Struct({
196
+ id: Schema.optionalKey(Schema.Union([Schema.String, Schema.Number])),
197
+ method: Schema.String,
198
+ }),
199
+ ),
200
+);
201
+const account = {
202
+ account: { type: "chatgpt", email: "test@example.com", planType: "pro" },
203
+ requiresOpenaiAuth: false,
204
+} as const;
205
+
206
+const startProbe = Effect.fn("startProbe")(function* (hang: ReadonlyArray<string>) {
207
+ const fs = yield* FileSystem.FileSystem;
208
+ const homePath = yield* fs.makeTempDirectoryScoped();
209
+ yield* fs.writeFileString(
210
+ `${homePath}/models_cache.json`,
211
+ JSON.stringify({ fetched_at: DateTime.formatIso(yield* DateTime.now) }),
212
+ );
213
+ const output = yield* Queue.unbounded<Uint8Array>();
214
+ const requests = new Map(
215
+ yield* Effect.forEach(
216
+ ["account/read", "skills/list", "model/list/1", "model/list/2", "account/rateLimits/read"],
217
+ (method) =>
218
+ Deferred.make<string | number>().pipe(Effect.map((signal) => [method, signal] as const)),
219
+ ),
220
+ );
221
+ const stopped = yield* Deferred.make<void>();
222
+ const reply = (id: string | number, result: unknown) =>
223
+ Queue.offer(output, new TextEncoder().encode(`${JSON.stringify({ id, result })}\n`));
224
+ let modelRequests = 0;
225
+ const spawner = ChildProcessSpawner.make(() =>
226
+ Effect.gen(function* () {
227
+ yield* Effect.addFinalizer(() => Deferred.succeed(stopped, undefined));
228
+ return ChildProcessSpawner.makeHandle({
229
+ pid: ChildProcessSpawner.ProcessId(1),
230
+ exitCode: Deferred.await(stopped).pipe(Effect.as(ChildProcessSpawner.ExitCode(0))),
231
+ isRunning: Deferred.isDone(stopped).pipe(Effect.map((done) => !done)),
232
+ kill: () => Deferred.succeed(stopped, undefined).pipe(Effect.asVoid),
233
+ unref: Effect.succeed(Effect.void),
234
+ stdin: Sink.forEach((bytes: Uint8Array) =>
235
+ Effect.forEach(
236
+ new TextDecoder().decode(bytes).split("\n").filter(Boolean),
237
+ (line) =>
238
+ Effect.gen(function* () {
239
+ const { id, method } = decodeRequest(line);
240
+ if (id === undefined) return;
241
+ const request = method === "model/list" ? `${method}/${++modelRequests}` : method;
242
+ const signal = requests.get(request);
243
+ if (signal) yield* Deferred.succeed(signal, id);
244
+ if (hang.includes(request) || method === "account/read") return;
245
+ if (method === "initialize") {
246
+ yield* reply(id, {
247
+ userAgent: "codex/0.163.0",
248
+ codexHome: homePath,
249
+ platformFamily: "unix",
250
+ platformOs: "linux",
251
+ });
252
+ } else if (method === "model/list") {
253
+ yield* reply(id, {
254
+ data: [
255
+ {
256
+ id: "gpt-test",
257
+ model: "gpt-test",
258
+ displayName: "Test",
259
+ description: "",
260
+ hidden: false,
261
+ isDefault: true,
262
+ defaultReasoningEffort: "high",
263
+ supportedReasoningEfforts: [],
264
+ },
265
+ ],
266
+ nextCursor: null,
267
+ });
268
+ } else if (method === "skills/list") {
269
+ yield* reply(id, { data: [] });
270
+ } else if (method === "account/rateLimits/read") {
271
+ yield* reply(id, {
272
+ rateLimits: { primary: null, secondary: null, credits: null, planType: "pro" },
273
+ });
274
+ }
275
+ }),
276
+ { discard: true },
277
+ ),
278
+ ),
279
+ stdout: Stream.fromQueue(output),
280
+ stderr: Stream.empty,
281
+ all: Stream.empty,
282
+ getInputFd: () => Sink.drain,
283
+ getOutputFd: () => Stream.empty,
284
+ });
285
+ }),
286
+ );
287
+ const fiber = yield* checkCodexProviderStatus(
288
+ decodeCodexSettings({ homePath, customModels: [{ slug: "custom-model" }] }),
289
+ ).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.forkChild);
290
+ const requested = (method: string) => Deferred.await(requests.get(method)!);
291
+ return {
292
+ fiber,
293
+ requested,
294
+ authenticate: requested("account/read").pipe(Effect.flatMap((id) => reply(id, account))),
295
+ };
296
+});
297
+
298
+it.layer(NodeServices.layer)("Codex probe budget", (it) => {
299
+ it.effect("keeps the first complete catalog when its refresh never answers", () =>
300
+ Effect.gen(function* () {
301
+ const probe = yield* startProbe(["model/list/2"]);
302
+ yield* probe.authenticate;
303
+ yield* probe.requested("model/list/2");
304
+ yield* TestClock.adjust("20 seconds");
305
+ const provider = yield* Fiber.join(probe.fiber);
306
+ assert.strictEqual(provider.status, "ready");
307
+ assert.strictEqual(provider.auth.status, "authenticated");
308
+ assert.deepStrictEqual(
309
+ provider.models.map((model) => model.slug),
310
+ ["gpt-test", "custom-model"],
311
+ );
312
+ }).pipe(Effect.scoped),
313
+ );
314
+
315
+ it.effect("warns with authentication and custom models when no catalog arrives", () =>
316
+ Effect.gen(function* () {
317
+ const probe = yield* startProbe(["model/list/1"]);
318
+ yield* probe.authenticate;
319
+ yield* probe.requested("model/list/1");
320
+ yield* TestClock.adjust("20 seconds");
321
+ const provider = yield* Fiber.join(probe.fiber);
322
+ assert.strictEqual(provider.status, "warning");
323
+ assert.strictEqual(provider.auth.status, "authenticated");
324
+ assert.strictEqual(provider.message, "Codex did not return its model catalog in time.");
325
+ assert.deepStrictEqual(
326
+ provider.models.map((model) => model.slug),
327
+ ["custom-model"],
328
+ );
329
+ }).pipe(Effect.scoped),
330
+ );
331
+
332
+ it.effect("bounds stalled skills and usage discovery by the remaining account probe budget", () =>
333
+ Effect.gen(function* () {
334
+ const probe = yield* startProbe(["skills/list", "account/rateLimits/read"]);
335
+ yield* probe.requested("account/read");
336
+ yield* TestClock.adjust(18_500);
337
+ yield* probe.authenticate;
338
+ yield* probe.requested("skills/list");
339
+ yield* probe.requested("account/rateLimits/read");
340
+ yield* probe.requested("model/list/2");
341
+ yield* TestClock.adjust(1_500);
342
+ const provider = yield* Fiber.join(probe.fiber);
343
+ assert.strictEqual(provider.status, "ready");
344
+ assert.strictEqual(provider.auth.status, "authenticated");
345
+ assert.deepStrictEqual(
346
+ provider.models.map((model) => model.slug),
347
+ ["gpt-test", "custom-model"],
348
+ );
349
+ assert.deepStrictEqual(provider.skills, []);
350
+ assert.strictEqual(provider.usageLimits?.unavailable?.reason, "probeFailed");
351
+ }).pipe(Effect.scoped),
352
+ );
353
+
354
+ it.effect("retains a completed probe when cleanup exceeds the work budget", () =>
355
+ Effect.gen(function* () {
356
+ const started = yield* Deferred.make<void>();
357
+ const complete = yield* Deferred.make<void>();
358
+ const cleanupStarted = yield* Deferred.make<void>();
359
+ const cleanupFinished = yield* Deferred.make<void>();
360
+ const fiber = yield* checkCodexProviderStatus(decodeCodexSettings({}), () =>
361
+ Effect.gen(function* () {
362
+ yield* Effect.addFinalizer(() =>
363
+ Deferred.succeed(cleanupStarted, undefined).pipe(
364
+ Effect.andThen(Deferred.await(cleanupFinished)),
365
+ ),
366
+ );
367
+ yield* Deferred.succeed(started, undefined);
368
+ yield* Deferred.await(complete);
369
+ return { account, version: undefined, models: [], skills: [] };
370
+ }),
371
+ ).pipe(Effect.forkChild);
372
+ yield* Deferred.await(started);
373
+ yield* TestClock.adjust(18_500);
374
+ yield* Deferred.succeed(complete, undefined);
375
+ yield* Deferred.await(cleanupStarted);
376
+ yield* TestClock.adjust("2 seconds");
377
+ yield* Deferred.succeed(cleanupFinished, undefined);
378
+ const provider = yield* Fiber.join(fiber);
379
+ assert.strictEqual(provider.status, "ready");
380
+ assert.strictEqual(provider.auth.status, "authenticated");
381
+ }),
382
+ );
383
+
384
+ it.effect("still errors when account authentication never answers", () =>
385
+ Effect.gen(function* () {
386
+ const probe = yield* startProbe([]);
387
+ yield* probe.requested("account/read");
388
+ yield* TestClock.adjust("20 seconds");
389
+ const provider = yield* Fiber.join(probe.fiber);
390
+ assert.strictEqual(provider.status, "error");
391
+ assert.strictEqual(provider.auth.status, "unknown");
392
+ assert.strictEqual(
393
+ provider.message,
394
+ "Timed out while checking Codex app-server provider status.",
395
+ );
396
+ }).pipe(Effect.scoped),
397
+ );
398
+});
apps/server/src/provider/CodexProvider.ts
+86
-46
@@ -67,8 +67,8 @@ type CodexRateLimitsProbe =
67
| { readonly failure: string };
68
69
const CODEX_APP_SERVER_PROBE_FORCE_KILL_AFTER = "2 seconds" as const;
70
-const CODEX_CATALOG_REFRESH_TIMEOUT = "3 seconds" as const;
71
-const CODEX_CONFIG_PROBE_TIMEOUT = "3 seconds" as const;
70
+const CODEX_CATALOG_REFRESH_TIMEOUT_MS = 3_000;
71
+const CODEX_CONFIG_PROBE_TIMEOUT_MS = 3_000;
72
const CODEX_CATALOG_REFRESH_POLL = "100 millis" as const;
73
const CODEX_CLIENT_NAME = "T3 Code";
74
// Codex's probe does a full handshake plus account, models, and skills requests, which can
@@ -76,6 +76,7 @@ const CODEX_CLIENT_NAME = "T3 Code";
76
// (most often reported on Windows). Give Codex its own longer budget instead of raising the
77
// timeout for every provider.
78
const CODEX_AUTH_PROBE_TIMEOUT_MS = 20_000;
79
+const CODEX_DISCOVERY_MARGIN_MS = 250;
80
81
const CODEX_PRESENTATION = {
82
displayName: "Codex",
@@ -87,7 +88,8 @@ export interface CodexAppServerProviderSnapshot {
88
readonly account: CodexSchema.V2GetAccountResponse;
89
readonly rateLimits?: CodexRateLimitsProbe;
90
readonly version: string | undefined;
90
- readonly models: ReadonlyArray<ServerProviderModel>;
91
+ readonly models: ReadonlyArray<ServerProviderModel> | undefined;
92
+ readonly serviceTier?: string | undefined;
93
readonly skills: ReadonlyArray<ServerProviderSkill>;
94
}
95
@@ -386,6 +388,19 @@ const readCodexModelsCacheFetchedAt = Effect.fn("readCodexModelsCacheFetchedAt")
388
);
389
});
390
391
+const withCodexDiscoveryDeadline = Effect.fnUntraced(function* <A, E, R>(
392
+ effect: Effect.Effect<A, E, R>,
393
+ deadlineMs: number,
394
+ timeoutMs = Infinity,
395
+) {
396
+ const remainingMs = Math.min(timeoutMs, deadlineMs - DateTime.toEpochMillis(yield* DateTime.now));
397
+ if (remainingMs <= 0) return undefined;
398
+ return yield* effect.pipe(
399
+ Effect.timeoutOption(Duration.millis(remainingMs)),
400
+ Effect.map(Option.getOrUndefined),
401
+ );
402
+});
403
+
404
/**
405
* Every Codex client on the machine shares that file, and the backend tailors
406
* the catalog to each client's originator: the plain CLI does not get Sol
@@ -396,22 +411,33 @@ const requestCodexChatGptModels = Effect.fn("requestCodexChatGptModels")(functio
411
readonly client: CodexClient.CodexAppServerClient["Service"];
412
readonly codexHome: string;
413
readonly spawnedAtMs: number;
414
+ readonly deadlineMs: number;
415
}) {
400
- const models = yield* requestAllCodexModels(input.client);
401
- const refreshed = yield* readCodexModelsCacheFetchedAt(input.codexHome).pipe(
402
- Effect.repeat({
403
- schedule: Schedule.spaced(CODEX_CATALOG_REFRESH_POLL),
404
- until: (fetchedAtMs) => fetchedAtMs >= input.spawnedAtMs,
405
- }),
406
- Effect.timeoutOption(CODEX_CATALOG_REFRESH_TIMEOUT),
416
+ const models = yield* withCodexDiscoveryDeadline(
417
+ requestAllCodexModels(input.client),
418
+ input.deadlineMs,
419
);
408
- if (Option.isNone(refreshed)) {
420
+ if (models === undefined) return undefined;
421
+ const refreshed = yield* withCodexDiscoveryDeadline(
422
+ readCodexModelsCacheFetchedAt(input.codexHome).pipe(
423
+ Effect.repeat({
424
+ schedule: Schedule.spaced(CODEX_CATALOG_REFRESH_POLL),
425
+ until: (fetchedAtMs) => fetchedAtMs >= input.spawnedAtMs,
426
+ }),
427
+ ),
428
+ input.deadlineMs,
429
+ CODEX_CATALOG_REFRESH_TIMEOUT_MS,
430
+ );
431
+ if (refreshed === undefined) {
432
yield* Effect.logWarning(
433
"Codex did not refresh its model catalog in time; using the cached catalog.",
434
);
435
return models;
436
}
414
- return yield* requestAllCodexModels(input.client);
437
+ return (
438
+ (yield* withCodexDiscoveryDeadline(requestAllCodexModels(input.client), input.deadlineMs)) ??
439
+ models
440
+ );
441
});
442
443
/**
@@ -496,7 +522,6 @@ const probeCodexAppServerProvider = Effect.fn("probeCodexAppServerProvider")(fun
522
readonly homePath?: string;
523
readonly launchArgs?: string;
524
readonly cwd: string;
499
- readonly customModels?: ReadonlyArray<CustomModelSetting>;
525
readonly environment?: NodeJS.ProcessEnv;
526
readonly skipNativeUsage?: boolean;
527
}) {
@@ -511,42 +536,51 @@ const probeCodexAppServerProvider = Effect.fn("probeCodexAppServerProvider")(fun
536
return {
537
account: accountResponse,
538
version,
514
- models: appendCustomCodexModels([], input.customModels ?? []),
539
+ models: [],
540
skills: [],
541
} satisfies CodexAppServerProviderSnapshot;
542
}
543
544
+ // Optional discovery must finish before the outer timeout can discard the account result.
545
+ const deadlineMs = spawnedAtMs + CODEX_AUTH_PROBE_TIMEOUT_MS - CODEX_DISCOVERY_MARGIN_MS;
546
const [skillsResponse, models, serviceTier, rateLimits] = yield* Effect.all(
547
[
521
- client.request("skills/list", {
522
- cwds: [input.cwd],
523
- }),
548
+ withCodexDiscoveryDeadline(client.request("skills/list", { cwds: [input.cwd] }), deadlineMs),
549
accountResponse.account?.type === "chatgpt"
525
- ? requestCodexChatGptModels({ client, codexHome: initialize.codexHome, spawnedAtMs })
526
- : requestAllCodexModels(client),
550
+ ? requestCodexChatGptModels({
551
+ client,
552
+ codexHome: initialize.codexHome,
553
+ spawnedAtMs,
554
+ deadlineMs,
555
+ })
556
+ : withCodexDiscoveryDeadline(requestAllCodexModels(client), deadlineMs),
557
// The shared catalog must exclude config from the server's launch project.
528
- client.request("config/read", { includeLayers: false }).pipe(
529
- Effect.map((response) => response.config.service_tier ?? undefined),
530
- Effect.timeoutOption(CODEX_CONFIG_PROBE_TIMEOUT),
531
- Effect.map(Option.getOrUndefined),
558
+ withCodexDiscoveryDeadline(
559
+ client.request("config/read", { includeLayers: false }),
560
+ deadlineMs,
561
+ CODEX_CONFIG_PROBE_TIMEOUT_MS,
562
+ ).pipe(
563
+ Effect.map((response) => response?.config.service_tier ?? undefined),
564
Effect.catch(() => Effect.logDebug("Codex config read failed.").pipe(Effect.as(undefined))),
565
),
566
// Usage is an enrichment: a failure or a slow answer degrades to "no
567
// usage this probe" rather than costing the account and models.
568
input.skipNativeUsage
569
? Effect.succeed(undefined)
538
- : client.request("account/rateLimits/read", null).pipe(
539
- Effect.map((response): CodexRateLimitsProbe => ({
540
- snapshot: response.rateLimits,
541
- rateLimitsByLimitId: response.rateLimitsByLimitId,
542
- resetCredits: response.rateLimitResetCredits,
543
- accountId: response.accountId,
544
- })),
545
- Effect.timeoutOption(Duration.millis(RATE_LIMITS_PROBE_TIMEOUT_MS)),
546
- Effect.map(
547
- Option.getOrElse((): CodexRateLimitsProbe => ({
548
- failure: "Codex did not answer the usage request.",
549
- })),
570
+ : withCodexDiscoveryDeadline(
571
+ client.request("account/rateLimits/read", null),
572
+ deadlineMs,
573
+ RATE_LIMITS_PROBE_TIMEOUT_MS,
574
+ ).pipe(
575
+ Effect.map((response): CodexRateLimitsProbe =>
576
+ response
577
+ ? {
578
+ snapshot: response.rateLimits,
579
+ rateLimitsByLimitId: response.rateLimitsByLimitId,
580
+ resetCredits: response.rateLimitResetCredits,
581
+ accountId: response.accountId,
582
+ }
583
+ : { failure: "Codex did not answer the usage request." },
584
),
585
Effect.catch((error) =>
586
Effect.logDebug("Codex rate-limit read failed.", { cause: error }).pipe(
@@ -562,11 +596,9 @@ const probeCodexAppServerProvider = Effect.fn("probeCodexAppServerProvider")(fun
596
account: accountResponse,
597
...(rateLimits ? { rateLimits } : {}),
598
version,
565
- models: applyConfiguredCodexServiceTier(
566
- applyPreferredCodexDefaultModel(appendCustomCodexModels(models, input.customModels ?? [])),
567
- serviceTier,
568
- ),
569
- skills: parseCodexSkillsListResponse(skillsResponse, input.cwd),
599
+ models,
600
+ serviceTier,
601
+ skills: skillsResponse ? parseCodexSkillsListResponse(skillsResponse, input.cwd) : [],
602
} satisfies CodexAppServerProviderSnapshot;
603
});
604
@@ -663,7 +695,6 @@ export const checkCodexProviderStatus = Effect.fn("checkCodexProviderStatus")(fu
695
readonly homePath?: string;
696
readonly launchArgs?: string;
697
readonly cwd: string;
666
- readonly customModels: ReadonlyArray<CustomModelSetting>;
698
readonly environment?: NodeJS.ProcessEnv;
699
readonly skipNativeUsage?: boolean;
700
}) => Effect.Effect<
@@ -704,12 +735,12 @@ export const checkCodexProviderStatus = Effect.fn("checkCodexProviderStatus")(fu
735
homePath: codexSettings.homePath,
736
launchArgs: resolveCodexLaunchArgs(codexSettings.launchArgs, resolvedEnvironment),
737
cwd: process.cwd(),
707
- customModels: codexSettings.customModels,
738
environment: resolvedEnvironment,
739
...(managedAuth ? { skipNativeUsage: true } : {}),
740
}).pipe(
711
- Effect.scoped,
741
+ // Process teardown can outlast the work budget without discarding a completed snapshot.
742
Effect.timeoutOption(Duration.millis(CODEX_AUTH_PROBE_TIMEOUT_MS)),
743
+ Effect.scoped,
744
Effect.result,
745
);
746
@@ -778,7 +809,12 @@ export const checkCodexProviderStatus = Effect.fn("checkCodexProviderStatus")(fu
809
presentation: CODEX_PRESENTATION,
810
enabled: codexSettings.enabled,
811
checkedAt,
781
- models: snapshot.models,
812
+ models: applyConfiguredCodexServiceTier(
813
+ applyPreferredCodexDefaultModel(
814
+ appendCustomCodexModels(snapshot.models ?? [], codexSettings.customModels),
815
+ ),
816
+ snapshot.serviceTier,
817
+ ),
818
skills: snapshot.skills,
819
slashCommands: [
820
COMPACT_SLASH_COMMAND,
@@ -796,9 +832,13 @@ export const checkCodexProviderStatus = Effect.fn("checkCodexProviderStatus")(fu
832
probe: {
833
installed: true,
834
version: snapshot.version ?? null,
799
- status: accountStatus.status,
835
+ status: snapshot.models === undefined ? "warning" : accountStatus.status,
836
auth: accountStatus.auth,
801
- ...(accountStatus.message ? { message: accountStatus.message } : {}),
837
+ ...(accountStatus.message
838
+ ? { message: accountStatus.message }
839
+ : snapshot.models === undefined
840
+ ? { message: "Codex did not return its model catalog in time." }
841
+ : {}),
842
...(managedAuth ? {} : { usageLimits }),
843
},
844
});
apps/server/src/provider/ProviderRegistry.test.ts
+6
-2
@@ -1491,8 +1491,12 @@ it.layer(
1491
}
1492
});
1493
1494
- it("keeps discovered models during startup and failed probes without restoring removed custom models", () => {
1495
- for (const provider of [pendingProvider, failedProvider]) {
1494
+ it("keeps discovered models during startup, errors, and discovery warnings without restoring removed custom models", () => {
1495
+ for (const provider of [
1496
+ pendingProvider,
1497
+ failedProvider,
1498
+ { ...failedProvider, status: "warning", auth: { status: "authenticated" } },
1499
+ ] satisfies ReadonlyArray<ServerProvider>) {
1500
assert.deepStrictEqual(
1501
ProviderRegistry.mergeProviderSnapshot(
1502
{
apps/server/src/provider/ProviderRegistry.ts
+4
-4
@@ -197,10 +197,10 @@ const shouldRetainMissingProviderModels = (provider: ServerProvider): boolean =>
197
isAntigravity && provider.status === "warning" && provider.auth.status === "unknown";
198
const isPendingInitialProbe =
199
provider.enabled && !provider.installed && provider.status === "warning";
200
- const didInstalledProviderProbeFail = provider.installed && provider.status === "error";
201
- return (
202
- isPendingAntigravityAuthentication || isPendingInitialProbe || didInstalledProviderProbeFail
203
- );
200
+ const isIncompleteInstalledProbe =
201
+ provider.installed &&
202
+ (provider.status === "error" || (isCodex && provider.status === "warning"));
203
+ return isPendingAntigravityAuthentication || isPendingInitialProbe || isIncompleteInstalledProbe;
204
};
205
206
const shouldRetainMissingOpenCodeMetadata = (provider: ServerProvider): boolean =>