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

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

feat(models): the model picker checks for new models when it opens (#33511)

Co-authored-by: Claude Code <noreply@anthropic.com>

Theo Browne committed Nov 9, 2026 at 11:49 UTC d0f7a509cc9143bf7511800d2f28b7d87e6ef1ec
15 files changed +154 -14
apps/mobile/src/features/threads/ThreadSettingsSheet.tsx
+13
@@ -913,6 +913,19 @@ function ThreadSettingsMainContent(props: {
913 reportFailure: false,
914 });
915 const refreshProviderCatalog = createProviderCatalogRefreshRunner(refreshProvidersCommand);
916 + const registry = use(RegistryContext);
917 + const refreshModelCatalog = useEffectEvent(() => {
918 + const environmentId = session.environmentId;
919 + if (!environmentId) return;
920 + // An older server drops the field and probes every provider.
921 + const config = registry.get(environmentServerConfigsAtom).get(environmentId);
922 + if (config?.environment.capabilities.modelCatalogRefresh !== true) return;
923 + void refreshProvidersCommand({ environmentId, input: { modelCatalogOnly: true } });
924 + });
925 + // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- asks the server for newly released models when the model list opens
926 + useEffect(() => {
927 + refreshModelCatalog();
928 + }, []);
929 const [isRefreshingProviders, setIsRefreshingProviders] = useState(false);
930 const refreshProviders = () => {
931 if (!session.environmentId || isRefreshingProviders) return;
apps/server/src/environment/ServerEnvironment.ts
+1
@@ -249,6 +249,7 @@ export const make = Effect.gen(function* () {
249 environmentThemes: true,
250 usageLimitSources: true,
251 providerWorkspaceSnapshotsOnDemand: true,
252 + modelCatalogRefresh: true,
253 usagePriceOverrides: true,
254 usageModelAliases: true,
255 threadPinning: true,
apps/server/src/provider/CodexInstallation.test.ts
+1
@@ -94,6 +94,7 @@ const makeHarness = Effect.fn("test.makeCodexInstallation")(function* (
94 current: input.manifestCurrent ?? Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST),
95 refresh: Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST),
96 forceRefresh: Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST),
97 + refreshOnDemand: Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST),
98 refreshInBackground: Effect.void,
99 }),
100 Effect.provideService(HostProcess.Platform, input.platform ?? "darwin"),
apps/server/src/provider/ModelManifest.test.ts
+29
@@ -87,6 +87,7 @@ describe("resolveProviderCatalog", () => {
87 current: Effect.succeed(manifest),
88 refresh: Effect.die("Catalog reads must not refresh the manifest"),
89 forceRefresh: Effect.die("Catalog reads must not refresh the manifest"),
90 + refreshOnDemand: Effect.die("Catalog reads must not refresh the manifest"),
91 refreshInBackground: Effect.die("Catalog reads must not refresh the manifest"),
92 }),
93 ),
@@ -335,6 +336,34 @@ describe("ModelManifest service", () => {
336 );
337 });
338
339 + it.effect("refetches for an opened model picker after five minutes, not an hour", () => {
340 + let fetches = 0;
341 + return Effect.gen(function* () {
342 + const service = yield* ModelManifest.make;
343 + yield* service.refresh;
344 + yield* TestClock.adjust("4 minutes");
345 + yield* service.refreshOnDemand;
346 + assert.strictEqual(fetches, 1);
347 +
348 + yield* TestClock.adjust("1 minute");
349 + yield* service.refresh;
350 + assert.strictEqual(fetches, 1);
351 + yield* service.refreshOnDemand;
352 + assert.strictEqual(fetches, 2);
353 + }).pipe(
354 + Effect.scoped,
355 + Effect.provide(
356 + layerService({
357 + prefix: "model-manifest-on-demand-test",
358 + response: () => {
359 + fetches += 1;
360 + return Response.json(REMOTE_MANIFEST);
361 + },
362 + }),
363 + ),
364 + );
365 + });
366 +
367 it.live("drops a disk cache of a manifest older than the bundled one", () =>
368 Effect.gen(function* () {
369 const fs = yield* FileSystem.FileSystem;
apps/server/src/provider/ModelManifest.ts
+12 -2
@@ -27,6 +27,9 @@ const MODEL_MANIFEST_URL =
27
28 const MANIFEST_TTL_MS = 60 * 60 * 1000;
29
30 +/** GitHub's raw CDN caches about this long, so a shorter window buys nothing. */
31 +const MANIFEST_ON_DEMAND_TTL_MS = 5 * 60 * 1000;
32 +
33 /** Back off failed fetches so offline health checks do not each wait on the network. */
34 const MANIFEST_RETRY_MS = 5 * 60 * 1000;
35
@@ -174,6 +177,8 @@ export class ModelManifest extends Context.Service<
177 readonly current: Effect.Effect<ModelManifestData>;
178 readonly refresh: Effect.Effect<ModelManifestData>;
179 readonly forceRefresh: Effect.Effect<ModelManifestData>;
180 + /** For a user looking at the model list: tolerates far less staleness than `refresh`. */
181 + readonly refreshOnDemand: Effect.Effect<ModelManifestData>;
182 /** Process-shared fetches must survive the triggering instance's teardown. */
183 readonly refreshInBackground: Effect.Effect<void>;
184 }
@@ -183,6 +188,7 @@ const BundledOnlyModelManifest: ModelManifest["Service"] = {
188 current: Effect.succeed(BUNDLED_MODEL_MANIFEST),
189 refresh: Effect.succeed(BUNDLED_MODEL_MANIFEST),
190 forceRefresh: Effect.succeed(BUNDLED_MODEL_MANIFEST),
191 + refreshOnDemand: Effect.succeed(BUNDLED_MODEL_MANIFEST),
192 refreshInBackground: Effect.void,
193 };
194
@@ -218,13 +224,16 @@ export const make = Effect.gen(function* () {
224 }),
225 );
226
221 - const refresh = Effect.fn("ModelManifest.refresh")(function* (force = false) {
227 + const refresh = Effect.fn("ModelManifest.refresh")(function* (
228 + force = false,
229 + ttlMs = MANIFEST_TTL_MS,
230 + ) {
231 yield* ensureDiskCacheLoaded;
232 const now = yield* Clock.currentTimeMillis;
233 // Expire future timestamps after clock rollback; disk caches cross restarts, ruling out monotonic time.
234 const isWithin = (sinceMs: number | null, windowMs: number) =>
235 sinceMs !== null && now >= sinceMs && now - sinceMs < windowMs;
227 - if (!force && isWithin(fetchedAtMs, MANIFEST_TTL_MS)) return manifest;
236 + if (!force && isWithin(fetchedAtMs, ttlMs)) return manifest;
237 if (!force && isWithin(lastAttemptMs, MANIFEST_RETRY_MS)) return manifest;
238
239 const settings = yield* settingsService.getSettings.pipe(
@@ -262,6 +271,7 @@ export const make = Effect.gen(function* () {
271 current: ensureDiskCacheLoaded.pipe(Effect.map(() => manifest)),
272 refresh: guardedRefresh,
273 forceRefresh: refreshSemaphore.withPermits(1)(refresh(true)),
274 + refreshOnDemand: refreshSemaphore.withPermits(1)(refresh(false, MANIFEST_ON_DEMAND_TTL_MS)),
275 refreshInBackground: Effect.forkIn(guardedRefresh, serviceScope).pipe(Effect.asVoid),
276 });
277 });
apps/server/src/provider/ProviderRegistry.test.ts
+18 -3
@@ -1492,6 +1492,7 @@ it.layer(
1492 it.effect("invalidates model caches only for an explicit model refresh", () =>
1493 Effect.gen(function* () {
1494 const forceRefreshCalls = yield* Ref.make(0);
1495 + const manifest = yield* Ref.make(ModelManifest.BUNDLED_MODEL_MANIFEST);
1496 const makeInstance = (name: string) =>
1497 Effect.gen(function* () {
1498 const driver = ProviderDriverKind.make("codex");
@@ -1510,6 +1511,7 @@ it.layer(
1511 skills: [],
1512 } as const satisfies ServerProvider;
1513 const invalidations = yield* Ref.make(0);
1514 + const probes = yield* Ref.make(0);
1515 const maintenanceReads = yield* Ref.make<ReadonlyArray<boolean>>([]);
1516 const instance = {
1517 instanceId,
@@ -1531,7 +1533,7 @@ it.layer(
1533 ),
1534 ),
1535 getSnapshot: Effect.succeed(provider),
1534 - refresh: Effect.succeed(provider),
1536 + refresh: Ref.update(probes, (count) => count + 1).pipe(Effect.as(provider)),
1537 streamChanges: Stream.empty,
1538 applyUsageLimits: () => Effect.void,
1539 },
@@ -1540,7 +1542,7 @@ it.layer(
1542 textGeneration: {} as ProviderInstance["textGeneration"],
1543 } satisfies ProviderInstance;
1544 const takeMaintenanceReads = Ref.getAndSet(maintenanceReads, []);
1543 - return { instance, invalidations, takeMaintenanceReads };
1545 + return { instance, invalidations, probes, takeMaintenanceReads };
1546 });
1547 const first = yield* makeInstance("codex_first");
1548 const second = yield* makeInstance("codex_second");
@@ -1557,11 +1559,12 @@ it.layer(
1559 },
1560 );
1561 const layerModelManifest = Layer.succeed(ModelManifest.ModelManifest, {
1560 - current: Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST),
1562 + current: Ref.get(manifest),
1563 refresh: Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST),
1564 forceRefresh: Ref.update(forceRefreshCalls, (count) => count + 1).pipe(
1565 Effect.as(ModelManifest.BUNDLED_MODEL_MANIFEST),
1566 ),
1567 + refreshOnDemand: Ref.get(manifest),
1568 refreshInBackground: Effect.void,
1569 });
1570 const layerLatestVersions = Layer.effect(
@@ -1607,6 +1610,18 @@ it.layer(
1610 assert.deepStrictEqual(yield* first.takeMaintenanceReads, [true]);
1611 yield* registry.invalidateModelCaches({ ...workspace, fresh: true });
1612 assert.deepStrictEqual(yield* first.takeMaintenanceReads, [false]);
1613 +
1614 + // An opened model picker probes only when the manifest differs from what the last pass saw.
1615 + const probesBefore = yield* Ref.get(second.probes);
1616 + yield* registry.refreshModelCatalog;
1617 + assert.strictEqual(yield* Ref.get(second.probes), probesBefore);
1618 + yield* Ref.set(manifest, {
1619 + ...ModelManifest.BUNDLED_MODEL_MANIFEST,
1620 + updatedAt: "2999-01-01T00:00:00Z",
1621 + });
1622 + yield* registry.refreshModelCatalog;
1623 + yield* registry.refreshModelCatalog;
1624 + assert.strictEqual(yield* Ref.get(second.probes), probesBefore + 1);
1625 }).pipe(
1626 Effect.provide(
1627 ProviderRegistry.layer.pipe(
apps/server/src/provider/ProviderRegistry.ts
+35 -8
@@ -92,6 +92,12 @@ export class ProviderRegistry extends Context.Service<
92 readonly fresh?: boolean | undefined;
93 }) => Effect.Effect<void>;
94
95 + /**
96 + * For an opened model picker: refetch a model manifest older than a few
97 + * minutes, and probe providers only when it has models they have not seen.
98 + */
99 + readonly refreshModelCatalog: Effect.Effect<void>;
100 +
101 readonly getProviderMaintenanceCapabilitiesForInstance: (
102 instanceId: ProviderInstanceId,
103 provider: ProviderDriverKind,
@@ -624,6 +630,9 @@ export const layer = Layer.effect(
630 Option.none(),
631 );
632
633 + // What the last full pass could see; a later manifest fetch does not reach providers by itself.
634 + const probedManifestUpdatedAt = yield* Ref.make(initialManifest.updatedAt);
635 +
636 const refreshAll = Effect.fn("refreshAll")(function* () {
637 const claimed = yield* Ref.modify(
638 refreshAllInFlightRef,
@@ -643,15 +652,20 @@ export const layer = Layer.effect(
652 if (claimed.owner) {
653 // Detach shared passes so the first caller's interruption cannot cancel other callers' work.
654 // Syncing first keeps a refresh right after a rebuild from probing the replaced instance.
646 - yield* syncLiveSourcesAndContinue.pipe(
647 - Effect.andThen(Ref.get(liveSubsRef)),
648 - Effect.flatMap((instances) =>
649 - Effect.forEach(instances.values(), (instance) => refreshOneSource(instance), {
650 - concurrency: "unbounded",
651 - discard: true,
652 - }),
655 + yield* manifestService.current.pipe(
656 + Effect.flatMap(({ updatedAt }) =>
657 + syncLiveSourcesAndContinue.pipe(
658 + Effect.andThen(Ref.get(liveSubsRef)),
659 + Effect.flatMap((instances) =>
660 + Effect.forEach(instances.values(), (instance) => refreshOneSource(instance), {
661 + concurrency: "unbounded",
662 + discard: true,
663 + }),
664 + ),
665 + Effect.andThen(Ref.get(providersRef)),
666 + Effect.tap(() => Ref.set(probedManifestUpdatedAt, updatedAt)),
667 + ),
668 ),
654 - Effect.andThen(Ref.get(providersRef)),
669 Effect.onExit((exit) =>
670 Ref.set(refreshAllInFlightRef, Option.none()).pipe(
671 Effect.andThen(Deferred.done(claimed.completion, exit)),
@@ -1069,6 +1083,15 @@ export const layer = Layer.effect(
1083 );
1084 });
1085
1086 + const refreshModelCatalog = Effect.fn("ProviderRegistry.refreshModelCatalog")(function* () {
1087 + const { updatedAt } = yield* manifestService.refreshOnDemand;
1088 + // The first pass can be one that started before the fetch, so allow one more.
1089 + for (let pass = 0; pass < 2; pass++) {
1090 + if ((yield* Ref.get(probedManifestUpdatedAt)) === updatedAt) return;
1091 + yield* refreshAll();
1092 + }
1093 + });
1094 +
1095 return {
1096 getProviders: Ref.get(providersRef),
1097 refresh: (provider?: ProviderDriverKind) =>
@@ -1081,6 +1104,10 @@ export const layer = Layer.effect(
1104 refreshWorkspaceSnapshot(input).pipe(Effect.catchCause(recoverRefreshFailure)),
1105 refreshAfterUpdate,
1106 invalidateModelCaches,
1107 + refreshModelCatalog: refreshModelCatalog().pipe(
1108 + Effect.catchCause(recoverRefreshFailure),
1109 + Effect.asVoid,
1110 + ),
1111 getProviderMaintenanceCapabilitiesForInstance,
1112 setProviderMaintenanceActionState,
1113 get streamChanges() {
apps/server/src/provider/providerCompatibility.test.ts
+1
@@ -285,6 +285,7 @@ it.effect("a remote policy refresh preserves a newer health result on the regist
285 current: Ref.get(manifest),
286 refresh,
287 forceRefresh: refresh,
288 + refreshOnDemand: refresh,
289 refreshInBackground: Effect.void,
290 }),
291 Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, {
apps/server/src/provider/providerMaintenanceRunner.test.ts
+2
@@ -212,6 +212,7 @@ function makeRegistry(
212 },
213 refreshWorkspaceSnapshot: () => Ref.get(providersRef),
214 invalidateModelCaches: () => Effect.void,
215 + refreshModelCatalog: Effect.void,
216 getProviderMaintenanceCapabilitiesForInstance: (_instanceId, provider) =>
217 Effect.succeed(lifecycleFor(provider)),
218 setProviderMaintenanceActionState,
@@ -249,6 +250,7 @@ const makeTestRunner = (
250 current: Effect.succeed(manifest),
251 refresh: Effect.succeed(manifest),
252 forceRefresh: Effect.succeed(manifest),
253 + refreshOnDemand: Effect.succeed(manifest),
254 refreshInBackground: Effect.void,
255 }),
256 latestVersions,
apps/server/src/provider/testUtils/providerRegistryMock.ts
+1
@@ -15,6 +15,7 @@ const makeProviderRegistryMock = (
15 refreshAfterUpdate: () => Effect.succeed(providers),
16 refreshWorkspaceSnapshot: () => Effect.succeed(providers),
17 invalidateModelCaches: () => Effect.void,
18 + refreshModelCatalog: Effect.void,
19 getProviderMaintenanceCapabilitiesForInstance: (_instanceId, provider) =>
20 Effect.succeed(makeManualOnlyProviderMaintenanceCapabilities({ provider, packageName: null })),
21 setProviderMaintenanceActionState: () => Effect.succeed(providers),
apps/server/src/ws.ts
+4
@@ -2494,6 +2494,10 @@ export const layerWsRpc = (
2494 [WS_METHODS.serverRefreshProviders]:
2495 /* Request instrumentation already owns the span; keep this helper in that context. */
2496 Effect.fnUntraced(function* (input) {
2497 + if (input.modelCatalogOnly === true) {
2498 + yield* providerRegistry.refreshModelCatalog;
2499 + return { providers: [] };
2500 + }
2501 if (input.refreshModels) {
2502 yield* providerRegistry.invalidateModelCaches({
2503 instanceId: input.instanceId,
apps/web/src/components/chat/ProviderModelPicker.tsx
+29 -1
@@ -5,7 +5,17 @@ import {
5 type ProviderDriverKind,
6 type ResolvedKeybindingsConfig,
7 } from "@t3tools/contracts";
8 -import { createContext, memo, type ReactNode, useRef, useState } from "react";
8 +import { RegistryContext } from "@effect/atom-react";
9 +import {
10 + createContext,
11 + memo,
12 + type ReactNode,
13 + useContext,
14 + useEffect,
15 + useEffectEvent,
16 + useRef,
17 + useState,
18 +} from "react";
19 import { Badge } from "../ui/badge";
20 import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover";
21 import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
@@ -18,6 +28,8 @@ import { shouldShowInstanceBadge, type ProviderInstanceEntry } from "../../provi
28 import { ComposerControl, type ComposerControlSize } from "./ComposerControl";
29 import { takeOpenTarget, useComposerMenuProps } from "./composerEventScope";
30 import { shortcutLabelForCommand } from "../../keybindings";
31 +import { serverEnvironment } from "../../state/server";
32 +import { useAtomCommand } from "../../state/use-atom-command";
33
34 /** Holds the page still behind the open picker; its lifetime is the popup element's. */
35 function lockBackgroundScroll(popup: HTMLElement | null) {
@@ -116,6 +128,22 @@ export const ProviderModelPicker = memo(function ProviderModelPicker(props: {
128 const composerFloatingLayerProps = useComposerMenuProps();
129 const [uncontrolledIsMenuOpen, setUncontrolledIsMenuOpen] = useState(false);
130 const isMenuOpen = props.open ?? uncontrolledIsMenuOpen;
131 + const registry = useContext(RegistryContext);
132 + const refreshProviders = useAtomCommand(serverEnvironment.refreshProviders, {
133 + reportFailure: false,
134 + });
135 + const refreshModelCatalog = useEffectEvent(() => {
136 + const environmentId = props.environmentId;
137 + if (environmentId === null) return;
138 + // An older server drops the field and probes every provider.
139 + const config = registry.get(serverEnvironment.configValueAtom(environmentId));
140 + if (config?.environment.capabilities.modelCatalogRefresh !== true) return;
141 + void refreshProviders({ environmentId, input: { modelCatalogOnly: true } });
142 + });
143 + // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- asks the server for newly released models on every open; a parent, a keybinding or the palette can open the picker, so no one handler sees them all
144 + useEffect(() => {
145 + if (isMenuOpen) refreshModelCatalog();
146 + }, [isMenuOpen]);
147 const searchInputRef = useRef<HTMLInputElement>(null);
148 const triggerRef = useRef<HTMLButtonElement>(null);
149 const popupRef = useRef<HTMLDivElement | null>(null);
packages/client-runtime/src/state/server.ts
+1
@@ -1441,6 +1441,7 @@ export function createServerEnvironmentAtoms<R, E>(
1441 input.cwd ?? null,
1442 input.fresh ?? false,
1443 input.refreshModels ?? false,
1444 + input.modelCatalogOnly ?? false,
1445 ]),
1446 },
1447 }),
packages/contracts/src/environment.ts
+2
@@ -116,6 +116,8 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({
116 usageLimitSources: Schema.optionalKey(Schema.Boolean),
117 /** Honors `workspaceSnapshotsOnDemand`; older servers send every snapshot and drop them in the stream. */
118 providerWorkspaceSnapshotsOnDemand: Schema.optionalKey(Schema.Boolean),
119 + /** Honors `modelCatalogOnly`; older servers drop the field and probe every provider. */
120 + modelCatalogRefresh: Schema.optionalKey(Schema.Boolean),
121 usagePriceOverrides: Schema.optionalKey(Schema.Boolean),
122 usageModelAliases: Schema.optionalKey(Schema.Boolean),
123 threadPinning: Schema.optionalKey(Schema.Boolean),
packages/contracts/src/rpc.ts
+5
@@ -657,6 +657,11 @@ export const WsServerRefreshProvidersRpc = Rpc.make(WS_METHODS.serverRefreshProv
657 fresh: Schema.optional(Schema.Boolean),
658 /** Bypass model caches; explicit rediscovery may open sessions, background refreshes must not. */
659 refreshModels: Schema.optional(Schema.Boolean),
660 + /**
661 + * A model picker opened: refetch a model manifest older than a few minutes and probe providers
662 + * only when it changed. The other fields are ignored and the config stream carries the result.
663 + */
664 + modelCatalogOnly: Schema.optional(Schema.Boolean),
665 /** Read secret references again; unlocking a vault can prompt on the host, so only explicit user refreshes ask. */
666 reloadSecrets: Schema.optional(Schema.Boolean),
667 /**