1import { describe, it, assert } from "@effect/vitest";
2import {
3 DEFAULT_SERVER_SETTINGS,
4 ProviderDriverKind,
5 ProviderInstanceId,
6 type ServerProvider,
7} from "@t3tools/contracts";
8import { createModelCapabilities } from "@t3tools/shared/model";
9import * as Deferred from "effect/Deferred";
10import * as Duration from "effect/Duration";
11import * as Effect from "effect/Effect";
12import * as Fiber from "effect/Fiber";
13import * as Layer from "effect/Layer";
14import * as PubSub from "effect/PubSub";
15import * as Ref from "effect/Ref";
16import * as Stream from "effect/Stream";
17import * as TestClock from "effect/testing/TestClock";
18
19import * as ProviderHost from "./ProviderHost.ts";
20import { makeManagedServerProvider } from "./managedProvider.ts";
21
22const emptyCapabilities = createModelCapabilities({ optionDescriptors: [] });
23const fastModeCapabilities = createModelCapabilities({
24 optionDescriptors: [
25 {
26 id: "fastMode",
27 label: "Fast Mode",
28 type: "boolean",
29 },
30 ],
31});
32
33interface TestSettings {
34 readonly enabled: boolean;
35}
36
37const maintenanceCapabilities = {
38 provider: ProviderDriverKind.make("codex"),
39 packageName: "@openai/codex",
40 update: {
41 command: "npm install -g @openai/codex@latest",
42
43 executable: "npm",
44
45 args: ["install", "-g", "@openai/codex@latest"],
46
47 lockKey: "npm-global",
48 },
49} as const;
50
51const initialSnapshot: ServerProvider = {
52 instanceId: ProviderInstanceId.make("codex"),
53 driver: ProviderDriverKind.make("codex"),
54 enabled: true,
55 installed: true,
56 version: null,
57 status: "warning",
58 auth: { status: "unknown" },
59 checkedAt: "2026-04-10T00:00:00.000Z",
60 message: "Checking provider availability...",
61 models: [],
62 slashCommands: [],
63 skills: [],
64};
65
66const refreshedSnapshot: ServerProvider = {
67 instanceId: ProviderInstanceId.make("codex"),
68 driver: ProviderDriverKind.make("codex"),
69 enabled: true,
70 installed: true,
71 version: "1.0.0",
72 status: "ready",
73 auth: { status: "authenticated" },
74 checkedAt: "2026-04-10T00:00:01.000Z",
75 models: [],
76 slashCommands: [],
77 skills: [],
78};
79
80const enrichedSnapshot: ServerProvider = {
81 ...refreshedSnapshot,
82 checkedAt: "2026-04-10T00:00:02.000Z",
83 models: [
84 {
85 slug: "composer-2",
86 name: "Composer 2",
87 isCustom: false,
88 capabilities: fastModeCapabilities,
89 },
90 ],
91};
92
93const refreshedSnapshotSecond: ServerProvider = {
94 ...refreshedSnapshot,
95 checkedAt: "2026-04-10T00:00:03.000Z",
96 message: "Refreshed provider availability again.",
97};
98
99/** A host whose settings never change and whose background demand is fixed. */
100function layerProviderHost(input: {
101 readonly runBackgroundWork: boolean;
102 readonly settings?: Pick<ProviderHost.ProviderHost["Service"], "settings">["settings"];
103}) {
104 return Layer.succeed(
105 ProviderHost.ProviderHost,
106 ProviderHost.ProviderHost.of({
107 paths: {
108 cwd: process.cwd(),
109 baseDir: "/t3",
110 stateDir: "/t3/userdata",
111 providerStatusCacheDir: "/t3/caches",
112 attachmentsDir: "/t3/userdata/attachments",
113 },
114 settings: input.settings ?? {
115 get: Effect.succeed(DEFAULT_SERVER_SETTINGS),
116 withSnapshot: (use) => use(DEFAULT_SERVER_SETTINGS),
117 changes: Stream.empty,
118 subscribe: Effect.succeed(Stream.empty),
119 },
120 shouldRunBackgroundWork: () => Effect.succeed(input.runBackgroundWork),
121 resolveAttachmentPath: () => null,
122 credentials: () => Effect.die("unused"),
123 }),
124 );
125}
126
127const layerAlwaysRunTest = layerProviderHost({ runBackgroundWork: true });
128const layerNeverRunTest = layerProviderHost({ runBackgroundWork: false });
129
130const enrichedSnapshotSecond: ServerProvider = {
131 ...refreshedSnapshotSecond,
132 checkedAt: "2026-04-10T00:00:04.000Z",
133 models: [
134 {
135 slug: "gpt-5.4",
136 name: "GPT-5.4",
137 isCustom: false,
138 capabilities: emptyCapabilities,
139 },
140 ],
141};
142
143describe("makeManagedServerProvider", () => {
144 it.effect(
145 "runs the initial provider check in the background and streams the refreshed snapshot",
146 () =>
147 Effect.scoped(
148 Effect.gen(function* () {
149 const checkCalls = yield* Ref.make(0);
150 const releaseCheck = yield* Deferred.make<void>();
151 const provider = yield* makeManagedServerProvider<TestSettings>({
152 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
153 getSettings: Effect.succeed({ enabled: true }),
154 streamSettings: Stream.empty,
155 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
156 initialSnapshot: () => Effect.succeed(initialSnapshot),
157 checkProvider: Ref.update(checkCalls, (count) => count + 1).pipe(
158 Effect.flatMap(() => Deferred.await(releaseCheck)),
159 Effect.as(refreshedSnapshot),
160 ),
161 refreshInterval: "1 hour",
162 });
163
164 const initial = yield* provider.getSnapshot;
165 assert.deepStrictEqual(initial, initialSnapshot);
166
167 const updatesFiber = yield* Stream.take(provider.streamChanges, 1).pipe(
168 Stream.runCollect,
169 Effect.forkChild,
170 );
171 yield* Effect.yieldNow;
172 assert.strictEqual(yield* Ref.get(checkCalls), 1);
173
174 yield* Deferred.succeed(releaseCheck, undefined);
175
176 const updates = Array.from(yield* Fiber.join(updatesFiber));
177 const latest = yield* provider.getSnapshot;
178
179 assert.deepStrictEqual(updates, [refreshedSnapshot]);
180 assert.deepStrictEqual(latest, refreshedSnapshot);
181 assert.strictEqual(yield* Ref.get(checkCalls), 1);
182 }),
183 ).pipe(Effect.provide(layerAlwaysRunTest)),
184 );
185
186 it.effect("does not enrich a disabled provider's snapshot", () =>
187 Effect.scoped(
188 Effect.gen(function* () {
189 let enrichmentCalls = 0;
190 const provider = yield* makeManagedServerProvider<TestSettings>({
191 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
192 getSettings: Effect.succeed({ enabled: false }),
193 streamSettings: Stream.empty,
194 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
195 refreshOnInterval: false,
196 initialSnapshot: () => Effect.succeed({ ...initialSnapshot, enabled: false }),
197 checkProvider: Effect.succeed({ ...refreshedSnapshot, enabled: false }),
198 enrichSnapshot: () => {
199 enrichmentCalls += 1;
200 return Effect.void;
201 },
202 });
203
204 yield* provider.refresh;
205
206 assert.strictEqual(enrichmentCalls, 0);
207 }),
208 ).pipe(Effect.provide(layerAlwaysRunTest)),
209 );
210
211 it.effect("skips periodic provider refreshes without foreground provider-status demand", () =>
212 Effect.scoped(
213 Effect.gen(function* () {
214 const checkCalls = yield* Ref.make(0);
215 const initialCheckDone = yield* Deferred.make<void>();
216 yield* makeManagedServerProvider<TestSettings>({
217 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
218 getSettings: Effect.succeed({ enabled: true }),
219 streamSettings: Stream.empty,
220 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
221 initialSnapshot: () => Effect.succeed(initialSnapshot),
222 checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
223 Effect.tap((count) =>
224 count === 1
225 ? Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)
226 : Effect.void,
227 ),
228 Effect.as(refreshedSnapshot),
229 ),
230 refreshInterval: "1 second",
231 });
232
233 yield* Deferred.await(initialCheckDone);
234 yield* TestClock.adjust("1 second");
235 yield* Effect.yieldNow;
236
237 assert.strictEqual(yield* Ref.get(checkCalls), 1);
238 }),
239 ).pipe(Effect.provide(Layer.mergeAll(layerNeverRunTest, TestClock.layer()))),
240 );
241
242 it.effect("disables periodic provider refreshes when the explicit interval is zero", () =>
243 Effect.scoped(
244 Effect.gen(function* () {
245 const checkCalls = yield* Ref.make(0);
246 const initialCheckDone = yield* Deferred.make<void>();
247 yield* makeManagedServerProvider<TestSettings>({
248 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
249 getSettings: Effect.succeed({ enabled: true }),
250 streamSettings: Stream.empty,
251 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
252 initialSnapshot: () => Effect.succeed(initialSnapshot),
253 checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
254 Effect.tap(() => Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)),
255 Effect.as(refreshedSnapshot),
256 ),
257 refreshInterval: 0,
258 });
259
260 yield* Deferred.await(initialCheckDone);
261 yield* TestClock.adjust("5 minutes");
262 yield* Effect.yieldNow;
263
264 assert.strictEqual(yield* Ref.get(checkCalls), 1);
265 }),
266 ).pipe(Effect.provide(Layer.mergeAll(layerAlwaysRunTest, TestClock.layer()))),
267 );
268
269 it.effect("keeps manual refresh when interval refresh is disabled", () =>
270 Effect.scoped(
271 Effect.gen(function* () {
272 const checkCalls = yield* Ref.make(0);
273 const initialCheckDone = yield* Deferred.make<void>();
274 const provider = yield* makeManagedServerProvider<TestSettings>({
275 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
276 getSettings: Effect.succeed({ enabled: true }),
277 streamSettings: Stream.empty,
278 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
279 initialSnapshot: () => Effect.succeed(initialSnapshot),
280 checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
281 Effect.tap((count) =>
282 count === 1
283 ? Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)
284 : Effect.void,
285 ),
286 Effect.as(refreshedSnapshot),
287 ),
288 refreshInterval: "1 second",
289 refreshOnInterval: false,
290 });
291
292 yield* Deferred.await(initialCheckDone);
293 yield* TestClock.adjust("5 minutes");
294 yield* Effect.yieldNow;
295 assert.strictEqual(yield* Ref.get(checkCalls), 1);
296
297 yield* provider.refresh;
298 assert.strictEqual(yield* Ref.get(checkCalls), 2);
299 }),
300 ).pipe(Effect.provide(Layer.mergeAll(layerAlwaysRunTest, TestClock.layer()))),
301 );
302
303 it.effect("wakes a sleeping provider refresh loop when its interval changes", () =>
304 Effect.scoped(
305 Effect.gen(function* () {
306 const initialServerSettings = {
307 ...DEFAULT_SERVER_SETTINGS,
308 providerHealthRefreshInterval: Duration.hours(1),
309 };
310 const serverSettingsRef = yield* Ref.make(initialServerSettings);
311 const serverSettingsChanges = yield* PubSub.unbounded<typeof initialServerSettings>();
312 const hostSettings: ProviderHost.ProviderHost["Service"]["settings"] = {
313 get: Ref.get(serverSettingsRef),
314 withSnapshot: (use) => Ref.get(serverSettingsRef).pipe(Effect.flatMap(use)),
315 changes: Stream.empty,
316 subscribe: PubSub.subscribe(serverSettingsChanges).pipe(
317 Effect.map((subscription) => Stream.fromSubscription(subscription)),
318 ),
319 };
320 const checkCalls = yield* Ref.make(0);
321 const initialCheckDone = yield* Deferred.make<void>();
322 const periodicCheckDone = yield* Deferred.make<void>();
323
324 yield* makeManagedServerProvider<TestSettings>({
325 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
326 getSettings: Effect.succeed({ enabled: true }),
327 streamSettings: Stream.empty,
328 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
329 initialSnapshot: () => Effect.succeed(initialSnapshot),
330 checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
331 Effect.tap((count) =>
332 count === 1
333 ? Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)
334 : Deferred.succeed(periodicCheckDone, undefined).pipe(Effect.ignore),
335 ),
336 Effect.as(refreshedSnapshot),
337 ),
338 }).pipe(
339 Effect.provide(layerProviderHost({ runBackgroundWork: true, settings: hostSettings })),
340 );
341
342 yield* Deferred.await(initialCheckDone);
343 const nextServerSettings = {
344 ...initialServerSettings,
345 providerHealthRefreshInterval: Duration.seconds(1),
346 };
347 yield* Ref.set(serverSettingsRef, nextServerSettings);
348 yield* PubSub.publish(serverSettingsChanges, nextServerSettings);
349 yield* Effect.yieldNow;
350
351 yield* TestClock.adjust("999 millis");
352 assert.strictEqual(yield* Ref.get(checkCalls), 1);
353 yield* TestClock.adjust("1 millis");
354 yield* Deferred.await(periodicCheckDone);
355 assert.strictEqual(yield* Ref.get(checkCalls), 2);
356 }),
357 ).pipe(Effect.provide(TestClock.layer())),
358 );
359
360 it.effect("reruns the provider check when streamed settings change", () =>
361 Effect.scoped(
362 Effect.gen(function* () {
363 const settingsRef = yield* Ref.make<TestSettings>({ enabled: true });
364 const settingsChanges = yield* PubSub.unbounded<TestSettings>();
365 const checkCalls = yield* Ref.make(0);
366 const releaseInitialCheck = yield* Deferred.make<void>();
367 const releaseSettingsCheck = yield* Deferred.make<void>();
368 const provider = yield* makeManagedServerProvider<TestSettings>({
369 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
370 getSettings: Ref.get(settingsRef),
371 streamSettings: Stream.fromPubSub(settingsChanges),
372 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
373 initialSnapshot: () => Effect.succeed(initialSnapshot),
374 checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
375 Effect.flatMap((count) =>
376 count === 1
377 ? Deferred.await(releaseInitialCheck).pipe(Effect.as(refreshedSnapshot))
378 : Deferred.await(releaseSettingsCheck).pipe(Effect.as(refreshedSnapshotSecond)),
379 ),
380 ),
381 refreshInterval: "1 hour",
382 });
383
384 const updatesFiber = yield* Stream.take(provider.streamChanges, 2).pipe(
385 Stream.runCollect,
386 Effect.forkChild,
387 );
388 yield* Effect.yieldNow;
389
390 yield* Deferred.succeed(releaseInitialCheck, undefined);
391 yield* Ref.set(settingsRef, { enabled: false });
392 yield* PubSub.publish(settingsChanges, { enabled: false });
393 yield* Deferred.succeed(releaseSettingsCheck, undefined);
394
395 const updates = Array.from(yield* Fiber.join(updatesFiber));
396 const latest = yield* provider.getSnapshot;
397
398 assert.deepStrictEqual(updates, [refreshedSnapshot, refreshedSnapshotSecond]);
399 assert.deepStrictEqual(latest, refreshedSnapshotSecond);
400 assert.strictEqual(yield* Ref.get(checkCalls), 2);
401 }),
402 ).pipe(Effect.provide(layerAlwaysRunTest)),
403 );
404
405 it.effect("can update settings and disable periodic checks without probing again", () =>
406 Effect.scoped(
407 Effect.gen(function* () {
408 const settingsChanges = yield* PubSub.unbounded<TestSettings>();
409 const checkCalls = yield* Ref.make(0);
410 const initialCheckDone = yield* Deferred.make<void>();
411 const enrichmentCalls = yield* Ref.make(0);
412 yield* makeManagedServerProvider<TestSettings>({
413 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
414 getSettings: Effect.succeed({ enabled: true }),
415 streamSettings: Stream.fromPubSub(settingsChanges),
416 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
417 checkProviderOnSettingsChange: () => false,
418 refreshOnInterval: false,
419 initialSnapshot: () => Effect.succeed(initialSnapshot),
420 checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
421 Effect.tap(() => Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)),
422 Effect.as(refreshedSnapshot),
423 ),
424 enrichSnapshot: () => Ref.update(enrichmentCalls, (count) => count + 1),
425 refreshInterval: "1 second",
426 });
427
428 yield* Deferred.await(initialCheckDone);
429 yield* PubSub.publish(settingsChanges, { enabled: false });
430 yield* Effect.yieldNow;
431 yield* TestClock.adjust("1 second");
432 yield* Effect.yieldNow;
433
434 assert.strictEqual(yield* Ref.get(checkCalls), 1);
435 assert.strictEqual(yield* Ref.get(enrichmentCalls), 2);
436 }),
437 ).pipe(Effect.provide(Layer.mergeAll(layerAlwaysRunTest, TestClock.layer()))),
438 );
439
440 it.effect("streams supplemental snapshot updates after the base provider check completes", () =>
441 Effect.scoped(
442 Effect.gen(function* () {
443 const releaseEnrichment = yield* Deferred.make<void>();
444 const releaseCheck = yield* Deferred.make<void>();
445 const provider = yield* makeManagedServerProvider<TestSettings>({
446 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
447 getSettings: Effect.succeed({ enabled: true }),
448 streamSettings: Stream.empty,
449 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
450 initialSnapshot: () => Effect.succeed(initialSnapshot),
451 checkProvider: Deferred.await(releaseCheck).pipe(Effect.as(refreshedSnapshot)),
452 enrichSnapshot: ({ publishSnapshot }) =>
453 Deferred.await(releaseEnrichment).pipe(
454 Effect.flatMap(() => publishSnapshot(enrichedSnapshot)),
455 ),
456 refreshInterval: "1 hour",
457 });
458
459 const updatesFiber = yield* Stream.take(provider.streamChanges, 2).pipe(
460 Stream.runCollect,
461 Effect.forkChild,
462 );
463 yield* Effect.yieldNow;
464
465 yield* Deferred.succeed(releaseCheck, undefined);
466
467 yield* Deferred.succeed(releaseEnrichment, undefined);
468
469 const updates = Array.from(yield* Fiber.join(updatesFiber));
470 const latest = yield* provider.getSnapshot;
471
472 assert.deepStrictEqual(updates, [refreshedSnapshot, enrichedSnapshot]);
473 assert.deepStrictEqual(latest, enrichedSnapshot);
474 }),
475 ).pipe(Effect.provide(layerAlwaysRunTest)),
476 );
477
478 it.effect("ignores stale enrichment callbacks after a newer refresh advances generation", () =>
479 Effect.scoped(
480 Effect.gen(function* () {
481 const publishCallbacks: Array<(snapshot: ServerProvider) => Effect.Effect<void>> = [];
482 const refreshCount = yield* Ref.make(0);
483 const firstCallbackReady = yield* Deferred.make<void>();
484 const secondCallbackReady = yield* Deferred.make<void>();
485 const allowFirstRefresh = yield* Deferred.make<void>();
486 const provider = yield* makeManagedServerProvider<TestSettings>({
487 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
488 getSettings: Effect.succeed({ enabled: true }),
489 streamSettings: Stream.empty,
490 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
491 initialSnapshot: () => Effect.succeed(initialSnapshot),
492 checkProvider: Ref.updateAndGet(refreshCount, (count) => count + 1).pipe(
493 Effect.flatMap((count) =>
494 count === 1
495 ? Deferred.await(allowFirstRefresh).pipe(Effect.as(refreshedSnapshot))
496 : Effect.succeed(refreshedSnapshotSecond),
497 ),
498 ),
499 enrichSnapshot: ({ publishSnapshot }) =>
500 Effect.gen(function* () {
501 publishCallbacks.push(publishSnapshot);
502 if (publishCallbacks.length === 1) {
503 yield* Deferred.succeed(firstCallbackReady, undefined).pipe(Effect.ignore);
504 } else if (publishCallbacks.length === 2) {
505 yield* Deferred.succeed(secondCallbackReady, undefined).pipe(Effect.ignore);
506 }
507 }),
508 refreshInterval: "1 hour",
509 });
510
511 const updatesFiber = yield* Stream.take(provider.streamChanges, 3).pipe(
512 Stream.runCollect,
513 Effect.forkChild,
514 );
515 yield* Effect.yieldNow;
516
517 yield* Deferred.succeed(allowFirstRefresh, undefined);
518 yield* Deferred.await(firstCallbackReady);
519
520 yield* provider.refresh;
521 yield* Deferred.await(secondCallbackReady);
522
523 yield* publishCallbacks[0]!(enrichedSnapshot);
524 yield* publishCallbacks[1]!(enrichedSnapshotSecond);
525
526 const updates = Array.from(yield* Fiber.join(updatesFiber));
527 const latest = yield* provider.getSnapshot;
528
529 assert.deepStrictEqual(updates, [
530 refreshedSnapshot,
531 refreshedSnapshotSecond,
532 enrichedSnapshotSecond,
533 ]);
534 assert.deepStrictEqual(latest, enrichedSnapshotSecond);
535 }),
536 ).pipe(Effect.provide(layerAlwaysRunTest)),
537 );
538
539 it.effect("applies runtime usage updates onto the published snapshot", () =>
540 Effect.scoped(
541 Effect.gen(function* () {
542 const provider = yield* makeManagedServerProvider<TestSettings>({
543 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
544 getSettings: Effect.succeed({ enabled: true }),
545 streamSettings: Stream.empty,
546 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
547 initialSnapshot: () => Effect.succeed(initialSnapshot),
548 checkProvider: Effect.succeed({
549 ...refreshedSnapshot,
550 usageLimits: {
551 checkedAt: "2026-04-10T00:00:01.000Z",
552 windows: [
553 { id: "five_hour", kind: "session", label: "Session", usedPercent: 10 },
554 {
555 id: "seven_day",
556 kind: "weekly",
557 label: "Weekly",
558 usedPercent: 20,
559 resetsAt: "2026-04-17T00:00:00.000Z",
560 },
561 ],
562 },
563 } satisfies ServerProvider),
564 refreshInterval: "1 hour",
565 });
566 yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain);
567
568 const updatesFiber = yield* Stream.take(provider.streamChanges, 1).pipe(
569 Stream.runCollect,
570 Effect.forkChild,
571 );
572 yield* Effect.yieldNow;
573
574 // Percent-only weekly update: keeps the probe's reset time.
575 yield* provider.applyUsageLimits({
576 checkedAt: "2026-04-10T00:05:00.000Z",
577 windows: [{ id: "seven_day", kind: "weekly", label: "Weekly", usedPercent: 25 }],
578 });
579 // No windows: nothing to merge, nothing published.
580 yield* provider.applyUsageLimits({ checkedAt: "2026-04-10T00:06:00.000Z", windows: [] });
581
582 const [update] = Array.from(yield* Fiber.join(updatesFiber));
583 assert.deepStrictEqual(update?.usageLimits, {
584 checkedAt: "2026-04-10T00:05:00.000Z",
585 windows: [
586 { id: "five_hour", kind: "session", label: "Session", usedPercent: 10 },
587 {
588 id: "seven_day",
589 kind: "weekly",
590 label: "Weekly",
591 usedPercent: 25,
592 resetsAt: "2026-04-17T00:00:00.000Z",
593 },
594 ],
595 });
596 assert.deepStrictEqual(yield* provider.getSnapshot, update);
597 }),
598 ).pipe(Effect.provide(layerAlwaysRunTest)),
599 );
600
601 it.effect("keeps live usage windows across a failed probe and a stale enrichment", () =>
602 Effect.scoped(
603 Effect.gen(function* () {
604 const releaseEnrichment = yield* Deferred.make<void>();
605 const refreshCount = yield* Ref.make(0);
606 const probedLimits = {
607 checkedAt: "2026-04-10T00:00:01.000Z",
608 windows: [{ id: "primary", kind: "session", label: "Session", usedPercent: 10 }],
609 } as const;
610 const provider = yield* makeManagedServerProvider<TestSettings>({
611 resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
612 getSettings: Effect.succeed({ enabled: true }),
613 streamSettings: Stream.empty,
614 haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
615 initialSnapshot: () => Effect.succeed(initialSnapshot),
616 checkProvider: Ref.updateAndGet(refreshCount, (count) => count + 1).pipe(
617 Effect.map((count) =>
618 count === 1
619 ? {
620 ...refreshedSnapshot,
621 auth: { ...refreshedSnapshot.auth, workspaceId: "ws-a" },
622 usageLimits: probedLimits,
623 }
624 : {
625 ...refreshedSnapshotSecond,
626 ...(count === 3
627 ? { auth: { ...refreshedSnapshotSecond.auth, workspaceId: "ws-b" } }
628 : {}),
629 usageLimits: {
630 checkedAt: "2026-04-10T00:00:03.000Z",
631 windows: [],
632 unavailable: { reason: "probeFailed" },
633 },
634 },
635 ),
636 ),
637 enrichSnapshot: ({ snapshot, publishSnapshot }) =>
638 Deferred.await(releaseEnrichment).pipe(
639 Effect.flatMap(() =>
640 publishSnapshot({
641 ...enrichedSnapshot,
642 ...snapshot,
643 models: enrichedSnapshot.models,
644 }),
645 ),
646 ),
647 refreshInterval: "1 hour",
648 });
649 yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain);
650
651 const liveWindow = {
652 id: "primary",
653 kind: "session",
654 label: "Session",
655 usedPercent: 60,
656 } as const;
657 yield* provider.applyUsageLimits({
658 checkedAt: "2026-04-10T00:00:02.000Z",
659 windows: [liveWindow],
660 });
661
662 // Enrichment computed from the pre-update snapshot lands afterwards.
663 yield* Deferred.succeed(releaseEnrichment, undefined);
664 const enriched = yield* Stream.take(provider.streamChanges, 1).pipe(
665 Stream.runCollect,
666 Effect.map((chunk) => Array.from(chunk)[0]!),
667 );
668 assert.deepStrictEqual(enriched.models, enrichedSnapshot.models);
669 assert.deepStrictEqual(enriched.usageLimits?.windows, [liveWindow]);
670
671 // A probe that could not read usage keeps the last good windows.
672 const refreshed = yield* provider.refresh;
673 assert.strictEqual(refreshed.message, refreshedSnapshotSecond.message);
674 assert.deepStrictEqual(refreshed.usageLimits?.windows, [liveWindow]);
675 // ...and the workspace they were read for.
676 assert.strictEqual(refreshed.auth.workspaceId, "ws-a");
677
678 // A failed read for another workspace does not inherit those windows.
679 const switched = yield* provider.refresh;
680 assert.strictEqual(switched.auth.workspaceId, "ws-b");
681 assert.strictEqual(switched.usageLimits?.unavailable?.reason, "probeFailed");
682 }),
683 ).pipe(Effect.provide(layerAlwaysRunTest)),
684 );
685});