Skip to content

Commit 2432221

Browse files
committed
refactor(server): provider registry owns explicit model cache invalidation
The provider refresh RPC handler forced the model manifest refresh, invalidated each instance's discovery caches, and cleared cached latest package versions itself. Move that into ProviderRegistry.invalidateModelCaches so the transport only decides when an explicit model refresh asks for it.
1 parent 680152e commit 2432221

5 files changed

Lines changed: 186 additions & 29 deletions

File tree

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

Lines changed: 136 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1240,6 +1240,142 @@ it.layer(
12401240
);
12411241
});
12421242

1243+
it.effect("invalidates model caches only for an explicit model refresh", () =>
1244+
Effect.gen(function* () {
1245+
const forceRefreshCalls = yield* Ref.make(0);
1246+
const makeInstance = (name: string) =>
1247+
Effect.gen(function* () {
1248+
const driver = ProviderDriverKind.make("codex");
1249+
const instanceId = ProviderInstanceId.make(name);
1250+
const provider = {
1251+
instanceId,
1252+
driver,
1253+
status: "ready",
1254+
enabled: true,
1255+
installed: true,
1256+
auth: { status: "authenticated" },
1257+
checkedAt: "2026-06-10T00:00:00.000Z",
1258+
version: "1.0.0",
1259+
models: [],
1260+
slashCommands: [],
1261+
skills: [],
1262+
} as const satisfies ServerProvider;
1263+
const invalidations = yield* Ref.make(0);
1264+
const maintenanceReads = yield* Ref.make<ReadonlyArray<boolean>>([]);
1265+
const instance = {
1266+
instanceId,
1267+
driverKind: driver,
1268+
continuationIdentity: {
1269+
driverKind: driver,
1270+
continuationKey: `codex:instance:${name}`,
1271+
},
1272+
displayName: undefined,
1273+
enabled: true,
1274+
snapshot: {
1275+
resolveMaintenance: (options) =>
1276+
Ref.update(maintenanceReads, (reads) => [...reads, options?.fresh === true]).pipe(
1277+
Effect.as(
1278+
makeManualOnlyProviderMaintenanceCapabilities({
1279+
provider: driver,
1280+
packageName: `${name}-package`,
1281+
}),
1282+
),
1283+
),
1284+
getSnapshot: Effect.succeed(provider),
1285+
refresh: Effect.succeed(provider),
1286+
streamChanges: Stream.empty,
1287+
applyUsageLimits: () => Effect.void,
1288+
},
1289+
invalidateCaches: Ref.update(invalidations, (count) => count + 1),
1290+
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
1291+
textGeneration: {} as ProviderInstance["textGeneration"],
1292+
} satisfies ProviderInstance;
1293+
const takeMaintenanceReads = Ref.getAndSet(maintenanceReads, []);
1294+
return { instance, invalidations, takeMaintenanceReads };
1295+
});
1296+
const first = yield* makeInstance("codex_first");
1297+
const second = yield* makeInstance("codex_second");
1298+
const instances = [first.instance, second.instance];
1299+
const layerInstanceRegistry = Layer.succeed(
1300+
ProviderInstanceRegistry.ProviderInstanceRegistry,
1301+
{
1302+
getInstance: (instanceId) =>
1303+
Effect.succeed(instances.find((instance) => instance.instanceId === instanceId)),
1304+
listInstances: Effect.succeed(instances),
1305+
listUnavailable: Effect.succeed([]),
1306+
streamChanges: Stream.empty,
1307+
subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), PubSub.subscribe),
1308+
},
1309+
);
1310+
const layerModelManifest = Layer.succeed(ModelManifest.ModelManifest, {
1311+
current: Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST),
1312+
refresh: Effect.succeed(ModelManifest.BUNDLED_MODEL_MANIFEST),
1313+
forceRefresh: Ref.update(forceRefreshCalls, (count) => count + 1).pipe(
1314+
Effect.as(ModelManifest.BUNDLED_MODEL_MANIFEST),
1315+
),
1316+
refreshInBackground: Effect.void,
1317+
});
1318+
const layerLatestVersions = Layer.effect(
1319+
ProviderLatestVersions.ProviderLatestVersions,
1320+
ProviderLatestVersions.make([
1321+
["codex_first-package", "1.0.0"],
1322+
["codex_second-package", "1.0.0"],
1323+
]),
1324+
);
1325+
const readCachedVersion = (key: string) =>
1326+
ProviderLatestVersions.ProviderLatestVersions.use((latestVersions) =>
1327+
latestVersions.cached(key, Effect.succeed("2.0.0")),
1328+
);
1329+
1330+
yield* Effect.gen(function* () {
1331+
const registry = yield* ProviderRegistry.ProviderRegistry;
1332+
1333+
yield* registry.refreshInstance(first.instance.instanceId);
1334+
yield* registry.refresh();
1335+
assert.strictEqual(yield* Ref.get(forceRefreshCalls), 0);
1336+
assert.strictEqual(yield* Ref.get(first.invalidations), 0);
1337+
assert.strictEqual(yield* readCachedVersion("codex_first-package"), "1.0.0");
1338+
yield* first.takeMaintenanceReads;
1339+
1340+
yield* registry.invalidateModelCaches({ instanceId: first.instance.instanceId });
1341+
// The instance refresh that follows resolves installer metadata fresh itself.
1342+
assert.deepStrictEqual(yield* first.takeMaintenanceReads, [false]);
1343+
assert.strictEqual(yield* Ref.get(forceRefreshCalls), 1);
1344+
assert.strictEqual(yield* Ref.get(first.invalidations), 1);
1345+
assert.strictEqual(yield* Ref.get(second.invalidations), 0);
1346+
assert.strictEqual(yield* readCachedVersion("codex_first-package"), "2.0.0");
1347+
assert.strictEqual(yield* readCachedVersion("codex_second-package"), "1.0.0");
1348+
1349+
yield* registry.invalidateModelCaches({});
1350+
assert.strictEqual(yield* Ref.get(first.invalidations), 2);
1351+
assert.strictEqual(yield* Ref.get(second.invalidations), 1);
1352+
assert.strictEqual(yield* readCachedVersion("codex_second-package"), "2.0.0");
1353+
yield* first.takeMaintenanceReads;
1354+
1355+
// Only a cached workspace refresh leaves the fresh resolution to this call.
1356+
const workspace = { instanceId: first.instance.instanceId, cwd: process.cwd() };
1357+
yield* registry.invalidateModelCaches(workspace);
1358+
assert.deepStrictEqual(yield* first.takeMaintenanceReads, [true]);
1359+
yield* registry.invalidateModelCaches({ ...workspace, fresh: true });
1360+
assert.deepStrictEqual(yield* first.takeMaintenanceReads, [false]);
1361+
}).pipe(
1362+
Effect.provide(
1363+
ProviderRegistry.layer.pipe(
1364+
Layer.provideMerge(layerInstanceRegistry),
1365+
Layer.provideMerge(layerModelManifest),
1366+
Layer.provideMerge(layerLatestVersions),
1367+
Layer.provideMerge(
1368+
ServerConfig.layerTest(process.cwd(), {
1369+
prefix: "t3-provider-registry-model-cache-",
1370+
}),
1371+
),
1372+
Layer.provideMerge(NodeServices.layer),
1373+
),
1374+
),
1375+
);
1376+
}),
1377+
);
1378+
12431379
it.effect("publishes workspace skills while machine health is in error", () =>
12441380
Effect.gen(function* () {
12451381
const driver = ProviderDriverKind.make("codex");

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

Lines changed: 43 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,7 @@ import type {
3939
ProviderWorkspaceSnapshot,
4040
} from "@t3tools/provider-core/server/driver";
4141
import {
42+
latestProviderVersionCacheKeys,
4243
makeManualOnlyProviderMaintenanceCapabilities,
4344
type ProviderMaintenanceCapabilities,
4445
} from "@t3tools/provider-core/server/maintenanceResolver";
@@ -76,6 +77,19 @@ export class ProviderRegistry extends Context.Service<
7677
readonly fresh?: boolean;
7778
}) => Effect.Effect<ReadonlyArray<ServerProvider>>;
7879

80+
/**
81+
* Drop T3-owned model caches before an explicit model refresh: the model
82+
* manifest, each instance's discovery caches, and its cached latest
83+
* versions. Takes the target of the refresh that follows; scoped to one
84+
* instance when `instanceId` is given. Background and ordinary refreshes
85+
* keep their cache timers and must not call this.
86+
*/
87+
readonly invalidateModelCaches: (input: {
88+
readonly instanceId?: ProviderInstanceId | undefined;
89+
readonly cwd?: string | undefined;
90+
readonly fresh?: boolean | undefined;
91+
}) => Effect.Effect<void>;
92+
7993
readonly getProviderMaintenanceCapabilitiesForInstance: (
8094
instanceId: ProviderInstanceId,
8195
provider: ProviderDriverKind,
@@ -1008,6 +1022,34 @@ export const layer = Layer.effect(
10081022
);
10091023
});
10101024

