From accf97b3d2a82f508058bc37dee68b5f88e861a9 Mon Sep 17 00:00:00 2001 From: Shadman Taqi <61359614+iamshadmantaqi@users.noreply.github.com> Date: Thu, 19 Nov 2026 04:54:02 +0600 Subject: [PATCH 1/2] test(server): Claude usage served from the CLI's saved reading keeps its fetch time Fails on main: the probe stamps the saved reading with the probe time. --- .../provider/ProviderInstanceRegistry.test.ts | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) diff --git a/apps/server/src/provider/ProviderInstanceRegistry.test.ts b/apps/server/src/provider/ProviderInstanceRegistry.test.ts index ce6416332bae0..ba7f3e21883e8 100644 --- a/apps/server/src/provider/ProviderInstanceRegistry.test.ts +++ b/apps/server/src/provider/ProviderInstanceRegistry.test.ts @@ -563,6 +563,75 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }).pipe(Effect.provide(layerTest)), ); + it.effect("dates Claude usage served from the CLI's saved reading by when it was fetched", () => + Effect.gen(function* () { + if (yield* HostProcess.isWindows) return; + + const fixtures = yield* makeTildeProviderFixtures(); + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + // While /api/oauth/usage is rate-limited, Claude Code answers get_usage from this reading. + const savedFiveHour = { utilization: 12, resets_at: "2026-07-18T14:39:00Z" }; + yield* fs.writeFileString( + path.join(fixtures.claudeHomePath, ".claude.json"), + JSON.stringify({ + cachedUsageUtilization: { + fetchedAtMs: 20 * 60_000, + utilization: { five_hour: savedFiveHour }, + }, + }), + ); + let fiveHour = savedFiveHour; + const query = vi.spyOn(ClaudeSdk, "query").mockImplementation( + () => + ({ + initializationResult: () => + Promise.resolve({ + commands: [{ name: "usage", description: "", argumentHint: "" }], + account: { + email: "test@example.com", + subscriptionType: "pro", + tokenSource: "oauth", + }, + }), + usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET: async () => ({ + rate_limits_available: true, + rate_limits: { five_hour: fiveHour }, + }), + }) as ReturnType, + ); + yield* Effect.addFinalizer(() => Effect.sync(() => query.mockRestore())); + yield* TestClock.adjust("1 hour"); + + const claudeId = ProviderInstanceId.make("claude_saved_usage"); + const { registry } = yield* makeProviderInstanceRegistry({ + drivers: [ClaudeDriver], + configMap: { + [claudeId]: { + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + config: makeClaudeConfig({ + enabled: true, + binaryPath: fixtures.claudeBinaryPath, + homePath: fixtures.claudeHomePath, + }), + }, + }, + }); + const claude = yield* registry.getInstance(claudeId); + + const saved = yield* claude!.snapshot.refresh; + expect(saved.usageLimits?.windows[0]?.usedPercent).toBe(12); + expect(saved.usageLimits?.checkedAt).toBe("1970-01-01T00:20:00.000Z"); + + fiveHour = { ...savedFiveHour, utilization: 30 }; + yield* claude!.invalidateCaches ?? Effect.void; + const fetched = yield* claude!.snapshot.refresh; + expect(fetched.usageLimits?.windows[0]?.usedPercent).toBe(30); + expect(fetched.usageLimits?.checkedAt).toBe("1970-01-01T01:00:00.000Z"); + }).pipe(Effect.provide(layerTest)), + ); + it.effect("scopes Claude's one-probe fallback to the logged-in organization", () => Effect.gen(function* () { if (yield* HostProcess.isWindows) return; From 17e172e2b8f7ca5d6be16396c82f57b28c1782c3 Mon Sep 17 00:00:00 2001 From: Shadman Taqi <61359614+iamshadmantaqi@users.noreply.github.com> Date: Thu, 19 Nov 2026 04:54:02 +0600 Subject: [PATCH 2/2] fix(server): Claude usage served from a saved reading keeps its real age While /api/oauth/usage is rate-limited, Claude Code answers get_usage from the reading it saved in .claude.json and does not say so. The probe stamped that reading with the probe time, so an hour-old reading showed as just checked. Usage that matches the saved reading now takes its fetch time, never later than the probe. --- .../src/provider/Drivers/ClaudeDriver.ts | 55 ++++++++++++++++--- .../server/src/provider/claudeResetCredits.ts | 16 ++++++ 2 files changed, 64 insertions(+), 7 deletions(-) diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts index 5bedffe9242b4..60b13885cf04a 100644 --- a/apps/server/src/provider/Drivers/ClaudeDriver.ts +++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts @@ -1,6 +1,7 @@ import { ClaudeSettings, ProviderDriverKind } from "@t3tools/contracts"; import * as Cache from "effect/Cache"; import type * as Cause from "effect/Cause"; +import * as DateTime from "effect/DateTime"; import * as Duration from "effect/Duration"; import * as SecureRandom from "effect/crypto/SecureRandom"; import * as Effect from "effect/Effect"; @@ -74,6 +75,40 @@ const withoutUsage = (capabilities: ClaudeCapabilitiesProbe): ClaudeCapabilities return result; }; +/** + * While `/api/oauth/usage` is rate-limited, Claude Code answers `get_usage` from its saved reading + * without saying so. Usage matching that reading is dated by its fetch, never later than the probe. + */ +const withSavedUsageAge = ( + capabilities: ClaudeCapabilitiesProbe, + saved: Effect.Success>, +): ClaudeCapabilitiesProbe => { + const windows = Object.entries(capabilities.usage?.rate_limits ?? {}).flatMap(([id, window]) => + window && "utilization" in window ? [{ id, utilization: window.utilization }] : [], + ); + const probedAt = capabilities.usageCheckedAt; + const matchesSaved = + saved !== undefined && + probedAt !== undefined && + saved.fetchedAtMs < DateTime.toEpochMillis(DateTime.makeUnsafe(probedAt)) && + windows.length > 0 && + windows.every(({ id, utilization }) => { + const savedWindow = saved.utilization[id]; + return ( + typeof savedWindow === "object" && + savedWindow !== null && + "utilization" in savedWindow && + savedWindow.utilization === utilization + ); + }); + return matchesSaved + ? { + ...capabilities, + usageCheckedAt: DateTime.formatIso(DateTime.makeUnsafe(saved.fetchedAtMs)), + } + : capabilities; +}; + export type ClaudeDriverEnv = | ClaudeAdapterV2DriverEnv | ProviderHost.ProviderHost @@ -214,13 +249,19 @@ export const ClaudeDriver: ProviderDriver probeClaudeCapabilities(effectiveConfig, processEnv, stateDir).pipe( - Effect.flatMap((capabilities) => - ClaudeResetCredits.readClaudeOrganizationId(accountConfigPath).pipe( - Effect.map((workspaceId) => ({ - _tag: "fresh" as const, - capabilities: - workspaceId === undefined ? capabilities : { ...capabilities, workspaceId }, - })), + Effect.flatMap((probed) => + Effect.all([ + ClaudeResetCredits.readClaudeOrganizationId(accountConfigPath), + ClaudeResetCredits.readClaudeSavedUsage(accountConfigPath), + ]).pipe( + Effect.map(([workspaceId, savedUsage]) => { + const capabilities = withSavedUsageAge(probed, savedUsage); + return { + _tag: "fresh" as const, + capabilities: + workspaceId === undefined ? capabilities : { ...capabilities, workspaceId }, + }; + }), ), ), Effect.tap(({ capabilities }) => diff --git a/apps/server/src/provider/claudeResetCredits.ts b/apps/server/src/provider/claudeResetCredits.ts index d2000804cf4f6..86a12a12650c8 100644 --- a/apps/server/src/provider/claudeResetCredits.ts +++ b/apps/server/src/provider/claudeResetCredits.ts @@ -235,6 +235,22 @@ export const readClaudeOauthAccount = (accountConfigPath: string) => Effect.orElseSucceed(() => undefined), ); +const SavedUsage = Schema.Struct({ + cachedUsageUtilization: Schema.optional( + Schema.Struct({ + fetchedAtMs: Schema.Number, + utilization: Schema.Record(Schema.String, Schema.Unknown), + }), + ), +}); + +/** Claude Code's last `/api/oauth/usage` reading, which `get_usage` serves while that endpoint is rate-limited. */ +export const readClaudeSavedUsage = (accountConfigPath: string) => + readJson(SavedUsage, accountConfigPath).pipe( + Effect.map((config) => config.cachedUsageUtilization), + Effect.orElseSucceed(() => undefined), + ); + export const readClaudeOrganizationId = (accountConfigPath: string) => readClaudeOauthAccount(accountConfigPath).pipe( Effect.map((account) => account?.organizationUuid?.trim() || undefined),