From a662142616ab0aa4bfb5c18a79ee511f6c1caa8b Mon Sep 17 00:00:00 2001 From: Renfei Zhou Date: Sat, 31 Oct 2026 13:59:39 +0000 Subject: [PATCH 1/2] feat(server): Claude reset credits for hub accounts Hub (CLIProxyAPI-compatible, e.g. t3switch) Claude accounts showed usage but never their reset credits, and could not redeem one, while native Claude logins and Codex hub accounts could. The hub Claude usage read now asks for the cedar_ember block and maps it with claudeResetCreditsToContract. Redemption posts the claim through the hub's api-call to the account's own organization (organization_uuid from auth-files), with a request id derived from account and grant so retries deduplicate, then clears the hub cooldown as for Codex. The native and hub paths share claim validation and answer mapping, so 429, 401/403, cooldown and unavailable read the same on both. The hub's Claude user agent is now the CLI's, which Anthropic requires for reset eligibility. Co-Authored-By: Claude Opus 5.5 --- .../server/src/provider/claudeResetCredits.ts | 75 ++++++---- apps/server/src/usage/cliproxyApi.test.ts | 100 ++++++++++++- apps/server/src/usage/cliproxyApi.ts | 135 +++++++++++++----- 3 files changed, 244 insertions(+), 66 deletions(-) diff --git a/apps/server/src/provider/claudeResetCredits.ts b/apps/server/src/provider/claudeResetCredits.ts index 35973378edada..1e23af87521ec 100644 --- a/apps/server/src/provider/claudeResetCredits.ts +++ b/apps/server/src/provider/claudeResetCredits.ts @@ -52,6 +52,7 @@ const ClaimResponse = Schema.Struct({ "unavailable", ]), }); +const decodeClaimResponse = Schema.decodeUnknownEffect(ClaimResponse); const RESET_CREDIT_FAILURES = { malformedCredit: "Claude returned a malformed reset credit.", @@ -195,6 +196,38 @@ const CLAIM_OUTCOMES = { } as const satisfies Record; /** requestId is the claim's idempotency key. */ +export const claudeClaimBody = (grantId: string, requestId: string) => + GRANT_ID.test(grantId) && REQUEST_ID.test(requestId) + ? Effect.succeed({ program: PROGRAM, grant_id: grantId, request_id: requestId }) + : Effect.fail(new ClaudeResetCreditError({ reason: "malformedCredit" })); + +/** body is the decoded JSON of a 2xx answer. */ +export const claudeClaimOutcome = Effect.fn("claudeClaimOutcome")(function* ( + status: number, + body: unknown, +) { + if (status === 429) { + return yield* new ClaudeResetCreditError({ reason: "rateLimited" }); + } + if (status === 401 || status === 403) { + return yield* new ClaudeResetCreditError({ reason: "signedOut" }); + } + if (status < 200 || status >= 300) { + return yield* new ClaudeResetCreditError({ reason: "requestFailed" }); + } + const claim = yield* decodeClaimResponse(body).pipe( + Effect.mapError((cause) => new ClaudeResetCreditError({ reason: "requestFailed", cause })), + ); + if (claim.result === "cooldown") { + return yield* new ClaudeResetCreditError({ reason: "coolingDown" }); + } + // Unknown outcomes retain the request ID so retries address the same claim. + if (claim.result === "unavailable") { + return yield* new ClaudeResetCreditError({ reason: "unconfirmed" }); + } + return CLAIM_OUTCOMES[claim.result]; +}); + export const consumeClaudeResetCredit = Effect.fn("consumeClaudeResetCredit")(function* (input: { readonly configDir: string; readonly accountConfigPath: string; @@ -202,9 +235,7 @@ export const consumeClaudeResetCredit = Effect.fn("consumeClaudeResetCredit")(fu readonly grantId: string; readonly requestId: string; }) { - if (!GRANT_ID.test(input.grantId) || !REQUEST_ID.test(input.requestId)) { - return yield* new ClaudeResetCreditError({ reason: "malformedCredit" }); - } + const claim = yield* claudeClaimBody(input.grantId, input.requestId); const token = yield* readAccessToken(input.configDir).pipe( Effect.mapError((cause) => new ClaudeResetCreditError({ reason: "loginUnreadable", cause })), ); @@ -223,36 +254,20 @@ export const consumeClaudeResetCredit = Effect.fn("consumeClaudeResetCredit")(fu `/api/organizations/${encodeURIComponent(organization)}/reset_rate_limits`, API_BASE, ), - ).pipe( - withClaudeHeaders(token, input.version), - HttpClientRequest.bodyJsonUnsafe({ - program: PROGRAM, - grant_id: input.grantId, - request_id: input.requestId, - }), - ), + ).pipe(withClaudeHeaders(token, input.version), HttpClientRequest.bodyJsonUnsafe(claim)), ) .pipe( Effect.timeout("25 seconds"), Effect.mapError((cause) => new ClaudeResetCreditError({ reason: "requestFailed", cause })), ); - if (response.status === 429) { - return yield* new ClaudeResetCreditError({ reason: "rateLimited" }); - } - if (response.status === 401 || response.status === 403) { - return yield* new ClaudeResetCreditError({ reason: "signedOut" }); - } - const body = yield* HttpClientResponse.filterStatusOk(response).pipe( - Effect.flatMap(HttpClientResponse.schemaBodyJson(ClaimResponse)), - Effect.timeout("25 seconds"), - Effect.mapError((cause) => new ClaudeResetCreditError({ reason: "requestFailed", cause })), - ); - if (body.result === "cooldown") { - return yield* new ClaudeResetCreditError({ reason: "coolingDown" }); - } - // Unknown outcomes retain the request ID so retries address the same claim. - if (body.result === "unavailable") { - return yield* new ClaudeResetCreditError({ reason: "unconfirmed" }); - } - return CLAIM_OUTCOMES[body.result]; + const body = + response.status >= 200 && response.status < 300 + ? yield* response.json.pipe( + Effect.timeout("25 seconds"), + Effect.mapError( + (cause) => new ClaudeResetCreditError({ reason: "requestFailed", cause }), + ), + ) + : undefined; + return yield* claudeClaimOutcome(response.status, body); }); diff --git a/apps/server/src/usage/cliproxyApi.test.ts b/apps/server/src/usage/cliproxyApi.test.ts index 0119adfd940f3..593136169896f 100644 --- a/apps/server/src/usage/cliproxyApi.test.ts +++ b/apps/server/src/usage/cliproxyApi.test.ts @@ -51,6 +51,7 @@ function fixture( accounts?: Array< (typeof accounts)[number] & { disabled?: boolean; + organization_uuid?: string; id_token: { chatgpt_account_id: string; plan_type?: string; chatgpt_plan_type?: string }; } >; @@ -312,14 +313,30 @@ describe("CLIProxyAPI built-in management API", () => { }), ); - it.effect("maps Claude scoped windows without a scheduler plugin", () => + it.effect("maps Claude scoped windows and reset credits without a scheduler plugin", () => Effect.gen(function* () { + yield* TestClock.setTime(Date.parse("2026-10-31T12:00:00Z")); const test = fixture({ accounts: [{ ...accounts[0]!, provider: "claude" }], - // The usage endpoint answers 429 to requests without a Claude Code user agent. + // Usage answers 429, and reset credits ineligible, without a Claude Code user agent. upstream: (request) => ({ - status: request.header?.["User-Agent"]?.startsWith("claude-code/") ? 200 : 429, + status: /^claude-cli\/\S+ \(external, cli\)$/.test(request.header?.["User-Agent"] ?? "") + ? 200 + : 429, body: { + cedar_ember: { + eligible: true, + next_grant_id: "grant_a", + grants: [ + { + id: "grant_a", + resets_left: 1, + usable_now: true, + ends_at: "2099-01-01T00:00:00Z", + }, + { id: "grant_b", resets_left: 2, usable_now: true }, + ], + }, five_hour: { utilization: 10, resets_at: null }, seven_day: { utilization: 50, resets_at: "2099-01-01T00:00:00Z" }, limits: [ @@ -342,6 +359,83 @@ describe("CLIProxyAPI built-in management API", () => { ["seven_day", 50], ["seven_day_fable", 80], ]); + expect(result[0]?.usageLimits.resetCredits).toEqual({ + availableCount: 3, + nextCreditId: "grant_a", + nextExpiresAt: "2099-01-01T00:00:00.000Z", + }); + expect(test.requests.find((request) => request.body?.url)?.body?.url).toBe( + "https://api.anthropic.com/api/oauth/usage?cedar_ember=1&skip_spend=1", + ); + }), + ); + + it.effect("redeems a Claude reset for the account's own organization", () => + Effect.gen(function* () { + const claude = { ...accounts[0]!, provider: "claude", organization_uuid: "org-1" }; + const answer = (status: number, body: unknown) => + fixture({ accounts: [claude], upstream: () => ({ status, body }) }); + for (const [status, body, outcome, clearsCooldown] of [ + [200, { result: "reset" }, "reset", true], + [200, { result: "already_used" }, "alreadyRedeemed", true], + [200, { result: "not_limited" }, "nothingToReset", false], + [200, { result: "ineligible" }, "noCredit", false], + ] as const) { + const test = answer(status, body); + expect(yield* (yield* test.api).consume(config, "first.json", "grant_a")).toEqual({ + outcome, + }); + const redemption = test.requests.find((request) => request.body?.url); + expect(redemption?.body?.url).toBe( + "https://api.anthropic.com/api/organizations/org-1/reset_rate_limits", + ); + expect(redemption?.body?.method).toBe("POST"); + expect(redemption?.body?.data).toBe( + encodeJson({ + program: "cedar_ember", + grant_id: "grant_a", + request_id: "2493d13b-1b9d-5e0f-96a6-a8113a4dd7f4", + }), + ); + expect(test.requests.some((request) => request.path.endsWith("/reset-quota"))).toBe( + clearsCooldown, + ); + } + for (const [status, body, detail] of [ + [200, { result: "cooldown" }, "Claude resets are cooling down. Try again later."], + [ + 200, + { result: "unavailable" }, + "Claude could not confirm the reset. If you are still limited in a moment, try again.", + ], + [429, {}, "Claude is rate limiting resets. Try again soon."], + [403, { error: "organization mismatch" }, "Sign in to Claude again to redeem resets."], + [502, {}, "Claude could not redeem the reset."], + ] as const) { + const test = answer(status, body); + const error = yield* Effect.flip( + (yield* test.api).consume(config, "first.json", "grant_a"), + ); + expect(error.detail).toBe(detail); + expect(test.requests.some((request) => request.path.endsWith("/reset-quota"))).toBe(false); + } + }), + ); + + it.effect("refuses a Claude redemption without an organization or with a malformed grant", () => + Effect.gen(function* () { + for (const [account, grantId] of [ + [{ ...accounts[0]!, provider: "claude" }, "grant_a"], + [{ ...accounts[0]!, provider: "claude", organization_uuid: " " }, "grant_a"], + [{ ...accounts[0]!, provider: "claude", organization_uuid: "org-1" }, "Bad Grant"], + ] as const) { + const test = fixture({ accounts: [account] }); + const result = yield* (yield* test.api) + .consume(config, "first.json", grantId) + .pipe(Effect.result); + expect(result._tag).toBe("Failure"); + expect(test.requests.every((request) => request.path.endsWith("/auth-files"))).toBe(true); + } }), ); diff --git a/apps/server/src/usage/cliproxyApi.ts b/apps/server/src/usage/cliproxyApi.ts index 91504d8002295..d90978606fc08 100644 --- a/apps/server/src/usage/cliproxyApi.ts +++ b/apps/server/src/usage/cliproxyApi.ts @@ -1,6 +1,7 @@ import { ProviderDriverKind, UsageLimitSourceError, + type ProviderConsumeResetCreditOutcome, type ProviderConsumeResetCreditResult, type UsageLimitSourceAccount, type UsageLimitSourceConfig, @@ -10,12 +11,18 @@ import * as Crypto from "effect/Crypto"; import * as DateTime from "effect/DateTime"; import * as Effect from "effect/Effect"; import * as Hex from "effect/encoding/Hex"; +import * as Option from "effect/Option"; import * as Schema from "effect/Schema"; import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http"; import { codexPlanLabel } from "../provider/CodexProvider.ts"; import { codexRateLimitsToLimits } from "../provider/codexUsageLimits.ts"; import { claudeUsageResponseToLimits } from "../provider/claudeUsageLimits.ts"; +import { + claudeClaimBody, + claudeClaimOutcome, + claudeResetCreditsToContract, +} from "../provider/claudeResetCredits.ts"; import { makeUnavailableUsageLimits } from "@t3tools/provider-core/server/usageLimits"; const AuthFile = Schema.Struct({ @@ -24,6 +31,7 @@ const AuthFile = Schema.Struct({ provider: Schema.String, email: Schema.optional(Schema.String), disabled: Schema.optional(Schema.Boolean), + organization_uuid: Schema.optional(Schema.String), id_token: Schema.optional( Schema.Struct({ chatgpt_account_id: Schema.optional(Schema.String), @@ -53,6 +61,7 @@ const ClaudeWindow = Schema.Struct({ resets_at: Schema.NullOr(Schema.String), }); const ClaudeUsage = Schema.Struct({ + cedar_ember: Schema.optional(Schema.NullOr(Schema.Unknown)), five_hour: Schema.optional(Schema.NullOr(ClaudeWindow)), seven_day: Schema.optional(Schema.NullOr(ClaudeWindow)), limits: Schema.optional( @@ -86,6 +95,7 @@ const CreditList = Schema.Struct({ const decodeAuthFiles = Schema.decodeUnknownEffect(AuthFiles); const encodeJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown)); const decodeApiResponse = Schema.decodeUnknownEffect(ApiResponse); +const decodeJsonOption = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown)); const decodeCreditList = Schema.decodeUnknownEffect(Schema.fromJsonString(CreditList)); const decodeClaudeUsage = Schema.decodeUnknownEffect(Schema.fromJsonString(ClaudeUsage)); const decodeCodexUsage = Schema.decodeUnknownEffect(Schema.fromJsonString(CodexUsage)); @@ -133,8 +143,16 @@ const decodeConsumeResponse = Schema.decodeUnknownEffect( ), ); +const CODEX_CLAIM_OUTCOMES = { + reset: "reset", + nothing_to_reset: "nothingToReset", + no_credit: "noCredit", + already_redeemed: "alreadyRedeemed", +} as const satisfies Record; + const CODEX_BASE = "https://chatgpt.com/backend-api/wham"; const CREDIT_URL = `${CODEX_BASE}/rate-limit-reset-credits`; +const CLAUDE_BASE = "https://api.anthropic.com/api"; const CREDIT_REDEEM_NAMESPACE = new Uint8Array([ 0x6f, 0x1c, 0x2a, 0x9e, 0x2d, 0x4b, 0x4c, 0x1e, 0x9a, 0x7f, 0x3b, 0x8d, 0x5e, 0x0c, 0x1a, 0x42, @@ -195,7 +213,7 @@ export const makeCliproxyApi = Effect.gen(function* () { return (yield* decodeAuthFiles(response)).files; }); - const apiCall = Effect.fn("CliproxyApi.apiCall")(function* ( + const apiResponse = Effect.fn("CliproxyApi.apiResponse")(function* ( config: UsageLimitSourceConfig, account: typeof AuthFile.Type, url: string, @@ -215,8 +233,8 @@ export const makeCliproxyApi = Effect.gen(function* () { : { Authorization: "Bearer $TOKEN$", "anthropic-beta": "oauth-2025-04-20", - // The OAuth usage endpoint can return 429 without a Claude Code user agent. - "User-Agent": "claude-code/2.1.273", + // Usage answers 429, and reset credits ineligible, without a Claude Code user agent. + "User-Agent": "claude-cli/2.1.273 (external, cli)", }; const raw = yield* management(config, "api-call", { auth_index: account.auth_index, @@ -225,7 +243,13 @@ export const makeCliproxyApi = Effect.gen(function* () { header, ...(data === undefined ? {} : { data: yield* encodeJson(data) }), }); - const response = yield* decodeApiResponse(raw); + return yield* decodeApiResponse(raw); + }); + + const apiCall = Effect.fn("CliproxyApi.apiCall")(function* ( + ...args: Parameters + ) { + const response = yield* apiResponse(...args); if (response.status_code < 200 || response.status_code >= 300) { return yield* new UsageLimitSourceError({ detail: `The provider refused the hub request (HTTP ${response.status_code}).`, @@ -266,8 +290,16 @@ export const makeCliproxyApi = Effect.gen(function* () { }; const read = Effect.gen(function* () { if (account.provider === "claude") { - const body = yield* apiCall(config, account, "https://api.anthropic.com/api/oauth/usage"); + const body = yield* apiCall( + config, + account, + `${CLAUDE_BASE}/oauth/usage?cedar_ember=1&skip_spend=1`, + ); const usage = yield* decodeClaudeUsage(body); + const resetCredits = claudeResetCreditsToContract( + usage.cedar_ember, + DateTime.toEpochMillis(yield* DateTime.now), + ); const model_scoped = (usage.limits ?? []).flatMap((limit) => limit.kind === "weekly_scoped" && limit.scope?.model && typeof limit.percent === "number" ? [ @@ -282,17 +314,20 @@ export const makeCliproxyApi = Effect.gen(function* () { return { ...base, plan: "Claude Subscription", - usageLimits: claudeUsageResponseToLimits({ - checkedAt, - response: { - rate_limits_available: true, - rate_limits: { - five_hour: usage.five_hour ?? null, - seven_day: usage.seven_day ?? null, - model_scoped, + usageLimits: { + ...claudeUsageResponseToLimits({ + checkedAt, + response: { + rate_limits_available: true, + rate_limits: { + five_hour: usage.five_hour ?? null, + seven_day: usage.seven_day ?? null, + model_scoped, + }, }, - }, - }).limits, + }).limits, + ...(resetCredits ? { resetCredits } : {}), + }, }; } const body = yield* apiCall(config, account, `${CODEX_BASE}/usage`); @@ -371,6 +406,37 @@ export const makeCliproxyApi = Effect.gen(function* () { ); }); + const consumeClaude = Effect.fn("CliproxyApi.consumeClaude")( + function* ( + config: UsageLimitSourceConfig, + account: typeof AuthFile.Type, + grantId: string, + requestId: string, + ) { + const claim = yield* claudeClaimBody(grantId, requestId); + const organization = account.organization_uuid?.trim(); + if (!organization) { + return yield* new UsageLimitSourceError({ + detail: "The hub does not know this Claude account's organization.", + }); + } + const response = yield* apiResponse( + config, + account, + `${CLAUDE_BASE}/organizations/${encodeURIComponent(organization)}/reset_rate_limits`, + claim, + ); + return yield* claudeClaimOutcome( + response.status_code, + Option.getOrUndefined(decodeJsonOption(response.body)), + ); + }, + Effect.catchTags({ + ClaudeResetCreditError: (error) => + Effect.fail(new UsageLimitSourceError({ detail: error.message })), + }), + ); + const consume = Effect.fn("CliproxyApi.consume")(function* ( config: UsageLimitSourceConfig, accountId: string, @@ -378,27 +444,30 @@ export const makeCliproxyApi = Effect.gen(function* () { ): Effect.fn.Return { const operation = Effect.gen(function* () { const account = (yield* authFiles(config)).find((account) => account.id === accountId); - if (!account || account.disabled || account.provider !== "codex") { + if ( + !account || + account.disabled || + (account.provider !== "codex" && account.provider !== "claude") + ) { return yield* new UsageLimitSourceError({ - detail: "The Codex hub account is missing or disabled.", + detail: "The hub account is missing or disabled.", }); } - const body = yield* apiCall(config, account, `${CREDIT_URL}/consume`, { - redeem_request_id: yield* creditRedeemRequestId( - account.id_token?.chatgpt_account_id ?? account.id, - creditId, - ).pipe(Effect.provideService(Crypto.Crypto, crypto)), - credit_id: creditId, - }); - const response = yield* decodeConsumeResponse(body); - const outcome = ( - { - reset: "reset", - nothing_to_reset: "nothingToReset", - no_credit: "noCredit", - already_redeemed: "alreadyRedeemed", - } as const - )[response.code]; + const requestId = yield* creditRedeemRequestId( + account.id_token?.chatgpt_account_id ?? account.id, + creditId, + ).pipe(Effect.provideService(Crypto.Crypto, crypto)); + const outcome = + account.provider === "claude" + ? yield* consumeClaude(config, account, creditId, requestId) + : CODEX_CLAIM_OUTCOMES[ + (yield* decodeConsumeResponse( + yield* apiCall(config, account, `${CREDIT_URL}/consume`, { + redeem_request_id: requestId, + credit_id: creditId, + }), + )).code + ]; if (outcome !== "reset" && outcome !== "alreadyRedeemed") return { outcome }; const cleared = yield* management(config, "reset-quota", { auth_index: account.auth_index, From a4fe68a1ca70cea5827881a6a613c6ea9ed260e6 Mon Sep 17 00:00:00 2001 From: Renfei Zhou Date: Sat, 31 Oct 2026 18:43:04 +0000 Subject: [PATCH 2/2] feat(server): route Claude usage and reset credits through t3switch Re-applies PR #34 (Claude reset credits for hub accounts) without its hard-coded user agent; t3switch sets the headers Anthropic sees. Directly signed-in Claude logins now read plan usage and reset credits from the t3switch account with the same email and organization, and redeem through it too, so T3 sends none of these requests to Anthropic itself. The CLI probe no longer asks Claude for usage. A login no t3switch source holds shows usage as unavailable and cannot redeem. Co-Authored-By: Claude Opus 5.5 --- .../src/provider/Drivers/ClaudeDriver.ts | 100 +++++++--- .../provider/ProviderInstanceRegistry.test.ts | 169 +++++++++++------ .../src/provider/claudeResetCredits.test.ts | 157 +++------------ .../server/src/provider/claudeResetCredits.ts | 92 --------- .../ProviderInstanceRegistryLive.fixture.mjs | 50 ----- apps/server/src/usage/cliproxyApi.test.ts | 71 ++++++- apps/server/src/usage/cliproxyApi.ts | 179 +++++++++++------- 7 files changed, 385 insertions(+), 433 deletions(-) diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts index e1fbcd30080fd..9fa34275161d0 100644 --- a/apps/server/src/provider/Drivers/ClaudeDriver.ts +++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts @@ -1,10 +1,12 @@ -import { ClaudeSettings, ProviderDriverKind } from "@t3tools/contracts"; +import { ClaudeSettings, ProviderDriverKind, UsageLimitSourceError } from "@t3tools/contracts"; import * as Cache from "effect/Cache"; +import * as DateTime from "effect/DateTime"; import * as Duration from "effect/Duration"; import * as Crypto from "effect/Crypto"; import * as Effect from "effect/Effect"; import * as Exit from "effect/Exit"; 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"; @@ -15,6 +17,8 @@ import { makeClaudeTextGeneration } from "../../textGeneration/ClaudeTextGenerat import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions"; import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost"; import * as ServerConfig from "../../config.ts"; +import * as Settings from "../../serverSettings.ts"; +import { makeCliproxyApi } from "../../usage/cliproxyApi.ts"; import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion"; import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers"; import { @@ -130,6 +134,16 @@ export const ClaudeDriver: ProviderDriver Effect.succeed([]), + onSome: (service) => + service.getSettings.pipe( + Effect.map((settings) => Object.values(settings.usageLimitSources)), + Effect.orElseSucceed(() => []), + ), + }); const catalogService = yield* ModelCatalog.ModelCatalog; const modelCatalog = catalogService .current(DRIVER_KIND) @@ -197,22 +211,55 @@ export const ClaudeDriver: ProviderDriver ({ capabilities, resetCredits: undefined }), + onSome: ({ response, resetCredits }) => ({ + capabilities: { ...capabilities, usage: response, usageCheckedAt }, + resetCredits, + }), + }); + }); + // Per-instance capabilities cache: keyed on binary + resolved HOME so // account-specific probes never share auth metadata across instances. // A transient miss may reuse the last account once, but its usage windows keep their age. const lastGoodCapabilities = yield* Ref.make(undefined); const capabilitiesProbeCache = yield* Cache.makeWith( () => - probeClaudeCapabilities(effectiveConfig, processEnv, stateDir).pipe( + probeClaudeCapabilities(effectiveConfig, processEnv, stateDir, false).pipe( Effect.flatMap((capabilities) => ClaudeResetCredits.readClaudeOrganizationId(accountConfigPath).pipe( - Effect.map((workspaceId) => ({ - _tag: "fresh" as const, - capabilities: - workspaceId === undefined ? capabilities : { ...capabilities, workspaceId }, - })), + Effect.map((workspaceId) => + workspaceId === undefined ? capabilities : { ...capabilities, workspaceId }, + ), ), ), + Effect.flatMap(withHubUsage), + Effect.map((entry) => ({ _tag: "fresh" as const, ...entry })), Effect.tap(({ capabilities }) => Ref.set(lastGoodCapabilities, capabilities)), Effect.catch((error) => Ref.getAndSet(lastGoodCapabilities, undefined).pipe( @@ -225,6 +272,7 @@ export const ClaudeDriver: ProviderDriver - ClaudeResetCredits.readClaudeResetCredits(configDir, version).pipe( - Effect.provideService(HttpClient.HttpClient, httpClient), - Effect.provideService(FileSystem.FileSystem, fileSystem), - Effect.provideService(Path.Path, path), + () => + Cache.get(capabilitiesProbeCache, capabilitiesCacheKey).pipe( + Effect.map((entry) => entry.resetCredits), + Effect.orElseSucceed(() => undefined), ), ), ), @@ -325,38 +372,37 @@ export const ClaudeDriver: ProviderDriver = Effect.fn( "ClaudeDriver.consumeResetCredit", )( function* () { const current = yield* snapshot.getSnapshot; const grantId = current.usageLimits?.resetCredits?.nextCreditId; - if (!grantId || !current.version) return "noCredit" as const; - const version = current.version; + const email = current.auth.email; + if (!grantId || !email) return "noCredit" as const; + const login = yield* hub.findClaudeLogin(yield* hubSources, { + email, + organizationId: current.auth.workspaceId, + }); + if (!login) { + return yield* new UsageLimitSourceError({ + detail: "No usage limit source holds this Claude login.", + }); + } return yield* resetCreditCoordinator.redeem( configDir, - (requestId) => - ClaudeResetCredits.consumeClaudeResetCredit({ - configDir, - accountConfigPath, - version, - grantId, - requestId, - }), + (requestId) => hub.claimClaudeLogin(login.config, login.account, grantId, requestId), ClaudeResetCredits.isSettledClaudeResetCreditFailure, ); }, - Effect.provideService(HttpClient.HttpClient, httpClient), - Effect.provideService(FileSystem.FileSystem, fileSystem), - Effect.provideService(Path.Path, path), Effect.mapError( (cause) => new ProviderDriverError({ driver: DRIVER_KIND, instanceId, detail: - cause._tag === "ClaudeResetCreditError" + cause._tag === "ClaudeResetCreditError" || cause._tag === "UsageLimitSourceError" ? cause.message : "Claude could not redeem the reset.", cause, diff --git a/apps/server/src/provider/ProviderInstanceRegistry.test.ts b/apps/server/src/provider/ProviderInstanceRegistry.test.ts index af3359ea7f27d..86adf9eb27336 100644 --- a/apps/server/src/provider/ProviderInstanceRegistry.test.ts +++ b/apps/server/src/provider/ProviderInstanceRegistry.test.ts @@ -17,6 +17,7 @@ import { SecretProviderId, SettingsSecretValue, type SecretReference, + UsageLimitSourceId, } from "@t3tools/contracts"; import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions"; import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions"; @@ -60,6 +61,62 @@ const layerTestHttpClient = Layer.succeed( ), ); +const decodeHubCall = Schema.decodeUnknownSync( + Schema.fromJsonString(Schema.Struct({ url: Schema.optional(Schema.String) })), +); + +// A t3switch hub holding the mock CLI's login. Claude usage and claims only go through it. +const claudeHub = (options: { + readonly accounts?: ReadonlyArray<{ readonly email: string; readonly organization_uuid: string }>; + readonly usage: Effect.Effect<{ readonly status: number; readonly body: unknown }>; + readonly claim?: Effect.Effect; +}) => + HttpClient.make((request) => + Effect.gen(function* () { + const json = (body: unknown) => HttpClientResponse.fromWeb(request, Response.json(body)); + const path = new URL(request.url).pathname; + if (path.endsWith("/auth-files")) { + const accounts = options.accounts ?? [ + { email: "test@example.com", organization_uuid: "fake-org" }, + ]; + return json({ + files: accounts.map((account, index) => ({ + id: `${index}.json`, + auth_index: `${index}`, + provider: "claude", + ...account, + })), + }); + } + if (path.endsWith("/reset-quota")) return json({}); + if (!path.endsWith("/api-call")) return json({ version: "0.0.0" }); + const call = decodeHubCall( + request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : "", + ); + const upstream = call.url?.endsWith("/reset_rate_limits") + ? { status: 200, body: yield* options.claim ?? Effect.die("unexpected claim") } + : yield* options.usage; + return json({ status_code: upstream.status, body: JSON.stringify(upstream.body) }); + }), + ); + +const withClaudeHub = (hub: HttpClient.HttpClient) => + Effect.provide( + Layer.mergeAll( + Layer.succeed(HttpClient.HttpClient, hub), + ServerSettings.layerTest({ + usageLimitSources: { + [UsageLimitSourceId.make("hub")]: { + kind: "cliproxy", + url: "http://hub.test", + managementKey: "hub-key", + enabled: true, + }, + }, + }), + ), + ); + // The mock CLIs from makeTildeProviderFixtures are scripts Windows cannot execute. const windowsHost = HostProcess.Platform.defaultValue() === "win32"; @@ -486,13 +543,7 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }, }); }, - usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET: async () => ({ - rate_limits_available: true, - rate_limits: { - five_hour: { utilization: 12, resets_at: "2026-07-18T14:39:00Z" }, - }, - }), - }) as ReturnType, + }) as unknown as ReturnType, ); yield* Effect.addFinalizer(() => Effect.sync(() => query.mockRestore())); @@ -509,7 +560,20 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), }, }, - }); + }).pipe( + withClaudeHub( + claudeHub({ + accounts: [ + { email: "account-a@example.com", organization_uuid: "org-a" }, + { email: "account-b@example.com", organization_uuid: "org-b" }, + ], + usage: Effect.succeed({ + status: 200, + body: { five_hour: { utilization: 12, resets_at: "2026-07-18T14:39:00Z" } }, + }), + }), + ), + ); const claude = yield* registry.getInstance(claudeId); expect(claude).toBeDefined(); @@ -587,36 +651,32 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; const fixtures = yield* makeTildeProviderFixtures(); - const marker = path.join(fixtures.claudeHomePath, "redeemed"); - yield* fs.writeFileString( - path.join(fixtures.claudeHomePath, ".credentials.json"), - '{"claudeAiOauth":{"accessToken":"fake-token"}}', - ); + let redeemed = false; yield* fs.writeFileString( path.join(fixtures.claudeHomePath, ".claude.json"), '{"oauthAccount":{"organizationUuid":"fake-org"}}', ); - const client = HttpClient.make((request) => - Effect.gen(function* () { - if (request.url.endsWith("/api/oauth/usage")) { - return HttpClientResponse.fromWeb( - request, - Response.json({ - cedar_ember: { - eligible: true, - next_grant_id: "grant_a", - grants: [{ id: "grant_a", resets_left: 1, usable_now: true }], + const hub = claudeHub({ + usage: Effect.sync(() => + redeemed && claim.usageFailsAfterClaim + ? { status: 503, body: {} } + : { + status: 200, + body: { + five_hour: { utilization: redeemed ? 0 : 100, resets_at: null }, + cedar_ember: { + eligible: true, + next_grant_id: "grant_a", + grants: [{ id: "grant_a", resets_left: 1, usable_now: true }], + }, }, - }), - ); - } - if (request.url.endsWith("/reset_rate_limits")) { - yield* fs.writeFileString(marker, "redeemed").pipe(Effect.orDie); - return HttpClientResponse.fromWeb(request, Response.json({ result: claim.result })); - } - return HttpClientResponse.fromWeb(request, Response.json({ version: "0.0.0" })); + }, + ), + claim: Effect.sync(() => { + redeemed = true; + return { result: claim.result }; }), - ); + }); const instanceId = ProviderInstanceId.make("claude_reset"); const { registry } = yield* makeProviderInstanceRegistry({ drivers: [ClaudeDriver], @@ -624,12 +684,6 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { [instanceId]: { driver: ProviderDriverKind.make("claudeAgent"), enabled: true, - environment: [ - { name: "T3_CLAUDE_RESET_MARKER", value: marker, sensitive: false }, - ...(claim.usageFailsAfterClaim - ? [{ name: "T3_CLAUDE_USAGE_FAILS_AFTER_CLAIM", value: "1", sensitive: false }] - : []), - ], config: makeClaudeConfig({ enabled: true, binaryPath: fixtures.claudeBinaryPath, @@ -637,7 +691,7 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), }, }, - }).pipe(Effect.provideService(HttpClient.HttpClient, client)); + }).pipe(withClaudeHub(hub)); const instance = yield* registry.getInstance(instanceId); expect(instance).toBeDefined(); const before = yield* instance!.snapshot.refresh; @@ -645,11 +699,7 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); const outcome = yield* instance!.consumeResetCredit!().pipe(Effect.result); return { outcome, after: yield* instance!.snapshot.getSnapshot }; - }).pipe( - // macOS logins live in the Keychain, where resets are never read. - Effect.provideService(HostProcess.Platform, "linux"), - Effect.provide(layerTest), - ); + }).pipe(Effect.provide(layerTest)); it.live.skipIf(windowsHost)("refreshes Claude usage after redeeming a reset", () => Effect.gen(function* () { @@ -691,18 +741,9 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { enabled: true, environment: [ { name: "T3_CLAUDE_PROBE_LOG", value: probeLog, sensitive: false }, - ...(state === "ready" - ? [] - : [ - { - name: - state === "signed-out" - ? "T3_CLAUDE_LOGIN_MARKER" - : "T3_CLAUDE_USAGE_FAILS_UNTIL", - value: recovered, - sensitive: false, - }, - ]), + ...(state === "signed-out" + ? [{ name: "T3_CLAUDE_LOGIN_MARKER", value: recovered, sensitive: false }] + : []), ], config: makeClaudeConfig({ enabled: true, @@ -711,7 +752,21 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), }, }, - }); + }).pipe( + withClaudeHub( + claudeHub({ + accounts: [{ email: "test@example.com", organization_uuid: "" }], + usage: fs.exists(recovered).pipe( + Effect.orDie, + Effect.map((exists) => + state === "usage-failed" && !exists + ? { status: 503, body: {} } + : { status: 200, body: { five_hour: { utilization: 10, resets_at: null } } }, + ), + ), + }), + ), + ); const instance = yield* registry.getInstance(instanceId); expect(instance).toBeDefined(); return { diff --git a/apps/server/src/provider/claudeResetCredits.test.ts b/apps/server/src/provider/claudeResetCredits.test.ts index 8db751657454c..7267cbe6815e8 100644 --- a/apps/server/src/provider/claudeResetCredits.test.ts +++ b/apps/server/src/provider/claudeResetCredits.test.ts @@ -1,11 +1,5 @@ -import * as NodeServices from "@effect/platform-node/NodeServices"; import { it as effectIt } from "@effect/vitest"; -import * as HostProcess from "@t3tools/shared/HostProcess"; import * as Effect from "effect/Effect"; -import * as FileSystem from "effect/FileSystem"; -import * as Path from "effect/Path"; -import * as Schema from "effect/Schema"; -import { HttpClient, HttpClientResponse, UrlParams } from "effect/http"; import { describe, expect, it } from "vite-plus/test"; import * as ClaudeResetCredits from "./claudeResetCredits.ts"; @@ -18,25 +12,6 @@ const grant = (overrides: Record) => ({ ...overrides, }); -const writeLogin = Effect.gen(function* () { - const fs = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - const directory = yield* fs.makeTempDirectoryScoped(); - yield* fs.writeFileString( - path.join(directory, ".credentials.json"), - '{"claudeAiOauth":{"accessToken":"oauth-token"}}', - ); - const accountConfigPath = path.join(directory, ".claude.json"); - yield* fs.writeFileString(accountConfigPath, '{"oauthAccount":{"organizationUuid":"org-1"}}'); - return { configDir: directory, accountConfigPath }; -}); - -const respond = (status: number, body: unknown) => - HttpClient.make((request) => - Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(body, { status }))), - ); -const refuseRequests = HttpClient.make(() => Effect.die("must not send a request")); - describe("claudeResetCreditsToContract", () => { it("counts live grants and pins the next usable one", () => { expect( @@ -87,132 +62,46 @@ describe("claudeResetCreditsToContract", () => { }); }); -effectIt.layer(NodeServices.layer)("readClaudeResetCredits", (it) => { - it.effect("reads the grants with the CLI's request", () => - Effect.gen(function* () { - const { configDir } = yield* writeLogin; - const client = HttpClient.make((request) => { - expect(request.method).toBe("GET"); - expect(request.url).toBe("https://api.anthropic.com/api/oauth/usage"); - expect(UrlParams.toString(request.urlParams)).toBe("cedar_ember=1&skip_spend=1"); - expect(request.headers.authorization).toBe("Bearer oauth-token"); - expect(request.headers["anthropic-beta"]).toBe("oauth-2025-04-20"); - expect(request.headers["user-agent"]).toBe("claude-cli/2.1.0 (external, cli)"); - return Effect.succeed( - HttpClientResponse.fromWeb( - request, - Response.json({ - cedar_ember: { eligible: true, next_grant_id: "grant_a", grants: [grant({})] }, - }), - ), - ); - }); - const credits = yield* ClaudeResetCredits.readClaudeResetCredits(configDir, "2.1.0").pipe( - Effect.provideService(HostProcess.Platform, "linux"), - Effect.provideService(HttpClient.HttpClient, client), - ); - expect(credits).toEqual({ availableCount: 1, nextCreditId: "grant_a" }); - }), - ); - - it.effect("reads nothing from keychain logins or failed requests", () => - 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 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]); - }), - ); -}); - -const ClaimBody = Schema.fromJsonString( - Schema.Struct({ program: Schema.String, grant_id: Schema.String, request_id: Schema.String }), -); -const decodeClaimBody = Schema.decodeEffect(ClaimBody); - -const consume = (client: HttpClient.HttpClient, ids = { grantId: "grant_a", requestId: "r-1" }) => - Effect.gen(function* () { - const login = yield* writeLogin; - return yield* ClaudeResetCredits.consumeClaudeResetCredit({ - ...login, - version: "2.1.0", - ...ids, - }).pipe( - Effect.provideService(HostProcess.Platform, "linux"), - Effect.provideService(HttpClient.HttpClient, client), - Effect.result, - ); - }); - -effectIt.layer(NodeServices.layer)("consumeClaudeResetCredit", (it) => { - it.effect("claims the grant for the organization", () => - Effect.gen(function* () { - const client = HttpClient.make((request) => - Effect.gen(function* () { - expect(request.method).toBe("POST"); - expect(request.url).toBe( - "https://api.anthropic.com/api/organizations/org-1/reset_rate_limits", - ); - expect(request.headers.authorization).toBe("Bearer oauth-token"); - const body = - request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : ""; - expect(yield* decodeClaimBody(body)).toEqual({ - program: "cedar_ember", - grant_id: "grant_a", - request_id: "r-1", - }); - return HttpClientResponse.fromWeb(request, Response.json({ result: "reset" })); - }).pipe(Effect.orDie), - ); - expect(yield* consume(client)).toMatchObject({ _tag: "Success", success: "reset" }); - }), - ); - - it.effect("maps each answer to an outcome or a failure", () => +describe("claudeClaimOutcome", () => { + effectIt.effect("maps each answer to an outcome or a failure", () => Effect.gen(function* () { + const answer = (status: number, body: unknown) => + ClaudeResetCredits.claudeClaimOutcome(status, body).pipe(Effect.result); for (const [result, outcome] of [ + ["reset", "reset"], ["not_limited", "nothingToReset"], ["already_used", "alreadyRedeemed"], ["ineligible", "noCredit"], ] as const) { - expect(yield* consume(respond(200, { result }))).toMatchObject({ success: outcome }); + expect(yield* answer(200, { result })).toMatchObject({ success: outcome }); } - for (const client of [ - respond(200, { result: "cooldown" }), - respond(429, {}), - respond(401, {}), - ]) { - const result = yield* consume(client); + for (const [status, body, settled] of [ + [200, { result: "cooldown" }, true], + [429, undefined, true], + [401, undefined, true], + [500, undefined, false], + [200, { result: "unavailable" }, false], + ] as const) { + const result = yield* answer(status, body); expect(result).toMatchObject({ _tag: "Failure" }); if (result._tag === "Failure") { - expect(ClaudeResetCredits.isSettledClaudeResetCreditFailure(result.failure)).toBe(true); - } - } - for (const client of [respond(500, {}), respond(200, { result: "unavailable" })]) { - const unanswered = yield* consume(client); - expect(unanswered).toMatchObject({ _tag: "Failure" }); - if (unanswered._tag === "Failure") { - expect(ClaudeResetCredits.isSettledClaudeResetCreditFailure(unanswered.failure)).toBe( - false, + expect(ClaudeResetCredits.isSettledClaudeResetCreditFailure(result.failure)).toBe( + settled, ); } } }), ); - it.effect("refuses malformed ids without sending anything", () => + effectIt.effect("refuses malformed ids", () => Effect.gen(function* () { - for (const ids of [ - { grantId: "Bad Grant", requestId: "r-1" }, - { grantId: "grant_a", requestId: "has space" }, + for (const [grantId, requestId] of [ + ["Bad Grant", "r-1"], + ["grant_a", "has space"], ]) { - expect(yield* consume(refuseRequests, ids)).toMatchObject({ _tag: "Failure" }); + expect( + yield* ClaudeResetCredits.claudeClaimBody(grantId!, requestId!).pipe(Effect.result), + ).toMatchObject({ _tag: "Failure" }); } }), ); diff --git a/apps/server/src/provider/claudeResetCredits.ts b/apps/server/src/provider/claudeResetCredits.ts index 1e23af87521ec..f77ff3737c5ba 100644 --- a/apps/server/src/provider/claudeResetCredits.ts +++ b/apps/server/src/provider/claudeResetCredits.ts @@ -9,17 +9,12 @@ import * as FileSystem from "effect/FileSystem"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; import * as Schema from "effect/Schema"; -import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"; -const API_BASE = "https://api.anthropic.com"; const PROGRAM = "cedar_ember"; const GRANT_ID = /^[a-z0-9_-]{1,40}$/; const REQUEST_ID = /^[A-Za-z0-9_-]{1,64}$/; const COMPLETE_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/; -const Credentials = Schema.Struct({ - claudeAiOauth: Schema.optional(Schema.Struct({ accessToken: Schema.optional(Schema.String) })), -}); const Config = Schema.Struct({ oauthAccount: Schema.optional( Schema.Struct({ organizationUuid: Schema.optional(Schema.String) }), @@ -38,9 +33,6 @@ const CedarEmber = Schema.Struct({ grants: Schema.optional(Schema.Array(Schema.Unknown)), next_grant_id: Schema.optional(Schema.NullOr(Schema.String)), }); -const UsageResponse = Schema.Struct({ - cedar_ember: Schema.optional(Schema.NullOr(Schema.Unknown)), -}); const decodeCedarEmber = Schema.decodeUnknownOption(CedarEmber); const ClaimResponse = Schema.Struct({ result: Schema.Literals([ @@ -56,8 +48,6 @@ const decodeClaimResponse = Schema.decodeUnknownEffect(ClaimResponse); const RESET_CREDIT_FAILURES = { malformedCredit: "Claude returned a malformed reset credit.", - loginUnreadable: "Claude could not read its login.", - accountUnreadable: "Claude could not read its account.", signedOut: "Sign in to Claude again to redeem resets.", rateLimited: "Claude is rate limiting resets. Try again soon.", coolingDown: "Claude resets are cooling down. Try again later.", @@ -135,44 +125,6 @@ const readJson = Effect.fn("claudeResetCredits.readJson")(function* - HttpClientRequest.setHeaders({ - authorization: `Bearer ${token}`, - "anthropic-beta": "oauth-2025-04-20", - "user-agent": `claude-cli/${version} (external, cli)`, - }); - -export const readClaudeResetCredits = Effect.fn("readClaudeResetCredits")( - function* (configDir: string, version: string) { - const token = yield* readAccessToken(configDir); - if (!token) return undefined; - 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 body = yield* HttpClientResponse.schemaBodyJson(UsageResponse)( - yield* HttpClientResponse.filterStatusOk(response), - ); - return claudeResetCreditsToContract( - body.cedar_ember, - DateTime.toEpochMillis(yield* DateTime.now), - ); - }, - Effect.timeout("10 seconds"), - Effect.orElseSucceed(() => undefined), -); - export const readClaudeOrganizationId = (accountConfigPath: string) => readJson(Config, accountConfigPath).pipe( Effect.map((config) => config.oauthAccount?.organizationUuid?.trim() || undefined), @@ -227,47 +179,3 @@ export const claudeClaimOutcome = Effect.fn("claudeClaimOutcome")(function* ( } return CLAIM_OUTCOMES[claim.result]; }); - -export const consumeClaudeResetCredit = Effect.fn("consumeClaudeResetCredit")(function* (input: { - readonly configDir: string; - readonly accountConfigPath: string; - readonly version: string; - readonly grantId: string; - readonly requestId: string; -}) { - const claim = yield* claudeClaimBody(input.grantId, input.requestId); - const token = yield* readAccessToken(input.configDir).pipe( - Effect.mapError((cause) => new ClaudeResetCreditError({ reason: "loginUnreadable", cause })), - ); - const config = yield* readJson(Config, input.accountConfigPath).pipe( - Effect.mapError((cause) => new ClaudeResetCreditError({ reason: "accountUnreadable", cause })), - ); - const organization = config.oauthAccount?.organizationUuid?.trim(); - if (!token || !organization) { - return yield* new ClaudeResetCreditError({ reason: "signedOut" }); - } - const client = yield* HttpClient.HttpClient; - const response = yield* client - .execute( - HttpClientRequest.post( - new URL( - `/api/organizations/${encodeURIComponent(organization)}/reset_rate_limits`, - API_BASE, - ), - ).pipe(withClaudeHeaders(token, input.version), HttpClientRequest.bodyJsonUnsafe(claim)), - ) - .pipe( - Effect.timeout("25 seconds"), - Effect.mapError((cause) => new ClaudeResetCreditError({ reason: "requestFailed", cause })), - ); - const body = - response.status >= 200 && response.status < 300 - ? yield* response.json.pipe( - Effect.timeout("25 seconds"), - Effect.mapError( - (cause) => new ClaudeResetCreditError({ reason: "requestFailed", cause }), - ), - ) - : undefined; - return yield* claudeClaimOutcome(response.status, body); -}); diff --git a/apps/server/src/provider/testing/ProviderInstanceRegistryLive.fixture.mjs b/apps/server/src/provider/testing/ProviderInstanceRegistryLive.fixture.mjs index 5c4c84f2aa3e3..a46ca4394ddd4 100755 --- a/apps/server/src/provider/testing/ProviderInstanceRegistryLive.fixture.mjs +++ b/apps/server/src/provider/testing/ProviderInstanceRegistryLive.fixture.mjs @@ -18,56 +18,6 @@ const lines = NodeReadline.createInterface({ input: process.stdin }); lines.on("line", (line) => { const message = JSON.parse(line); if (message.type !== "control_request") return; - if (message.request?.subtype === "get_usage" && signedOut) { - process.stdout.write( - JSON.stringify({ - type: "control_response", - response: { - subtype: "success", - request_id: message.request_id, - response: { session: {}, rate_limits_available: false, rate_limits: null }, - }, - }) + "\n", - ); - return; - } - if (message.request?.subtype === "get_usage") { - const marker = process.env.T3_CLAUDE_RESET_MARKER; - const usageFailsUntil = process.env.T3_CLAUDE_USAGE_FAILS_UNTIL; - if ( - (usageFailsUntil && !NodeFS.existsSync(usageFailsUntil)) || - (process.env.T3_CLAUDE_USAGE_FAILS_AFTER_CLAIM && marker && NodeFS.existsSync(marker)) - ) { - process.stdout.write( - JSON.stringify({ - type: "control_response", - response: { subtype: "error", request_id: message.request_id, error: "usage failed" }, - }) + "\n", - ); - return; - } - process.stdout.write( - JSON.stringify({ - type: "control_response", - response: { - subtype: "success", - request_id: message.request_id, - response: { - session: {}, - subscription_type: "pro", - rate_limits_available: true, - rate_limits: { - five_hour: { - utilization: marker && NodeFS.existsSync(marker) ? 0 : 100, - resets_at: null, - }, - }, - }, - }, - }) + "\n", - ); - return; - } if (message.request?.subtype !== "initialize") return; process.stdout.write( JSON.stringify({ diff --git a/apps/server/src/usage/cliproxyApi.test.ts b/apps/server/src/usage/cliproxyApi.test.ts index 593136169896f..17e0eacdc9123 100644 --- a/apps/server/src/usage/cliproxyApi.test.ts +++ b/apps/server/src/usage/cliproxyApi.test.ts @@ -1,10 +1,12 @@ import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; +import type { UsageLimitSourceConfig } from "@t3tools/contracts"; import { describe, expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import * as Schema from "effect/Schema"; import * as TestClock from "effect/testing/TestClock"; import { HttpClient, HttpClientError, HttpClientResponse } from "effect/http"; +import { isSettledClaudeResetCreditFailure } from "../provider/claudeResetCredits.ts"; import { makeCliproxyApi } from "./cliproxyApi.ts"; const config = { @@ -318,11 +320,8 @@ describe("CLIProxyAPI built-in management API", () => { yield* TestClock.setTime(Date.parse("2026-10-31T12:00:00Z")); const test = fixture({ accounts: [{ ...accounts[0]!, provider: "claude" }], - // Usage answers 429, and reset credits ineligible, without a Claude Code user agent. - upstream: (request) => ({ - status: /^claude-cli\/\S+ \(external, cli\)$/.test(request.header?.["User-Agent"] ?? "") - ? 200 - : 429, + upstream: () => ({ + status: 200, body: { cedar_ember: { eligible: true, @@ -439,6 +438,68 @@ describe("CLIProxyAPI built-in management API", () => { }), ); + it.effect( + "finds a signed-in Claude login by email and organization and claims through the hub", + () => + Effect.gen(function* () { + const claude = (id: string, organization_uuid: string, disabled = false) => ({ + ...accounts[0]!, + id, + auth_index: id, + provider: "claude", + email: "Me@Example.com", + organization_uuid, + disabled, + }); + let answer: unknown = { result: "reset" }; + const test = fixture({ + accounts: [ + claude("personal.json", "org-1"), + claude("team.json", "org-2"), + claude("off.json", "org-3", true), + ], + upstream: () => ({ status: 200, body: answer }), + }); + const api = yield* test.api; + const find = ( + organizationId: string | undefined, + sources: ReadonlyArray = [config], + ) => api.findClaudeLogin(sources, { email: "me@example.com", organizationId }); + const login = (yield* find("org-2"))!; + expect(login.account.id).toBe("team.json"); + expect(yield* find(undefined)).toBeUndefined(); + expect(yield* find("org-3")).toBeUndefined(); + expect(yield* find("org-1", [{ ...config, enabled: false }])).toBeUndefined(); + + expect(yield* api.claimClaudeLogin(login.config, login.account, "grant_a", "r-1")).toBe( + "reset", + ); + const claim = test.requests.find((request) => request.body?.url); + expect(claim?.body?.url).toBe( + "https://api.anthropic.com/api/organizations/org-2/reset_rate_limits", + ); + expect(claim?.body?.data).toBe( + encodeJson({ program: "cedar_ember", grant_id: "grant_a", request_id: "r-1" }), + ); + expect( + test.requests + .filter((request) => request.path.endsWith("/reset-quota")) + .map((request) => request.body?.auth_index), + ).toEqual(["team.json"]); + + for (const [result, settled] of [ + ["cooldown", true], + ["unavailable", false], + ] as const) { + answer = { result }; + const error = yield* Effect.flip( + api.claimClaudeLogin(login.config, login.account, "grant_a", "r-1"), + ); + expect(isSettledClaudeResetCreditFailure(error)).toBe(settled); + } + }), + ); + it.effect("pins redemption to the displayed credit and clears only that account's cooldown", () => Effect.gen(function* () { const test = fixture(); diff --git a/apps/server/src/usage/cliproxyApi.ts b/apps/server/src/usage/cliproxyApi.ts index d90978606fc08..a57242c9c855f 100644 --- a/apps/server/src/usage/cliproxyApi.ts +++ b/apps/server/src/usage/cliproxyApi.ts @@ -233,8 +233,8 @@ export const makeCliproxyApi = Effect.gen(function* () { : { Authorization: "Bearer $TOKEN$", "anthropic-beta": "oauth-2025-04-20", - // Usage answers 429, and reset credits ineligible, without a Claude Code user agent. - "User-Agent": "claude-cli/2.1.273 (external, cli)", + // The OAuth usage endpoint can return 429 without a Claude Code user agent. + "User-Agent": "claude-code/2.1.273", }; const raw = yield* management(config, "api-call", { auth_index: account.auth_index, @@ -275,6 +275,44 @@ export const makeCliproxyApi = Effect.gen(function* () { .toSorted((a, b) => Date.parse(a.expires_at) - Date.parse(b.expires_at)); }); + /** Usage in the Claude SDK's get_usage shape, plus reset credits. */ + const claudeUsage = Effect.fn("CliproxyApi.claudeUsage")(function* ( + config: UsageLimitSourceConfig, + account: typeof AuthFile.Type, + ) { + const body = yield* apiCall( + config, + account, + `${CLAUDE_BASE}/oauth/usage?cedar_ember=1&skip_spend=1`, + ); + const usage = yield* decodeClaudeUsage(body); + const model_scoped = (usage.limits ?? []).flatMap((limit) => + limit.kind === "weekly_scoped" && limit.scope?.model && typeof limit.percent === "number" + ? [ + { + display_name: limit.scope.model.display_name, + utilization: limit.percent, + resets_at: limit.resets_at ?? null, + }, + ] + : [], + ); + return { + response: { + rate_limits_available: true, + rate_limits: { + five_hour: usage.five_hour ?? null, + seven_day: usage.seven_day ?? null, + model_scoped, + }, + }, + resetCredits: claudeResetCreditsToContract( + usage.cedar_ember, + DateTime.toEpochMillis(yield* DateTime.now), + ), + }; + }); + const readAccount = Effect.fn("CliproxyApi.readAccount")(function* ( config: UsageLimitSourceConfig, account: typeof AuthFile.Type, @@ -290,42 +328,12 @@ export const makeCliproxyApi = Effect.gen(function* () { }; const read = Effect.gen(function* () { if (account.provider === "claude") { - const body = yield* apiCall( - config, - account, - `${CLAUDE_BASE}/oauth/usage?cedar_ember=1&skip_spend=1`, - ); - const usage = yield* decodeClaudeUsage(body); - const resetCredits = claudeResetCreditsToContract( - usage.cedar_ember, - DateTime.toEpochMillis(yield* DateTime.now), - ); - const model_scoped = (usage.limits ?? []).flatMap((limit) => - limit.kind === "weekly_scoped" && limit.scope?.model && typeof limit.percent === "number" - ? [ - { - display_name: limit.scope.model.display_name, - utilization: limit.percent, - resets_at: limit.resets_at ?? null, - }, - ] - : [], - ); + const { response, resetCredits } = yield* claudeUsage(config, account); return { ...base, plan: "Claude Subscription", usageLimits: { - ...claudeUsageResponseToLimits({ - checkedAt, - response: { - rate_limits_available: true, - rate_limits: { - five_hour: usage.five_hour ?? null, - seven_day: usage.seven_day ?? null, - model_scoped, - }, - }, - }).limits, + ...claudeUsageResponseToLimits({ checkedAt, response }).limits, ...(resetCredits ? { resetCredits } : {}), }, }; @@ -406,36 +414,68 @@ export const makeCliproxyApi = Effect.gen(function* () { ); }); - const consumeClaude = Effect.fn("CliproxyApi.consumeClaude")( - function* ( - config: UsageLimitSourceConfig, - account: typeof AuthFile.Type, - grantId: string, - requestId: string, - ) { - const claim = yield* claudeClaimBody(grantId, requestId); - const organization = account.organization_uuid?.trim(); - if (!organization) { - return yield* new UsageLimitSourceError({ - detail: "The hub does not know this Claude account's organization.", - }); - } - const response = yield* apiResponse( - config, - account, - `${CLAUDE_BASE}/organizations/${encodeURIComponent(organization)}/reset_rate_limits`, - claim, - ); - return yield* claudeClaimOutcome( - response.status_code, - Option.getOrUndefined(decodeJsonOption(response.body)), + const claimClaude = Effect.fn("CliproxyApi.claimClaude")(function* ( + config: UsageLimitSourceConfig, + account: typeof AuthFile.Type, + grantId: string, + requestId: string, + ) { + const claim = yield* claudeClaimBody(grantId, requestId); + const organization = account.organization_uuid?.trim(); + if (!organization) { + return yield* new UsageLimitSourceError({ + detail: "The hub does not know this Claude account's organization.", + }); + } + const response = yield* apiResponse( + config, + account, + `${CLAUDE_BASE}/organizations/${encodeURIComponent(organization)}/reset_rate_limits`, + claim, + ); + return yield* claudeClaimOutcome( + response.status_code, + Option.getOrUndefined(decodeJsonOption(response.body)), + ); + }); + + const clearCooldown = (config: UsageLimitSourceConfig, account: typeof AuthFile.Type) => + management(config, "reset-quota", { auth_index: account.auth_index }); + + /** The one enabled hub account holding a directly signed-in Claude login. */ + const findClaudeLogin = Effect.fn("CliproxyApi.findClaudeLogin")(function* ( + sources: ReadonlyArray, + login: { readonly email: string; readonly organizationId: string | undefined }, + ) { + for (const config of sources) { + if (!config.enabled || !config.managementKey) continue; + const files = yield* authFiles(config).pipe(Effect.orElseSucceed(() => [])); + const matches = files.filter( + (account) => + account.provider === "claude" && + !account.disabled && + account.email?.toLowerCase() === login.email.toLowerCase() && + (login.organizationId === undefined || + account.organization_uuid === login.organizationId), ); - }, - Effect.catchTags({ - ClaudeResetCreditError: (error) => - Effect.fail(new UsageLimitSourceError({ detail: error.message })), - }), - ); + if (matches.length === 1) return { config, account: matches[0]! }; + } + return undefined; + }); + + // Claim errors stay typed so the caller's coordinator keeps the request id for retries. + const claimClaudeLogin = Effect.fn("CliproxyApi.claimClaudeLogin")(function* ( + config: UsageLimitSourceConfig, + account: typeof AuthFile.Type, + grantId: string, + requestId: string, + ) { + const outcome = yield* claimClaude(config, account, grantId, requestId); + if (outcome === "reset" || outcome === "alreadyRedeemed") { + yield* clearCooldown(config, account).pipe(Effect.ignore); + } + return outcome; + }); const consume = Effect.fn("CliproxyApi.consume")(function* ( config: UsageLimitSourceConfig, @@ -459,7 +499,12 @@ export const makeCliproxyApi = Effect.gen(function* () { ).pipe(Effect.provideService(Crypto.Crypto, crypto)); const outcome = account.provider === "claude" - ? yield* consumeClaude(config, account, creditId, requestId) + ? yield* claimClaude(config, account, creditId, requestId).pipe( + Effect.catchTags({ + ClaudeResetCreditError: (error) => + Effect.fail(new UsageLimitSourceError({ detail: error.message })), + }), + ) : CODEX_CLAIM_OUTCOMES[ (yield* decodeConsumeResponse( yield* apiCall(config, account, `${CREDIT_URL}/consume`, { @@ -469,9 +514,7 @@ export const makeCliproxyApi = Effect.gen(function* () { )).code ]; if (outcome !== "reset" && outcome !== "alreadyRedeemed") return { outcome }; - const cleared = yield* management(config, "reset-quota", { - auth_index: account.auth_index, - }).pipe(Effect.result); + const cleared = yield* clearCooldown(config, account).pipe(Effect.result); return { outcome, ...(cleared._tag === "Failure" @@ -492,5 +535,5 @@ export const makeCliproxyApi = Effect.gen(function* () { ), ); }); - return { readAccounts, consume }; + return { readAccounts, consume, findClaudeLogin, claudeUsage, claimClaudeLogin }; });