Skip to content
TypeScript

fix(server): provider refresh no longer reverts an enriched sign-in status (#29627)

Julius Marminged0f5ae6067be
diff --git a/apps/server/src/provider/ProviderRegistry.test.ts b/apps/server/src/provider/ProviderRegistry.test.ts
index 674da66b5b3..93fec081ebb 100644
--- a/apps/server/src/provider/ProviderRegistry.test.ts
+++ b/apps/server/src/provider/ProviderRegistry.test.ts
@@ -1068,6 +1068,7 @@ it.layer(
});
yield* writeProviderStatusCache({ filePath, provider: cachedProvider });
const nextProvider = yield* Ref.make<ServerProvider>(refreshedProvider);
+ const currentProvider = yield* Ref.make<ServerProvider>(pendingProvider);
const instance = {
instanceId: cachedProvider.instanceId,
driverKind: cachedProvider.driver,
@@ -1085,8 +1086,10 @@ it.layer(
packageName: null,
}),
),
- getSnapshot: Effect.succeed(pendingProvider),
- refresh: Ref.get(nextProvider),
+ getSnapshot: Ref.get(currentProvider),
+ refresh: Ref.get(nextProvider).pipe(
+ Effect.tap((provider) => Ref.set(currentProvider, provider)),
+ ),
streamChanges: Stream.empty,
applyUsageLimits: () => Effect.void,
},
@@ -1107,6 +1110,7 @@ it.layer(
const retainedModels = [defaultModel, customModel, currentModel];
for (const restarted of [false, true]) {
+ yield* Ref.set(currentProvider, pendingProvider);
yield* Effect.gen(function* () {
const registry = yield* ProviderRegistry.ProviderRegistry;
assert.deepStrictEqual(
@@ -1203,6 +1207,7 @@ it.layer(
});
yield* writeProviderStatusCache({ filePath, provider: cachedProvider });
const nextProvider = yield* Ref.make<ServerProvider>(refreshedProvider);
+ const currentProvider = yield* Ref.make<ServerProvider>(pendingProvider);
const instance = {
instanceId: cachedProvider.instanceId,
driverKind: cachedProvider.driver,
@@ -1220,8 +1225,10 @@ it.layer(
packageName: null,
}),
),
- getSnapshot: Effect.succeed(pendingProvider),
- refresh: Ref.get(nextProvider),
+ getSnapshot: Ref.get(currentProvider),
+ refresh: Ref.get(nextProvider).pipe(
+ Effect.tap((provider) => Ref.set(currentProvider, provider)),
+ ),
streamChanges: Stream.empty,
applyUsageLimits: () => Effect.void,
},
@@ -1245,6 +1252,7 @@ it.layer(
];
for (const restarted of [false, true]) {
+ yield* Ref.set(currentProvider, pendingProvider);
yield* Effect.gen(function* () {
const registry = yield* ProviderRegistry.ProviderRegistry;
const expectedModels = restarted
@@ -1926,6 +1934,133 @@ it.layer(
}),
);
+ it.effect("keeps an enriched snapshot that streams in before a manual refresh returns", () =>
+ Effect.gen(function* () {
+ const driver = ProviderDriverKind.make("acpRegistry");
+ const instanceId = ProviderInstanceId.make("gemini");
+ const initialProvider = {
+ instanceId,
+ driver,
+ status: "ready",
+ enabled: true,
+ installed: true,
+ auth: { status: "authenticated" },
+ checkedAt: "2026-06-10T00:00:00.000Z",
+ version: "1.0.0",
+ models: [],
+ slashCommands: [],
+ skills: [],
+ } as const satisfies ServerProvider;
+ const pendingProvider = {
+ ...initialProvider,
+ status: "warning",
+ auth: { status: "unknown" },
+ checkedAt: "2026-06-10T00:01:00.000Z",
+ message: "Checking ACP authentication, models, and commands in the background...",
+ } as const satisfies ServerProvider;
+ const enrichedProvider = {
+ ...initialProvider,
+ status: "error",
+ auth: { status: "unauthenticated" },
+ checkedAt: "2026-06-10T00:01:01.000Z",
+ message: "Sign in to Gemini to use this agent.",
+ } as const satisfies ServerProvider;
+ const snapshotRef = yield* Ref.make<ServerProvider>(initialProvider);
+ const changes = yield* PubSub.unbounded<ServerProvider>();
+ const publishSnapshot = (provider: ServerProvider) =>
+ Ref.set(snapshotRef, provider).pipe(Effect.andThen(PubSub.publish(changes, provider)));
+ const releaseRefresh = yield* Deferred.make<void>();
+ const instance = {
+ instanceId,
+ driverKind: driver,
+ continuationIdentity: { driverKind: driver, continuationKey: "acpRegistry:gemini" },
+ displayName: undefined,
+ enabled: true,
+ snapshot: {
+ resolveMaintenance: () =>
+ Effect.succeed(
+ makeManualOnlyProviderMaintenanceCapabilities({
+ provider: driver,
+ packageName: null,
+ }),
+ ),
+ getSnapshot: Ref.get(snapshotRef),
+ // Like a managed provider: publish the probe, let enrichment publish its result,
+ // then return the probe after a slow tail such as ACP's refreshMethods.
+ refresh: Effect.gen(function* () {
+ yield* publishSnapshot(pendingProvider);
+ yield* publishSnapshot(enrichedProvider);
+ yield* Deferred.await(releaseRefresh);
+ return pendingProvider;
+ }),
+ streamChanges: Stream.fromPubSub(changes),
+ applyUsageLimits: () => Effect.void,
+ },
+ orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
+ textGeneration: {} as ProviderInstance["textGeneration"],
+ } satisfies ProviderInstance;
+ const instanceRegistryLayer = Layer.succeed(
+ ProviderInstanceRegistry.ProviderInstanceRegistry,
+ {
+ getInstance: (requestedId) =>
+ Effect.succeed(requestedId === instanceId ? instance : undefined),
+ listInstances: Effect.succeed([instance]),
+ listUnavailable: Effect.succeed([]),
+ streamChanges: Stream.empty,
+ subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), PubSub.subscribe),
+ },
+ );
+ const scope = yield* Scope.make();
+ yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));
+ const runtimeServices = yield* Layer.build(
+ ProviderRegistry.layer.pipe(
+ Layer.provide(layerUnusedMutator),
+ Layer.provideMerge(instanceRegistryLayer),
+ Layer.provideMerge(
+ ServerConfig.layerTest(process.cwd(), {
+ prefix: "t3-provider-registry-enriched-refresh-",
+ }),
+ ),
+ Layer.provideMerge(NodeServices.layer),
+ ),
+ ).pipe(Scope.provide(scope));
+
+ yield* Effect.gen(function* () {
+ const registry = yield* ProviderRegistry.ProviderRegistry;
+ const config = yield* ServerConfig.ServerConfig;
+ const filePath = yield* resolveProviderStatusCachePath({
+ cacheDir: config.providerStatusCacheDir,
+ instanceId,
+ });
+ expect(yield* registry.getProviders).toEqual([expect.objectContaining(initialProvider)]);
+
+ const enrichedObserved = yield* awaitPersistedProvider(
+ registry,
+ enrichedProvider.checkedAt,
+ );
+ const refreshed = yield* registry.refreshInstance(instanceId).pipe(Effect.forkChild);
+ yield* Fiber.join(enrichedObserved);
+ yield* Deferred.succeed(releaseRefresh, undefined);
+ const returned = yield* Fiber.join(refreshed);
+
+ const enriched = {
+ status: enrichedProvider.status,
+ auth: enrichedProvider.auth,
+ message: enrichedProvider.message,
+ checkedAt: enrichedProvider.checkedAt,
+ };
+ expect(
+ yield* registry.getProviders,
+ "getProviders should hold the enriched snapshot, not the stale pending one refresh returned",
+ ).toEqual([expect.objectContaining(enriched)]);
+ expect(returned).toEqual([expect.objectContaining(enriched)]);
+ expect(yield* readProviderStatusCache(filePath)).toEqual(
+ expect.objectContaining(enriched),
+ );
+ }).pipe(Effect.provide(runtimeServices));
+ }),
+ );
+
it.effect("persists the merged snapshot when a live update has empty models", () =>
Effect.gen(function* () {
const cursorDriver = ProviderDriverKind.make("cursor");
diff --git a/apps/server/src/provider/ProviderRegistry.ts b/apps/server/src/provider/ProviderRegistry.ts
index 28a0dcf6d19..76f2723cd9d 100644
--- a/apps/server/src/provider/ProviderRegistry.ts
+++ b/apps/server/src/provider/ProviderRegistry.ts
@@ -604,7 +604,9 @@ export const layer = Layer.effect(
const refreshOneSource = Effect.fn("refreshOneSource")(function* (
providerSource: ProviderSnapshotSource,
) {
+ // Enrichment can publish a newer snapshot before refresh returns its pre-enrichment probe.
return yield* providerSource.refresh.pipe(
+ Effect.andThen(providerSource.getSnapshot),
Effect.flatMap((nextProvider) =>
correlateSnapshotWithSource(providerSource, nextProvider).pipe(
Effect.flatMap(syncProvider),