1025+
const invalidateModelCaches = Effect.fn("invalidateModelCaches")(function* (
1026+
input: Parameters<ProviderRegistry["Service"]["invalidateModelCaches"]>[0],
1027+
) {
1028+
yield* manifestService.forceRefresh;
1029+
const instances = yield* instanceRegistry.listInstances;
1030+
yield* Effect.forEach(
1031+
instances.filter(
1032+
(instance) => input.instanceId === undefined || input.instanceId === instance.instanceId,
1033+
),
1034+
(instance) =>
1035+
Effect.gen(function* () {
1036+
yield* instance.invalidateCaches ?? Effect.void;
1037+
// Instance and full refreshes resolve installer metadata fresh
1038+
// themselves; a cached workspace refresh needs it resolved here.
1039+
const maintenance = yield* instance.snapshot.resolveMaintenance({
1040+
fresh:
1041+
input.instanceId !== undefined && input.cwd !== undefined && input.fresh !== true,
1042+
});
1043+
yield* Effect.forEach(
1044+
latestProviderVersionCacheKeys(maintenance),
1045+
latestVersions.invalidate,
1046+
{ discard: true },
1047+
);
1048+
}),
1049+
{ concurrency: "unbounded", discard: true },
1050+
);
1051+
});
1052+
10111053
return {
10121054
getProviders: Ref.get(providersRef),
10131055
refresh: (provider?: ProviderDriverKind) =>
@@ -1017,6 +1059,7 @@ export const layer = Layer.effect(
10171059
refreshWorkspaceSnapshot: (input) =>
10181060
refreshWorkspaceSnapshot(input).pipe(Effect.catchCause(recoverRefreshFailure)),
10191061
refreshAfterUpdate,
1062+
invalidateModelCaches,
10201063
getProviderMaintenanceCapabilitiesForInstance,
10211064
setProviderMaintenanceActionState,
10221065
get streamChanges() {

‎apps/server/src/provider/providerMaintenanceRunner.test.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -197,6 +197,7 @@ function makeRegistry(
197197
refreshInstance: () => Ref.get(providersRef),
198198
refreshAfterUpdate: () => Ref.get(providersRef),
199199
refreshWorkspaceSnapshot: () => Ref.get(providersRef),
200+
invalidateModelCaches: () => Effect.void,
200201
getProviderMaintenanceCapabilitiesForInstance: (_instanceId, provider) =>
201202
Effect.succeed(lifecycleFor(provider)),
202203
setProviderMaintenanceActionState,

‎apps/server/src/provider/testUtils/providerRegistryMock.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ const makeProviderRegistryMock = (
1313
refreshInstance: () => Effect.succeed(providers),
1414
refreshAfterUpdate: () => Effect.succeed(providers),
1515
refreshWorkspaceSnapshot: () => Effect.succeed(providers),
16+
invalidateModelCaches: () => Effect.void,
1617
getProviderMaintenanceCapabilitiesForInstance: (_instanceId, provider) =>
1718
Effect.succeed(makeManualOnlyProviderMaintenanceCapabilities({ provider, packageName: null })),
1819
setProviderMaintenanceActionState: () => Effect.succeed(providers),

‎apps/server/src/ws.ts‎

Lines changed: 5 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -162,9 +162,6 @@ import * as ProviderRegistry from "./provider/ProviderRegistry.ts";
162162
import * as ProviderInstanceRegistry from "./provider/ProviderInstanceRegistry.ts";
163163
import * as AcpRegistrySupport from "@t3tools/provider-acp-registry/server/AcpRegistrySupport";
164164
import * as AcpRegistryRuntimeCoordinator from "@t3tools/provider-acp-registry/server/AcpRegistryRuntimeCoordinator";
165-
import * as ModelManifest from "./provider/ModelManifest.ts";
166-
import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
167-
import { latestProviderVersionCacheKeys } from "@t3tools/provider-core/server/maintenanceResolver";
168165
import * as ProviderMaintenanceRunner from "./provider/providerMaintenanceRunner.ts";
169166
import * as ProviderAuthService from "./provider/ProviderAuthService.ts";
170167
import { makeProviderInstallation } from "./provider/providerInstallation.ts";
@@ -1269,8 +1266,6 @@ export const layerWsRpc = (
12691266
const previewManager = yield* PreviewManager.PreviewManager;
12701267
const portDiscovery = yield* PortScanner.PortDiscovery;
12711268
const providerRegistry = yield* ProviderRegistry.ProviderRegistry;
1272-
const modelManifest = yield* ModelManifest.ModelManifest;
1273-
const providerLatestVersions = yield* ProviderLatestVersions.ProviderLatestVersions;
12741269
const providerInstances = yield* ProviderInstanceRegistry.ProviderInstanceRegistry;
12751270
const acpRegistryCatalog = yield* AcpRegistrySupport.AcpRegistryCatalog;
12761271
const acpRegistryRuntimeCoordinator =
@@ -2180,30 +2175,11 @@ export const layerWsRpc = (
21802175
/* Request instrumentation already owns the span; keep this helper in that context. */
21812176
Effect.fnUntraced(function* (input) {
21822177
if (input.refreshModels) {
2183-
yield* modelManifest.forceRefresh;
2184-
const instances = yield* providerInstances.listInstances;
2185-
yield* Effect.forEach(
2186-
instances.filter(
2187-
(instance) =>
2188-
input.instanceId === undefined || input.instanceId === instance.instanceId,
2189-
),
2190-
(instance) =>
2191-
Effect.gen(function* () {
2192-
yield* instance.invalidateCaches ?? Effect.void;
2193-
const maintenance = yield* instance.snapshot.resolveMaintenance({
2194-
fresh:
2195-
input.instanceId !== undefined &&
2196-
input.cwd !== undefined &&
2197-
input.fresh !== true,
2198-
});
2199-
yield* Effect.forEach(
2200-
latestProviderVersionCacheKeys(maintenance),
2201-
providerLatestVersions.invalidate,
2202-
{ discard: true },
2203-
);
2204-
}),
2205-
{ concurrency: "unbounded", discard: true },
2206-
);
2178+
yield* providerRegistry.invalidateModelCaches({
2179+
instanceId: input.instanceId,
2180+
cwd: input.cwd,
2181+
fresh: input.fresh,
2182+
});
22072183
}
22082184
// Awaited, not forked: the RPC scope closes on return and would
22092185
// interrupt a fork before the hub answered.

0 commit comments

Comments
 (0)