From f2cac8de51ccaf8af2cc332b40a91e5d5a7b595d Mon Sep 17 00:00:00 2001 From: mths-mcfs <214165874+mths-mcfs@users.noreply.github.com> Date: Wed, 11 Nov 2026 12:06:44 -0300 Subject: [PATCH 01/11] fix(antigravity): usage limits no longer show another account's quota with the agy CLI The usage probe always read the profile's acp_token.json. Only the ACP executable writes that file. With the agy CLI as the binary path, a token left by an earlier ACP sign-in was still read, and Usage > Limits showed that account's quota. The probe now asks which runtime resolves and reports limits as unavailable for the CLI without reading the profile token. If the runtime stops resolving, the last known answer holds. Refs #34381 Co-Authored-By: Claude Fable 5.2 --- .../src/provider/Drivers/AntigravityDriver.ts | 4 ++ .../provider/antigravityUsageLimits.test.ts | 58 +++++++++++++++++++ .../src/provider/antigravityUsageLimits.ts | 23 +++++++- docs/user/providers-antigravity.md | 1 + 4 files changed, 85 insertions(+), 1 deletion(-) diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.ts b/apps/server/src/provider/Drivers/AntigravityDriver.ts index 7bb1f25b67ce..77370d393b1e 100644 --- a/apps/server/src/provider/Drivers/AntigravityDriver.ts +++ b/apps/server/src/provider/Drivers/AntigravityDriver.ts @@ -427,6 +427,10 @@ export const AntigravityDriver: ProviderDriver< const usage = yield* makeAntigravityUsageProbe({ profileDirectory, authMethod: auth.authMethod, + // Resolved per probe because the binary path's target can change. + credentialsInProfile: installation + .resolve(settings.binaryPath, processEnvironment) + .pipe(Effect.map((executable) => executable.harnessPath !== null)), }).pipe( Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path), diff --git a/apps/server/src/provider/antigravityUsageLimits.test.ts b/apps/server/src/provider/antigravityUsageLimits.test.ts index 9defd9df90dc..0d2be0689fe8 100644 --- a/apps/server/src/provider/antigravityUsageLimits.test.ts +++ b/apps/server/src/provider/antigravityUsageLimits.test.ts @@ -66,6 +66,8 @@ const fixture = Effect.fn("AntigravityUsageTest.fixture")(function* ( userInfoAt?: number; missingToken?: boolean; authMethod?: "oauth-personal" | "oauth-business" | "gemini-api-key"; + /** Read on every probe; defaults to the ACP executable, which stores its token in the profile. */ + credentialsInProfile?: Effect.Effect; } = {}, ) { const fs = yield* FileSystem.FileSystem; @@ -132,6 +134,7 @@ const fixture = Effect.fn("AntigravityUsageTest.fixture")(function* ( const usage = yield* makeAntigravityUsageProbe({ profileDirectory, authMethod: options.authMethod ?? "oauth-personal", + credentialsInProfile: options.credentialsInProfile ?? Effect.succeed(true), }).pipe(Effect.provideService(HttpClient.HttpClient, http)); return { ...usage, requests, writeToken, tokenPath }; }); @@ -663,4 +666,59 @@ describe("Antigravity subscription limits", () => { } }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); + + // Oracle: only the ACP executable writes the profile token; a leftover one is another account's. + it.effect("ignores a leftover profile token while the runtime is the agy CLI", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + // "unresolved" stands for a runtime that no longer resolves, such as a launcher mid-update. + let credentialsInProfile: boolean | "unresolved" = false; + let tokenPath: string | undefined; + const cliTokenAccesses: Array = []; + const watched = (operation: string, file: string) => { + if (file === tokenPath && credentialsInProfile !== true) cliTokenAccesses.push(operation); + }; + const { probe, requests, ...usage } = yield* fixture({ + credentialsInProfile: Effect.suspend(() => + credentialsInProfile === "unresolved" + ? Effect.fail("unresolved") + : Effect.succeed(credentialsInProfile), + ), + }).pipe( + Effect.provideService(FileSystem.FileSystem, { + ...fs, + exists: (file) => Effect.suspend(() => (watched("exists", file), fs.exists(file))), + readFileString: (file, encoding) => + Effect.suspend(() => (watched("read", file), fs.readFileString(file, encoding))), + }), + ); + tokenPath = usage.tokenPath; + const cli = { + windows: [], + unavailable: { + reason: "unsupported", + message: "Antigravity limits are unavailable when using the agy CLI.", + }, + }; + expect(yield* probe).toMatchObject(cli); + credentialsInProfile = "unresolved"; + expect(yield* probe).toMatchObject(cli); + expect(requests).toEqual([]); + + credentialsInProfile = true; + expect((yield* probe).credentialFingerprint).toMatch(/^[0-9a-f]{64}$/); + credentialsInProfile = false; + const limits = yield* probe; + expect(limits).toMatchObject(cli); + expect(limits.credentialFingerprint).toBeUndefined(); + credentialsInProfile = true; + yield* probe; + expect(requests.filter((request) => request.url.endsWith("/token"))).toHaveLength(2); + expect(cliTokenAccesses).toEqual([]); + + // A runtime that never resolved keeps the profile path, so a removed ACP runtime keeps its limits. + const neverResolved = yield* fixture({ credentialsInProfile: Effect.fail("unresolved") }); + expect((yield* neverResolved.probe).windows).toHaveLength(4); + }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), + ); }); diff --git a/apps/server/src/provider/antigravityUsageLimits.ts b/apps/server/src/provider/antigravityUsageLimits.ts index ede0e5c47d20..0f76f20708a8 100644 --- a/apps/server/src/provider/antigravityUsageLimits.ts +++ b/apps/server/src/provider/antigravityUsageLimits.ts @@ -207,9 +207,16 @@ function modelWindows(models: typeof Models.Type) { return [...windows.values()]; } -export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")(function* (input: { +export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")(function* < + E, +>(input: { readonly profileDirectory: string; readonly authMethod: AntigravitySettings["authMethod"]; + /** + * False for the `agy` CLI, which keeps its sign-in outside the profile. A failure keeps the + * last answer, so a runtime that stops resolving is still read as the kind it was. + */ + readonly credentialsInProfile: Effect.Effect; }) { const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; @@ -222,6 +229,8 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( | { fingerprint: string; account: string; accessToken: string; expiresAt: number } | undefined; let generation = 0; + // Outlives `clear`: signing out does not change which runtime is installed. + let credentialsInProfile = true; const request = (request: HttpClientRequest.HttpClientRequest) => client.execute(request).pipe( @@ -236,6 +245,18 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( if (input.authMethod !== "oauth-personal" && input.authMethod !== "oauth-business") { return makeUnavailableUsageLimits({ checkedAt, reason: "unsupported" }); } + credentialsInProfile = yield* input.credentialsInProfile.pipe( + Effect.orElseSucceed(() => credentialsInProfile), + ); + if (!credentialsInProfile) { + // A leftover ACP token here can belong to another account than the CLI's. + cached = undefined; + return makeUnavailableUsageLimits({ + checkedAt, + reason: "unsupported", + message: "Antigravity limits are unavailable when using the agy CLI.", + }); + } if (!(yield* fs.exists(tokenPath))) { cached = undefined; return makeUnavailableUsageLimits({ diff --git a/docs/user/providers-antigravity.md b/docs/user/providers-antigravity.md index c3177c29a12c..e867d40e8ea3 100644 --- a/docs/user/providers-antigravity.md +++ b/docs/user/providers-antigravity.md @@ -140,6 +140,7 @@ is refused while the runtime is in use. Open **Usage > Limits** to see the remaining Gemini and shared Claude/GPT allowances for Google sign-ins. Each group has separate five-hour and weekly limits and reset times. Limits refresh with provider status and include usage outside T3 Code. +Limits are not shown when the binary path is the `agy` CLI. A server restart keeps your Google sign-in. The provider shows the saved account until a session, a refresh, or a sign-out reports something new. From 5937e05af8fa2bc9d12fa9e6688fa384fde60c38 Mon Sep 17 00:00:00 2001 From: mths-mcfs <214165874+mths-mcfs@users.noreply.github.com> Date: Tue, 17 Nov 2026 15:17:25 -0300 Subject: [PATCH 02/11] fix(antigravity): hide limits while the runtime cannot be resolved The probe kept its last answer when the executable lookup failed, and started from "ACP" before any lookup succeeded, so it could still read a leftover profile token that belongs to another account. An unresolved runtime now reports limits as unavailable and drops the cached token. Co-Authored-By: Claude Opus 5.5 --- .../provider/antigravityUsageLimits.test.ts | 25 ++++++++++++++++--- .../src/provider/antigravityUsageLimits.ts | 21 ++++++++++------ docs/user/providers-antigravity.md | 3 ++- 3 files changed, 37 insertions(+), 12 deletions(-) diff --git a/apps/server/src/provider/antigravityUsageLimits.test.ts b/apps/server/src/provider/antigravityUsageLimits.test.ts index 0d2be0689fe8..d7377a1831a6 100644 --- a/apps/server/src/provider/antigravityUsageLimits.test.ts +++ b/apps/server/src/provider/antigravityUsageLimits.test.ts @@ -700,9 +700,16 @@ describe("Antigravity subscription limits", () => { message: "Antigravity limits are unavailable when using the agy CLI.", }, }; + const unresolved = { + windows: [], + unavailable: { + reason: "unsupported", + message: "Antigravity limits are unavailable while its runtime cannot be resolved.", + }, + }; expect(yield* probe).toMatchObject(cli); credentialsInProfile = "unresolved"; - expect(yield* probe).toMatchObject(cli); + expect(yield* probe).toMatchObject(unresolved); expect(requests).toEqual([]); credentialsInProfile = true; @@ -714,11 +721,23 @@ describe("Antigravity subscription limits", () => { credentialsInProfile = true; yield* probe; expect(requests.filter((request) => request.url.endsWith("/token"))).toHaveLength(2); + + // An ACP runtime that stops resolving may have been replaced by the CLI, so its limits go. + const requestsBeforeLoss = requests.length; + credentialsInProfile = "unresolved"; + const lost = yield* probe; + expect(lost).toMatchObject(unresolved); + expect(lost.credentialFingerprint).toBeUndefined(); + expect(requests).toHaveLength(requestsBeforeLoss); + credentialsInProfile = true; + expect((yield* probe).credentialFingerprint).toMatch(/^[0-9a-f]{64}$/); + expect(requests.filter((request) => request.url.endsWith("/token"))).toHaveLength(3); expect(cliTokenAccesses).toEqual([]); - // A runtime that never resolved keeps the profile path, so a removed ACP runtime keeps its limits. + // A runtime that never resolved could be either kind, so no profile token is trusted. const neverResolved = yield* fixture({ credentialsInProfile: Effect.fail("unresolved") }); - expect((yield* neverResolved.probe).windows).toHaveLength(4); + expect(yield* neverResolved.probe).toMatchObject(unresolved); + expect(neverResolved.requests).toEqual([]); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); }); diff --git a/apps/server/src/provider/antigravityUsageLimits.ts b/apps/server/src/provider/antigravityUsageLimits.ts index 0f76f20708a8..c2d6272855b3 100644 --- a/apps/server/src/provider/antigravityUsageLimits.ts +++ b/apps/server/src/provider/antigravityUsageLimits.ts @@ -213,8 +213,8 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( readonly profileDirectory: string; readonly authMethod: AntigravitySettings["authMethod"]; /** - * False for the `agy` CLI, which keeps its sign-in outside the profile. A failure keeps the - * last answer, so a runtime that stops resolving is still read as the kind it was. + * False for the `agy` CLI, which keeps its sign-in outside the profile. A failure means the + * runtime cannot be identified, so no limits are shown rather than trusting a profile token. */ readonly credentialsInProfile: Effect.Effect; }) { @@ -229,8 +229,6 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( | { fingerprint: string; account: string; accessToken: string; expiresAt: number } | undefined; let generation = 0; - // Outlives `clear`: signing out does not change which runtime is installed. - let credentialsInProfile = true; const request = (request: HttpClientRequest.HttpClientRequest) => client.execute(request).pipe( @@ -245,10 +243,17 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( if (input.authMethod !== "oauth-personal" && input.authMethod !== "oauth-business") { return makeUnavailableUsageLimits({ checkedAt, reason: "unsupported" }); } - credentialsInProfile = yield* input.credentialsInProfile.pipe( - Effect.orElseSucceed(() => credentialsInProfile), - ); - if (!credentialsInProfile) { + const credentialsInProfile = yield* Effect.option(input.credentialsInProfile); + if (Option.isNone(credentialsInProfile)) { + // The runtime may now be the CLI, so a profile token could belong to another account. + cached = undefined; + return makeUnavailableUsageLimits({ + checkedAt, + reason: "unsupported", + message: "Antigravity limits are unavailable while its runtime cannot be resolved.", + }); + } + if (!credentialsInProfile.value) { // A leftover ACP token here can belong to another account than the CLI's. cached = undefined; return makeUnavailableUsageLimits({ diff --git a/docs/user/providers-antigravity.md b/docs/user/providers-antigravity.md index 87d520de0c60..0b01f056a002 100644 --- a/docs/user/providers-antigravity.md +++ b/docs/user/providers-antigravity.md @@ -160,7 +160,8 @@ T3 does not support Antigravity goal status, pause, resume, or clear commands. Open **Usage > Limits** to see the remaining Gemini and shared Claude/GPT allowances for Google sign-ins. Each group has separate five-hour and weekly limits and reset times. Limits refresh with provider status and include usage outside T3 Code. -Limits are not shown when the binary path is the `agy` CLI. +Limits are not shown when the binary path is the `agy` CLI, or while T3 Code cannot +find the Antigravity runtime, such as during an update. A server restart keeps your Google sign-in. The provider shows the saved account until a session, a refresh, or a sign-out reports something new. From 5def194b4fb5998f99777f6caba63d246b1c002e Mon Sep 17 00:00:00 2001 From: mths-mcfs Date: Fri, 20 Nov 2026 17:04:34 -0300 Subject: [PATCH 03/11] fix(server): Antigravity limits no longer show old readings after a failed probe When the Antigravity quota read failed after a good one, Usage > Limits kept showing the old windows as current. The provider now publishes the failed read as it came, so clients show the failure notice. Other providers keep the last good read, through a new managed-provider option whose default is unchanged. Co-Authored-By: Claude Opus 5.5 --- .../src/provider/AntigravityProvider.test.ts | 106 +++++++++--------- .../src/provider/AntigravityProvider.ts | 8 +- .../src/server/managedProvider.ts | 13 ++- 3 files changed, 65 insertions(+), 62 deletions(-) diff --git a/apps/server/src/provider/AntigravityProvider.test.ts b/apps/server/src/provider/AntigravityProvider.test.ts index 522be29a8b18..ac0e48a96463 100644 --- a/apps/server/src/provider/AntigravityProvider.test.ts +++ b/apps/server/src/provider/AntigravityProvider.test.ts @@ -715,59 +715,59 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { }), ); - it.effect( - "publishes limits, retains a successful read on failure, and clears them on sign-out", - () => - Effect.gen(function* () { - const limits: ServerProviderUsageLimits = { - checkedAt: "2026-10-09T12:00:00.000Z", - windows: [ - { - id: "3p-weekly", - kind: "weekly", - label: "Claude & GPT (shared) · Weekly", - usedPercent: 75, - }, - ], - }; - const usage = yield* Ref.make(limits); - const harness = yield* makeHarness({ probeUsage: Ref.get(usage) }); - const published = yield* harness.nextPublish((snapshot) => !!snapshot.usageLimits); - yield* harness.initialize; - expect((yield* published)?.usageLimits).toEqual(limits); - // The second health check is the one the failed background read triggers. - const checks = yield* Ref.make(0); - const failedReadApplied = yield* Deferred.make(); - yield* Ref.set( - harness.probe, - Ref.updateAndGet(checks, (count) => count + 1).pipe( - Effect.tap((count) => - count === 2 ? Deferred.succeed(failedReadApplied, undefined) : Effect.void, - ), - Effect.as(initializeResult), - ), - ); - yield* Ref.set(usage, { - checkedAt: "2026-10-09T12:01:00.000Z", - windows: [], - unavailable: { reason: "probeFailed" }, - }); - yield* harness.provider.snapshot.refresh; - yield* Deferred.await(failedReadApplied); - expect((yield* harness.provider.snapshot.getSnapshot).usageLimits).toEqual(limits); - yield* harness.provider.onSignedOut; - expect((yield* harness.provider.snapshot.getSnapshot).usageLimits).toBeUndefined(); - yield* Ref.set(usage, { - checkedAt: "2026-10-09T12:02:00.000Z", - windows: [], - unavailable: { reason: "unsupported" }, - }); - const unsupported = yield* harness.nextPublish( - (snapshot) => snapshot.usageLimits?.unavailable?.reason === "unsupported", - ); - yield* harness.provider.snapshot.refresh; - expect((yield* unsupported)?.usageLimits?.windows).toEqual([]); - }), + it.effect("publishes limits, shows a failed read as failed, and clears them on sign-out", () => + Effect.gen(function* () { + const limits: ServerProviderUsageLimits = { + checkedAt: "2026-10-09T12:00:00.000Z", + windows: [ + { + id: "3p-weekly", + kind: "weekly", + label: "Claude & GPT (shared) · Weekly", + usedPercent: 75, + }, + ], + }; + const usage = yield* Ref.make(limits); + const harness = yield* makeHarness({ probeUsage: Ref.get(usage) }); + const published = yield* harness.nextPublish((snapshot) => !!snapshot.usageLimits); + yield* harness.initialize; + expect((yield* published)?.usageLimits).toEqual(limits); + const failedRead: ServerProviderUsageLimits = { + checkedAt: "2026-10-09T12:01:00.000Z", + windows: [], + unavailable: { reason: "probeFailed" }, + }; + // The second health check is the republish the failed background read triggers. + let checks = 0; + yield* Ref.set(harness.probe, Effect.sync(() => checks++).pipe(Effect.as(initializeResult))); + yield* Ref.set(usage, failedRead); + const failed = yield* harness.nextPublish(() => checks === 2); + yield* harness.provider.snapshot.refresh; + expect((yield* failed)?.usageLimits).toEqual(failedRead); + const recovered: ServerProviderUsageLimits = { + ...limits, + checkedAt: "2026-10-09T12:01:30.000Z", + }; + yield* Ref.set(usage, recovered); + const recoveredPublish = yield* harness.nextPublish( + (snapshot) => snapshot.usageLimits?.checkedAt === recovered.checkedAt, + ); + yield* harness.provider.snapshot.refresh; + expect((yield* recoveredPublish)?.usageLimits).toEqual(recovered); + yield* harness.provider.onSignedOut; + expect((yield* harness.provider.snapshot.getSnapshot).usageLimits).toBeUndefined(); + yield* Ref.set(usage, { + checkedAt: "2026-10-09T12:02:00.000Z", + windows: [], + unavailable: { reason: "unsupported" }, + }); + const unsupported = yield* harness.nextPublish( + (snapshot) => snapshot.usageLimits?.unavailable?.reason === "unsupported", + ); + yield* harness.provider.snapshot.refresh; + expect((yield* unsupported)?.usageLimits?.windows).toEqual([]); + }), ); it.effect("a quota read finishing after sign-out cannot restore account limits", () => diff --git a/apps/server/src/provider/AntigravityProvider.ts b/apps/server/src/provider/AntigravityProvider.ts index b3b68d46e8ba..a25f6a5d2fea 100644 --- a/apps/server/src/provider/AntigravityProvider.ts +++ b/apps/server/src/provider/AntigravityProvider.ts @@ -40,7 +40,6 @@ import { isCommandMissingCause, type ServerProviderDraft, } from "@t3tools/provider-core/server/snapshotProbe"; -import { resolveUsageLimitsAfterProbe } from "@t3tools/provider-core/server/usageLimits"; import { antigravityThinkingConfig } from "./acp/AntigravityAcpSupport.ts"; @@ -265,10 +264,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func ...state, draft: { ...state.draft, - usageLimits: resolveUsageLimitsAfterProbe({ - published: state.draft.usageLimits, - probed, - }), + usageLimits: probed, }, })), ), @@ -382,6 +378,8 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func haveSettingsChanged: () => false, initialSnapshot: () => getSnapshot, checkProvider: checkProvider(), + // A failed read is shown as failed; the CLI token expires, so old limits would mislead. + retainUsageLimitsOnProbeFailure: false, enrichSnapshot: ({ publishSnapshot }) => SubscriptionRef.changes(metadata).pipe( Stream.runForEach((state) => diff --git a/packages/provider-core/src/server/managedProvider.ts b/packages/provider-core/src/server/managedProvider.ts index 2762930b5e1e..a0bace848df5 100644 --- a/packages/provider-core/src/server/managedProvider.ts +++ b/packages/provider-core/src/server/managedProvider.ts @@ -73,6 +73,8 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( readonly refreshInterval?: Duration.Input; readonly refreshOnInterval?: boolean | ((snapshot: ServerProvider) => boolean); readonly checkProviderOnSettingsChange?: (previous: Settings, next: Settings) => boolean; + /** False publishes a failed usage probe as-is instead of keeping the last good read. */ + readonly retainUsageLimitsOnProbeFailure?: boolean; }): Effect.fn.Return< ManagedServerProvider, ServerSettingsError, @@ -221,10 +223,13 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( : probedSnapshot.usageLimits === undefined && state.snapshot.usageLimits !== usageBeforeProbe ? state.snapshot.usageLimits - : resolveUsageLimitsAfterProbe({ - published: state.snapshot.usageLimits, - probed: probedSnapshot.usageLimits, - }); + : input.retainUsageLimitsOnProbeFailure === false && + probedSnapshot.usageLimits?.unavailable?.reason === "probeFailed" + ? probedSnapshot.usageLimits + : resolveUsageLimitsAfterProbe({ + published: state.snapshot.usageLimits, + probed: probedSnapshot.usageLimits, + }); const workspaceId = usageLimits === probedSnapshot.usageLimits ? undefined : state.snapshot.auth.workspaceId; const usageAuthLabel = From 4da0a1521f198ef93680ebad42bd9ac806b87406 Mon Sep 17 00:00:00 2001 From: mths-mcfs Date: Fri, 20 Nov 2026 17:31:01 -0300 Subject: [PATCH 04/11] fix(server): Antigravity sign-out no longer republishes the previous account's limits Snapshot enrichment always put the last published usage limits back, so after sign-out the stream still carried the old account's windows, and a failed read briefly showed the old bars before the republish. The managed-provider option becomes retainUsageLimits; with false, enrichment publishes the limits the provider reports. Antigravity uses it; the default is unchanged. The Antigravity test now subscribes before each trigger and waits for the republish that follows each read, so it no longer depends on timing. Co-Authored-By: Claude Opus 5.5 --- .../src/provider/AntigravityProvider.test.ts | 41 ++++++++++++++----- .../src/provider/AntigravityProvider.ts | 9 ++-- .../src/server/managedProvider.ts | 11 +++-- 3 files changed, 42 insertions(+), 19 deletions(-) diff --git a/apps/server/src/provider/AntigravityProvider.test.ts b/apps/server/src/provider/AntigravityProvider.test.ts index ac0e48a96463..7e3f110cdbb2 100644 --- a/apps/server/src/provider/AntigravityProvider.test.ts +++ b/apps/server/src/provider/AntigravityProvider.test.ts @@ -13,6 +13,7 @@ import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as Fiber from "effect/Fiber"; import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; import * as Ref from "effect/Ref"; import * as Schema from "effect/Schema"; import * as Stream from "effect/Stream"; @@ -172,10 +173,14 @@ const makeHarness = Effect.fn("makeAntigravityProviderHarness")(function* ( Effect.andThen(initialUpdate), Effect.asVoid, ); - // Subscribe before the trigger; yield the returned pull to await the publish. + // Subscribes now, before the trigger runs; yield the returned effect to await the publish. const nextPublish = (predicate: (snapshot: ServerProvider) => boolean) => - Stream.toPull(provider.snapshot.streamChanges.pipe(Stream.filter(predicate))).pipe( - Effect.map((pull) => pull.pipe(Effect.map((snapshots) => snapshots[0]))), + provider.snapshot.streamChanges.pipe( + Stream.filter(predicate), + Stream.runHead, + Effect.map(Option.getOrUndefined), + Effect.forkChild({ startImmediately: true }), + Effect.map(Fiber.join), ); return { provider, @@ -729,8 +734,24 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { ], }; const usage = yield* Ref.make(limits); - const harness = yield* makeHarness({ probeUsage: Ref.get(usage) }); - const published = yield* harness.nextPublish((snapshot) => !!snapshot.usageLimits); + const reads = yield* Ref.make(0); + const harness = yield* makeHarness({ + probeUsage: Ref.update(reads, (count) => count + 1).pipe(Effect.andThen(Ref.get(usage))), + }); + // The health check after read N republishes it; its version marks that publish. + const republished = yield* Ref.make(0); + yield* Ref.set( + harness.probe, + Effect.gen(function* () { + const read = yield* Ref.get(reads); + const isRepublish = (yield* Ref.getAndSet(republished, read)) < read; + const version = isRepublish ? `republish-${read}` : `check-${read}`; + return { ...initializeResult, agentInfo: { ...initializeResult.agentInfo, version } }; + }), + ); + const published = yield* harness.nextPublish( + (snapshot) => snapshot.version === "republish-1" && snapshot.usageLimits !== undefined, + ); yield* harness.initialize; expect((yield* published)?.usageLimits).toEqual(limits); const failedRead: ServerProviderUsageLimits = { @@ -738,11 +759,8 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { windows: [], unavailable: { reason: "probeFailed" }, }; - // The second health check is the republish the failed background read triggers. - let checks = 0; - yield* Ref.set(harness.probe, Effect.sync(() => checks++).pipe(Effect.as(initializeResult))); yield* Ref.set(usage, failedRead); - const failed = yield* harness.nextPublish(() => checks === 2); + const failed = yield* harness.nextPublish((snapshot) => snapshot.version === "republish-2"); yield* harness.provider.snapshot.refresh; expect((yield* failed)?.usageLimits).toEqual(failedRead); const recovered: ServerProviderUsageLimits = { @@ -755,8 +773,11 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { ); yield* harness.provider.snapshot.refresh; expect((yield* recoveredPublish)?.usageLimits).toEqual(recovered); + const signedOut = yield* harness.nextPublish( + (snapshot) => snapshot.auth.status === "unauthenticated", + ); yield* harness.provider.onSignedOut; - expect((yield* harness.provider.snapshot.getSnapshot).usageLimits).toBeUndefined(); + expect((yield* signedOut)?.usageLimits).toBeUndefined(); yield* Ref.set(usage, { checkedAt: "2026-10-09T12:02:00.000Z", windows: [], diff --git a/apps/server/src/provider/AntigravityProvider.ts b/apps/server/src/provider/AntigravityProvider.ts index a25f6a5d2fea..0522175187c0 100644 --- a/apps/server/src/provider/AntigravityProvider.ts +++ b/apps/server/src/provider/AntigravityProvider.ts @@ -268,7 +268,6 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func }, })), ), - // Enrichment cannot change published limits; a health check publishes them. Effect.andThen( Deferred.await(republish).pipe( Effect.flatten, @@ -378,8 +377,8 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func haveSettingsChanged: () => false, initialSnapshot: () => getSnapshot, checkProvider: checkProvider(), - // A failed read is shown as failed; the CLI token expires, so old limits would mislead. - retainUsageLimitsOnProbeFailure: false, + // The draft holds the current account's limits; the CLI token expires, so old ones mislead. + retainUsageLimits: false, enrichSnapshot: ({ publishSnapshot }) => SubscriptionRef.changes(metadata).pipe( Stream.runForEach((state) => @@ -554,8 +553,8 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func onSessionStarted, onConfigOptionsUpdated, onAvailableCommands, - // The new sign-in may be another account. Clear and republish its limits so a failed read - // cannot fall back to them; the session start then reads the new account's limits. + // The new sign-in may be another account. Clear the old limits and republish; the session + // start then reads the new account's limits. onSignedIn: resetUsage.pipe( Effect.andThen( SubscriptionRef.update(metadata, (state) => { diff --git a/packages/provider-core/src/server/managedProvider.ts b/packages/provider-core/src/server/managedProvider.ts index a0bace848df5..54e28bd39fcb 100644 --- a/packages/provider-core/src/server/managedProvider.ts +++ b/packages/provider-core/src/server/managedProvider.ts @@ -73,8 +73,11 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( readonly refreshInterval?: Duration.Input; readonly refreshOnInterval?: boolean | ((snapshot: ServerProvider) => boolean); readonly checkProviderOnSettingsChange?: (previous: Settings, next: Settings) => boolean; - /** False publishes a failed usage probe as-is instead of keeping the last good read. */ - readonly retainUsageLimitsOnProbeFailure?: boolean; + /** + * False publishes the limits that probes and enrichment report, so a failed read or a cleared + * account replaces the last good read instead of keeping it. + */ + readonly retainUsageLimits?: boolean; }): Effect.fn.Return< ManagedServerProvider, ServerSettingsError, @@ -116,7 +119,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( ...nextSnapshot, auth: { ...nextSnapshot.auth, label: state.usageAuthLabel ?? undefined }, }, - state.snapshot.usageLimits, + input.retainUsageLimits === false ? nextSnapshot.usageLimits : state.snapshot.usageLimits, ); if (Equal.equals(state.snapshot, merged)) { return [null, state] as const; @@ -223,7 +226,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( : probedSnapshot.usageLimits === undefined && state.snapshot.usageLimits !== usageBeforeProbe ? state.snapshot.usageLimits - : input.retainUsageLimitsOnProbeFailure === false && + : input.retainUsageLimits === false && probedSnapshot.usageLimits?.unavailable?.reason === "probeFailed" ? probedSnapshot.usageLimits : resolveUsageLimitsAfterProbe({ From c4d780e94d2bc5edf05e06ea8ae41ff31a3f1adb Mon Sep 17 00:00:00 2001 From: mths-mcfs Date: Fri, 20 Nov 2026 18:05:44 -0300 Subject: [PATCH 05/11] fix(server): a slow Antigravity health check no longer flashes old limits A health check could read the limits, wait, and then publish them after enrichment had already published a newer read, so the old reading (or the previous account's after sign-out) showed for a moment. With retainUsageLimits: false, enrichment is now the only writer of limits: a provider check keeps the published limits instead of applying the ones it read. The health check Antigravity ran after each quota read only existed to publish it, so it is gone. Co-Authored-By: Claude Opus 5.5 --- .../src/provider/AntigravityProvider.test.ts | 22 ++---- .../src/provider/AntigravityProvider.ts | 11 +-- .../src/server/managedProvider.test.ts | 73 +++++++++++++++++++ .../src/server/managedProvider.ts | 25 ++++--- 4 files changed, 92 insertions(+), 39 deletions(-) diff --git a/apps/server/src/provider/AntigravityProvider.test.ts b/apps/server/src/provider/AntigravityProvider.test.ts index 7e3f110cdbb2..01e5c4f5a545 100644 --- a/apps/server/src/provider/AntigravityProvider.test.ts +++ b/apps/server/src/provider/AntigravityProvider.test.ts @@ -734,23 +734,9 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { ], }; const usage = yield* Ref.make(limits); - const reads = yield* Ref.make(0); - const harness = yield* makeHarness({ - probeUsage: Ref.update(reads, (count) => count + 1).pipe(Effect.andThen(Ref.get(usage))), - }); - // The health check after read N republishes it; its version marks that publish. - const republished = yield* Ref.make(0); - yield* Ref.set( - harness.probe, - Effect.gen(function* () { - const read = yield* Ref.get(reads); - const isRepublish = (yield* Ref.getAndSet(republished, read)) < read; - const version = isRepublish ? `republish-${read}` : `check-${read}`; - return { ...initializeResult, agentInfo: { ...initializeResult.agentInfo, version } }; - }), - ); + const harness = yield* makeHarness({ probeUsage: Ref.get(usage) }); const published = yield* harness.nextPublish( - (snapshot) => snapshot.version === "republish-1" && snapshot.usageLimits !== undefined, + (snapshot) => snapshot.usageLimits !== undefined, ); yield* harness.initialize; expect((yield* published)?.usageLimits).toEqual(limits); @@ -760,7 +746,9 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { unavailable: { reason: "probeFailed" }, }; yield* Ref.set(usage, failedRead); - const failed = yield* harness.nextPublish((snapshot) => snapshot.version === "republish-2"); + const failed = yield* harness.nextPublish( + (snapshot) => snapshot.usageLimits?.checkedAt === failedRead.checkedAt, + ); yield* harness.provider.snapshot.refresh; expect((yield* failed)?.usageLimits).toEqual(failedRead); const recovered: ServerProviderUsageLimits = { diff --git a/apps/server/src/provider/AntigravityProvider.ts b/apps/server/src/provider/AntigravityProvider.ts index 0522175187c0..2e57bf801e79 100644 --- a/apps/server/src/provider/AntigravityProvider.ts +++ b/apps/server/src/provider/AntigravityProvider.ts @@ -49,7 +49,7 @@ const HEALTH_CHECK_TIMEOUT_MS = 90_000; const SIGN_IN_MESSAGE = "Sign in with Google to use Antigravity."; const AUTH_UNCHECKED_MESSAGE = "Antigravity is installed. Google account access is not checked yet."; -// Set while a finished quota read republishes, so that health check does not read again. +// Set while sign-in republishes, so that health check leaves the quota read to the session start. const PublishingUsage = Context.Reference("t3/provider/AntigravityPublishingUsage", { defaultValue: () => false, }); @@ -253,7 +253,6 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func // One read runs at a time; sign-in and sign-out interrupt it so a stale account never lands. const usageRead = yield* FiberHandle.make(); const republish = yield* Deferred.make>(); - const scope = yield* Effect.scope; const refreshUsage = Effect.fn("AntigravityProvider.refreshUsage")(function* () { if (!options.probeUsage || (yield* PublishingUsage)) return; yield* FiberHandle.run( @@ -268,14 +267,6 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func }, })), ), - Effect.andThen( - Deferred.await(republish).pipe( - Effect.flatten, - Effect.provideService(PublishingUsage, true), - Effect.ignoreCause({ log: true }), - Effect.forkIn(scope), - ), - ), ), // Store the fiber before it runs, so a sign-out during the read can interrupt it. { onlyIfMissing: true, startImmediately: false }, diff --git a/packages/provider-core/src/server/managedProvider.test.ts b/packages/provider-core/src/server/managedProvider.test.ts index 0eccada27c50..c7ae95a085a5 100644 --- a/packages/provider-core/src/server/managedProvider.test.ts +++ b/packages/provider-core/src/server/managedProvider.test.ts @@ -15,6 +15,7 @@ import * as Layer from "effect/Layer"; import * as PubSub from "effect/PubSub"; import * as Ref from "effect/Ref"; import * as Stream from "effect/Stream"; +import * as SubscriptionRef from "effect/SubscriptionRef"; import * as TestClock from "effect/testing/TestClock"; import * as ProviderHost from "./ProviderHost.ts"; @@ -1030,4 +1031,76 @@ describe("makeManagedServerProvider", () => { }), ).pipe(Effect.provide(layerAlwaysRunTest)), ); + + it.effect("does not let a check that read the limits before a newer read republish them", () => + Effect.scoped( + Effect.gen(function* () { + const older = { + checkedAt: "2026-04-10T00:00:01.000Z", + windows: [{ id: "weekly", kind: "weekly", label: "Weekly", usedPercent: 75 }], + } as const; + const newer = { + checkedAt: "2026-04-10T00:00:02.000Z", + windows: [], + unavailable: { reason: "probeFailed" }, + } as const; + const limits = yield* SubscriptionRef.make(older); + const holdCheck = yield* Ref.make>(Effect.void); + const checks = yield* Ref.make(0); + const provider = yield* makeManagedServerProvider({ + resolveMaintenance: () => Effect.succeed(maintenanceCapabilities), + getSettings: Effect.succeed({ enabled: true }), + streamSettings: Stream.empty, + haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled, + initialSnapshot: () => Effect.succeed(initialSnapshot), + checkProvider: Effect.gen(function* () { + const base = + (yield* Ref.updateAndGet(checks, (count) => count + 1)) === 1 + ? refreshedSnapshot + : refreshedSnapshotSecond; + const usageLimits = yield* SubscriptionRef.get(limits); + yield* Effect.flatten(Ref.get(holdCheck)); + return { ...base, usageLimits }; + }), + retainUsageLimits: false, + enrichSnapshot: ({ publishSnapshot }) => + SubscriptionRef.changes(limits).pipe( + Stream.runForEach((usageLimits) => + publishSnapshot({ ...refreshedSnapshot, usageLimits }), + ), + ), + refreshOnInterval: false, + }); + yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain); + + const checkRead = yield* Deferred.make(); + const releaseCheck = yield* Deferred.make(); + yield* Ref.set( + holdCheck, + Deferred.succeed(checkRead, undefined).pipe(Effect.andThen(Deferred.await(releaseCheck))), + ); + const published = yield* provider.streamChanges.pipe( + Stream.takeUntil((snapshot) => snapshot.message === refreshedSnapshotSecond.message), + Stream.runCollect, + Effect.forkChild({ startImmediately: true }), + ); + const refresh = yield* provider.refresh.pipe(Effect.forkChild); + yield* Deferred.await(checkRead); + const newerPublished = yield* provider.streamChanges.pipe( + Stream.filter((snapshot) => snapshot.usageLimits?.checkedAt === newer.checkedAt), + Stream.runHead, + Effect.forkChild({ startImmediately: true }), + ); + yield* SubscriptionRef.set(limits, newer); + yield* Fiber.join(newerPublished); + yield* Deferred.succeed(releaseCheck, undefined); + + assert.deepStrictEqual( + Array.from(yield* Fiber.join(published), (snapshot) => snapshot.usageLimits), + [newer, newer], + ); + assert.deepStrictEqual((yield* Fiber.join(refresh)).usageLimits, newer); + }), + ).pipe(Effect.provide(layerAlwaysRunTest)), + ); }); diff --git a/packages/provider-core/src/server/managedProvider.ts b/packages/provider-core/src/server/managedProvider.ts index 54e28bd39fcb..56d4b4c2754f 100644 --- a/packages/provider-core/src/server/managedProvider.ts +++ b/packages/provider-core/src/server/managedProvider.ts @@ -74,8 +74,8 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( readonly refreshOnInterval?: boolean | ((snapshot: ServerProvider) => boolean); readonly checkProviderOnSettingsChange?: (previous: Settings, next: Settings) => boolean; /** - * False publishes the limits that probes and enrichment report, so a failed read or a cleared - * account replaces the last good read instead of keeping it. + * False makes enrichment the only writer of limits: it publishes the limits it reports, so a + * failed read or a cleared account replaces the last good one, and a check keeps what it finds. */ readonly retainUsageLimits?: boolean; }): Effect.fn.Return< @@ -221,18 +221,19 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( differs(probedSnapshot.auth.email?.toLowerCase(), previous.email?.toLowerCase()) || (probedSnapshot.auth.workspaceId !== undefined && probedSnapshot.auth.workspaceId !== previous.workspaceId); - const usageLimits = switchedAccount - ? probedSnapshot.usageLimits - : probedSnapshot.usageLimits === undefined && - state.snapshot.usageLimits !== usageBeforeProbe + // The check may have read limits older than ones enrichment published meanwhile. + const usageLimits = + input.retainUsageLimits === false ? state.snapshot.usageLimits - : input.retainUsageLimits === false && - probedSnapshot.usageLimits?.unavailable?.reason === "probeFailed" + : switchedAccount ? probedSnapshot.usageLimits - : resolveUsageLimitsAfterProbe({ - published: state.snapshot.usageLimits, - probed: probedSnapshot.usageLimits, - }); + : probedSnapshot.usageLimits === undefined && + state.snapshot.usageLimits !== usageBeforeProbe + ? state.snapshot.usageLimits + : resolveUsageLimitsAfterProbe({ + published: state.snapshot.usageLimits, + probed: probedSnapshot.usageLimits, + }); const workspaceId = usageLimits === probedSnapshot.usageLimits ? undefined : state.snapshot.auth.workspaceId; const usageAuthLabel = From 566a64991457465b044948dbf3e2ad4ab8772e4c Mon Sep 17 00:00:00 2001 From: mths-mcfs Date: Fri, 20 Nov 2026 18:37:46 -0300 Subject: [PATCH 06/11] fix(server): an interrupted provider refresh no longer freezes the limits A refresh bumps the enrichment generation, which retires the running enrichment, and only then starts the next one. Interrupting the refresh in between left no enrichment running, so for Antigravity, where enrichment is the only writer of limits, finished quota reads never reached clients until the next health check. applySnapshotBase is now uninterruptible except for the provider check itself, so a new generation always gets its enrichment fiber. The test for stale check results also no longer depends on scheduler order. Co-Authored-By: Claude Opus 5.5 --- .../src/server/managedProvider.test.ts | 89 ++++++++++++++++++- .../src/server/managedProvider.ts | 4 +- 2 files changed, 88 insertions(+), 5 deletions(-) diff --git a/packages/provider-core/src/server/managedProvider.test.ts b/packages/provider-core/src/server/managedProvider.test.ts index c7ae95a085a5..4c13d2d240cc 100644 --- a/packages/provider-core/src/server/managedProvider.test.ts +++ b/packages/provider-core/src/server/managedProvider.test.ts @@ -12,6 +12,7 @@ import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as Fiber from "effect/Fiber"; import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; import * as PubSub from "effect/PubSub"; import * as Ref from "effect/Ref"; import * as Stream from "effect/Stream"; @@ -1047,6 +1048,7 @@ describe("makeManagedServerProvider", () => { const limits = yield* SubscriptionRef.make(older); const holdCheck = yield* Ref.make>(Effect.void); const checks = yield* Ref.make(0); + const enrichmentStarted = yield* Deferred.make(); const provider = yield* makeManagedServerProvider({ resolveMaintenance: () => Effect.succeed(maintenanceCapabilities), getSettings: Effect.succeed({ enabled: true }), @@ -1064,14 +1066,19 @@ describe("makeManagedServerProvider", () => { }), retainUsageLimits: false, enrichSnapshot: ({ publishSnapshot }) => - SubscriptionRef.changes(limits).pipe( - Stream.runForEach((usageLimits) => - publishSnapshot({ ...refreshedSnapshot, usageLimits }), + Deferred.succeed(enrichmentStarted, undefined).pipe( + Effect.andThen( + SubscriptionRef.changes(limits).pipe( + Stream.runForEach((usageLimits) => + publishSnapshot({ ...refreshedSnapshot, usageLimits }), + ), + ), ), ), refreshOnInterval: false, }); - yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain); + // The first check has published once its enrichment runs; a subscription could miss it. + yield* Deferred.await(enrichmentStarted); const checkRead = yield* Deferred.make(); const releaseCheck = yield* Deferred.make(); @@ -1079,7 +1086,9 @@ describe("makeManagedServerProvider", () => { holdCheck, Deferred.succeed(checkRead, undefined).pipe(Effect.andThen(Deferred.await(releaseCheck))), ); + // Starts at the newer read, so the first check's enrichment republishing the older one is out. const published = yield* provider.streamChanges.pipe( + Stream.dropWhile((snapshot) => snapshot.usageLimits?.checkedAt !== newer.checkedAt), Stream.takeUntil((snapshot) => snapshot.message === refreshedSnapshotSecond.message), Stream.runCollect, Effect.forkChild({ startImmediately: true }), @@ -1103,4 +1112,76 @@ describe("makeManagedServerProvider", () => { }), ).pipe(Effect.provide(layerAlwaysRunTest)), ); + + it.effect("keeps an enrichment publishing when a refresh is interrupted while replacing it", () => + Effect.scoped( + Effect.gen(function* () { + const older = { + checkedAt: "2026-04-10T00:00:01.000Z", + windows: [{ id: "weekly", kind: "weekly", label: "Weekly", usedPercent: 75 }], + } as const; + const newer = { + checkedAt: "2026-04-10T00:00:02.000Z", + windows: [{ id: "weekly", kind: "weekly", label: "Weekly", usedPercent: 18 }], + } as const; + const limits = yield* SubscriptionRef.make(older); + let enrichments = 0; + const firstStarted = yield* Deferred.make(); + const firstStopping = yield* Deferred.make(); + const releaseFirst = yield* Deferred.make(); + const provider = yield* makeManagedServerProvider({ + resolveMaintenance: () => Effect.succeed(maintenanceCapabilities), + getSettings: Effect.succeed({ enabled: true }), + streamSettings: Stream.empty, + haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled, + initialSnapshot: () => Effect.succeed(initialSnapshot), + checkProvider: SubscriptionRef.get(limits).pipe( + Effect.map((usageLimits) => ({ ...refreshedSnapshot, usageLimits })), + ), + retainUsageLimits: false, + enrichSnapshot: ({ publishSnapshot }) => { + const first = ++enrichments === 1; + return Effect.gen(function* () { + // The first enrichment stops slowly, holding the refresh that replaces it. + if (first) { + yield* Effect.addFinalizer(() => + Deferred.succeed(firstStopping, undefined).pipe( + Effect.andThen(Deferred.await(releaseFirst)), + ), + ); + yield* Deferred.succeed(firstStarted, undefined); + } + yield* SubscriptionRef.changes(limits).pipe( + Stream.runForEach((usageLimits) => + publishSnapshot({ ...refreshedSnapshot, usageLimits }), + ), + ); + }).pipe(Effect.scoped); + }, + refreshOnInterval: false, + }); + yield* Deferred.await(firstStarted); + + const refresh = yield* provider.refresh.pipe(Effect.forkChild); + yield* Deferred.await(firstStopping); + const interrupting = yield* Fiber.interrupt(refresh).pipe( + Effect.forkChild({ startImmediately: true }), + ); + yield* Deferred.succeed(releaseFirst, undefined); + yield* Fiber.join(interrupting); + + const newerPublished = yield* provider.streamChanges.pipe( + Stream.filter((snapshot) => snapshot.usageLimits?.checkedAt === newer.checkedAt), + Stream.runHead, + Effect.forkChild({ startImmediately: true }), + ); + yield* SubscriptionRef.set(limits, newer); + assert.strictEqual(enrichments, 2); + assert.deepStrictEqual( + Option.getOrUndefined(yield* Fiber.join(newerPublished))?.usageLimits, + newer, + ); + }), + ).pipe(Effect.provide(layerAlwaysRunTest)), + ); }); diff --git a/packages/provider-core/src/server/managedProvider.ts b/packages/provider-core/src/server/managedProvider.ts index 56d4b4c2754f..845415e26e7c 100644 --- a/packages/provider-core/src/server/managedProvider.ts +++ b/packages/provider-core/src/server/managedProvider.ts @@ -158,6 +158,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( yield* Ref.set(enrichmentFiberRef, fiber); }); + // Only the check is interruptible, so a new enrichment generation always gets its fiber. const applySnapshotBase = Effect.fn("applySnapshot")(function* ( nextSettings: Settings, options?: { readonly forceRefresh?: boolean; readonly deferFailure?: boolean }, @@ -194,6 +195,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( const usageBeforeProbe = (yield* Ref.get(snapshotStateRef)).snapshot.usageLimits; const probedSnapshot = yield* input.checkProvider.pipe( Effect.provideService(DeferringFailedCheck, options?.deferFailure === true), + Effect.interruptible, ); // One failed periodic check over a ready provider is often transient; recheck before showing it. if ( @@ -263,7 +265,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( yield* PubSub.publish(changesPubSub, nextSnapshot); yield* restartSnapshotEnrichment(nextSettings, nextSnapshot, nextGeneration); return nextSnapshot; - }); + }, Effect.uninterruptible); const applySnapshot = (nextSettings: Settings, options?: { readonly forceRefresh?: boolean }) => refreshSemaphore.withPermits(1)(applySnapshotBase(nextSettings, options)); From f3a4ef2b922a1c77058cfd8fa0335992c6a74127 Mon Sep 17 00:00:00 2001 From: mths-mcfs Date: Fri, 20 Nov 2026 19:41:36 -0300 Subject: [PATCH 07/11] Revert "fix(server): an interrupted provider refresh no longer freezes the limits" This reverts commit 566a64991457465b044948dbf3e2ad4ab8772e4c. --- .../src/server/managedProvider.test.ts | 89 +------------------ .../src/server/managedProvider.ts | 4 +- 2 files changed, 5 insertions(+), 88 deletions(-) diff --git a/packages/provider-core/src/server/managedProvider.test.ts b/packages/provider-core/src/server/managedProvider.test.ts index 4c13d2d240cc..c7ae95a085a5 100644 --- a/packages/provider-core/src/server/managedProvider.test.ts +++ b/packages/provider-core/src/server/managedProvider.test.ts @@ -12,7 +12,6 @@ import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as Fiber from "effect/Fiber"; import * as Layer from "effect/Layer"; -import * as Option from "effect/Option"; import * as PubSub from "effect/PubSub"; import * as Ref from "effect/Ref"; import * as Stream from "effect/Stream"; @@ -1048,7 +1047,6 @@ describe("makeManagedServerProvider", () => { const limits = yield* SubscriptionRef.make(older); const holdCheck = yield* Ref.make>(Effect.void); const checks = yield* Ref.make(0); - const enrichmentStarted = yield* Deferred.make(); const provider = yield* makeManagedServerProvider({ resolveMaintenance: () => Effect.succeed(maintenanceCapabilities), getSettings: Effect.succeed({ enabled: true }), @@ -1066,19 +1064,14 @@ describe("makeManagedServerProvider", () => { }), retainUsageLimits: false, enrichSnapshot: ({ publishSnapshot }) => - Deferred.succeed(enrichmentStarted, undefined).pipe( - Effect.andThen( - SubscriptionRef.changes(limits).pipe( - Stream.runForEach((usageLimits) => - publishSnapshot({ ...refreshedSnapshot, usageLimits }), - ), - ), + SubscriptionRef.changes(limits).pipe( + Stream.runForEach((usageLimits) => + publishSnapshot({ ...refreshedSnapshot, usageLimits }), ), ), refreshOnInterval: false, }); - // The first check has published once its enrichment runs; a subscription could miss it. - yield* Deferred.await(enrichmentStarted); + yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain); const checkRead = yield* Deferred.make(); const releaseCheck = yield* Deferred.make(); @@ -1086,9 +1079,7 @@ describe("makeManagedServerProvider", () => { holdCheck, Deferred.succeed(checkRead, undefined).pipe(Effect.andThen(Deferred.await(releaseCheck))), ); - // Starts at the newer read, so the first check's enrichment republishing the older one is out. const published = yield* provider.streamChanges.pipe( - Stream.dropWhile((snapshot) => snapshot.usageLimits?.checkedAt !== newer.checkedAt), Stream.takeUntil((snapshot) => snapshot.message === refreshedSnapshotSecond.message), Stream.runCollect, Effect.forkChild({ startImmediately: true }), @@ -1112,76 +1103,4 @@ describe("makeManagedServerProvider", () => { }), ).pipe(Effect.provide(layerAlwaysRunTest)), ); - - it.effect("keeps an enrichment publishing when a refresh is interrupted while replacing it", () => - Effect.scoped( - Effect.gen(function* () { - const older = { - checkedAt: "2026-04-10T00:00:01.000Z", - windows: [{ id: "weekly", kind: "weekly", label: "Weekly", usedPercent: 75 }], - } as const; - const newer = { - checkedAt: "2026-04-10T00:00:02.000Z", - windows: [{ id: "weekly", kind: "weekly", label: "Weekly", usedPercent: 18 }], - } as const; - const limits = yield* SubscriptionRef.make(older); - let enrichments = 0; - const firstStarted = yield* Deferred.make(); - const firstStopping = yield* Deferred.make(); - const releaseFirst = yield* Deferred.make(); - const provider = yield* makeManagedServerProvider({ - resolveMaintenance: () => Effect.succeed(maintenanceCapabilities), - getSettings: Effect.succeed({ enabled: true }), - streamSettings: Stream.empty, - haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled, - initialSnapshot: () => Effect.succeed(initialSnapshot), - checkProvider: SubscriptionRef.get(limits).pipe( - Effect.map((usageLimits) => ({ ...refreshedSnapshot, usageLimits })), - ), - retainUsageLimits: false, - enrichSnapshot: ({ publishSnapshot }) => { - const first = ++enrichments === 1; - return Effect.gen(function* () { - // The first enrichment stops slowly, holding the refresh that replaces it. - if (first) { - yield* Effect.addFinalizer(() => - Deferred.succeed(firstStopping, undefined).pipe( - Effect.andThen(Deferred.await(releaseFirst)), - ), - ); - yield* Deferred.succeed(firstStarted, undefined); - } - yield* SubscriptionRef.changes(limits).pipe( - Stream.runForEach((usageLimits) => - publishSnapshot({ ...refreshedSnapshot, usageLimits }), - ), - ); - }).pipe(Effect.scoped); - }, - refreshOnInterval: false, - }); - yield* Deferred.await(firstStarted); - - const refresh = yield* provider.refresh.pipe(Effect.forkChild); - yield* Deferred.await(firstStopping); - const interrupting = yield* Fiber.interrupt(refresh).pipe( - Effect.forkChild({ startImmediately: true }), - ); - yield* Deferred.succeed(releaseFirst, undefined); - yield* Fiber.join(interrupting); - - const newerPublished = yield* provider.streamChanges.pipe( - Stream.filter((snapshot) => snapshot.usageLimits?.checkedAt === newer.checkedAt), - Stream.runHead, - Effect.forkChild({ startImmediately: true }), - ); - yield* SubscriptionRef.set(limits, newer); - assert.strictEqual(enrichments, 2); - assert.deepStrictEqual( - Option.getOrUndefined(yield* Fiber.join(newerPublished))?.usageLimits, - newer, - ); - }), - ).pipe(Effect.provide(layerAlwaysRunTest)), - ); }); diff --git a/packages/provider-core/src/server/managedProvider.ts b/packages/provider-core/src/server/managedProvider.ts index 845415e26e7c..56d4b4c2754f 100644 --- a/packages/provider-core/src/server/managedProvider.ts +++ b/packages/provider-core/src/server/managedProvider.ts @@ -158,7 +158,6 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( yield* Ref.set(enrichmentFiberRef, fiber); }); - // Only the check is interruptible, so a new enrichment generation always gets its fiber. const applySnapshotBase = Effect.fn("applySnapshot")(function* ( nextSettings: Settings, options?: { readonly forceRefresh?: boolean; readonly deferFailure?: boolean }, @@ -195,7 +194,6 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( const usageBeforeProbe = (yield* Ref.get(snapshotStateRef)).snapshot.usageLimits; const probedSnapshot = yield* input.checkProvider.pipe( Effect.provideService(DeferringFailedCheck, options?.deferFailure === true), - Effect.interruptible, ); // One failed periodic check over a ready provider is often transient; recheck before showing it. if ( @@ -265,7 +263,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( yield* PubSub.publish(changesPubSub, nextSnapshot); yield* restartSnapshotEnrichment(nextSettings, nextSnapshot, nextGeneration); return nextSnapshot; - }, Effect.uninterruptible); + }); const applySnapshot = (nextSettings: Settings, options?: { readonly forceRefresh?: boolean }) => refreshSemaphore.withPermits(1)(applySnapshotBase(nextSettings, options)); From 7f28802c5cc248591b5cf9cff5e52f88e127f820 Mon Sep 17 00:00:00 2001 From: mths-mcfs Date: Fri, 20 Nov 2026 19:41:36 -0300 Subject: [PATCH 08/11] Revert "fix(server): a slow Antigravity health check no longer flashes old limits" This reverts commit c4d780e94d2bc5edf05e06ea8ae41ff31a3f1adb. --- .../src/provider/AntigravityProvider.test.ts | 22 ++++-- .../src/provider/AntigravityProvider.ts | 11 ++- .../src/server/managedProvider.test.ts | 73 ------------------- .../src/server/managedProvider.ts | 25 +++---- 4 files changed, 39 insertions(+), 92 deletions(-) diff --git a/apps/server/src/provider/AntigravityProvider.test.ts b/apps/server/src/provider/AntigravityProvider.test.ts index 01e5c4f5a545..7e3f110cdbb2 100644 --- a/apps/server/src/provider/AntigravityProvider.test.ts +++ b/apps/server/src/provider/AntigravityProvider.test.ts @@ -734,9 +734,23 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { ], }; const usage = yield* Ref.make(limits); - const harness = yield* makeHarness({ probeUsage: Ref.get(usage) }); + const reads = yield* Ref.make(0); + const harness = yield* makeHarness({ + probeUsage: Ref.update(reads, (count) => count + 1).pipe(Effect.andThen(Ref.get(usage))), + }); + // The health check after read N republishes it; its version marks that publish. + const republished = yield* Ref.make(0); + yield* Ref.set( + harness.probe, + Effect.gen(function* () { + const read = yield* Ref.get(reads); + const isRepublish = (yield* Ref.getAndSet(republished, read)) < read; + const version = isRepublish ? `republish-${read}` : `check-${read}`; + return { ...initializeResult, agentInfo: { ...initializeResult.agentInfo, version } }; + }), + ); const published = yield* harness.nextPublish( - (snapshot) => snapshot.usageLimits !== undefined, + (snapshot) => snapshot.version === "republish-1" && snapshot.usageLimits !== undefined, ); yield* harness.initialize; expect((yield* published)?.usageLimits).toEqual(limits); @@ -746,9 +760,7 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { unavailable: { reason: "probeFailed" }, }; yield* Ref.set(usage, failedRead); - const failed = yield* harness.nextPublish( - (snapshot) => snapshot.usageLimits?.checkedAt === failedRead.checkedAt, - ); + const failed = yield* harness.nextPublish((snapshot) => snapshot.version === "republish-2"); yield* harness.provider.snapshot.refresh; expect((yield* failed)?.usageLimits).toEqual(failedRead); const recovered: ServerProviderUsageLimits = { diff --git a/apps/server/src/provider/AntigravityProvider.ts b/apps/server/src/provider/AntigravityProvider.ts index 2e57bf801e79..0522175187c0 100644 --- a/apps/server/src/provider/AntigravityProvider.ts +++ b/apps/server/src/provider/AntigravityProvider.ts @@ -49,7 +49,7 @@ const HEALTH_CHECK_TIMEOUT_MS = 90_000; const SIGN_IN_MESSAGE = "Sign in with Google to use Antigravity."; const AUTH_UNCHECKED_MESSAGE = "Antigravity is installed. Google account access is not checked yet."; -// Set while sign-in republishes, so that health check leaves the quota read to the session start. +// Set while a finished quota read republishes, so that health check does not read again. const PublishingUsage = Context.Reference("t3/provider/AntigravityPublishingUsage", { defaultValue: () => false, }); @@ -253,6 +253,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func // One read runs at a time; sign-in and sign-out interrupt it so a stale account never lands. const usageRead = yield* FiberHandle.make(); const republish = yield* Deferred.make>(); + const scope = yield* Effect.scope; const refreshUsage = Effect.fn("AntigravityProvider.refreshUsage")(function* () { if (!options.probeUsage || (yield* PublishingUsage)) return; yield* FiberHandle.run( @@ -267,6 +268,14 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func }, })), ), + Effect.andThen( + Deferred.await(republish).pipe( + Effect.flatten, + Effect.provideService(PublishingUsage, true), + Effect.ignoreCause({ log: true }), + Effect.forkIn(scope), + ), + ), ), // Store the fiber before it runs, so a sign-out during the read can interrupt it. { onlyIfMissing: true, startImmediately: false }, diff --git a/packages/provider-core/src/server/managedProvider.test.ts b/packages/provider-core/src/server/managedProvider.test.ts index c7ae95a085a5..0eccada27c50 100644 --- a/packages/provider-core/src/server/managedProvider.test.ts +++ b/packages/provider-core/src/server/managedProvider.test.ts @@ -15,7 +15,6 @@ import * as Layer from "effect/Layer"; import * as PubSub from "effect/PubSub"; import * as Ref from "effect/Ref"; import * as Stream from "effect/Stream"; -import * as SubscriptionRef from "effect/SubscriptionRef"; import * as TestClock from "effect/testing/TestClock"; import * as ProviderHost from "./ProviderHost.ts"; @@ -1031,76 +1030,4 @@ describe("makeManagedServerProvider", () => { }), ).pipe(Effect.provide(layerAlwaysRunTest)), ); - - it.effect("does not let a check that read the limits before a newer read republish them", () => - Effect.scoped( - Effect.gen(function* () { - const older = { - checkedAt: "2026-04-10T00:00:01.000Z", - windows: [{ id: "weekly", kind: "weekly", label: "Weekly", usedPercent: 75 }], - } as const; - const newer = { - checkedAt: "2026-04-10T00:00:02.000Z", - windows: [], - unavailable: { reason: "probeFailed" }, - } as const; - const limits = yield* SubscriptionRef.make(older); - const holdCheck = yield* Ref.make>(Effect.void); - const checks = yield* Ref.make(0); - const provider = yield* makeManagedServerProvider({ - resolveMaintenance: () => Effect.succeed(maintenanceCapabilities), - getSettings: Effect.succeed({ enabled: true }), - streamSettings: Stream.empty, - haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled, - initialSnapshot: () => Effect.succeed(initialSnapshot), - checkProvider: Effect.gen(function* () { - const base = - (yield* Ref.updateAndGet(checks, (count) => count + 1)) === 1 - ? refreshedSnapshot - : refreshedSnapshotSecond; - const usageLimits = yield* SubscriptionRef.get(limits); - yield* Effect.flatten(Ref.get(holdCheck)); - return { ...base, usageLimits }; - }), - retainUsageLimits: false, - enrichSnapshot: ({ publishSnapshot }) => - SubscriptionRef.changes(limits).pipe( - Stream.runForEach((usageLimits) => - publishSnapshot({ ...refreshedSnapshot, usageLimits }), - ), - ), - refreshOnInterval: false, - }); - yield* Stream.take(provider.streamChanges, 1).pipe(Stream.runDrain); - - const checkRead = yield* Deferred.make(); - const releaseCheck = yield* Deferred.make(); - yield* Ref.set( - holdCheck, - Deferred.succeed(checkRead, undefined).pipe(Effect.andThen(Deferred.await(releaseCheck))), - ); - const published = yield* provider.streamChanges.pipe( - Stream.takeUntil((snapshot) => snapshot.message === refreshedSnapshotSecond.message), - Stream.runCollect, - Effect.forkChild({ startImmediately: true }), - ); - const refresh = yield* provider.refresh.pipe(Effect.forkChild); - yield* Deferred.await(checkRead); - const newerPublished = yield* provider.streamChanges.pipe( - Stream.filter((snapshot) => snapshot.usageLimits?.checkedAt === newer.checkedAt), - Stream.runHead, - Effect.forkChild({ startImmediately: true }), - ); - yield* SubscriptionRef.set(limits, newer); - yield* Fiber.join(newerPublished); - yield* Deferred.succeed(releaseCheck, undefined); - - assert.deepStrictEqual( - Array.from(yield* Fiber.join(published), (snapshot) => snapshot.usageLimits), - [newer, newer], - ); - assert.deepStrictEqual((yield* Fiber.join(refresh)).usageLimits, newer); - }), - ).pipe(Effect.provide(layerAlwaysRunTest)), - ); }); diff --git a/packages/provider-core/src/server/managedProvider.ts b/packages/provider-core/src/server/managedProvider.ts index 56d4b4c2754f..54e28bd39fcb 100644 --- a/packages/provider-core/src/server/managedProvider.ts +++ b/packages/provider-core/src/server/managedProvider.ts @@ -74,8 +74,8 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( readonly refreshOnInterval?: boolean | ((snapshot: ServerProvider) => boolean); readonly checkProviderOnSettingsChange?: (previous: Settings, next: Settings) => boolean; /** - * False makes enrichment the only writer of limits: it publishes the limits it reports, so a - * failed read or a cleared account replaces the last good one, and a check keeps what it finds. + * False publishes the limits that probes and enrichment report, so a failed read or a cleared + * account replaces the last good read instead of keeping it. */ readonly retainUsageLimits?: boolean; }): Effect.fn.Return< @@ -221,19 +221,18 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( differs(probedSnapshot.auth.email?.toLowerCase(), previous.email?.toLowerCase()) || (probedSnapshot.auth.workspaceId !== undefined && probedSnapshot.auth.workspaceId !== previous.workspaceId); - // The check may have read limits older than ones enrichment published meanwhile. - const usageLimits = - input.retainUsageLimits === false + const usageLimits = switchedAccount + ? probedSnapshot.usageLimits + : probedSnapshot.usageLimits === undefined && + state.snapshot.usageLimits !== usageBeforeProbe ? state.snapshot.usageLimits - : switchedAccount + : input.retainUsageLimits === false && + probedSnapshot.usageLimits?.unavailable?.reason === "probeFailed" ? probedSnapshot.usageLimits - : probedSnapshot.usageLimits === undefined && - state.snapshot.usageLimits !== usageBeforeProbe - ? state.snapshot.usageLimits - : resolveUsageLimitsAfterProbe({ - published: state.snapshot.usageLimits, - probed: probedSnapshot.usageLimits, - }); + : resolveUsageLimitsAfterProbe({ + published: state.snapshot.usageLimits, + probed: probedSnapshot.usageLimits, + }); const workspaceId = usageLimits === probedSnapshot.usageLimits ? undefined : state.snapshot.auth.workspaceId; const usageAuthLabel = From 981ecb8f9a40c2206b6fdf5567f579e58479f55a Mon Sep 17 00:00:00 2001 From: mths-mcfs Date: Fri, 20 Nov 2026 19:41:36 -0300 Subject: [PATCH 09/11] Revert "fix(server): Antigravity sign-out no longer republishes the previous account's limits" This reverts commit 4da0a1521f198ef93680ebad42bd9ac806b87406. --- .../src/provider/AntigravityProvider.test.ts | 41 +++++-------------- .../src/provider/AntigravityProvider.ts | 9 ++-- .../src/server/managedProvider.ts | 11 ++--- 3 files changed, 19 insertions(+), 42 deletions(-) diff --git a/apps/server/src/provider/AntigravityProvider.test.ts b/apps/server/src/provider/AntigravityProvider.test.ts index 7e3f110cdbb2..ac0e48a96463 100644 --- a/apps/server/src/provider/AntigravityProvider.test.ts +++ b/apps/server/src/provider/AntigravityProvider.test.ts @@ -13,7 +13,6 @@ import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as Fiber from "effect/Fiber"; import * as Layer from "effect/Layer"; -import * as Option from "effect/Option"; import * as Ref from "effect/Ref"; import * as Schema from "effect/Schema"; import * as Stream from "effect/Stream"; @@ -173,14 +172,10 @@ const makeHarness = Effect.fn("makeAntigravityProviderHarness")(function* ( Effect.andThen(initialUpdate), Effect.asVoid, ); - // Subscribes now, before the trigger runs; yield the returned effect to await the publish. + // Subscribe before the trigger; yield the returned pull to await the publish. const nextPublish = (predicate: (snapshot: ServerProvider) => boolean) => - provider.snapshot.streamChanges.pipe( - Stream.filter(predicate), - Stream.runHead, - Effect.map(Option.getOrUndefined), - Effect.forkChild({ startImmediately: true }), - Effect.map(Fiber.join), + Stream.toPull(provider.snapshot.streamChanges.pipe(Stream.filter(predicate))).pipe( + Effect.map((pull) => pull.pipe(Effect.map((snapshots) => snapshots[0]))), ); return { provider, @@ -734,24 +729,8 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { ], }; const usage = yield* Ref.make(limits); - const reads = yield* Ref.make(0); - const harness = yield* makeHarness({ - probeUsage: Ref.update(reads, (count) => count + 1).pipe(Effect.andThen(Ref.get(usage))), - }); - // The health check after read N republishes it; its version marks that publish. - const republished = yield* Ref.make(0); - yield* Ref.set( - harness.probe, - Effect.gen(function* () { - const read = yield* Ref.get(reads); - const isRepublish = (yield* Ref.getAndSet(republished, read)) < read; - const version = isRepublish ? `republish-${read}` : `check-${read}`; - return { ...initializeResult, agentInfo: { ...initializeResult.agentInfo, version } }; - }), - ); - const published = yield* harness.nextPublish( - (snapshot) => snapshot.version === "republish-1" && snapshot.usageLimits !== undefined, - ); + const harness = yield* makeHarness({ probeUsage: Ref.get(usage) }); + const published = yield* harness.nextPublish((snapshot) => !!snapshot.usageLimits); yield* harness.initialize; expect((yield* published)?.usageLimits).toEqual(limits); const failedRead: ServerProviderUsageLimits = { @@ -759,8 +738,11 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { windows: [], unavailable: { reason: "probeFailed" }, }; + // The second health check is the republish the failed background read triggers. + let checks = 0; + yield* Ref.set(harness.probe, Effect.sync(() => checks++).pipe(Effect.as(initializeResult))); yield* Ref.set(usage, failedRead); - const failed = yield* harness.nextPublish((snapshot) => snapshot.version === "republish-2"); + const failed = yield* harness.nextPublish(() => checks === 2); yield* harness.provider.snapshot.refresh; expect((yield* failed)?.usageLimits).toEqual(failedRead); const recovered: ServerProviderUsageLimits = { @@ -773,11 +755,8 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { ); yield* harness.provider.snapshot.refresh; expect((yield* recoveredPublish)?.usageLimits).toEqual(recovered); - const signedOut = yield* harness.nextPublish( - (snapshot) => snapshot.auth.status === "unauthenticated", - ); yield* harness.provider.onSignedOut; - expect((yield* signedOut)?.usageLimits).toBeUndefined(); + expect((yield* harness.provider.snapshot.getSnapshot).usageLimits).toBeUndefined(); yield* Ref.set(usage, { checkedAt: "2026-10-09T12:02:00.000Z", windows: [], diff --git a/apps/server/src/provider/AntigravityProvider.ts b/apps/server/src/provider/AntigravityProvider.ts index 0522175187c0..a25f6a5d2fea 100644 --- a/apps/server/src/provider/AntigravityProvider.ts +++ b/apps/server/src/provider/AntigravityProvider.ts @@ -268,6 +268,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func }, })), ), + // Enrichment cannot change published limits; a health check publishes them. Effect.andThen( Deferred.await(republish).pipe( Effect.flatten, @@ -377,8 +378,8 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func haveSettingsChanged: () => false, initialSnapshot: () => getSnapshot, checkProvider: checkProvider(), - // The draft holds the current account's limits; the CLI token expires, so old ones mislead. - retainUsageLimits: false, + // A failed read is shown as failed; the CLI token expires, so old limits would mislead. + retainUsageLimitsOnProbeFailure: false, enrichSnapshot: ({ publishSnapshot }) => SubscriptionRef.changes(metadata).pipe( Stream.runForEach((state) => @@ -553,8 +554,8 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func onSessionStarted, onConfigOptionsUpdated, onAvailableCommands, - // The new sign-in may be another account. Clear the old limits and republish; the session - // start then reads the new account's limits. + // The new sign-in may be another account. Clear and republish its limits so a failed read + // cannot fall back to them; the session start then reads the new account's limits. onSignedIn: resetUsage.pipe( Effect.andThen( SubscriptionRef.update(metadata, (state) => { diff --git a/packages/provider-core/src/server/managedProvider.ts b/packages/provider-core/src/server/managedProvider.ts index 54e28bd39fcb..a0bace848df5 100644 --- a/packages/provider-core/src/server/managedProvider.ts +++ b/packages/provider-core/src/server/managedProvider.ts @@ -73,11 +73,8 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( readonly refreshInterval?: Duration.Input; readonly refreshOnInterval?: boolean | ((snapshot: ServerProvider) => boolean); readonly checkProviderOnSettingsChange?: (previous: Settings, next: Settings) => boolean; - /** - * False publishes the limits that probes and enrichment report, so a failed read or a cleared - * account replaces the last good read instead of keeping it. - */ - readonly retainUsageLimits?: boolean; + /** False publishes a failed usage probe as-is instead of keeping the last good read. */ + readonly retainUsageLimitsOnProbeFailure?: boolean; }): Effect.fn.Return< ManagedServerProvider, ServerSettingsError, @@ -119,7 +116,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( ...nextSnapshot, auth: { ...nextSnapshot.auth, label: state.usageAuthLabel ?? undefined }, }, - input.retainUsageLimits === false ? nextSnapshot.usageLimits : state.snapshot.usageLimits, + state.snapshot.usageLimits, ); if (Equal.equals(state.snapshot, merged)) { return [null, state] as const; @@ -226,7 +223,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")( : probedSnapshot.usageLimits === undefined && state.snapshot.usageLimits !== usageBeforeProbe ? state.snapshot.usageLimits - : input.retainUsageLimits === false && + : input.retainUsageLimitsOnProbeFailure === false && probedSnapshot.usageLimits?.unavailable?.reason === "probeFailed" ? probedSnapshot.usageLimits : resolveUsageLimitsAfterProbe({ From 44d9c31d4cc0a13789371ac1038573245513d1ed Mon Sep 17 00:00:00 2001 From: mths-mcfs Date: Fri, 20 Nov 2026 20:14:58 -0300 Subject: [PATCH 10/11] test(server): Antigravity limits test no longer depends on scheduler order The limits case waited on stream publishes, and nextPublish only subscribed when first pulled, so a publish could land before the subscription. Each read now resolves its own Deferred and the case asserts what the health check that republishes a read publishes, read through a refresh queued behind it. It no longer claims that sign-out clears the published limits. nextPublish subscribes when called, and the onSignedIn comment matches the code. Co-Authored-By: Claude Opus 5.5 --- .../src/provider/AntigravityProvider.test.ts | 85 ++++++++++++------- .../src/provider/AntigravityProvider.ts | 4 +- 2 files changed, 56 insertions(+), 33 deletions(-) diff --git a/apps/server/src/provider/AntigravityProvider.test.ts b/apps/server/src/provider/AntigravityProvider.test.ts index ac0e48a96463..7085162f6bfd 100644 --- a/apps/server/src/provider/AntigravityProvider.test.ts +++ b/apps/server/src/provider/AntigravityProvider.test.ts @@ -13,6 +13,7 @@ import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as Fiber from "effect/Fiber"; import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; import * as Ref from "effect/Ref"; import * as Schema from "effect/Schema"; import * as Stream from "effect/Stream"; @@ -172,10 +173,15 @@ const makeHarness = Effect.fn("makeAntigravityProviderHarness")(function* ( Effect.andThen(initialUpdate), Effect.asVoid, ); - // Subscribe before the trigger; yield the returned pull to await the publish. + // Subscribes now, before the trigger runs (a pull would subscribe only when first pulled); + // yield the returned effect to await the publish. const nextPublish = (predicate: (snapshot: ServerProvider) => boolean) => - Stream.toPull(provider.snapshot.streamChanges.pipe(Stream.filter(predicate))).pipe( - Effect.map((pull) => pull.pipe(Effect.map((snapshots) => snapshots[0]))), + provider.snapshot.streamChanges.pipe( + Stream.filter(predicate), + Stream.runHead, + Effect.map(Option.getOrUndefined), + Effect.forkChild({ startImmediately: true }), + Effect.map(Fiber.join), ); return { provider, @@ -715,8 +721,46 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { }), ); - it.effect("publishes limits, shows a failed read as failed, and clears them on sign-out", () => + it.effect("publishes each limits read, showing a failed read as failed until one recovers", () => Effect.gen(function* () { + // Read N always gets results[N], however its fiber is scheduled. + const results = yield* Effect.forEach([0, 1, 2, 3, 4], () => + Deferred.make(), + ); + const reads = yield* Ref.make(0); + const firstReadStarted = yield* Deferred.make(); + const harness = yield* makeHarness({ + probeUsage: Ref.getAndUpdate(reads, (count) => count + 1).pipe( + Effect.tap(() => Deferred.succeed(firstReadStarted, undefined)), + Effect.flatMap((read) => Deferred.await(results[read]!)), + ), + }); + // The first check has run its probe once it starts the first read. + yield* Deferred.succeed(harness.initialProbe, initializeResult); + yield* Deferred.await(firstReadStarted); + // A health check holds the refresh lock, so a refresh issued once the check that republishes + // a read has started returns what that check published. + const nextCheck = yield* Ref.make | undefined>(undefined); + yield* Ref.set( + harness.probe, + Ref.getAndSet(nextCheck, undefined).pipe( + Effect.flatMap((started) => + started ? Deferred.succeed(started, undefined) : Effect.void, + ), + Effect.as(initializeResult), + ), + ); + const finishRead = Effect.fn("finishRead")(function* ( + read: number, + result: ServerProviderUsageLimits, + ) { + const republishing = yield* Deferred.make(); + yield* Ref.set(nextCheck, republishing); + yield* Deferred.succeed(results[read]!, result); + yield* Deferred.await(republishing); + return (yield* harness.provider.snapshot.refresh).usageLimits; + }); + const limits: ServerProviderUsageLimits = { checkedAt: "2026-10-09T12:00:00.000Z", windows: [ @@ -728,45 +772,24 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { }, ], }; - const usage = yield* Ref.make(limits); - const harness = yield* makeHarness({ probeUsage: Ref.get(usage) }); - const published = yield* harness.nextPublish((snapshot) => !!snapshot.usageLimits); - yield* harness.initialize; - expect((yield* published)?.usageLimits).toEqual(limits); + expect(yield* finishRead(0, limits)).toEqual(limits); const failedRead: ServerProviderUsageLimits = { checkedAt: "2026-10-09T12:01:00.000Z", windows: [], unavailable: { reason: "probeFailed" }, }; - // The second health check is the republish the failed background read triggers. - let checks = 0; - yield* Ref.set(harness.probe, Effect.sync(() => checks++).pipe(Effect.as(initializeResult))); - yield* Ref.set(usage, failedRead); - const failed = yield* harness.nextPublish(() => checks === 2); - yield* harness.provider.snapshot.refresh; - expect((yield* failed)?.usageLimits).toEqual(failedRead); + expect(yield* finishRead(1, failedRead)).toEqual(failedRead); const recovered: ServerProviderUsageLimits = { ...limits, checkedAt: "2026-10-09T12:01:30.000Z", }; - yield* Ref.set(usage, recovered); - const recoveredPublish = yield* harness.nextPublish( - (snapshot) => snapshot.usageLimits?.checkedAt === recovered.checkedAt, - ); - yield* harness.provider.snapshot.refresh; - expect((yield* recoveredPublish)?.usageLimits).toEqual(recovered); - yield* harness.provider.onSignedOut; - expect((yield* harness.provider.snapshot.getSnapshot).usageLimits).toBeUndefined(); - yield* Ref.set(usage, { + expect(yield* finishRead(2, recovered)).toEqual(recovered); + const unsupported: ServerProviderUsageLimits = { checkedAt: "2026-10-09T12:02:00.000Z", windows: [], unavailable: { reason: "unsupported" }, - }); - const unsupported = yield* harness.nextPublish( - (snapshot) => snapshot.usageLimits?.unavailable?.reason === "unsupported", - ); - yield* harness.provider.snapshot.refresh; - expect((yield* unsupported)?.usageLimits?.windows).toEqual([]); + }; + expect(yield* finishRead(3, unsupported)).toEqual(unsupported); }), ); diff --git a/apps/server/src/provider/AntigravityProvider.ts b/apps/server/src/provider/AntigravityProvider.ts index a25f6a5d2fea..7fb3d2d1beaa 100644 --- a/apps/server/src/provider/AntigravityProvider.ts +++ b/apps/server/src/provider/AntigravityProvider.ts @@ -554,8 +554,8 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func onSessionStarted, onConfigOptionsUpdated, onAvailableCommands, - // The new sign-in may be another account. Clear and republish its limits so a failed read - // cannot fall back to them; the session start then reads the new account's limits. + // The new sign-in may be another account. Clear and republish its limits so they are not + // shown for it; the session start then reads the new account's limits. onSignedIn: resetUsage.pipe( Effect.andThen( SubscriptionRef.update(metadata, (state) => { From 93e70cf600e4903db00eae660687421c4f2b77b2 Mon Sep 17 00:00:00 2001 From: mths-mcfs Date: Fri, 20 Nov 2026 20:45:01 -0300 Subject: [PATCH 11/11] fix(server): Antigravity keeps the newer limits read after the clock moves back The draft stored every quota read as-is, so a good read stamped before the published one replaced it in getSnapshot while clients kept the newer one. It now stores only a failed read as-is and otherwise keeps main's rule, like the managed provider's check. The limits test also asserts what streamChanges publishes for each read, ending at a command update it makes afterwards, and covers the clock moving back. Co-Authored-By: Claude Opus 5.5 --- .../src/provider/AntigravityProvider.test.ts | 45 ++++++++++++++++--- .../src/provider/AntigravityProvider.ts | 7 ++- 2 files changed, 44 insertions(+), 8 deletions(-) diff --git a/apps/server/src/provider/AntigravityProvider.test.ts b/apps/server/src/provider/AntigravityProvider.test.ts index 7085162f6bfd..581fceb0736b 100644 --- a/apps/server/src/provider/AntigravityProvider.test.ts +++ b/apps/server/src/provider/AntigravityProvider.test.ts @@ -724,7 +724,7 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { it.effect("publishes each limits read, showing a failed read as failed until one recovers", () => Effect.gen(function* () { // Read N always gets results[N], however its fiber is scheduled. - const results = yield* Effect.forEach([0, 1, 2, 3, 4], () => + const results = yield* Effect.forEach([0, 1, 2, 3, 4, 5], () => Deferred.make(), ); const reads = yield* Ref.make(0); @@ -739,7 +739,7 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { yield* Deferred.succeed(harness.initialProbe, initializeResult); yield* Deferred.await(firstReadStarted); // A health check holds the refresh lock, so a refresh issued once the check that republishes - // a read has started returns what that check published. + // a read has started runs after it; new commands then mark the end of what both published. const nextCheck = yield* Ref.make | undefined>(undefined); yield* Ref.set( harness.probe, @@ -754,12 +754,35 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { read: number, result: ServerProviderUsageLimits, ) { + const barrier = `barrier-${read}`; + const published = yield* harness.provider.snapshot.streamChanges.pipe( + Stream.takeUntil((snapshot) => + snapshot.slashCommands.some((command) => command.name === barrier), + ), + Stream.runCollect, + Effect.forkChild({ startImmediately: true }), + ); const republishing = yield* Deferred.make(); yield* Ref.set(nextCheck, republishing); yield* Deferred.succeed(results[read]!, result); yield* Deferred.await(republishing); - return (yield* harness.provider.snapshot.refresh).usageLimits; + const refreshed = (yield* harness.provider.snapshot.refresh).usageLimits; + yield* harness.provider.onAvailableCommands([{ name: barrier, description: "Barrier" }]); + const checked = Array.from(yield* Fiber.join(published)).slice(0, -1); + return { + refreshed, + published: checked.map((snapshot) => snapshot.usageLimits), + current: (yield* harness.provider.snapshot.getSnapshot).usageLimits, + }; }); + const expectShown = ( + shown: Effect.Success>, + expected: ServerProviderUsageLimits, + ) => { + expect(shown.refreshed).toEqual(expected); + expect(shown.published).toContainEqual(expected); + expect(shown.current).toEqual(expected); + }; const limits: ServerProviderUsageLimits = { checkedAt: "2026-10-09T12:00:00.000Z", @@ -772,24 +795,32 @@ it.layer(layerTest)("Antigravity provider snapshots", (it) => { }, ], }; - expect(yield* finishRead(0, limits)).toEqual(limits); + expectShown(yield* finishRead(0, limits), limits); const failedRead: ServerProviderUsageLimits = { checkedAt: "2026-10-09T12:01:00.000Z", windows: [], unavailable: { reason: "probeFailed" }, }; - expect(yield* finishRead(1, failedRead)).toEqual(failedRead); + expectShown(yield* finishRead(1, failedRead), failedRead); const recovered: ServerProviderUsageLimits = { ...limits, checkedAt: "2026-10-09T12:01:30.000Z", }; - expect(yield* finishRead(2, recovered)).toEqual(recovered); + expectShown(yield* finishRead(2, recovered), recovered); + // A read stamped before the published one, after the clock moved back, does not replace it. + expectShown( + yield* finishRead(3, { + checkedAt: "2026-10-09T12:01:15.000Z", + windows: [{ ...limits.windows[0]!, usedPercent: 18 }], + }), + recovered, + ); const unsupported: ServerProviderUsageLimits = { checkedAt: "2026-10-09T12:02:00.000Z", windows: [], unavailable: { reason: "unsupported" }, }; - expect(yield* finishRead(3, unsupported)).toEqual(unsupported); + expectShown(yield* finishRead(4, unsupported), unsupported); }), ); diff --git a/apps/server/src/provider/AntigravityProvider.ts b/apps/server/src/provider/AntigravityProvider.ts index 7fb3d2d1beaa..f9e244482632 100644 --- a/apps/server/src/provider/AntigravityProvider.ts +++ b/apps/server/src/provider/AntigravityProvider.ts @@ -40,6 +40,7 @@ import { isCommandMissingCause, type ServerProviderDraft, } from "@t3tools/provider-core/server/snapshotProbe"; +import { resolveUsageLimitsAfterProbe } from "@t3tools/provider-core/server/usageLimits"; import { antigravityThinkingConfig } from "./acp/AntigravityAcpSupport.ts"; @@ -264,7 +265,11 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func ...state, draft: { ...state.draft, - usageLimits: probed, + // A failed read shows as failed, like the managed provider's check publishes it. + usageLimits: + probed.unavailable?.reason === "probeFailed" + ? probed + : resolveUsageLimitsAfterProbe({ published: state.draft.usageLimits, probed }), }, })), ),