From 4bfe6c26af041a4deb9bc2c948bc4e214f4a87b9 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Fri, 20 Nov 2026 20:21:07 +0000 Subject: [PATCH 1/3] test(server): Claude reset credits survive a rate-limited read Fails on main: a 429 from the cedar_ember usage read publishes a snapshot without resetCredits, hiding the reset button until the next 200 (#39868). Co-Authored-By: Claude Opus 5.5 --- .../provider/ProviderInstanceRegistry.test.ts | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/apps/server/src/provider/ProviderInstanceRegistry.test.ts b/apps/server/src/provider/ProviderInstanceRegistry.test.ts index ce6416332bae0..a6d388068fd08 100644 --- a/apps/server/src/provider/ProviderInstanceRegistry.test.ts +++ b/apps/server/src/provider/ProviderInstanceRegistry.test.ts @@ -790,6 +790,60 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), ); + it.live.skipIf(windowsHost)("keeps Claude reset credits when a later read is rate limited", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const fixtures = yield* makeTildeProviderFixtures(); + yield* fs.writeFileString( + path.join(fixtures.claudeHomePath, ".credentials.json"), + '{"claudeAiOauth":{"accessToken":"fake-token"}}', + ); + let rateLimited = false; + const client = HttpClient.make((request) => + Effect.succeed( + request.url.endsWith("/api/oauth/usage") + ? HttpClientResponse.fromWeb( + request, + rateLimited + ? Response.json({}, { status: 429, headers: { "retry-after": "60" } }) + : Response.json({ + cedar_ember: { + eligible: true, + next_grant_id: "grant_a", + grants: [{ id: "grant_a", resets_left: 1, usable_now: true }], + }, + }), + ) + : HttpClientResponse.fromWeb(request, Response.json({ version: "0.0.0" })), + ), + ); + const instanceId = ProviderInstanceId.make("claude_reset_429"); + const { registry } = yield* makeProviderInstanceRegistry({ + drivers: [ClaudeDriver], + configMap: { + [instanceId]: { + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + config: makeClaudeConfig({ + enabled: true, + binaryPath: fixtures.claudeBinaryPath, + homePath: fixtures.claudeHomePath, + }), + }, + }, + }).pipe(Effect.provideService(HttpClient.HttpClient, client)); + const instance = yield* registry.getInstance(instanceId); + const before = yield* instance!.snapshot.refresh; + expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); + + rateLimited = true; + const after = yield* instance!.snapshot.refresh; + expect(after.usageLimits?.windows.length).toBeGreaterThan(0); + expect(after.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); + }).pipe(Effect.provideService(HostProcess.Platform, "linux"), Effect.provide(layerTest)), + ); + const makeClaudeCacheFixture = Effect.fnUntraced(function* ( state: "ready" | "signed-out" | "usage-failed", ) { From 7c3bc7e76c9cb001eff7b70fd83d98a622ee565a Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Fri, 20 Nov 2026 20:27:34 +0000 Subject: [PATCH 2/3] fix(server): Claude reset credits survive a rate-limited read A 429 from the cedar_ember usage read published a snapshot without resetCredits, hiding the 'Use reset' button until the next 200. Each Claude instance now keeps the last credits it read for the same account through a 429 and skips further reads until Retry-After has passed. A redemption forgets the kept credits so a spent grant is never shown again. Fixes pingdotgg/t3code#39868 Co-Authored-By: Claude Opus 5.5 --- .../src/provider/Drivers/ClaudeDriver.ts | 14 ++-- .../src/provider/claudeResetCredits.test.ts | 57 +++++++++++++++- .../server/src/provider/claudeResetCredits.ts | 65 +++++++++++++++++-- 3 files changed, 122 insertions(+), 14 deletions(-) diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts index 5bedffe9242b4..432c60b2d5092 100644 --- a/apps/server/src/provider/Drivers/ClaudeDriver.ts +++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts @@ -210,6 +210,7 @@ export const ClaudeDriver: ProviderDriver(undefined); const capabilitiesProbeCache = yield* Cache.makeWith( () => @@ -282,11 +283,13 @@ export const ClaudeDriver: ProviderDriver - ClaudeResetCredits.readClaudeResetCredits(configDir, version).pipe( - Effect.provideService(HttpClient.HttpClient, httpClient), - Effect.provideService(FileSystem.FileSystem, fileSystem), - Effect.provideService(Path.Path, path), - ), + resetCreditsReader + .read({ configDir, accountConfigPath, version }) + .pipe( + Effect.provideService(HttpClient.HttpClient, httpClient), + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + ), ), ), Effect.tap((provider) => @@ -390,6 +393,7 @@ export const ClaudeDriver: ProviderDriver { Effect.provideService(HostProcess.Platform, "linux"), Effect.provideService(HttpClient.HttpClient, client), ); - expect(credits).toMatchObject({ availableCount: 1, nextCreditId: "grant_a" }); + expect(credits).toMatchObject({ + _tag: "read", + credits: { availableCount: 1, nextCreditId: "grant_a" }, + }); }), ); - it.effect("reads nothing from keychain logins or failed requests", () => + it.effect("reads nothing from keychain logins or failed requests, and reports rate limits", () => Effect.gen(function* () { const { configDir } = yield* writeLogin; const darwin = yield* ClaudeResetCredits.readClaudeResetCredits(configDir, "2.1.0").pipe( Effect.provideService(HostProcess.Platform, "darwin"), Effect.provideService(HttpClient.HttpClient, refuseRequests), ); + const failed = yield* ClaudeResetCredits.readClaudeResetCredits(configDir, "2.1.0").pipe( + Effect.provideService(HostProcess.Platform, "linux"), + Effect.provideService(HttpClient.HttpClient, respond(500, {})), + ); const limited = yield* ClaudeResetCredits.readClaudeResetCredits(configDir, "2.1.0").pipe( Effect.provideService(HostProcess.Platform, "linux"), Effect.provideService(HttpClient.HttpClient, respond(429, {})), ); - expect([darwin, limited]).toEqual([undefined, undefined]); + expect([darwin, failed, limited]).toEqual([ + { _tag: "read", credits: undefined }, + { _tag: "read", credits: undefined }, + { _tag: "rateLimited", retryAfterMillis: 0 }, + ]); + }), + ); + + it.effect("keeps the last credits through a rate limit and waits out Retry-After", () => + Effect.gen(function* () { + const login = yield* writeLogin; + let limited = false; + let requests = 0; + const client = HttpClient.make((request) => { + requests++; + return Effect.succeed( + HttpClientResponse.fromWeb( + request, + limited + ? Response.json({}, { status: 429, headers: { "retry-after": "60" } }) + : Response.json({ + cedar_ember: { eligible: true, next_grant_id: "grant_a", grants: [grant({})] }, + }), + ), + ); + }); + const reader = yield* ClaudeResetCredits.makeClaudeResetCreditsReader(); + const read = reader + .read({ ...login, version: "2.1.0" }) + .pipe( + Effect.provideService(HostProcess.Platform, "linux"), + Effect.provideService(HttpClient.HttpClient, client), + ); + expect((yield* read)?.nextCreditId).toBe("grant_a"); + limited = true; + expect((yield* read)?.nextCreditId).toBe("grant_a"); + yield* TestClock.adjust("59 seconds"); + expect((yield* read)?.nextCreditId).toBe("grant_a"); + expect(requests).toBe(2); + yield* TestClock.adjust("1 second"); + yield* read; + expect(requests).toBe(3); + yield* reader.forget; + expect(yield* read).toBeUndefined(); }), ); }); diff --git a/apps/server/src/provider/claudeResetCredits.ts b/apps/server/src/provider/claudeResetCredits.ts index d2000804cf4f6..9e253b437a4fa 100644 --- a/apps/server/src/provider/claudeResetCredits.ts +++ b/apps/server/src/provider/claudeResetCredits.ts @@ -4,11 +4,13 @@ import type { ServerProviderResetCredits, } from "@t3tools/contracts"; import * as HostProcess from "@t3tools/shared/HostProcess"; +import * as Clock from "effect/Clock"; import * as DateTime from "effect/DateTime"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; +import * as Ref from "effect/Ref"; import * as Schema from "effect/Schema"; import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"; @@ -207,28 +209,79 @@ const withClaudeHeaders = (token: string, version: string) => "user-agent": `claude-cli/${version} (external, cli)`, }); +// Retry-After is delay-seconds or an HTTP date (RFC 9110 §10.2.3). +const MAX_RETRY_AFTER_MILLIS = 60 * 60 * 1000; +const retryAfterMillis = (value: string | undefined, nowMs: number) => { + const trimmed = value?.trim() ?? ""; + const millis = /^\d+$/.test(trimmed) ? Number(trimmed) * 1000 : Date.parse(trimmed) - nowMs; + return Number.isFinite(millis) && millis > 0 ? Math.min(millis, MAX_RETRY_AFTER_MILLIS) : 0; +}; + +export type ClaudeResetCreditsRead = + | { readonly _tag: "read"; readonly credits: ServerProviderResetCredits | undefined } + | { readonly _tag: "rateLimited"; readonly retryAfterMillis: number }; + +const unread: ClaudeResetCreditsRead = { _tag: "read", credits: undefined }; + export const readClaudeResetCredits = Effect.fn("readClaudeResetCredits")( function* (configDir: string, version: string) { const token = yield* readAccessToken(configDir); - if (!token) return undefined; + if (!token) return unread; const client = yield* HttpClient.HttpClient; const response = yield* client.execute( HttpClientRequest.get(`${API_BASE}/api/oauth/usage`, { urlParams: { cedar_ember: "1", skip_spend: "1" }, }).pipe(withClaudeHeaders(token, version)), ); + const nowMs = yield* Clock.currentTimeMillis; + if (response.status === 429) { + return { + _tag: "rateLimited", + retryAfterMillis: retryAfterMillis(response.headers["retry-after"], nowMs), + } satisfies ClaudeResetCreditsRead; + } const body = yield* HttpClientResponse.schemaBodyJson(UsageResponse)( yield* HttpClientResponse.filterStatusOk(response), ); - return claudeResetCreditsToContract( - body.cedar_ember, - DateTime.toEpochMillis(yield* DateTime.now), - ); + return { + _tag: "read", + credits: claudeResetCreditsToContract(body.cedar_ember, nowMs), + } satisfies ClaudeResetCreditsRead; }, Effect.timeout("10 seconds"), - Effect.orElseSucceed(() => undefined), + Effect.orElseSucceed(() => unread), ); +/** Keeps an account's last credits through a rate limit and skips reads until Retry-After. */ +export const makeClaudeResetCreditsReader = Effect.fn("makeClaudeResetCreditsReader")(function* () { + const known = yield* Ref.make<{ + readonly account?: string | undefined; + readonly credits?: ServerProviderResetCredits | undefined; + readonly retryAtMs: number; + }>({ retryAtMs: 0 }); + const read = Effect.fn("ClaudeResetCreditsReader.read")(function* (input: { + readonly configDir: string; + readonly accountConfigPath: string; + readonly version: string; + }) { + const account = yield* readClaudeOrganizationId(input.accountConfigPath); + const state = yield* Ref.get(known); + const kept = state.account === account ? state.credits : undefined; + if ((yield* Clock.currentTimeMillis) < state.retryAtMs) return kept; + const result = yield* readClaudeResetCredits(input.configDir, input.version); + if (result._tag === "read") { + yield* Ref.set(known, { account, credits: result.credits, retryAtMs: 0 }); + return result.credits; + } + const retryAtMs = (yield* Clock.currentTimeMillis) + result.retryAfterMillis; + yield* Ref.set(known, { account, credits: kept, retryAtMs }); + return kept; + }); + /** A redeemed credit is gone; never show it again from memory. */ + const forget = Ref.update(known, ({ retryAtMs }) => ({ retryAtMs })); + return { read, forget }; +}); + export const readClaudeOauthAccount = (accountConfigPath: string) => readJson(Config, accountConfigPath).pipe( Effect.map((config) => config.oauthAccount), From 036292b169a5c8a4c232431969311c27cb4b738a Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Fri, 20 Nov 2026 20:34:09 +0000 Subject: [PATCH 3/3] fix(server): a Claude reset-credit cooldown applies only to its own organization The Retry-After cooldown from one organization's 429 blocked the first read after signing the same instance into another organization. The cooldown is now honored only while the organization is unchanged, and forgetting redeemed credits keeps the organization so its cooldown still holds. Co-Authored-By: Claude Opus 5.5 --- apps/server/src/provider/claudeResetCredits.test.ts | 11 +++++++++++ apps/server/src/provider/claudeResetCredits.ts | 7 ++++--- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/apps/server/src/provider/claudeResetCredits.test.ts b/apps/server/src/provider/claudeResetCredits.test.ts index e962ee8856190..bce5c59a3eb90 100644 --- a/apps/server/src/provider/claudeResetCredits.test.ts +++ b/apps/server/src/provider/claudeResetCredits.test.ts @@ -220,6 +220,17 @@ effectIt.layer(NodeServices.layer)("readClaudeResetCredits", (it) => { expect(requests).toBe(3); yield* reader.forget; expect(yield* read).toBeUndefined(); + + // Another organization is not held to the previous one's Retry-After. + expect(requests).toBe(3); + const fs = yield* FileSystem.FileSystem; + yield* fs.writeFileString( + login.accountConfigPath, + '{"oauthAccount":{"organizationUuid":"org-2"}}', + ); + limited = false; + expect((yield* read)?.nextCreditId).toBe("grant_a"); + expect(requests).toBe(4); }), ); }); diff --git a/apps/server/src/provider/claudeResetCredits.ts b/apps/server/src/provider/claudeResetCredits.ts index 9e253b437a4fa..b2caaeee2eab8 100644 --- a/apps/server/src/provider/claudeResetCredits.ts +++ b/apps/server/src/provider/claudeResetCredits.ts @@ -266,8 +266,9 @@ export const makeClaudeResetCreditsReader = Effect.fn("makeClaudeResetCreditsRea }) { const account = yield* readClaudeOrganizationId(input.accountConfigPath); const state = yield* Ref.get(known); - const kept = state.account === account ? state.credits : undefined; - if ((yield* Clock.currentTimeMillis) < state.retryAtMs) return kept; + const sameAccount = state.account === account; + const kept = sameAccount ? state.credits : undefined; + if (sameAccount && (yield* Clock.currentTimeMillis) < state.retryAtMs) return kept; const result = yield* readClaudeResetCredits(input.configDir, input.version); if (result._tag === "read") { yield* Ref.set(known, { account, credits: result.credits, retryAtMs: 0 }); @@ -278,7 +279,7 @@ export const makeClaudeResetCreditsReader = Effect.fn("makeClaudeResetCreditsRea return kept; }); /** A redeemed credit is gone; never show it again from memory. */ - const forget = Ref.update(known, ({ retryAtMs }) => ({ retryAtMs })); + const forget = Ref.update(known, ({ account, retryAtMs }) => ({ account, retryAtMs })); return { read, forget }; });