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, 00:45 UTC
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
/**