@devries-cameron20 / t3code Mirror · read-only / commits / d0f5ae6067
Fork 0

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, 05:45 UTC

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

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Nov 2, 2026 at 17:59 UTC d0f5ae6067bec1a033edd6886c8cd5ef0e98e218
2 files changed +141 -4
apps/server/src/provider/ProviderRegistry.test.ts
+139 -4
@@ -1068,6 +1068,7 @@ it.layer(
1068 });
1069 yield* writeProviderStatusCache({ filePath, provider: cachedProvider });
1070 const nextProvider = yield* Ref.make<ServerProvider>(refreshedProvider);
1071 + const currentProvider = yield* Ref.make<ServerProvider>(pendingProvider);
1072 const instance = {
1073 instanceId: cachedProvider.instanceId,
1074 driverKind: cachedProvider.driver,
@@ -1085,8 +1086,10 @@ it.layer(
1086 packageName: null,
1087 }),
1088 ),
1088 - getSnapshot: Effect.succeed(pendingProvider),
1089 - refresh: Ref.get(nextProvider),
1089 + getSnapshot: Ref.get(currentProvider),
1090 + refresh: Ref.get(nextProvider).pipe(
1091 + Effect.tap((provider) => Ref.set(currentProvider, provider)),
1092 + ),
1093 streamChanges: Stream.empty,
1094 applyUsageLimits: () => Effect.void,
1095 },
@@ -1107,6 +1110,7 @@ it.layer(
1110 const retainedModels = [defaultModel, customModel, currentModel];
1111
1112 for (const restarted of [false, true]) {
1113 + yield* Ref.set(currentProvider, pendingProvider);
1114 yield* Effect.gen(function* () {
1115 const registry = yield* ProviderRegistry.ProviderRegistry;
1116 assert.deepStrictEqual(
@@ -1203,6 +1207,7 @@ it.layer(
1207 });
1208 yield* writeProviderStatusCache({ filePath, provider: cachedProvider });
1209 const nextProvider = yield* Ref.make<ServerProvider>(refreshedProvider);
1210 + const currentProvider = yield* Ref.make<ServerProvider>(pendingProvider);
1211 const instance = {
1212 instanceId: cachedProvider.instanceId,
1213 driverKind: cachedProvider.driver,
@@ -1220,8 +1225,10 @@ it.layer(
1225 packageName: null,
1226 }),
1227 ),
1223 - getSnapshot: Effect.succeed(pendingProvider),
1224 - refresh: Ref.get(nextProvider),
1228 + getSnapshot: Ref.get(currentProvider),
1229 + refresh: Ref.get(nextProvider).pipe(
1230 + Effect.tap((provider) => Ref.set(currentProvider, provider)),
1231 + ),
1232 streamChanges: Stream.empty,
1233 applyUsageLimits: () => Effect.void,
1234 },
@@ -1245,6 +1252,7 @@ it.layer(
1252 ];
1253
1254 for (const restarted of [false, true]) {
1255 + yield* Ref.set(currentProvider, pendingProvider);
1256 yield* Effect.gen(function* () {
1257 const registry = yield* ProviderRegistry.ProviderRegistry;
1258 const expectedModels = restarted
@@ -1926,6 +1934,133 @@ it.layer(
1934 }),
1935 );
1936
1937 + it.effect("keeps an enriched snapshot that streams in before a manual refresh returns", () =>
1938 + Effect.gen(function* () {
1939 + const driver = ProviderDriverKind.make("acpRegistry");
1940 + const instanceId = ProviderInstanceId.make("gemini");
1941 + const initialProvider = {
1942 + instanceId,
1943 + driver,
1944 + status: "ready",
1945 + enabled: true,
1946 + installed: true,
1947 + auth: { status: "authenticated" },
1948 + checkedAt: "2026-06-10T00:00:00.000Z",
1949 + version: "1.0.0",
1950 + models: [],
1951 + slashCommands: [],
1952 + skills: [],
1953 + } as const satisfies ServerProvider;
1954 + const pendingProvider = {
1955 + ...initialProvider,
1956 + status: "warning",
1957 + auth: { status: "unknown" },
1958 + checkedAt: "2026-06-10T00:01:00.000Z",
1959 + message: "Checking ACP authentication, models, and commands in the background...",
1960 + } as const satisfies ServerProvider;
1961 + const enrichedProvider = {
1962 + ...initialProvider,
1963 + status: "error",
1964 + auth: { status: "unauthenticated" },
1965 + checkedAt: "2026-06-10T00:01:01.000Z",
1966 + message: "Sign in to Gemini to use this agent.",
1967 + } as const satisfies ServerProvider;
1968 + const snapshotRef = yield* Ref.make<ServerProvider>(initialProvider);
1969 + const changes = yield* PubSub.unbounded<ServerProvider>();
1970 + const publishSnapshot = (provider: ServerProvider) =>
1971 + Ref.set(snapshotRef, provider).pipe(Effect.andThen(PubSub.publish(changes, provider)));
1972 + const releaseRefresh = yield* Deferred.make<void>();
1973 + const instance = {
1974 + instanceId,
1975 + driverKind: driver,
1976 + continuationIdentity: { driverKind: driver, continuationKey: "acpRegistry:gemini" },
1977 + displayName: undefined,
1978 + enabled: true,
1979 + snapshot: {
1980 + resolveMaintenance: () =>
1981 + Effect.succeed(
1982 + makeManualOnlyProviderMaintenanceCapabilities({
1983 + provider: driver,
1984 + packageName: null,
1985 + }),
1986 + ),
1987 + getSnapshot: Ref.get(snapshotRef),
1988 + // Like a managed provider: publish the probe, let enrichment publish its result,
1989 + // then return the probe after a slow tail such as ACP's refreshMethods.
1990 + refresh: Effect.gen(function* () {
1991 + yield* publishSnapshot(pendingProvider);
1992 + yield* publishSnapshot(enrichedProvider);
1993 + yield* Deferred.await(releaseRefresh);
1994 + return pendingProvider;
1995 + }),
1996 + streamChanges: Stream.fromPubSub(changes),
1997 + applyUsageLimits: () => Effect.void,
1998 + },
1999 + orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
2000 + textGeneration: {} as ProviderInstance["textGeneration"],
2001 + } satisfies ProviderInstance;
2002 + const instanceRegistryLayer = Layer.succeed(
2003 + ProviderInstanceRegistry.ProviderInstanceRegistry,
2004 + {
2005 + getInstance: (requestedId) =>
2006 + Effect.succeed(requestedId === instanceId ? instance : undefined),
2007 + listInstances: Effect.succeed([instance]),
2008 + listUnavailable: Effect.succeed([]),
2009 + streamChanges: Stream.empty,
2010 + subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), PubSub.subscribe),
2011 + },
2012 + );
2013 + const scope = yield* Scope.make();
2014 + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));
2015 + const runtimeServices = yield* Layer.build(
2016 + ProviderRegistry.layer.pipe(
2017 + Layer.provide(layerUnusedMutator),
2018 + Layer.provideMerge(instanceRegistryLayer),
2019 + Layer.provideMerge(
2020 + ServerConfig.layerTest(process.cwd(), {
2021 + prefix: "t3-provider-registry-enriched-refresh-",
2022 + }),
2023 + ),
2024 + Layer.provideMerge(NodeServices.layer),
2025 + ),
2026 + ).pipe(Scope.provide(scope));
2027 +
2028 + yield* Effect.gen(function* () {
2029 + const registry = yield* ProviderRegistry.ProviderRegistry;
2030 + const config = yield* ServerConfig.ServerConfig;
2031 + const filePath = yield* resolveProviderStatusCachePath({
2032 + cacheDir: config.providerStatusCacheDir,
2033 + instanceId,
2034 + });
2035 + expect(yield* registry.getProviders).toEqual([expect.objectContaining(initialProvider)]);
2036 +
2037 + const enrichedObserved = yield* awaitPersistedProvider(
2038 + registry,
2039 + enrichedProvider.checkedAt,
2040 + );
2041 + const refreshed = yield* registry.refreshInstance(instanceId).pipe(Effect.forkChild);
2042 + yield* Fiber.join(enrichedObserved);
2043 + yield* Deferred.succeed(releaseRefresh, undefined);
2044 + const returned = yield* Fiber.join(refreshed);
2045 +
2046 + const enriched = {
2047 + status: enrichedProvider.status,
2048 + auth: enrichedProvider.auth,
2049 + message: enrichedProvider.message,
2050 + checkedAt: enrichedProvider.checkedAt,
2051 + };
2052 + expect(
2053 + yield* registry.getProviders,
2054 + "getProviders should hold the enriched snapshot, not the stale pending one refresh returned",
2055 + ).toEqual([expect.objectContaining(enriched)]);
2056 + expect(returned).toEqual([expect.objectContaining(enriched)]);
2057 + expect(yield* readProviderStatusCache(filePath)).toEqual(
2058 + expect.objectContaining(enriched),
2059 + );
2060 + }).pipe(Effect.provide(runtimeServices));
2061 + }),
2062 + );
2063 +
2064 it.effect("persists the merged snapshot when a live update has empty models", () =>
2065 Effect.gen(function* () {
2066 const cursorDriver = ProviderDriverKind.make("cursor");
apps/server/src/provider/ProviderRegistry.ts
+2
@@ -604,7 +604,9 @@ export const layer = Layer.effect(
604 const refreshOneSource = Effect.fn("refreshOneSource")(function* (
605 providerSource: ProviderSnapshotSource,
606 ) {
607 + // Enrichment can publish a newer snapshot before refresh returns its pre-enrichment probe.
608 return yield* providerSource.refresh.pipe(
609 + Effect.andThen(providerSource.getSnapshot),
610 Effect.flatMap((nextProvider) =>
611 correlateSnapshotWithSource(providerSource, nextProvider).pipe(
612 Effect.flatMap(syncProvider),