Skip to content

Commit ade8819

Browse files
committed
fix(server): stale provider update results clear once the provider is up to date
A finished update that reported "unchanged" or "failed" stayed attached to the provider until the server restarted, even after the install was fixed and a refresh showed the provider current. A refreshed snapshot that reports the provider current now retires those results; queued, running and succeeded results, and any provider still behind or not yet checked, are left alone.
1 parent d14ace8 commit ade8819

2 files changed

Lines changed: 171 additions & 0 deletions

File tree

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

Lines changed: 149 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,8 @@ import {
3030
ServerSettingsError,
3131
ServerProvider,
3232
type ServerProviderSlashCommand,
33+
type ServerProviderUpdateState,
34+
type ServerProviderVersionAdvisoryStatus,
3335
type ServerSettings as ContractServerSettings,
3436
} from "@t3tools/contracts";
3537
import { HttpClient, HttpClientResponse } from "effect/http";
@@ -305,6 +307,85 @@ const awaitPersistedProvider = (
305307
Effect.forkScoped,
306308
);
307309

310+
const codexUpdateSnapshot = (advisory: ServerProviderVersionAdvisoryStatus) =>
311+
({
312+
instanceId: ProviderInstanceId.make("codex"),
313+
driver: ProviderDriverKind.make("codex"),
314+
status: "ready",
315+
enabled: true,
316+
installed: true,
317+
auth: { status: "authenticated" },
318+
checkedAt: "2026-06-10T00:00:00.000Z",
319+
version: "1.0.0",
320+
models: [],
321+
slashCommands: [],
322+
skills: [],
323+
versionAdvisory: {
324+
status: advisory,
325+
currentVersion: "1.0.0",
326+
latestVersion: advisory === "unknown" ? null : "2.0.0",
327+
updateCommand: null,
328+
canUpdate: true,
329+
checkedAt: "2026-06-10T00:00:00.000Z",
330+
message: null,
331+
},
332+
}) as const satisfies ServerProvider;
333+
334+
const makeUpdateState = (status: ServerProviderUpdateState["status"]) =>
335+
({
336+
status,
337+
startedAt: "2026-06-10T00:00:00.000Z",
338+
finishedAt: status === "queued" || status === "running" ? null : "2026-06-10T00:01:00.000Z",
339+
message: `update ${status}`,
340+
output: null,
341+
}) satisfies ServerProviderUpdateState;
342+
343+
// One Codex instance whose probe returns whatever `snapshot` currently holds.
344+
const buildRegistryOverSnapshot = Effect.fn("buildRegistryOverSnapshot")(function* (
345+
snapshot: Ref.Ref<ServerProvider>,
346+
) {
347+
const driver = ProviderDriverKind.make("codex");
348+
const instance = {
349+
instanceId: ProviderInstanceId.make("codex"),
350+
driverKind: driver,
351+
continuationIdentity: { driverKind: driver, continuationKey: "codex:instance:codex" },
352+
displayName: undefined,
353+
enabled: true,
354+
snapshot: {
355+
resolveMaintenance: () =>
356+
Effect.succeed(
357+
makeManualOnlyProviderMaintenanceCapabilities({ provider: driver, packageName: null }),
358+
),
359+
getSnapshot: Ref.get(snapshot),
360+
refresh: Ref.get(snapshot),
361+
streamChanges: Stream.empty,
362+
applyUsageLimits: () => Effect.void,
363+
},
364+
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
365+
textGeneration: {} as ProviderInstance["textGeneration"],
366+
} satisfies ProviderInstance;
367+
const layerInstanceRegistry = Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, {
368+
getInstance: (instanceId) =>
369+
Effect.succeed(instanceId === instance.instanceId ? instance : undefined),
370+
listInstances: Effect.succeed([instance]),
371+
listUnavailable: Effect.succeed([]),
372+
streamChanges: Stream.empty,
373+
subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), PubSub.subscribe),
374+
});
375+
const scope = yield* Scope.make();
376+
yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));
377+
return yield* Layer.build(
378+
ProviderRegistry.layer.pipe(
379+
Layer.provideMerge(layerInstanceRegistry),
380+
Layer.provideMerge(
381+
ServerConfig.layerTest(process.cwd(), { prefix: "t3-provider-registry-update-state-" }),
382+
),
383+
Layer.provideMerge(layerBackgroundPolicyAlwaysRun),
384+
Layer.provideMerge(NodeServices.layer),
385+
),
386+
).pipe(Scope.provide(scope));
387+
});
388+
308389
const layerTestNodeServices = Layer.mergeAll(
309390
ProviderLatestVersions.layer,
310391
NodeServices.layer,
@@ -1808,6 +1889,74 @@ it.layer(
18081889
}),
18091890
);
18101891

