fix(server): slow-starting Codex app-server no longer reports Unavailable

apps/server/src/provider/CodexProvider.test.ts

@@ -2,10 +2,23 @@ import { assert, it } from "@effect/vitest";
 
 import {
   applyPreferredCodexDefaultModel,
+  codexDiscoveryDeadlineMs,
   codexRoutesSpendNativeQuota,
   mapCodexModelCapabilities,
 } from "./CodexProvider.ts";
 
+it("counts the Codex discovery budget from initialize, capped by the probe timeout (#27230)", () => {
+  // [initialized after spawn, deadline after spawn]
+  const cases = [
+    [500, 20_250],
+    [25_000, 44_750],
+    [50_000, 59_750],
+  ] as const;
+  for (const [initializedAtMs, expected] of cases) {
+    assert.strictEqual(codexDiscoveryDeadlineMs(0, initializedAtMs), expected);
+  }
+});
+
 it("maps current Codex model capability fields", () => {
   const capabilities = mapCodexModelCapabilities({
     additionalSpeedTiers: [],

apps/server/src/provider/CodexProvider.ts

@@ -113,8 +113,10 @@ const CODEX_CATALOG_REFRESH_TIMEOUT_MS = 3_000;
 const CODEX_CONFIG_PROBE_TIMEOUT_MS = 3_000;
 const CODEX_CATALOG_REFRESH_POLL = "100 millis" as const;
 const CODEX_CLIENT_NAME = "T3 Code";
-// Handshake plus account/models/skills requests can exceed the shared 10s probe budget.
-const CODEX_AUTH_PROBE_TIMEOUT_MS = 20_000;
+// Old machines can take ~25s to start app-server and answer initialize.
+export const CODEX_APP_SERVER_PROBE_TIMEOUT_MS = 60_000;
+// Account/models/skills requests after initialize can exceed the shared 10s probe budget.
+const CODEX_DISCOVERY_BUDGET_MS = 20_000;
 const CODEX_DISCOVERY_MARGIN_MS = 250;
 // `codex-cli 0.159.0`, `codex-cli 0.160.0-alpha.1` or the npm CLI's bare `0.1.4161006`.
 // Keep a prerelease suffix so compatibility stays unknown for it, as it does for `initialize`.
@@ -436,6 +438,14 @@ const readCodexModelsCacheFetchedAt = Effect.fn("readCodexModelsCacheFetchedAt")
   );
 });
 
+// Discovery gets its own budget from `initialize`, so a slow start still lists models, and must
+// finish before the outer timeout can discard the account result.
+export const codexDiscoveryDeadlineMs = (spawnedAtMs: number, initializedAtMs: number) =>
+  Math.min(
+    spawnedAtMs + CODEX_APP_SERVER_PROBE_TIMEOUT_MS,
+    initializedAtMs + CODEX_DISCOVERY_BUDGET_MS,
+  ) - CODEX_DISCOVERY_MARGIN_MS;
+
 const withCodexDiscoveryDeadline = Effect.fnUntraced(function* <A, E, R>(
   effect: Effect.Effect<A, E, R>,
   deadlineMs: number,
@@ -603,6 +613,7 @@ const probeCodexAppServerProvider = Effect.fn("probeCodexAppServerProvider")(fun
 }) {
   const spawnedAtMs = DateTime.toEpochMillis(yield* DateTime.now);
   const { client, initialize } = yield* withCodexAppServerClient(input);
+  const initializedAtMs = DateTime.toEpochMillis(yield* DateTime.now);
 
   const versionMatch = initialize.userAgent.match(/\/([^\s]+)/);
   const version = versionMatch ? versionMatch[1] : undefined;
@@ -617,8 +628,7 @@ const probeCodexAppServerProvider = Effect.fn("probeCodexAppServerProvider")(fun
     } satisfies CodexAppServerProviderSnapshot;
   }
 
-  // Optional discovery must finish before the outer timeout can discard the account result.
-  const deadlineMs = spawnedAtMs + CODEX_AUTH_PROBE_TIMEOUT_MS - CODEX_DISCOVERY_MARGIN_MS;
+  const deadlineMs = codexDiscoveryDeadlineMs(spawnedAtMs, initializedAtMs);
   const [skillsResponse, models, { serviceTier, nativeUsage, rateLimits }] = yield* Effect.all(
     [
       withCodexDiscoveryDeadline(client.request("skills/list", { cwds: [input.cwd] }), deadlineMs),
@@ -846,7 +856,7 @@ export const checkCodexProviderStatus = Effect.fn("checkCodexProviderStatus")(fu
     ...(managedAuth ? { skipNativeUsage: true } : {}),
   }).pipe(
     // Process teardown can outlast the work budget without discarding a completed snapshot.
-    Effect.timeoutOption(Duration.millis(CODEX_AUTH_PROBE_TIMEOUT_MS)),
+    Effect.timeoutOption(Duration.millis(CODEX_APP_SERVER_PROBE_TIMEOUT_MS)),
     Effect.scoped,
     Effect.result,
   );

apps/server/src/provider/Drivers/CodexDriver.ts

@@ -24,6 +24,7 @@ import { ProviderDriverError } from "../Errors.ts";
 import * as ResetCreditCoordinator from "../resetCreditCoordinator.ts";
 import {
   checkCodexProviderStatus,
+  CODEX_APP_SERVER_PROBE_TIMEOUT_MS,
   makePendingCodexProvider,
   probeCodexSkillsForCwd,
   withCodexAppServerClient,
@@ -297,7 +298,7 @@ export const CodexDriver: ProviderDriver<
               environment: processEnv,
             }).pipe(
               Effect.scoped,
-              Effect.timeout("20 seconds"),
+              Effect.timeout(CODEX_APP_SERVER_PROBE_TIMEOUT_MS),
               Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
             ),
           ]).pipe(

apps/server/src/provider/ProviderRegistry.test.ts

@@ -481,6 +481,35 @@ it.layer(
       }),
     );
 
+    it.effect("returns ready when app-server answers slowly but correctly", () =>
+      Effect.gen(function* () {
+        const fiber = yield* checkCodexProviderStatus(defaultCodexSettings, () =>
+          Effect.sleep("25 seconds").pipe(Effect.as(makeCodexProbeSnapshot())),
+        ).pipe(Effect.forkChild);
+        yield* TestClock.adjust("25 seconds");
+        const status = yield* Fiber.join(fiber);
+
+        assert.strictEqual(status.message, undefined);
+        assert.strictEqual(status.status, "ready");
+      }),
+    );
+
+    it.effect("times out when app-server never answers", () =>
+      Effect.gen(function* () {
+        const fiber = yield* checkCodexProviderStatus(defaultCodexSettings, () =>
+          Effect.never.pipe(Effect.as(makeCodexProbeSnapshot())),
+        ).pipe(Effect.forkChild);
+        yield* TestClock.adjust("60 seconds");
+        const status = yield* Fiber.join(fiber);
+
+        assert.strictEqual(status.status, "error");
+        assert.strictEqual(
+          status.message,
+          "Timed out while checking Codex app-server provider status.",
+        );
+      }),
+    );
+
     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;