@devries-cameron20 / t3code Mirror · read-only / commits / 09548f6145
Fork 0

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