1892+
describe("update results across refreshes", () => {
1893+
const instanceId = ProviderInstanceId.make("codex");
1894+
1895+
it.effect.each([
1896+
{ status: "unchanged", advisory: "current", retired: true },
1897+
{ status: "failed", advisory: "current", retired: true },
1898+
{ status: "unchanged", advisory: "behind_latest", retired: false },
1899+
{ status: "failed", advisory: "behind_latest", retired: false },
1900+
// The probe publishes `unknown` until the latest-version check lands.
1901+
{ status: "unchanged", advisory: "unknown", retired: false },
1902+
{ status: "queued", advisory: "current", retired: false },
1903+
{ status: "running", advisory: "current", retired: false },
1904+
] as const)(
1905+
"a $status update result is retired: $retired when a refresh reports the provider $advisory",
1906+
({ status, advisory, retired }) =>
1907+
Effect.gen(function* () {
1908+
const snapshot = yield* Ref.make<ServerProvider>(codexUpdateSnapshot("behind_latest"));
1909+
const runtimeServices = yield* buildRegistryOverSnapshot(snapshot);
1910+
1911+
yield* Effect.gen(function* () {
1912+
const registry = yield* ProviderRegistry.ProviderRegistry;
1913+
const state = makeUpdateState(status);
1914+
yield* registry.setProviderMaintenanceActionState({
1915+
instanceId,
1916+
action: "update",
1917+
state,
1918+
});
1919+
yield* Ref.set(snapshot, codexUpdateSnapshot(advisory));
1920+
1921+
const [refreshed] = yield* registry.refresh(ProviderDriverKind.make("codex"));
1922+
1923+
expect(refreshed?.updateState).toEqual(retired ? undefined : state);
1924+
}).pipe(Effect.provide(runtimeServices));
1925+
}),
1926+
);
1927+
1928+
it.effect("does not bring a retired result back, and a later update still reports", () =>
1929+
Effect.gen(function* () {
1930+
const snapshot = yield* Ref.make<ServerProvider>(codexUpdateSnapshot("behind_latest"));
1931+
const runtimeServices = yield* buildRegistryOverSnapshot(snapshot);
1932+
1933+
yield* Effect.gen(function* () {
1934+
const registry = yield* ProviderRegistry.ProviderRegistry;
1935+
const codex = ProviderDriverKind.make("codex");
1936+
yield* registry.setProviderMaintenanceActionState({
1937+
instanceId,
1938+
action: "update",
1939+
state: makeUpdateState("unchanged"),
1940+
});
1941+
yield* Ref.set(snapshot, codexUpdateSnapshot("current"));
1942+
yield* registry.refresh(codex);
1943+
1944+
yield* Ref.set(snapshot, codexUpdateSnapshot("unknown"));
1945+
const [reprobed] = yield* registry.refresh(codex);
1946+
expect(reprobed?.updateState).toBeUndefined();
1947+
1948+
const running = makeUpdateState("running");
1949+
const [updating] = yield* registry.setProviderMaintenanceActionState({
1950+
instanceId,
1951+
action: "update",
1952+
state: running,
1953+
});
1954+
expect(updating?.updateState).toEqual(running);
1955+
}).pipe(Effect.provide(runtimeServices));
1956+
}),
1957+
);
1958+
});
1959+
18111960
it.effect("re-probes when settings change the codex binaryPath", () =>
18121961
Effect.gen(function* () {
18131962
const firstMissing = `t3code_codex_first_`;

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

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -470,6 +470,27 @@ export const layer = Layer.effect(
470470
};
471471
});
472472

473+
// Runs on source snapshots only. `setProviderMaintenanceActionState` re-applies the stored
474+
// snapshot, whose advisory may already read `current`, and must not discard the result the
475+
// runner is recording. A probe publishes `unknown` until the latest-version check lands, so
476+
// only `current` shows the provider is up to date.
477+
const retireStaleUpdateState = Effect.fn("retireStaleUpdateState")(function* (
478+
provider: ServerProvider,
479+
) {
480+
if (provider.versionAdvisory?.status !== "current") {
481+
return;
482+
}
483+
yield* Ref.update(maintenanceActionStatesRef, (previous) => {
484+
const status = previous.get(provider.instanceId)?.update?.status;
485+
if (status !== "unchanged" && status !== "failed") {
486+
return previous;
487+
}
488+
const next = new Map(previous);
489+
next.delete(provider.instanceId);
490+
return next;
491+
});
492+
});
493+
473494
const upsertProviders = Effect.fn("upsertProviders")(function* (
474495
nextProviders: ReadonlyArray<ServerProvider>,
475496
options?: {
@@ -539,6 +560,7 @@ export const layer = Layer.effect(
539560
readonly publish?: boolean;
540561
},
541562
) {
563+
yield* retireStaleUpdateState(provider);
542564
const providers = yield* upsertProviders([provider], options);
543565
// Reclassify the current read model after fetching. Never republish the
544566
// probe captured before the fetch: a newer health result may have landed.

0 commit comments

Comments
 (0)