Skip to content

Commit 21042d4

Browse files
committed
test(server): cover model refresh at the registry boundary
1 parent c9d556f commit 21042d4

2 files changed

Lines changed: 201 additions & 104 deletions

File tree

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

Lines changed: 162 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -76,6 +76,7 @@ import * as ProviderInstanceRegistryMutator from "./ProviderInstanceRegistryMuta
7676
import * as ProviderRegistry from "./ProviderRegistry.ts";
7777
import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment";
7878
import { makeManualOnlyProviderMaintenanceCapabilities } from "@t3tools/provider-core/server/maintenanceResolver";
79+
import { ProviderDriverError } from "@t3tools/provider-core/server/errors";
7980
vi.mock("@anthropic-ai/claude-agent-sdk", { spy: true });
8081

8182
const decodeServerProvider = Schema.decodeSync(ServerProvider);
@@ -1489,6 +1490,167 @@ it.layer(
14891490
);
14901491
});
14911492

1493+
it.effect.each(["all", "single", "disabled", "uninstalled", "non-refreshable"] as const)(
1494+
"%s model refresh preserves cached models and skips ineligible instances",
1495+
(target) =>
1496+
Effect.gen(function* () {
1497+
const driver = ProviderDriverKind.make("antigravity");
1498+
const firstId = ProviderInstanceId.make("antigravity_first");
1499+
const secondId = ProviderInstanceId.make("antigravity_second");
1500+
const thirdId = ProviderInstanceId.make("antigravity_third");
1501+
const skippedIds = {
1502+
disabled: ProviderInstanceId.make("antigravity_disabled"),
1503+
uninstalled: ProviderInstanceId.make("antigravity_uninstalled"),
1504+
"non-refreshable": ProviderInstanceId.make("antigravity_static"),
1505+
};
1506+
const driverError = new ProviderDriverError({
1507+
driver,
1508+
instanceId: firstId,
1509+
detail: "Model refresh failed.",
1510+
cause: new Error("native refresh failure"),
1511+
});
1512+
const thirdStarted = yield* Deferred.make<void>();
1513+
const calls = yield* Ref.make<ReadonlyArray<ProviderInstanceId>>([]);
1514+
const activeRefreshes = yield* Ref.make(0);
1515+
const maxRefreshes = yield* Ref.make(0);
1516+
const model = (slug: string) => ({
1517+
slug,
1518+
name: slug,
1519+
isCustom: false,
1520+
capabilities: null,
1521+
});
1522+
const makeInstance = Effect.fn("Test.makeModelRefreshInstance")(function* (
1523+
instanceId: ProviderInstanceId,
1524+
options: { enabled?: boolean; installed?: boolean; refreshable?: boolean } = {},
1525+
) {
1526+
const snapshot = yield* Ref.make<ServerProvider>({
1527+
instanceId,
1528+
driver,
1529+
enabled: options.enabled ?? true,
1530+
installed: options.installed ?? true,
1531+
version: "1.1.1",
1532+
status: "ready",
1533+
auth: { status: "authenticated" },
1534+
checkedAt: "2026-10-25T00:00:00.000Z",
1535+
models: [model("cached-model")],
1536+
slashCommands: [],
1537+
skills: [],
1538+
});
1539+
return {
1540+
instanceId,
1541+
driverKind: driver,
1542+
continuationIdentity: { driverKind: driver, continuationKey: instanceId },
1543+
displayName: undefined,
1544+
enabled: options.enabled ?? true,
1545+
snapshot: {
1546+
getSnapshot: Ref.get(snapshot),
1547+
refresh: Ref.get(snapshot),
1548+
resolveMaintenance: () =>
1549+
Effect.succeed(
1550+
makeManualOnlyProviderMaintenanceCapabilities({
1551+
provider: driver,
1552+
packageName: null,
1553+
}),
1554+
),
1555+
streamChanges: Stream.empty,
1556+
applyUsageLimits: () => Effect.void,
1557+
},
1558+
...(options.refreshable === false
1559+
? {}
1560+
: {
1561+
refreshModels: () =>
1562+
Effect.gen(function* () {
1563+
yield* Ref.update(calls, (ids) => [...ids, instanceId]);
1564+
if (instanceId === firstId) {
1565+
return yield* driverError;
1566+
}
1567+
const active = yield* Ref.updateAndGet(
1568+
activeRefreshes,
1569+
(count) => count + 1,
1570+
);
1571+
yield* Ref.update(maxRefreshes, (count) => Math.max(count, active));
1572+
yield* instanceId === secondId
1573+
? Deferred.await(thirdStarted)
1574+
: Deferred.succeed(thirdStarted, undefined);
1575+
yield* Ref.update(snapshot, (provider) => ({
1576+
...provider,
1577+
models: [model("refreshed-model")],
1578+
}));
1579+
yield* Ref.update(activeRefreshes, (count) => count - 1);
1580+
}),
1581+
}),
1582+
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
1583+
textGeneration: {} as ProviderInstance["textGeneration"],
1584+
} satisfies ProviderInstance;
1585+
});
1586+
const instances = [
1587+
yield* makeInstance(firstId),
1588+
yield* makeInstance(secondId),
1589+
yield* makeInstance(thirdId),
1590+
yield* makeInstance(skippedIds.disabled, { enabled: false }),
1591+
yield* makeInstance(skippedIds.uninstalled, { installed: false }),
1592+
yield* makeInstance(skippedIds["non-refreshable"], { refreshable: false }),
1593+
];
1594+
const instanceLayer = Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, {
1595+
listInstances: Effect.succeed(instances),
1596+
getInstance: (id) =>
1597+
Effect.succeed(instances.find((instance) => instance.instanceId === id)),
1598+
listUnavailable: Effect.succeed([]),
1599+
streamChanges: Stream.empty,
1600+
subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), PubSub.subscribe),
1601+
});
1602+
yield* Effect.gen(function* () {
1603+
const registry = yield* ProviderRegistry.ProviderRegistry;
1604+
if (target === "single") {
1605+
const failure = yield* registry.refreshModels(firstId).pipe(Effect.flip);
1606+
assert.equal(failure.instanceId, firstId);
1607+
assert.equal(failure.operation, "refresh-models");
1608+
assert.equal(failure.detail, driverError.detail);
1609+
assert.strictEqual(failure.cause, driverError);
1610+
} else {
1611+
yield* registry.refreshModels(target === "all" ? undefined : skippedIds[target]);
1612+
}
1613+
assert.sameMembers(
1614+
[...(yield* Ref.get(calls))],
1615+
target === "all"
1616+
? [firstId, secondId, thirdId]
1617+
: target === "single"
1618+
? [firstId]
1619+
: [],
1620+
);
1621+
assert.equal(yield* Ref.get(maxRefreshes), target === "all" ? 2 : 0);
1622+
assert.deepEqual(
1623+
Object.fromEntries(
1624+
(yield* registry.getProviders).map((provider) => [
1625+
provider.instanceId,
1626+
provider.models.map((entry) => entry.slug),
1627+
]),
1628+
),
1629+
{
1630+
[firstId]: ["cached-model"],
1631+
[secondId]: [target === "all" ? "refreshed-model" : "cached-model"],
1632+
[thirdId]: [target === "all" ? "refreshed-model" : "cached-model"],
1633+
[skippedIds.disabled]: ["cached-model"],
1634+
[skippedIds.uninstalled]: ["cached-model"],
1635+
[skippedIds["non-refreshable"]]: ["cached-model"],
1636+
},
1637+
);
1638+
}).pipe(
1639+
Effect.provide(
1640+
ProviderRegistry.layer.pipe(
1641+
Layer.provide(instanceLayer),
1642+
Layer.provide(layerUnusedMutator),
1643+
Layer.provide(
1644+
ServerConfig.layerTest(process.cwd(), {
1645+
prefix: "t3-provider-registry-model-refresh-",
1646+
}),
1647+
),
1648+
),
1649+
),
1650+
);
1651+
}),
1652+
);
1653+
14921654
it.effect("invalidates model caches only for an explicit model refresh", () =>
14931655
Effect.gen(function* () {
14941656
const forceRefreshCalls = yield* Ref.make(0);

‎apps/server/src/ws.test.ts‎

Lines changed: 39 additions & 104 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ import {
1313
TurnItemId,
1414
ProviderDriverKind,
1515
ProviderInstanceId,
16+
ProviderSetupError,
1617
SourceControlRepositoryError,
1718
WS_METHODS,
1819
WsRpcGroup,
@@ -32,9 +33,9 @@ import * as Exit from "effect/Exit";
3233
import * as Cause from "effect/Cause";
3334
import * as Fiber from "effect/Fiber";
3435
import * as Layer from "effect/Layer";
36+
import * as Option from "effect/Option";
3537
import * as PubSub from "effect/PubSub";
3638
import * as Queue from "effect/Queue";
37-
import * as Ref from "effect/Ref";
3839
import * as Schema from "effect/Schema";
3940
import * as Stream from "effect/Stream";
4041
import * as TestClock from "effect/testing/TestClock";
@@ -83,10 +84,7 @@ import * as ProjectCloneTracker from "./project/ProjectCloneTracker.ts";
8384
import * as ProjectSetupScriptRunner from "./project/ProjectSetupScriptRunner.ts";
8485
import * as ProviderAuthService from "./provider/ProviderAuthService.ts";
8586
import * as ProviderInstanceRegistry from "./provider/ProviderInstanceRegistry.ts";
86-
import * as ProviderInstanceRegistryMutator from "./provider/ProviderInstanceRegistryMutator.ts";
87-
import type { ProviderInstance } from "@t3tools/provider-core/server/driver";
8887
import { ProviderDriverError } from "@t3tools/provider-core/server/errors";
89-
import { makeManualOnlyProviderMaintenanceCapabilities } from "@t3tools/provider-core/server/maintenanceResolver";
9088
import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
9189
import * as ProviderMaintenanceRunner from "./provider/providerMaintenanceRunner.ts";
9290
import * as ProviderRegistry from "./provider/ProviderRegistry.ts";
@@ -1357,111 +1355,56 @@ it.effect("on-demand clients get provider config without workspace snapshots", (
13571355
);
13581356

13591357
it.effect.each(["all", "single"] as const)(
1360-
"%s model refresh preserves cached models when an instance fails",
1358+
"%s model refresh RPC encodes responses without internal causes",
13611359
(target) =>
13621360
Effect.gen(function* () {
13631361
const driver = ProviderDriverKind.make("antigravity");
13641362
const firstId = ProviderInstanceId.make("antigravity_first");
1365-
const secondId = ProviderInstanceId.make("antigravity_second");
1366-
const thirdId = ProviderInstanceId.make("antigravity_third");
13671363
const privateCode = "private-model-refresh-oauth-code";
13681364
const driverError = new ProviderDriverError({
13691365
driver,
13701366
instanceId: firstId,
13711367
detail: "Model refresh failed.",
13721368
cause: new Error(`https://oauth.invalid/callback?code=${privateCode}`),
13731369
});
1374-
const thirdStarted = yield* Deferred.make<void>();
1375-
const activeRefreshes = yield* Ref.make(0);
1376-
const maxRefreshes = yield* Ref.make(0);
1377-
const model = (slug: string) => ({ slug, name: slug, isCustom: false, capabilities: null });
1378-
const makeInstance = Effect.fn("Test.makeModelRefreshInstance")(function* (
1379-
instanceId: ProviderInstanceId,
1380-
) {
1381-
const snapshot = yield* Ref.make<ServerProvider>({
1382-
instanceId,
1370+
const providers: ReadonlyArray<ServerProvider> = [
1371+
{
1372+
instanceId: firstId,
13831373
driver,
13841374
enabled: true,
13851375
installed: true,
13861376
version: "1.1.1",
13871377
status: "ready",
13881378
auth: { status: "authenticated" },
13891379
checkedAt: "2026-10-25T00:00:00.000Z",
1390-
models: [model("cached-model")],
1380+
models: [{ slug: "model", name: "Model", isCustom: false, capabilities: null }],
13911381
slashCommands: [],
13921382
skills: [],
1393-
});
1394-
return {
1395-
instanceId,
1396-
driverKind: driver,
1397-
continuationIdentity: { driverKind: driver, continuationKey: instanceId },
1398-
displayName: undefined,
1399-
enabled: true,
1400-
snapshot: {
1401-
getSnapshot: Ref.get(snapshot),
1402-
refresh: Ref.get(snapshot),
1403-
resolveMaintenance: () =>
1404-
Effect.succeed(
1405-
makeManualOnlyProviderMaintenanceCapabilities({
1406-
provider: driver,
1407-
packageName: null,
1408-
}),
1409-
),
1410-
streamChanges: Stream.empty,
1411-
applyUsageLimits: () => Effect.void,
1412-
},
1413-
refreshModels: () =>
1414-
Effect.gen(function* () {
1415-
if (instanceId === firstId) {
1416-
return yield* driverError;
1417-
}
1418-
const active = yield* Ref.updateAndGet(activeRefreshes, (count) => count + 1);
1419-
yield* Ref.update(maxRefreshes, (count) => Math.max(count, active));
1420-
yield* instanceId === secondId
1421-
? Deferred.await(thirdStarted)
1422-
: Deferred.succeed(thirdStarted, undefined);
1423-
yield* Ref.update(snapshot, (provider) => ({
1424-
...provider,
1425-
models: [model("refreshed-model")],
1426-
}));
1427-
yield* Ref.update(activeRefreshes, (count) => count - 1);
1428-
}),
1429-
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
1430-
textGeneration: {} as ProviderInstance["textGeneration"],
1431-
} satisfies ProviderInstance;
1432-
});
1433-
const instances = [
1434-
yield* makeInstance(firstId),
1435-
yield* makeInstance(secondId),
1436-
yield* makeInstance(thirdId),
1383+
},
14371384
];
1438-
const changes = yield* PubSub.unbounded<void>();
1439-
const instanceLayer = Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, {
1440-
listInstances: Effect.succeed(instances),
1441-
getInstance: (id) =>
1442-
Effect.succeed(instances.find((instance) => instance.instanceId === id)),
1443-
listUnavailable: Effect.succeed([]),
1385+
const requests = yield* Queue.unbounded<ProviderInstanceId | undefined>();
1386+
const registryLayer = Layer.mock(ProviderRegistry.ProviderRegistry)({
1387+
getProviders: Effect.succeed(providers),
1388+
refresh: () => Effect.succeed(providers),
1389+
refreshInstance: () => Effect.succeed(providers),
1390+
invalidateModelCaches: () => Effect.void,
14441391
streamChanges: Stream.empty,
1445-
subscribeChanges: PubSub.subscribe(changes),
1446-
});
1447-
const registryLayer = ProviderRegistry.layer.pipe(
1448-
Layer.provide(
1449-
Layer.mergeAll(
1450-
instanceLayer,
1451-
ModelManifest.layerTest,
1452-
Layer.mock(ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator)({}),
1453-
Layer.mock(ProviderLatestVersions.ProviderLatestVersions)({}),
1392+
refreshModels: (instanceId) =>
1393+
Queue.offer(requests, instanceId).pipe(
1394+
Effect.andThen(
1395+
instanceId === undefined
1396+
? Effect.succeed(providers)
1397+
: Effect.fail(
1398+
new ProviderSetupError({
1399+
instanceId,
1400+
operation: "refresh-models",
1401+
detail: driverError.detail,
1402+
cause: driverError,
1403+
}),
1404+
),
1405+
),
14541406
),
1455-
),
1456-
);
1457-
if (target === "single") {
1458-
const failure = yield* ProviderRegistry.ProviderRegistry.pipe(
1459-
Effect.flatMap((registry) => registry.refreshModels(firstId)),
1460-
Effect.flip,
1461-
Effect.provide(registryLayer),
1462-
);
1463-
assert.strictEqual(failure.cause, driverError);
1464-
}
1407+
});
14651408
const responses = yield* Queue.unbounded<RpcMessage.ResponseExitEncoded>();
14661409
const receive = yield* Deferred.make<Parameters<RpcServer.Protocol["Service"]["run"]>[0]>();
14671410
const protocol = yield* RpcServer.Protocol.make((write) =>
@@ -1485,7 +1428,6 @@ it.effect.each(["all", "single"] as const)(
14851428
);
14861429
const services = Layer.mergeAll(
14871430
layerUnusedConfigRpcServices,
1488-
instanceLayer,
14891431
registryLayer,
14901432
Layer.mock(UsageLimitSources.UsageLimitSources)({ refresh: Effect.void }),
14911433
Layer.mock(ExternalLauncher.ExternalLauncher)({}),
@@ -1523,33 +1465,26 @@ it.effect.each(["all", "single"] as const)(
15231465
headers: [],
15241466
});
15251467
const encoded = yield* Queue.take(responses);
1468+
assert.equal(yield* Queue.take(requests), target === "single" ? firstId : undefined);
15261469
assert.notInclude(JSON.stringify(encoded), privateCode);
15271470
const response = yield* decodeModelRefreshExit(encoded.exit);
15281471
if (target === "single") {
15291472
assert.equal(response._tag, "Failure");
15301473
if (response._tag === "Failure") {
1531-
assert.match(Cause.pretty(response.cause), /Model refresh failed/);
1532-
assert.notMatch(Cause.pretty(response.cause), /ProviderDriverError/);
1474+
const error = Cause.findErrorOption(response.cause).pipe(Option.getOrThrow);
1475+
assert.equal(error._tag, "ProviderSetupError");
1476+
if (error._tag === "ProviderSetupError") {
1477+
assert.equal(error.instanceId, firstId);
1478+
assert.equal(error.operation, "refresh-models");
1479+
assert.equal(error.detail, "Model refresh failed.");
1480+
assert.isUndefined(error.cause);
1481+
}
15331482
}
1534-
assert.equal(yield* Ref.get(maxRefreshes), 0);
15351483
return;
15361484
}
15371485
assert.equal(response._tag, "Success");
15381486
if (response._tag === "Success") {
1539-
assert.deepEqual(
1540-
Object.fromEntries(
1541-
response.value.providers.map((provider) => [
1542-
provider.instanceId,
1543-
provider.models.map((entry) => entry.slug),
1544-
]),
1545-
),
1546-
{
1547-
[firstId]: ["cached-model"],
1548-
[secondId]: ["refreshed-model"],
1549-
[thirdId]: ["refreshed-model"],
1550-
},
1551-
);
1552-
assert.equal(yield* Ref.get(maxRefreshes), 2);
1487+
assert.deepEqual(response.value, { providers });
15531488
}
15541489
}).pipe(
15551490
Effect.provide(

0 commit comments

Comments
 (0)