From 76f1e519af0f2246931278ca9ca4f264107ab3b9 Mon Sep 17 00:00:00 2001 From: Renfei Zhou Date: Sat, 31 Oct 2026 22:57:20 +0000 Subject: [PATCH 1/8] feat(server): Claude reset credits for usage source accounts Claude accounts listed by a usage source showed usage but never their reset credits, and could not redeem one, while native Claude logins and Codex source accounts could. The source's Claude usage read now asks for the cedar_ember block and maps it with claudeResetCreditsToContract. Redemption posts the claim through the source'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 source cooldown as for Codex. The native and source paths share claim validation and answer mapping, so 429, 401/403, cooldown and unavailable read the same on both. The source'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 0bb26cedbf488baecd4d5f8608ef7cf839de6b55 Mon Sep 17 00:00:00 2001 From: Renfei Zhou Date: Sat, 31 Oct 2026 23:09:28 +0000 Subject: [PATCH 2/8] feat(server): route native Claude usage and resets through a matching usage source A Claude login signed in on this machine may also be held by an enabled usage source. When exactly one account in a source has the same email and organization, plan usage, reset credits and reset claims now go through that source's api-call, and a successful claim clears the account's cooldown there. Source failures show as unavailable usage or a failed claim instead of falling back to a direct request. Logins no source holds keep reading and redeeming directly, as before. Co-Authored-By: Claude Opus 5.5 --- apps/server/src/provider/ClaudeProvider.ts | 7 +- .../src/provider/Drivers/ClaudeDriver.ts | 97 +++++++-- .../provider/ProviderInstanceRegistry.test.ts | 171 +++++++++++++-- .../server/src/provider/claudeResetCredits.ts | 17 +- apps/server/src/usage/cliproxyApi.test.ts | 41 ++++ apps/server/src/usage/cliproxyApi.ts | 202 +++++++++++------- 6 files changed, 407 insertions(+), 128 deletions(-) diff --git a/apps/server/src/provider/ClaudeProvider.ts b/apps/server/src/provider/ClaudeProvider.ts index 95f5c6709a4ea..53212dcd9fa7c 100644 --- a/apps/server/src/provider/ClaudeProvider.ts +++ b/apps/server/src/provider/ClaudeProvider.ts @@ -244,6 +244,7 @@ export type ClaudeCapabilitiesProbe = { /** Undefined means get_usage failed; absent windows on success mean no subscription windows, as with API keys. */ readonly usage?: Pick; readonly usageCheckedAt?: string; + readonly usageError?: string; }; function parseClaudeInitializationCommands( @@ -638,7 +639,11 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")( }); const usageCheckedAt = capabilities.usageCheckedAt ?? checkedAt; const usageLimits = !capabilities.usage - ? makeUnavailableUsageLimits({ checkedAt, reason: "probeFailed" }) + ? makeUnavailableUsageLimits({ + checkedAt, + reason: "probeFailed", + ...(capabilities.usageError ? { message: capabilities.usageError } : {}), + }) : scopedLimitNames ? yield* recordClaudeUsageResponse(scopedLimitNames, { response: capabilities.usage, diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts index e1fbcd30080fd..53500de376600 100644 --- a/apps/server/src/provider/Drivers/ClaudeDriver.ts +++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts @@ -1,12 +1,15 @@ -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 Result from "effect/Result"; import * as Schema from "effect/Schema"; import { HttpClient } from "effect/http"; import { ChildProcessSpawner } from "effect/process"; @@ -15,6 +18,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 +135,8 @@ export const ClaudeDriver: ProviderDriver>, + ) { + if (Option.isNone(serverSettings)) return undefined; + const settings = yield* serverSettings.value.getSettings.pipe( + Effect.mapError( + () => new UsageLimitSourceError({ detail: "The usage sources could not be read." }), + ), + ); + return yield* usageSources.findClaudeLogin(Object.values(settings.usageLimitSources), login); + }); + + const probeCapabilities = Effect.fn("ClaudeDriver.probeCapabilities")(function* () { + const login = yield* ClaudeResetCredits.readClaudeLogin(accountConfigPath); + const usageCheckedAt = DateTime.formatIso(yield* DateTime.now); + const viaSource = yield* findUsageSource(login).pipe( + Effect.flatMap((source) => + source + ? usageSources.claudeUsage(source.config, source.account).pipe(Effect.asSome) + : Effect.succeedNone, + ), + Effect.result, + ); + const direct = Result.isSuccess(viaSource) && Option.isNone(viaSource.success); + const probed = yield* probeClaudeCapabilities(effectiveConfig, processEnv, stateDir, direct); + const capabilities: ClaudeCapabilitiesProbe = login.organizationId + ? { ...probed, workspaceId: login.organizationId } + : probed; + if (Result.isFailure(viaSource)) { + return { capabilities: { ...capabilities, usageError: viaSource.failure.detail } }; + } + if (Option.isNone(viaSource.success)) return { capabilities }; + const { response, resetCredits } = viaSource.success.value; + return { + capabilities: { ...capabilities, usage: response, usageCheckedAt }, + source: { 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( - Effect.flatMap((capabilities) => - ClaudeResetCredits.readClaudeOrganizationId(accountConfigPath).pipe( - Effect.map((workspaceId) => ({ - _tag: "fresh" as const, - capabilities: - workspaceId === undefined ? capabilities : { ...capabilities, workspaceId }, - })), - ), - ), + probeCapabilities().pipe( + Effect.map((entry) => ({ _tag: "fresh" as const, ...entry })), Effect.tap(({ capabilities }) => Ref.set(lastGoodCapabilities, capabilities)), Effect.catch((error) => Ref.getAndSet(lastGoodCapabilities, undefined).pipe( @@ -267,10 +306,17 @@ 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.flatMap((entry) => + "source" in entry && entry.source + ? Effect.succeed(entry.source.resetCredits) + : ClaudeResetCredits.readClaudeResetCredits(configDir, version).pipe( + Effect.provideService(HttpClient.HttpClient, httpClient), + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + ), + ), + Effect.orElseSucceed(() => undefined), ), ), ), @@ -334,16 +380,21 @@ export const ClaudeDriver: ProviderDriver - ClaudeResetCredits.consumeClaudeResetCredit({ - configDir, - accountConfigPath, - version, - grantId, - requestId, - }), + source + ? usageSources.claimClaudeLogin(source.config, source.account, grantId, requestId) + : ClaudeResetCredits.consumeClaudeResetCredit({ + configDir, + accountConfigPath, + version, + grantId, + requestId, + }), ClaudeResetCredits.isSettledClaudeResetCreditFailure, ); }, @@ -356,7 +407,7 @@ export const ClaudeDriver: ProviderDriver { }).pipe(Effect.provide(layerTest)), ); - const redeemClaudeReset = (claim: { result: string; usageFailsAfterClaim: boolean }) => + const redeemClaudeReset = (claim: { + result: string; + usageFailsAfterClaim: boolean; + hub?: { + accounts: ReadonlyArray<{ email: string; organization_uuid?: string }>; + listStatus?: number; + usageStatus?: number; + }; + }) => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; @@ -594,27 +607,65 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { ); yield* fs.writeFileString( path.join(fixtures.claudeHomePath, ".claude.json"), - '{"oauthAccount":{"organizationUuid":"fake-org"}}', + '{"oauthAccount":{"emailAddress":"test@example.com","organizationUuid":"fake-org"}}', ); + const direct: Array = []; + const viaHub: Array = []; + let hubRedeemed = false; + const credits = { + eligible: true, + next_grant_id: "grant_a", + grants: [{ id: "grant_a", resets_left: 1, usable_now: true }], + }; 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 json = (body: unknown, status = 200) => + HttpClientResponse.fromWeb(request, Response.json(body, { status })); + const url = new URL(request.url); + if (claim.hub && url.host === "hub.test") { + if (url.pathname.endsWith("/auth-files")) { + viaHub.push("auth-files"); + return json( + { + files: claim.hub.accounts.map((account, index) => ({ + id: `${index}.json`, + auth_index: `${index}`, + provider: "claude", + ...account, + })), }, - }), + claim.hub.listStatus, + ); + } + if (url.pathname.endsWith("/reset-quota")) { + viaHub.push("reset-quota"); + return json({}); + } + const call = decodeHubCall( + request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : "", ); + viaHub.push(call.url); + if (call.url.endsWith("/reset_rate_limits")) { + hubRedeemed = true; + return json({ status_code: 200, body: JSON.stringify({ result: claim.result }) }); + } + return json({ + status_code: claim.hub.usageStatus ?? 200, + body: JSON.stringify({ + five_hour: { utilization: hubRedeemed ? 0 : 100, resets_at: null }, + cedar_ember: credits, + }), + }); + } + if (url.host === "api.anthropic.com") direct.push(url.pathname); + if (request.url.endsWith("/api/oauth/usage")) { + return json({ cedar_ember: credits }); } 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 json({ result: claim.result }); } - return HttpClientResponse.fromWeb(request, Response.json({ version: "0.0.0" })); + return json({ version: "0.0.0" }); }), ); const instanceId = ProviderInstanceId.make("claude_reset"); @@ -637,14 +688,30 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), }, }, - }).pipe(Effect.provideService(HttpClient.HttpClient, client)); + }).pipe( + Effect.provideService(HttpClient.HttpClient, client), + Effect.provide( + ServerSettings.layerTest( + claim.hub + ? { + usageLimitSources: { + [UsageLimitSourceId.make("hub")]: { + kind: "cliproxy", + url: "http://hub.test", + managementKey: "hub-key", + enabled: true, + }, + }, + } + : {}, + ), + ), + ); const instance = yield* registry.getInstance(instanceId); expect(instance).toBeDefined(); const before = yield* instance!.snapshot.refresh; - expect(before.usageLimits?.windows[0]?.usedPercent).toBe(100); - expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); const outcome = yield* instance!.consumeResetCredit!().pipe(Effect.result); - return { outcome, after: yield* instance!.snapshot.getSnapshot }; + return { before, outcome, after: yield* instance!.snapshot.getSnapshot, direct, viaHub }; }).pipe( // macOS logins live in the Keychain, where resets are never read. Effect.provideService(HostProcess.Platform, "linux"), @@ -653,12 +720,25 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { it.live.skipIf(windowsHost)("refreshes Claude usage after redeeming a reset", () => Effect.gen(function* () { - const { outcome, after } = yield* redeemClaudeReset({ - result: "reset", - usageFailsAfterClaim: false, - }); - expect(outcome).toMatchObject({ _tag: "Success", success: "reset" }); - expect(after.usageLimits?.windows[0]?.usedPercent).toBe(0); + for (const accounts of [ + [], + [ + { email: "test@example.com", organization_uuid: "other-org" }, + { email: "test@example.com" }, + ], + ]) { + const { before, outcome, after, direct, viaHub } = yield* redeemClaudeReset({ + result: "reset", + usageFailsAfterClaim: false, + hub: { accounts }, + }); + expect(before.usageLimits?.windows[0]?.usedPercent).toBe(100); + expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); + expect(outcome).toMatchObject({ _tag: "Success", success: "reset" }); + expect(after.usageLimits?.windows[0]?.usedPercent).toBe(0); + expect(direct).toContain("/api/organizations/fake-org/reset_rate_limits"); + expect(viaHub.every((call) => call === "auth-files")).toBe(true); + } }), ); @@ -674,6 +754,51 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), ); + it.live.skipIf(windowsHost)( + "reads and redeems a Claude login only through the usage source holding it", + () => + Effect.gen(function* () { + const { before, outcome, after, direct, viaHub } = yield* redeemClaudeReset({ + result: "reset", + usageFailsAfterClaim: false, + hub: { accounts: [{ email: "TEST@example.com", organization_uuid: "fake-org" }] }, + }); + expect(before.usageLimits?.windows[0]?.usedPercent).toBe(100); + expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); + expect(outcome).toMatchObject({ _tag: "Success", success: "reset" }); + expect(after.usageLimits?.windows[0]?.usedPercent).toBe(0); + expect(direct).toEqual([]); + expect(viaHub).toContain( + "https://api.anthropic.com/api/organizations/fake-org/reset_rate_limits", + ); + expect(viaHub).toContain("reset-quota"); + }), + ); + + it.live.skipIf(windowsHost)( + "shows a usage source failure instead of reading Claude directly", + () => + Effect.gen(function* () { + for (const failure of [{ usageStatus: 503 }, { listStatus: 500 }]) { + const { before, outcome, direct } = yield* redeemClaudeReset({ + result: "reset", + usageFailsAfterClaim: false, + hub: { + accounts: [{ email: "test@example.com", organization_uuid: "fake-org" }], + ...failure, + }, + }); + expect(before.usageLimits?.unavailable).toMatchObject({ + reason: "probeFailed", + message: expect.any(String), + }); + expect(before.usageLimits?.resetCredits).toBeUndefined(); + expect(outcome).toMatchObject({ _tag: "Success", success: "noCredit" }); + expect(direct).toEqual([]); + } + }), + ); + const makeClaudeCacheFixture = Effect.fnUntraced(function* ( state: "ready" | "signed-out" | "usage-failed", ) { diff --git a/apps/server/src/provider/claudeResetCredits.ts b/apps/server/src/provider/claudeResetCredits.ts index 1e23af87521ec..090fb441a0b72 100644 --- a/apps/server/src/provider/claudeResetCredits.ts +++ b/apps/server/src/provider/claudeResetCredits.ts @@ -22,7 +22,10 @@ const Credentials = Schema.Struct({ }); const Config = Schema.Struct({ oauthAccount: Schema.optional( - Schema.Struct({ organizationUuid: Schema.optional(Schema.String) }), + Schema.Struct({ + emailAddress: Schema.optional(Schema.String), + organizationUuid: Schema.optional(Schema.String), + }), ), }); const Grant = Schema.Struct({ @@ -173,12 +176,18 @@ export const readClaudeResetCredits = Effect.fn("readClaudeResetCredits")( Effect.orElseSucceed(() => undefined), ); -export const readClaudeOrganizationId = (accountConfigPath: string) => +export const readClaudeLogin = (accountConfigPath: string) => readJson(Config, accountConfigPath).pipe( - Effect.map((config) => config.oauthAccount?.organizationUuid?.trim() || undefined), - Effect.orElseSucceed(() => undefined), + Effect.map((config) => ({ + email: config.oauthAccount?.emailAddress?.trim() || undefined, + organizationId: config.oauthAccount?.organizationUuid?.trim() || undefined, + })), + Effect.orElseSucceed(() => ({ email: undefined, organizationId: undefined })), ); +export const readClaudeOrganizationId = (accountConfigPath: string) => + readClaudeLogin(accountConfigPath).pipe(Effect.map((login) => login.organizationId)); + export const claudeAccountConfigPath = Effect.fn("claudeAccountConfigPath")(function* ( configDir: string | undefined, ) { diff --git a/apps/server/src/usage/cliproxyApi.test.ts b/apps/server/src/usage/cliproxyApi.test.ts index 593136169896f..5ae0d297d28f4 100644 --- a/apps/server/src/usage/cliproxyApi.test.ts +++ b/apps/server/src/usage/cliproxyApi.test.ts @@ -370,6 +370,47 @@ describe("CLIProxyAPI built-in management API", () => { }), ); + it.effect("finds a Claude login only by its exact email and organization", () => + Effect.gen(function* () { + const claude = { ...accounts[0]!, provider: "claude", organization_uuid: "org-1" }; + const login = { email: "FIRST@example.com", organizationId: "org-1" }; + for (const [hubAccounts, expected] of [ + [[{ ...claude, organization_uuid: "org-2" }, claude], "first.json"], + [[{ ...claude, organization_uuid: "org-2" }], undefined], + [[{ ...accounts[0]!, provider: "claude" }], undefined], + [[{ ...claude, disabled: true }], undefined], + [[claude, { ...claude, id: "copy.json" }], undefined], + ] as const) { + const api = yield* fixture({ accounts: [...hubAccounts] }).api; + expect((yield* api.findClaudeLogin([config], login))?.account.id).toBe(expected); + } + const test = fixture({ accounts: [claude] }); + const api = yield* test.api; + expect( + yield* api.findClaudeLogin( + [ + { ...config, enabled: false }, + { ...config, managementKey: "" }, + ], + login, + ), + ).toBeUndefined(); + expect( + yield* api.findClaudeLogin([config], { ...login, organizationId: undefined }), + ).toBeUndefined(); + expect(test.requests).toEqual([]); + const unreadable = yield* Effect.flip( + (yield* unreachableHub( + (request) => + new HttpClientError.HttpClientError({ + reason: new HttpClientError.TransportError({ request }), + }), + )).findClaudeLogin([config], login), + ); + expect(unreadable._tag).toBe("UsageLimitSourceError"); + }), + ); + 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" }; diff --git a/apps/server/src/usage/cliproxyApi.ts b/apps/server/src/usage/cliproxyApi.ts index d90978606fc08..198bef10aae4e 100644 --- a/apps/server/src/usage/cliproxyApi.ts +++ b/apps/server/src/usage/cliproxyApi.ts @@ -208,10 +208,17 @@ export const makeCliproxyApi = Effect.gen(function* () { return response; }); - const authFiles = Effect.fn("CliproxyApi.authFiles")(function* (config: UsageLimitSourceConfig) { - const response = yield* management(config, "auth-files"); - return (yield* decodeAuthFiles(response)).files; - }); + const authFiles = Effect.fn("CliproxyApi.authFiles")( + function* (config: UsageLimitSourceConfig) { + const response = yield* management(config, "auth-files"); + return (yield* decodeAuthFiles(response)).files; + }, + Effect.mapError((error) => + isUsageLimitSourceError(error) + ? error + : new UsageLimitSourceError({ detail: "The hub could not list accounts." }), + ), + ); const apiResponse = Effect.fn("CliproxyApi.apiResponse")(function* ( config: UsageLimitSourceConfig, @@ -275,6 +282,48 @@ 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), + ), + }; + }, + Effect.mapError((error) => + isUsageLimitSourceError(error) + ? error + : new UsageLimitSourceError({ detail: "The hub returned an unexpected usage response." }), + ), + ); + const readAccount = Effect.fn("CliproxyApi.readAccount")(function* ( config: UsageLimitSourceConfig, account: typeof AuthFile.Type, @@ -290,42 +339,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 } : {}), }, }; @@ -389,13 +408,7 @@ export const makeCliproxyApi = Effect.gen(function* () { const readAccounts = Effect.fn("CliproxyApi.readAccounts")(function* ( config: UsageLimitSourceConfig, ): Effect.fn.Return, UsageLimitSourceError> { - const accounts = yield* authFiles(config).pipe( - Effect.mapError((error) => - isUsageLimitSourceError(error) - ? error - : new UsageLimitSourceError({ detail: "The hub could not list accounts." }), - ), - ); + const accounts = yield* authFiles(config); return yield* Effect.forEach( accounts.filter( (account) => @@ -406,36 +419,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 source account holding a directly signed-in Claude login, if exactly one source has it. */ + const findClaudeLogin = Effect.fn("CliproxyApi.findClaudeLogin")(function* ( + sources: ReadonlyArray, + login: { readonly email: string | undefined; readonly organizationId: string | undefined }, + ) { + const { email, organizationId } = login; + if (!email || !organizationId) return undefined; + for (const config of sources) { + if (!config.enabled || !config.managementKey) continue; + const matches = (yield* authFiles(config)).filter( + (account) => + account.provider === "claude" && + !account.disabled && + account.email?.toLowerCase() === email.toLowerCase() && + account.organization_uuid === 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 +504,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 +519,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 +540,5 @@ export const makeCliproxyApi = Effect.gen(function* () { ), ); }); - return { readAccounts, consume }; + return { readAccounts, consume, findClaudeLogin, claudeUsage, claimClaudeLogin }; }); From 35057149b3cc9e254fe30ecc497dc0cb69c32faa Mon Sep 17 00:00:00 2001 From: Renfei Zhou Date: Sat, 31 Oct 2026 23:20:09 +0000 Subject: [PATCH 3/8] fix(server): give each usage source Claude claim its own request id A Claude grant can hold several resets. Claims for a usage source account derived the request id from the account and grant, so a second claim on the same grant repeated the first and never spent the next reset. Co-Authored-By: Claude Opus 5.5 --- apps/server/src/usage/cliproxyApi.test.ts | 20 +++++++++++++------- apps/server/src/usage/cliproxyApi.ts | 12 ++++++------ 2 files changed, 19 insertions(+), 13 deletions(-) diff --git a/apps/server/src/usage/cliproxyApi.test.ts b/apps/server/src/usage/cliproxyApi.test.ts index 5ae0d297d28f4..85d25d3cde969 100644 --- a/apps/server/src/usage/cliproxyApi.test.ts +++ b/apps/server/src/usage/cliproxyApi.test.ts @@ -431,17 +431,23 @@ describe("CLIProxyAPI built-in management API", () => { "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(JSON.parse(redemption?.body?.data ?? "")).toEqual({ + program: "cedar_ember", + grant_id: "grant_a", + request_id: expect.stringMatching(/^[0-9a-f-]{36}$/), + }); expect(test.requests.some((request) => request.path.endsWith("/reset-quota"))).toBe( clearsCooldown, ); } + const twice = answer(200, { result: "reset" }); + const api = yield* twice.api; + yield* api.consume(config, "first.json", "grant_a"); + yield* api.consume(config, "first.json", "grant_a"); + const requestIds = twice.requests.flatMap((request) => + request.body?.data ? [JSON.parse(request.body.data).request_id] : [], + ); + expect(new Set(requestIds).size).toBe(2); for (const [status, body, detail] of [ [200, { result: "cooldown" }, "Claude resets are cooling down. Try again later."], [ diff --git a/apps/server/src/usage/cliproxyApi.ts b/apps/server/src/usage/cliproxyApi.ts index 198bef10aae4e..7d595e1c3798a 100644 --- a/apps/server/src/usage/cliproxyApi.ts +++ b/apps/server/src/usage/cliproxyApi.ts @@ -498,13 +498,10 @@ export const makeCliproxyApi = Effect.gen(function* () { detail: "The hub account is missing or disabled.", }); } - 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* claimClaude(config, account, creditId, requestId).pipe( + ? // A Claude grant can hold several resets, so each claim needs its own request id. + yield* claimClaude(config, account, creditId, yield* crypto.randomUUIDv4()).pipe( Effect.catchTags({ ClaudeResetCreditError: (error) => Effect.fail(new UsageLimitSourceError({ detail: error.message })), @@ -513,7 +510,10 @@ export const makeCliproxyApi = Effect.gen(function* () { : CODEX_CLAIM_OUTCOMES[ (yield* decodeConsumeResponse( yield* apiCall(config, account, `${CREDIT_URL}/consume`, { - redeem_request_id: requestId, + redeem_request_id: yield* creditRedeemRequestId( + account.id_token?.chatgpt_account_id ?? account.id, + creditId, + ).pipe(Effect.provideService(Crypto.Crypto, crypto)), credit_id: creditId, }), )).code From 234ffb26a5b241dff68c693ab3d0356a28a60a4c Mon Sep 17 00:00:00 2001 From: Renfei Zhou Date: Sat, 31 Oct 2026 23:27:52 +0000 Subject: [PATCH 4/8] fix(server): let usage sources set Claude headers and give redeems 30 s Claude requests through a usage source no longer carry a hard-coded Claude Code user agent; the source sets its own client headers. A redeem through a source now waits 30 seconds for the source's answer, since it includes the source's own upstream call; reads keep 15 seconds. Co-Authored-By: Claude Opus 5.5 --- apps/server/src/usage/cliproxyApi.test.ts | 36 +++++++++++++++++++---- apps/server/src/usage/cliproxyApi.ts | 26 +++++++++------- 2 files changed, 47 insertions(+), 15 deletions(-) diff --git a/apps/server/src/usage/cliproxyApi.test.ts b/apps/server/src/usage/cliproxyApi.test.ts index 85d25d3cde969..c090382b356d8 100644 --- a/apps/server/src/usage/cliproxyApi.test.ts +++ b/apps/server/src/usage/cliproxyApi.test.ts @@ -1,6 +1,8 @@ import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; import { describe, expect, it } from "@effect/vitest"; +import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; import * as Schema from "effect/Schema"; import * as TestClock from "effect/testing/TestClock"; import { HttpClient, HttpClientError, HttpClientResponse } from "effect/http"; @@ -57,6 +59,7 @@ function fixture( >; upstream?: (request: RequestBody) => { status: number; body: unknown }; cooldownStatus?: number; + redeemDelay?: Duration.Input; } = {}, ) { const requests: Array<{ path: string; body?: RequestBody }> = []; @@ -109,7 +112,13 @@ function fixture( request, Response.json({ status_code: upstream.status, body: encodeJson(upstream.body) }), ); - }), + }).pipe( + Effect.delay( + request.method === "POST" && request.url.endsWith("/api-call") + ? (options.redeemDelay ?? 0) + : 0, + ), + ), ); return { requests, @@ -318,11 +327,9 @@ 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. + // The hub sets its own client headers. upstream: (request) => ({ - status: /^claude-cli\/\S+ \(external, cli\)$/.test(request.header?.["User-Agent"] ?? "") - ? 200 - : 429, + status: request.header?.["User-Agent"] === undefined ? 200 : 400, body: { cedar_ember: { eligible: true, @@ -469,6 +476,25 @@ describe("CLIProxyAPI built-in management API", () => { }), ); + it.effect("waits longer for a redeem than for a read", () => + Effect.gen(function* () { + const claude = { ...accounts[0]!, provider: "claude", organization_uuid: "org-1" }; + for (const account of [accounts[0]!, claude]) { + const api = yield* fixture({ + accounts: [account], + upstream: (request) => ({ + status: 200, + body: request.url?.endsWith("/consume") ? { code: "reset" } : { result: "reset" }, + }), + redeemDelay: "29 seconds", + }).api; + const redeem = yield* Effect.forkChild(api.consume(config, "first.json", "grant_a")); + yield* TestClock.adjust("29 seconds"); + expect((yield* Fiber.join(redeem)).outcome).toBe("reset"); + } + }), + ); + it.effect("refuses a Claude redemption without an organization or with a malformed grant", () => Effect.gen(function* () { for (const [account, grantId] of [ diff --git a/apps/server/src/usage/cliproxyApi.ts b/apps/server/src/usage/cliproxyApi.ts index 7d595e1c3798a..739b8eef867f2 100644 --- a/apps/server/src/usage/cliproxyApi.ts +++ b/apps/server/src/usage/cliproxyApi.ts @@ -9,6 +9,7 @@ import { import * as Cause from "effect/Cause"; import * as Crypto from "effect/Crypto"; import * as DateTime from "effect/DateTime"; +import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; import * as Hex from "effect/encoding/Hex"; import * as Option from "effect/Option"; @@ -183,6 +184,7 @@ export const makeCliproxyApi = Effect.gen(function* () { config: UsageLimitSourceConfig, path: string, body?: unknown, + timeout: Duration.Input = "15 seconds", ) { const url = yield* Effect.try({ try: () => @@ -200,7 +202,7 @@ export const makeCliproxyApi = Effect.gen(function* () { .pipe( Effect.flatMap(HttpClientResponse.filterStatusOk), Effect.flatMap((response) => response.json), - Effect.timeout("15 seconds"), + Effect.timeout(timeout), Effect.mapError( (error) => new UsageLimitSourceError({ detail: describeManagementFailure(error) }), ), @@ -240,16 +242,20 @@ 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)", }; - const raw = yield* management(config, "api-call", { - auth_index: account.auth_index, - method: data === undefined ? "GET" : "POST", - url, - header, - ...(data === undefined ? {} : { data: yield* encodeJson(data) }), - }); + // A redeem waits on the hub's own upstream call, which can take longer than a read. + const raw = yield* management( + config, + "api-call", + { + auth_index: account.auth_index, + method: data === undefined ? "GET" : "POST", + url, + header, + ...(data === undefined ? {} : { data: yield* encodeJson(data) }), + }, + data === undefined ? undefined : "30 seconds", + ); return yield* decodeApiResponse(raw); }); From f430e1dde548002803b6453bbb84d03d13ab3091 Mon Sep 17 00:00:00 2001 From: Renfei Zhou Date: Sat, 31 Oct 2026 23:42:07 +0000 Subject: [PATCH 5/8] feat(server): optionally require a usage source for Claude logins With T3CODE_CLAUDE_USAGE_SOURCE_ONLY=1, a Claude login that no usage source holds is never read or redeemed directly: its usage shows as unavailable with "No usage source holds this Claude login." Off by default, so an unmatched login keeps reading Claude directly. The whiteboard launch script turns it on. Co-Authored-By: Claude Opus 5.5 --- .../src/provider/Drivers/ClaudeDriver.ts | 25 +++++++++++++------ .../provider/ProviderInstanceRegistry.test.ts | 25 +++++++++++++++++++ fork/whiteboard/run-t3.sh | 2 ++ 3 files changed, 45 insertions(+), 7 deletions(-) diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts index 53500de376600..155c41f85a5a3 100644 --- a/apps/server/src/provider/Drivers/ClaudeDriver.ts +++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts @@ -205,16 +205,27 @@ export const ClaudeDriver: ProviderDriver>, ) { - if (Option.isNone(serverSettings)) return undefined; - const settings = yield* serverSettings.value.getSettings.pipe( - Effect.mapError( - () => new UsageLimitSourceError({ detail: "The usage sources could not be read." }), - ), - ); - return yield* usageSources.findClaudeLogin(Object.values(settings.usageLimitSources), login); + const source = Option.isNone(serverSettings) + ? undefined + : yield* serverSettings.value.getSettings.pipe( + Effect.mapError( + () => new UsageLimitSourceError({ detail: "The usage sources could not be read." }), + ), + Effect.flatMap((settings) => + usageSources.findClaudeLogin(Object.values(settings.usageLimitSources), login), + ), + ); + if (!source && usageSourceOnly) { + return yield* new UsageLimitSourceError({ + detail: "No usage source holds this Claude login.", + }); + } + return source; }); const probeCapabilities = Effect.fn("ClaudeDriver.probeCapabilities")(function* () { diff --git a/apps/server/src/provider/ProviderInstanceRegistry.test.ts b/apps/server/src/provider/ProviderInstanceRegistry.test.ts index 178a2e3549d79..88b0728903e0b 100644 --- a/apps/server/src/provider/ProviderInstanceRegistry.test.ts +++ b/apps/server/src/provider/ProviderInstanceRegistry.test.ts @@ -590,6 +590,7 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { const redeemClaudeReset = (claim: { result: string; usageFailsAfterClaim: boolean; + usageSourceOnly?: boolean; hub?: { accounts: ReadonlyArray<{ email: string; organization_uuid?: string }>; listStatus?: number; @@ -680,6 +681,9 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { ...(claim.usageFailsAfterClaim ? [{ name: "T3_CLAUDE_USAGE_FAILS_AFTER_CLAIM", value: "1", sensitive: false }] : []), + ...(claim.usageSourceOnly + ? [{ name: "T3CODE_CLAUDE_USAGE_SOURCE_ONLY", value: "1", sensitive: false }] + : []), ], config: makeClaudeConfig({ enabled: true, @@ -775,6 +779,27 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), ); + it.live.skipIf(windowsHost)( + "never reads Claude directly for a login no usage source holds when sources are required", + () => + Effect.gen(function* () { + for (const hub of [undefined, { accounts: [{ email: "test@example.com" }] }]) { + const { before, outcome, direct } = yield* redeemClaudeReset({ + result: "reset", + usageFailsAfterClaim: false, + usageSourceOnly: true, + ...(hub ? { hub } : {}), + }); + expect(before.usageLimits?.unavailable).toMatchObject({ + reason: "probeFailed", + message: "No usage source holds this Claude login.", + }); + expect(outcome).toMatchObject({ _tag: "Success", success: "noCredit" }); + expect(direct).toEqual([]); + } + }), + ); + it.live.skipIf(windowsHost)( "shows a usage source failure instead of reading Claude directly", () => diff --git a/fork/whiteboard/run-t3.sh b/fork/whiteboard/run-t3.sh index 32903a58efd30..163caf6d94328 100755 --- a/fork/whiteboard/run-t3.sh +++ b/fork/whiteboard/run-t3.sh @@ -24,6 +24,8 @@ export BASH_ENV="$WB_DIR/tools/agent-env.sh" # into it. The whiteboard wants the new-thread landing instead. export T3CODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD=false export T3CODE_UNSAFE_NO_AUTH=1 +# Claude usage and resets go only through a usage source holding the login, never direct. +export T3CODE_CLAUDE_USAGE_SOURCE_ONLY=1 # exec keeps this PID, so `wb` finds its agent among the server's children. export WB_CHAT_PID=$$ From ba0781c1fc372e373c06aa2c257f6865b695cc60 Mon Sep 17 00:00:00 2001 From: Renfei Zhou Date: Sun, 1 Nov 2026 00:09:59 +0000 Subject: [PATCH 6/8] refactor(server): move Claude usage-source logic into fork-only files Claude reads and resets through a usage source now live in apps/server/src/fork/claudeUsageSource/, with their tests beside them. Upstream files keep only the hooks that call into it, so upstream merges touch as little as possible. Behaviour is unchanged: the PR's original hub and registry tests pass against the new layout. Co-Authored-By: Claude Opus 5.5 --- .../fork/claudeUsageSource/claudeHub.test.ts | 256 +++++++++++++++ .../src/fork/claudeUsageSource/claudeHub.ts | 278 +++++++++++++++++ .../claudeLoginSource.test.ts | 295 ++++++++++++++++++ .../claudeUsageSource/claudeLoginSource.ts | 118 +++++++ apps/server/src/provider/ClaudeProvider.ts | 8 +- .../src/provider/Drivers/ClaudeDriver.ts | 111 ++----- .../provider/ProviderInstanceRegistry.test.ts | 196 ++---------- .../server/src/provider/claudeResetCredits.ts | 104 +++--- apps/server/src/usage/cliproxyApi.test.ts | 171 +--------- apps/server/src/usage/cliproxyApi.ts | 263 +++++----------- 10 files changed, 1111 insertions(+), 689 deletions(-) create mode 100644 apps/server/src/fork/claudeUsageSource/claudeHub.test.ts create mode 100644 apps/server/src/fork/claudeUsageSource/claudeHub.ts create mode 100644 apps/server/src/fork/claudeUsageSource/claudeLoginSource.test.ts create mode 100644 apps/server/src/fork/claudeUsageSource/claudeLoginSource.ts diff --git a/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts b/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts new file mode 100644 index 0000000000000..36048b22918ae --- /dev/null +++ b/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts @@ -0,0 +1,256 @@ +import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; +import { describe, expect, it } from "@effect/vitest"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as Schema from "effect/Schema"; +import * as TestClock from "effect/testing/TestClock"; +import { HttpClient, HttpClientError, HttpClientResponse } from "effect/http"; + +import { makeCliproxyApi } from "../../usage/cliproxyApi.ts"; + +const config = { + kind: "cliproxy", + url: "http://hub.test:8317", + managementKey: "management-secret", + enabled: true, +} as const; +const codex = { + id: "first.json", + auth_index: "a", + provider: "codex", + email: "first@example.com", + id_token: { chatgpt_account_id: "account-a" }, +}; +const claude = { ...codex, provider: "claude", organization_uuid: "org-1" }; +type HubAccount = typeof codex & { disabled?: boolean; organization_uuid?: string }; + +const RequestBody = Schema.Struct({ + auth_index: Schema.String, + method: Schema.optional(Schema.String), + url: Schema.optional(Schema.String), + header: Schema.optional(Schema.Record(Schema.String, Schema.String)), + data: Schema.optional(Schema.String), +}); +type RequestBody = typeof RequestBody.Type; +const decodeRequest = Schema.decodeUnknownSync(Schema.fromJsonString(RequestBody)); +const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown)); + +function fixture(options: { + accounts: ReadonlyArray; + upstream?: (request: RequestBody) => { status: number; body: unknown }; + redeemDelay?: Duration.Input; +}) { + const requests: Array<{ path: string; body?: RequestBody }> = []; + const http = HttpClient.make((request) => + Effect.sync(() => { + const path = new URL(request.url).pathname; + const body = + request.body._tag === "Uint8Array" + ? decodeRequest(new TextDecoder().decode(request.body.body)) + : undefined; + requests.push({ path, ...(body ? { body } : {}) }); + if (path.endsWith("/auth-files")) { + return HttpClientResponse.fromWeb(request, Response.json({ files: options.accounts })); + } + if (path.endsWith("/reset-quota")) { + return HttpClientResponse.fromWeb(request, Response.json({})); + } + const upstream = options.upstream?.(body!) ?? { status: 200, body: {} }; + return HttpClientResponse.fromWeb( + request, + Response.json({ status_code: upstream.status, body: encodeJson(upstream.body) }), + ); + }).pipe( + Effect.delay( + request.method === "POST" && request.url.endsWith("/api-call") + ? (options.redeemDelay ?? 0) + : 0, + ), + ), + ); + return { + requests, + api: makeCliproxyApi.pipe( + Effect.provideService(HttpClient.HttpClient, http), + Effect.provide(NodeCrypto.layer), + ), + }; +} + +describe("Claude through a CLIProxyAPI hub", () => { + it.effect("reads Claude reset credits with the account's usage", () => + Effect.gen(function* () { + yield* TestClock.setTime(Date.parse("2026-10-31T12:00:00Z")); + const test = fixture({ + accounts: [claude], + upstream: () => ({ + status: 200, + 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 }, + }, + }), + }); + const result = yield* (yield* test.api).readAccounts(config); + 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("finds a Claude login only by its exact email and organization", () => + Effect.gen(function* () { + const login = { email: "FIRST@example.com", organizationId: "org-1" }; + for (const [hubAccounts, expected] of [ + [[{ ...claude, organization_uuid: "org-2" }, claude], "first.json"], + [[{ ...claude, organization_uuid: "org-2" }], undefined], + [[{ ...codex, provider: "claude" }], undefined], + [[{ ...claude, disabled: true }], undefined], + [[claude, { ...claude, id: "copy.json" }], undefined], + ] as const) { + const api = yield* fixture({ accounts: hubAccounts }).api; + expect((yield* api.claude.findLogin([config], login))?.account.id).toBe(expected); + } + const test = fixture({ accounts: [claude] }); + const api = yield* test.api; + expect( + yield* api.claude.findLogin( + [ + { ...config, enabled: false }, + { ...config, managementKey: "" }, + ], + login, + ), + ).toBeUndefined(); + expect( + yield* api.claude.findLogin([config], { ...login, organizationId: undefined }), + ).toBeUndefined(); + expect(test.requests).toEqual([]); + const unreachable = yield* makeCliproxyApi.pipe( + Effect.provideService( + HttpClient.HttpClient, + HttpClient.make((request) => + Effect.fail( + new HttpClientError.HttpClientError({ + reason: new HttpClientError.TransportError({ request }), + }), + ), + ), + ), + Effect.provide(NodeCrypto.layer), + ); + const error = yield* Effect.flip(unreachable.claude.findLogin([config], login)); + expect(error._tag).toBe("UsageLimitSourceError"); + }), + ); + + it.effect("redeems a Claude reset for the account's own organization", () => + Effect.gen(function* () { + 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(JSON.parse(redemption?.body?.data ?? "")).toEqual({ + program: "cedar_ember", + grant_id: "grant_a", + request_id: expect.stringMatching(/^[0-9a-f-]{36}$/), + }); + expect(test.requests.some((request) => request.path.endsWith("/reset-quota"))).toBe( + clearsCooldown, + ); + } + const twice = answer(200, { result: "reset" }); + const api = yield* twice.api; + yield* api.consume(config, "first.json", "grant_a"); + yield* api.consume(config, "first.json", "grant_a"); + const requestIds = twice.requests.flatMap((request) => + request.body?.data ? [JSON.parse(request.body.data).request_id] : [], + ); + expect(new Set(requestIds).size).toBe(2); + 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("waits longer for a redeem than for a read", () => + Effect.gen(function* () { + for (const account of [codex, claude]) { + const api = yield* fixture({ + accounts: [account], + upstream: (request) => ({ + status: 200, + body: request.url?.endsWith("/consume") ? { code: "reset" } : { result: "reset" }, + }), + redeemDelay: "29 seconds", + }).api; + const redeem = yield* Effect.forkChild(api.consume(config, "first.json", "grant_a")); + yield* TestClock.adjust("29 seconds"); + expect((yield* Fiber.join(redeem)).outcome).toBe("reset"); + } + }), + ); + + it.effect("refuses a Claude redemption without an organization or with a malformed grant", () => + Effect.gen(function* () { + for (const [account, grantId] of [ + [{ ...codex, provider: "claude" }, "grant_a"], + [{ ...claude, organization_uuid: " " }, "grant_a"], + [claude, "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/fork/claudeUsageSource/claudeHub.ts b/apps/server/src/fork/claudeUsageSource/claudeHub.ts new file mode 100644 index 0000000000000..c4ac606638c9e --- /dev/null +++ b/apps/server/src/fork/claudeUsageSource/claudeHub.ts @@ -0,0 +1,278 @@ +import { UsageLimitSourceError, type UsageLimitSourceConfig } from "@t3tools/contracts"; +import * as Crypto from "effect/Crypto"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; + +import { + CLAIM_OUTCOMES, + ClaimResponse, + ClaudeResetCreditError, + GRANT_ID, + PROGRAM, + REQUEST_ID, + claudeResetCreditsToContract, +} from "../../provider/claudeResetCredits.ts"; + +type HubAccount = { + readonly auth_index: string; + readonly provider: string; + readonly email?: string | undefined; + readonly disabled?: boolean | undefined; + readonly organization_uuid?: string | undefined; +}; + +export type ClaudeLogin = { + readonly email: string | undefined; + readonly organizationId: string | undefined; +}; + +const ClaudeWindow = Schema.Struct({ + utilization: Schema.Number, + 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( + Schema.Array( + Schema.Struct({ + kind: Schema.String, + percent: Schema.optional(Schema.NullOr(Schema.Number)), + resets_at: Schema.optional(Schema.NullOr(Schema.String)), + scope: Schema.optional( + Schema.NullOr( + Schema.Struct({ + model: Schema.optional(Schema.NullOr(Schema.Struct({ display_name: Schema.String }))), + }), + ), + ), + }), + ), + ), +}); +const ApiResponse = Schema.Struct({ status_code: Schema.Number, body: Schema.String }); + +const decodeClaudeUsage = Schema.decodeUnknownEffect(Schema.fromJsonString(ClaudeUsage)); +const decodeApiResponse = Schema.decodeUnknownEffect(ApiResponse); +const decodeClaimResponse = Schema.decodeUnknownEffect(Schema.fromJsonString(ClaimResponse)); +const encodeJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown)); +const isUsageLimitSourceError = Schema.is(UsageLimitSourceError); + +const CLAUDE_API = "https://api.anthropic.com/api"; +export const CLAUDE_USAGE_URL = `${CLAUDE_API}/oauth/usage?cedar_ember=1&skip_spend=1`; + +/** A redeem waits on the hub's own call to the provider, which can take longer than a read. */ +export const managementTimeout = (body: unknown) => + typeof body === "object" && body !== null && "data" in body ? "30 seconds" : "15 seconds"; + +/** Claude reads and reset claims through a CLIProxyAPI hub's management API. */ +export const makeClaudeHub = Effect.fn("makeClaudeHub")(function* ( + management: ( + config: UsageLimitSourceConfig, + path: string, + body?: unknown, + ) => Effect.Effect, + authFiles: ( + config: UsageLimitSourceConfig, + ) => Effect.Effect, UsageLimitSourceError | Schema.SchemaError>, +) { + const crypto = yield* Crypto.Crypto; + + const apiCall = Effect.fn("ClaudeHub.apiCall")(function* ( + config: UsageLimitSourceConfig, + account: HubAccount, + url: string, + data?: unknown, + ) { + const raw = yield* management(config, "api-call", { + auth_index: account.auth_index, + method: data === undefined ? "GET" : "POST", + url, + header: { Authorization: "Bearer $TOKEN$", "anthropic-beta": "oauth-2025-04-20" }, + ...(data === undefined ? {} : { data: yield* encodeJson(data) }), + }); + return yield* decodeApiResponse(raw); + }); + + const resetCredits = Effect.fn("ClaudeHub.resetCredits")(function* ( + usage: typeof ClaudeUsage.Type, + ) { + return claudeResetCreditsToContract( + usage.cedar_ember, + DateTime.toEpochMillis(yield* DateTime.now), + ); + }); + + /** Adds reset credits from a usage answer to a hub account read from it. */ + const withResetCredits = Effect.fn("ClaudeHub.withResetCredits")(function* < + A extends { readonly usageLimits: object }, + >(body: string, account: A) { + const credits = yield* resetCredits(yield* decodeClaudeUsage(body)); + return credits + ? { ...account, usageLimits: { ...account.usageLimits, resetCredits: credits } } + : account; + }); + + /** Usage in the Claude SDK's get_usage shape, plus reset credits. */ + const usage = Effect.fn("ClaudeHub.usage")( + function* (config: UsageLimitSourceConfig, account: HubAccount) { + const response = yield* apiCall(config, account, CLAUDE_USAGE_URL); + if (response.status_code < 200 || response.status_code >= 300) { + return yield* new UsageLimitSourceError({ + detail: `The provider refused the hub request (HTTP ${response.status_code}).`, + }); + } + const usage = yield* decodeClaudeUsage(response.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: yield* resetCredits(usage), + }; + }, + Effect.mapError((error) => + isUsageLimitSourceError(error) + ? error + : new UsageLimitSourceError({ detail: "The hub returned an unexpected usage response." }), + ), + ); + + const claim = Effect.fn("ClaudeHub.claim")(function* ( + config: UsageLimitSourceConfig, + account: HubAccount, + grantId: string, + requestId: string, + ) { + if (!GRANT_ID.test(grantId) || !REQUEST_ID.test(requestId)) { + return yield* new ClaudeResetCreditError({ reason: "malformedCredit" }); + } + 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* apiCall( + config, + account, + `${CLAUDE_API}/organizations/${encodeURIComponent(organization)}/reset_rate_limits`, + { program: PROGRAM, grant_id: grantId, request_id: requestId }, + ); + if (response.status_code === 429) { + return yield* new ClaudeResetCreditError({ reason: "rateLimited" }); + } + if (response.status_code === 401 || response.status_code === 403) { + return yield* new ClaudeResetCreditError({ reason: "signedOut" }); + } + if (response.status_code < 200 || response.status_code >= 300) { + return yield* new ClaudeResetCreditError({ reason: "requestFailed" }); + } + const body = yield* decodeClaimResponse(response.body).pipe( + 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 clearCooldown = (config: UsageLimitSourceConfig, account: HubAccount) => + management(config, "reset-quota", { auth_index: account.auth_index }); + + /** The source account holding a directly signed-in Claude login, if exactly one source has it. */ + const findLogin = Effect.fn("ClaudeHub.findLogin")(function* ( + sources: ReadonlyArray, + login: ClaudeLogin, + ) { + const { email, organizationId } = login; + if (!email || !organizationId) return undefined; + for (const config of sources) { + if (!config.enabled || !config.managementKey) continue; + const accounts = yield* authFiles(config).pipe( + Effect.mapError((error) => + isUsageLimitSourceError(error) + ? error + : new UsageLimitSourceError({ detail: "The hub could not list accounts." }), + ), + ); + const matches = accounts.filter( + (account) => + account.provider === "claude" && + !account.disabled && + account.email?.toLowerCase() === email.toLowerCase() && + account.organization_uuid === organizationId, + ); + 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 claimLogin = Effect.fn("ClaudeHub.claimLogin")(function* ( + config: UsageLimitSourceConfig, + account: HubAccount, + grantId: string, + requestId: string, + ) { + const outcome = yield* claim(config, account, grantId, requestId); + if (outcome === "reset" || outcome === "alreadyRedeemed") { + yield* clearCooldown(config, account).pipe(Effect.ignore); + } + return outcome; + }); + + /** Redeems a reset on a Claude account the hub lists. */ + const consume = Effect.fn("ClaudeHub.consume")(function* ( + config: UsageLimitSourceConfig, + account: HubAccount, + grantId: string, + ) { + if (account.disabled) { + return yield* new UsageLimitSourceError({ + detail: "The hub account is missing or disabled.", + }); + } + // A Claude grant can hold several resets, so each claim needs its own request id. + const outcome = yield* claim(config, account, grantId, yield* crypto.randomUUIDv4()).pipe( + Effect.catchTags({ + ClaudeResetCreditError: (error) => + Effect.fail(new UsageLimitSourceError({ detail: error.message })), + }), + ); + if (outcome !== "reset" && outcome !== "alreadyRedeemed") return { outcome }; + const cleared = yield* clearCooldown(config, account).pipe(Effect.result); + return { + outcome, + ...(cleared._tag === "Failure" + ? { + warning: + "Credit redeemed, but the hub cooldown could not be cleared. Routing may resume after its cooldown expires.", + } + : {}), + } as const; + }); + + return { withResetCredits, usage, findLogin, claimLogin, consume }; +}); diff --git a/apps/server/src/fork/claudeUsageSource/claudeLoginSource.test.ts b/apps/server/src/fork/claudeUsageSource/claudeLoginSource.test.ts new file mode 100644 index 0000000000000..e51e7dd16b45a --- /dev/null +++ b/apps/server/src/fork/claudeUsageSource/claudeLoginSource.test.ts @@ -0,0 +1,295 @@ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { describe, expect, it } from "@effect/vitest"; +import { + type ClaudeSettings, + EnvironmentId, + ProviderDriverKind, + ProviderInstanceId, + UsageLimitSourceId, +} from "@t3tools/contracts"; +import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions"; +import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers"; +import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions"; +import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver"; +import * as HostProcess from "@t3tools/shared/HostProcess"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Layer from "effect/Layer"; +import * as Path from "effect/Path"; +import * as Schema from "effect/Schema"; +import { HttpClient, HttpClientResponse } from "effect/http"; + +import * as ServerSecretStore from "../../auth/ServerSecretStore.ts"; +import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts"; +import * as ServerConfig from "../../config.ts"; +import * as ServerEnvironment from "../../environment/ServerEnvironment.ts"; +import * as PortScanner from "../../preview/PortScanner.ts"; +import { ClaudeDriver } from "../../provider/Drivers/ClaudeDriver.ts"; +import * as ModelManifest from "../../provider/ModelManifest.ts"; +import { makeProviderInstanceRegistry } from "../../provider/ProviderInstanceRegistry.ts"; +import * as ProviderHostLive from "../../provider/ProviderHostLive.ts"; +import * as ProviderOrchestrationAdapterInfrastructure from "../../provider/ProviderOrchestrationAdapterInfrastructure.ts"; +import * as ResetCreditCoordinator from "../../provider/resetCreditCoordinator.ts"; +import * as ServerSettings from "../../serverSettings.ts"; + +// The mock Claude CLI is a script Windows cannot execute. +const windowsHost = HostProcess.Platform.defaultValue() === "win32"; + +const decodeHubCall = Schema.decodeUnknownSync( + Schema.fromJsonString(Schema.Struct({ url: Schema.String })), +); + +const layerTest = ProviderOrchestrationAdapterInfrastructure.layer.pipe( + Layer.provide(PortScanner.layerTest), + Layer.provideMerge(ProviderHostLive.layer), + Layer.provideMerge( + ServerConfig.layerTest(process.cwd(), { prefix: "claude-login-source-test" }).pipe( + Layer.provideMerge(NodeServices.layer), + Layer.provideMerge(ServerSettings.layerTest()), + Layer.provideMerge(Layer.mock(ServerSecretStore.ServerSecretStore)({})), + Layer.provideMerge(Layer.mock(SecretResolver.SecretResolver)({})), + Layer.provideMerge( + Layer.succeed(ServerEnvironment.ServerEnvironmentIdentity, { + getEnvironmentId: Effect.succeed( + EnvironmentId.make("00000000-0000-4000-8000-000000000001"), + ), + }), + ), + Layer.provideMerge( + Layer.mock(BackgroundPolicy.BackgroundPolicy)({ + shouldRunScopeWork: () => Effect.succeed(true), + shouldRunOpportunisticWork: Effect.succeed(true), + }), + ), + Layer.provideMerge( + Layer.succeed( + ProviderEventLoggers.ProviderEventLoggers, + ProviderEventLoggers.NoOpProviderEventLoggers, + ), + ), + Layer.provideMerge(ProviderLatestVersions.layer), + Layer.provideMerge(McpProviderSessions.layer), + Layer.provideMerge(ModelManifest.layerTest), + Layer.provideMerge(ResetCreditCoordinator.layerTest), + ), + ), +); + +const redeemClaudeReset = (claim: { + usageSourceOnly?: boolean; + hub?: { + accounts: ReadonlyArray<{ email: string; organization_uuid?: string }>; + listStatus?: number; + usageStatus?: number; + }; +}) => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const fixtureDir = yield* fs.makeTempDirectoryScoped(); + const claudePath = path.join(fixtureDir, "claude"); + const claudeHomePath = path.join(fixtureDir, "claude-home"); + yield* fs.copyFile( + yield* path.fromFileUrl( + new URL("../../provider/testing/ProviderInstanceRegistryLive.fixture.mjs", import.meta.url), + ), + claudePath, + ); + yield* fs.chmod(claudePath, 0o755); + yield* fs.makeDirectory(claudeHomePath); + const marker = path.join(claudeHomePath, "redeemed"); + yield* fs.writeFileString( + path.join(claudeHomePath, ".credentials.json"), + '{"claudeAiOauth":{"accessToken":"fake-token"}}', + ); + yield* fs.writeFileString( + path.join(claudeHomePath, ".claude.json"), + '{"oauthAccount":{"emailAddress":"test@example.com","organizationUuid":"fake-org"}}', + ); + const direct: Array = []; + const viaHub: Array = []; + let hubRedeemed = false; + const credits = { + eligible: true, + next_grant_id: "grant_a", + grants: [{ id: "grant_a", resets_left: 1, usable_now: true }], + }; + const client = HttpClient.make((request) => + Effect.gen(function* () { + const json = (body: unknown, status = 200) => + HttpClientResponse.fromWeb(request, Response.json(body, { status })); + const url = new URL(request.url); + if (claim.hub && url.host === "hub.test") { + if (url.pathname.endsWith("/auth-files")) { + viaHub.push("auth-files"); + return json( + { + files: claim.hub.accounts.map((account, index) => ({ + id: `${index}.json`, + auth_index: `${index}`, + provider: "claude", + ...account, + })), + }, + claim.hub.listStatus, + ); + } + if (url.pathname.endsWith("/reset-quota")) { + viaHub.push("reset-quota"); + return json({}); + } + const call = decodeHubCall( + request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : "", + ); + viaHub.push(call.url); + if (call.url.endsWith("/reset_rate_limits")) { + hubRedeemed = true; + return json({ status_code: 200, body: JSON.stringify({ result: "reset" }) }); + } + return json({ + status_code: claim.hub.usageStatus ?? 200, + body: JSON.stringify({ + five_hour: { utilization: hubRedeemed ? 0 : 100, resets_at: null }, + cedar_ember: credits, + }), + }); + } + if (url.host === "api.anthropic.com") direct.push(url.pathname); + if (request.url.endsWith("/api/oauth/usage")) return json({ cedar_ember: credits }); + if (request.url.endsWith("/reset_rate_limits")) { + yield* fs.writeFileString(marker, "redeemed").pipe(Effect.orDie); + return json({ result: "reset" }); + } + return json({ version: "0.0.0" }); + }), + ); + const instanceId = ProviderInstanceId.make("claude_reset"); + const { registry } = yield* makeProviderInstanceRegistry({ + drivers: [ClaudeDriver], + configMap: { + [instanceId]: { + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + environment: [ + { name: "T3_CLAUDE_RESET_MARKER", value: marker, sensitive: false }, + ...(claim.usageSourceOnly + ? [{ name: "T3CODE_CLAUDE_USAGE_SOURCE_ONLY", value: "1", sensitive: false }] + : []), + ], + config: { + enabled: true, + binaryPath: claudePath, + homePath: claudeHomePath, + customModels: [], + launchArgs: "", + autoCompactWindow: "", + idleCompaction: "default", + } satisfies ClaudeSettings, + }, + }, + }).pipe( + Effect.provideService(HttpClient.HttpClient, client), + Effect.provide( + ServerSettings.layerTest( + claim.hub + ? { + usageLimitSources: { + [UsageLimitSourceId.make("hub")]: { + kind: "cliproxy", + url: "http://hub.test", + managementKey: "hub-key", + enabled: true, + }, + }, + } + : {}, + ), + ), + ); + const instance = yield* registry.getInstance(instanceId); + expect(instance).toBeDefined(); + const before = yield* instance!.snapshot.refresh; + const outcome = yield* instance!.consumeResetCredit!().pipe(Effect.result); + return { before, outcome, after: yield* instance!.snapshot.getSnapshot, direct, viaHub }; + }).pipe( + // macOS logins live in the Keychain, where resets are never read. + Effect.provideService(HostProcess.Platform, "linux"), + Effect.provide(layerTest), + ); + +describe("Claude logins held by a usage source", () => { + it.live.skipIf(windowsHost)("reads Claude directly when no usage source holds the login", () => + Effect.gen(function* () { + const { before, outcome, after, direct, viaHub } = yield* redeemClaudeReset({ + hub: { + accounts: [ + { email: "test@example.com", organization_uuid: "other-org" }, + { email: "test@example.com" }, + ], + }, + }); + expect(before.usageLimits?.windows[0]?.usedPercent).toBe(100); + expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); + expect(outcome).toMatchObject({ _tag: "Success", success: "reset" }); + expect(after.usageLimits?.windows[0]?.usedPercent).toBe(0); + expect(direct).toContain("/api/organizations/fake-org/reset_rate_limits"); + expect(viaHub.every((call) => call === "auth-files")).toBe(true); + }), + ); + + it.live.skipIf(windowsHost)("reads and redeems the login only through that source", () => + Effect.gen(function* () { + const { before, outcome, after, direct, viaHub } = yield* redeemClaudeReset({ + hub: { accounts: [{ email: "TEST@example.com", organization_uuid: "fake-org" }] }, + }); + expect(before.usageLimits?.windows[0]?.usedPercent).toBe(100); + expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); + expect(outcome).toMatchObject({ _tag: "Success", success: "reset" }); + expect(after.usageLimits?.windows[0]?.usedPercent).toBe(0); + expect(direct).toEqual([]); + expect(viaHub).toContain( + "https://api.anthropic.com/api/organizations/fake-org/reset_rate_limits", + ); + expect(viaHub).toContain("reset-quota"); + }), + ); + + it.live.skipIf(windowsHost)( + "never reads Claude directly for a login no source holds when sources are required", + () => + Effect.gen(function* () { + for (const hub of [undefined, { accounts: [{ email: "test@example.com" }] }]) { + const { before, outcome, direct } = yield* redeemClaudeReset({ + usageSourceOnly: true, + ...(hub ? { hub } : {}), + }); + expect(before.usageLimits?.unavailable).toMatchObject({ + reason: "probeFailed", + message: "No usage source holds this Claude login.", + }); + expect(outcome).toMatchObject({ _tag: "Success", success: "noCredit" }); + expect(direct).toEqual([]); + } + }), + ); + + it.live.skipIf(windowsHost)("shows a usage source failure instead of reading Claude", () => + Effect.gen(function* () { + for (const failure of [{ usageStatus: 503 }, { listStatus: 500 }]) { + const { before, outcome, direct } = yield* redeemClaudeReset({ + hub: { + accounts: [{ email: "test@example.com", organization_uuid: "fake-org" }], + ...failure, + }, + }); + expect(before.usageLimits?.unavailable).toMatchObject({ + reason: "probeFailed", + message: expect.any(String), + }); + expect(before.usageLimits?.resetCredits).toBeUndefined(); + expect(outcome).toMatchObject({ _tag: "Success", success: "noCredit" }); + expect(direct).toEqual([]); + } + }), + ); +}); diff --git a/apps/server/src/fork/claudeUsageSource/claudeLoginSource.ts b/apps/server/src/fork/claudeUsageSource/claudeLoginSource.ts new file mode 100644 index 0000000000000..7441eb02a298a --- /dev/null +++ b/apps/server/src/fork/claudeUsageSource/claudeLoginSource.ts @@ -0,0 +1,118 @@ +import { + UsageLimitSourceError, + type ClaudeSettings, + type ServerProviderResetCredits, +} from "@t3tools/contracts"; +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 Ref from "effect/Ref"; +import * as Result from "effect/Result"; +import * as Schema from "effect/Schema"; + +import * as Settings from "../../serverSettings.ts"; +import { makeCliproxyApi } from "../../usage/cliproxyApi.ts"; +import { probeClaudeCapabilities } from "../../provider/ClaudeProvider.ts"; + +const AccountConfig = Schema.Struct({ + oauthAccount: Schema.optional( + Schema.Struct({ + emailAddress: Schema.optional(Schema.String), + organizationUuid: Schema.optional(Schema.String), + }), + ), +}); +const decodeAccountConfig = Schema.decodeEffect(Schema.fromJsonString(AccountConfig)); + +/** + * A Claude login held by a usage source is read and redeemed only through that source. + * With T3CODE_CLAUDE_USAGE_SOURCE_ONLY=1 a login no source holds is never read directly. + */ +export const makeClaudeLoginSource = Effect.fn("makeClaudeLoginSource")(function* ( + accountConfigPath: string, + processEnv: NodeJS.ProcessEnv, +) { + const { claude } = yield* makeCliproxyApi; + const serverSettings = yield* Effect.serviceOption(Settings.ServerSettingsService); + const fileSystem = yield* FileSystem.FileSystem; + const sourceOnly = processEnv.T3CODE_CLAUDE_USAGE_SOURCE_ONLY === "1"; + const sourceCredits = yield* Ref.make(Option.none()); + + const readLogin = fileSystem.readFileString(accountConfigPath).pipe( + Effect.flatMap(decodeAccountConfig), + Effect.map(({ oauthAccount }) => ({ + email: oauthAccount?.emailAddress?.trim() || undefined, + organizationId: oauthAccount?.organizationUuid?.trim() || undefined, + })), + Effect.orElseSucceed(() => ({ email: undefined, organizationId: undefined })), + ); + + const findSource = Effect.fn("ClaudeLoginSource.findSource")(function* () { + const login = yield* readLogin; + const source = Option.isNone(serverSettings) + ? undefined + : yield* serverSettings.value.getSettings.pipe( + Effect.mapError( + () => new UsageLimitSourceError({ detail: "The usage sources could not be read." }), + ), + Effect.flatMap((settings) => + claude.findLogin(Object.values(settings.usageLimitSources), login), + ), + ); + if (!source && sourceOnly) { + return yield* new UsageLimitSourceError({ + detail: "No usage source holds this Claude login.", + }); + } + return source; + }); + + /** Probes Claude, taking usage from the source holding the login instead of from Claude. */ + const probe = Effect.fn("ClaudeLoginSource.probe")(function* ( + settings: ClaudeSettings, + environment: NodeJS.ProcessEnv, + cwd: string, + ) { + const usageCheckedAt = DateTime.formatIso(yield* DateTime.now); + const viaSource = yield* findSource().pipe( + Effect.flatMap((source) => + source + ? claude.usage(source.config, source.account).pipe(Effect.asSome) + : Effect.succeedNone, + ), + Effect.result, + ); + const direct = Result.isSuccess(viaSource) && Option.isNone(viaSource.success); + const capabilities = yield* probeClaudeCapabilities(settings, environment, cwd, direct); + yield* Ref.set( + sourceCredits, + Result.isSuccess(viaSource) + ? Option.map(viaSource.success, (usage) => usage.resetCredits) + : Option.none(), + ); + if (Result.isFailure(viaSource)) { + return { ...capabilities, usageError: { message: viaSource.failure.detail } }; + } + if (Option.isNone(viaSource.success)) return capabilities; + return { ...capabilities, usage: viaSource.success.value.response, usageCheckedAt }; + }); + + /** Reset credits from the source that answered the last probe, else the direct read. */ + const resetCredits = ( + direct: Effect.Effect, + ) => + Ref.get(sourceCredits).pipe( + Effect.flatMap(Option.match({ onNone: () => direct, onSome: Effect.succeed })), + ); + + /** Sends a claim to the source holding the login instead of to Claude. */ + const claimRoute = Effect.fn("ClaudeLoginSource.claimRoute")(function* (grantId: string) { + const source = yield* findSource(); + return (requestId: string) => + (direct: Effect.Effect) => + source ? claude.claimLogin(source.config, source.account, grantId, requestId) : direct; + }); + + return { probe, resetCredits, claimRoute }; +}); diff --git a/apps/server/src/provider/ClaudeProvider.ts b/apps/server/src/provider/ClaudeProvider.ts index 53212dcd9fa7c..fd2e17e343c77 100644 --- a/apps/server/src/provider/ClaudeProvider.ts +++ b/apps/server/src/provider/ClaudeProvider.ts @@ -244,7 +244,7 @@ export type ClaudeCapabilitiesProbe = { /** Undefined means get_usage failed; absent windows on success mean no subscription windows, as with API keys. */ readonly usage?: Pick; readonly usageCheckedAt?: string; - readonly usageError?: string; + readonly usageError?: { readonly message: string }; }; function parseClaudeInitializationCommands( @@ -639,11 +639,7 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")( }); const usageCheckedAt = capabilities.usageCheckedAt ?? checkedAt; const usageLimits = !capabilities.usage - ? makeUnavailableUsageLimits({ - checkedAt, - reason: "probeFailed", - ...(capabilities.usageError ? { message: capabilities.usageError } : {}), - }) + ? makeUnavailableUsageLimits({ checkedAt, reason: "probeFailed", ...capabilities.usageError }) : scopedLimitNames ? yield* recordClaudeUsageResponse(scopedLimitNames, { response: capabilities.usage, diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts index 155c41f85a5a3..adcc13f607b19 100644 --- a/apps/server/src/provider/Drivers/ClaudeDriver.ts +++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts @@ -1,15 +1,12 @@ -import { ClaudeSettings, ProviderDriverKind, UsageLimitSourceError } from "@t3tools/contracts"; +import { ClaudeSettings, ProviderDriverKind } 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 Result from "effect/Result"; import * as Schema from "effect/Schema"; import { HttpClient } from "effect/http"; import { ChildProcessSpawner } from "effect/process"; @@ -18,8 +15,6 @@ 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 { @@ -31,10 +26,10 @@ import { claudeUsageReader } from "./claudeUsage.ts"; import { makeClaudeScopedLimitNames } from "../claudeUsageLimits.ts"; import * as ClaudeResetCredits from "../claudeResetCredits.ts"; import * as ResetCreditCoordinator from "../resetCreditCoordinator.ts"; +import { makeClaudeLoginSource } from "../../fork/claudeUsageSource/claudeLoginSource.ts"; import { checkClaudeProviderStatus, makePendingClaudeProvider, - probeClaudeCapabilities, probeClaudeWorkspaceSnapshot, type ClaudeCapabilitiesProbe, } from "../ClaudeProvider.ts"; @@ -135,8 +130,6 @@ export const ClaudeDriver: ProviderDriver>, - ) { - const source = Option.isNone(serverSettings) - ? undefined - : yield* serverSettings.value.getSettings.pipe( - Effect.mapError( - () => new UsageLimitSourceError({ detail: "The usage sources could not be read." }), - ), - Effect.flatMap((settings) => - usageSources.findClaudeLogin(Object.values(settings.usageLimitSources), login), - ), - ); - if (!source && usageSourceOnly) { - return yield* new UsageLimitSourceError({ - detail: "No usage source holds this Claude login.", - }); - } - return source; - }); - - const probeCapabilities = Effect.fn("ClaudeDriver.probeCapabilities")(function* () { - const login = yield* ClaudeResetCredits.readClaudeLogin(accountConfigPath); - const usageCheckedAt = DateTime.formatIso(yield* DateTime.now); - const viaSource = yield* findUsageSource(login).pipe( - Effect.flatMap((source) => - source - ? usageSources.claudeUsage(source.config, source.account).pipe(Effect.asSome) - : Effect.succeedNone, - ), - Effect.result, - ); - const direct = Result.isSuccess(viaSource) && Option.isNone(viaSource.success); - const probed = yield* probeClaudeCapabilities(effectiveConfig, processEnv, stateDir, direct); - const capabilities: ClaudeCapabilitiesProbe = login.organizationId - ? { ...probed, workspaceId: login.organizationId } - : probed; - if (Result.isFailure(viaSource)) { - return { capabilities: { ...capabilities, usageError: viaSource.failure.detail } }; - } - if (Option.isNone(viaSource.success)) return { capabilities }; - const { response, resetCredits } = viaSource.success.value; - return { - capabilities: { ...capabilities, usage: response, usageCheckedAt }, - source: { 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( () => - probeCapabilities().pipe( - Effect.map((entry) => ({ _tag: "fresh" as const, ...entry })), + claudeSource.probe(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.tap(({ capabilities }) => Ref.set(lastGoodCapabilities, capabilities)), Effect.catch((error) => Ref.getAndSet(lastGoodCapabilities, undefined).pipe( @@ -317,17 +268,11 @@ export const ClaudeDriver: ProviderDriver - Cache.get(capabilitiesProbeCache, capabilitiesCacheKey).pipe( - Effect.flatMap((entry) => - "source" in entry && entry.source - ? Effect.succeed(entry.source.resetCredits) - : ClaudeResetCredits.readClaudeResetCredits(configDir, version).pipe( - Effect.provideService(HttpClient.HttpClient, httpClient), - Effect.provideService(FileSystem.FileSystem, fileSystem), - Effect.provideService(Path.Path, path), - ), - ), - Effect.orElseSucceed(() => undefined), + ClaudeResetCredits.readClaudeResetCredits(configDir, version).pipe( + Effect.provideService(HttpClient.HttpClient, httpClient), + Effect.provideService(FileSystem.FileSystem, fileSystem), + Effect.provideService(Path.Path, path), + claudeSource.resetCredits, ), ), ), @@ -391,21 +336,17 @@ export const ClaudeDriver: ProviderDriver - source - ? usageSources.claimClaudeLogin(source.config, source.account, grantId, requestId) - : ClaudeResetCredits.consumeClaudeResetCredit({ - configDir, - accountConfigPath, - version, - grantId, - requestId, - }), + ClaudeResetCredits.consumeClaudeResetCredit({ + configDir, + accountConfigPath, + version, + grantId, + requestId, + }).pipe(viaSource(requestId)), ClaudeResetCredits.isSettledClaudeResetCreditFailure, ); }, diff --git a/apps/server/src/provider/ProviderInstanceRegistry.test.ts b/apps/server/src/provider/ProviderInstanceRegistry.test.ts index 88b0728903e0b..af3359ea7f27d 100644 --- a/apps/server/src/provider/ProviderInstanceRegistry.test.ts +++ b/apps/server/src/provider/ProviderInstanceRegistry.test.ts @@ -17,7 +17,6 @@ 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"; @@ -61,10 +60,6 @@ const layerTestHttpClient = Layer.succeed( ), ); -const decodeHubCall = Schema.decodeUnknownSync( - Schema.fromJsonString(Schema.Struct({ url: Schema.String })), -); - // The mock CLIs from makeTildeProviderFixtures are scripts Windows cannot execute. const windowsHost = HostProcess.Platform.defaultValue() === "win32"; @@ -587,16 +582,7 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }).pipe(Effect.provide(layerTest)), ); - const redeemClaudeReset = (claim: { - result: string; - usageFailsAfterClaim: boolean; - usageSourceOnly?: boolean; - hub?: { - accounts: ReadonlyArray<{ email: string; organization_uuid?: string }>; - listStatus?: number; - usageStatus?: number; - }; - }) => + const redeemClaudeReset = (claim: { result: string; usageFailsAfterClaim: boolean }) => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; @@ -608,65 +594,27 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { ); yield* fs.writeFileString( path.join(fixtures.claudeHomePath, ".claude.json"), - '{"oauthAccount":{"emailAddress":"test@example.com","organizationUuid":"fake-org"}}', + '{"oauthAccount":{"organizationUuid":"fake-org"}}', ); - const direct: Array = []; - const viaHub: Array = []; - let hubRedeemed = false; - const credits = { - eligible: true, - next_grant_id: "grant_a", - grants: [{ id: "grant_a", resets_left: 1, usable_now: true }], - }; const client = HttpClient.make((request) => Effect.gen(function* () { - const json = (body: unknown, status = 200) => - HttpClientResponse.fromWeb(request, Response.json(body, { status })); - const url = new URL(request.url); - if (claim.hub && url.host === "hub.test") { - if (url.pathname.endsWith("/auth-files")) { - viaHub.push("auth-files"); - return json( - { - files: claim.hub.accounts.map((account, index) => ({ - id: `${index}.json`, - auth_index: `${index}`, - provider: "claude", - ...account, - })), + 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 }], }, - claim.hub.listStatus, - ); - } - if (url.pathname.endsWith("/reset-quota")) { - viaHub.push("reset-quota"); - return json({}); - } - const call = decodeHubCall( - request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : "", - ); - viaHub.push(call.url); - if (call.url.endsWith("/reset_rate_limits")) { - hubRedeemed = true; - return json({ status_code: 200, body: JSON.stringify({ result: claim.result }) }); - } - return json({ - status_code: claim.hub.usageStatus ?? 200, - body: JSON.stringify({ - five_hour: { utilization: hubRedeemed ? 0 : 100, resets_at: null }, - cedar_ember: credits, }), - }); - } - if (url.host === "api.anthropic.com") direct.push(url.pathname); - if (request.url.endsWith("/api/oauth/usage")) { - return json({ cedar_ember: credits }); + ); } if (request.url.endsWith("/reset_rate_limits")) { yield* fs.writeFileString(marker, "redeemed").pipe(Effect.orDie); - return json({ result: claim.result }); + return HttpClientResponse.fromWeb(request, Response.json({ result: claim.result })); } - return json({ version: "0.0.0" }); + return HttpClientResponse.fromWeb(request, Response.json({ version: "0.0.0" })); }), ); const instanceId = ProviderInstanceId.make("claude_reset"); @@ -681,9 +629,6 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { ...(claim.usageFailsAfterClaim ? [{ name: "T3_CLAUDE_USAGE_FAILS_AFTER_CLAIM", value: "1", sensitive: false }] : []), - ...(claim.usageSourceOnly - ? [{ name: "T3CODE_CLAUDE_USAGE_SOURCE_ONLY", value: "1", sensitive: false }] - : []), ], config: makeClaudeConfig({ enabled: true, @@ -692,30 +637,14 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), }, }, - }).pipe( - Effect.provideService(HttpClient.HttpClient, client), - Effect.provide( - ServerSettings.layerTest( - claim.hub - ? { - usageLimitSources: { - [UsageLimitSourceId.make("hub")]: { - kind: "cliproxy", - url: "http://hub.test", - managementKey: "hub-key", - enabled: true, - }, - }, - } - : {}, - ), - ), - ); + }).pipe(Effect.provideService(HttpClient.HttpClient, client)); const instance = yield* registry.getInstance(instanceId); expect(instance).toBeDefined(); const before = yield* instance!.snapshot.refresh; + expect(before.usageLimits?.windows[0]?.usedPercent).toBe(100); + expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); const outcome = yield* instance!.consumeResetCredit!().pipe(Effect.result); - return { before, outcome, after: yield* instance!.snapshot.getSnapshot, direct, viaHub }; + return { outcome, after: yield* instance!.snapshot.getSnapshot }; }).pipe( // macOS logins live in the Keychain, where resets are never read. Effect.provideService(HostProcess.Platform, "linux"), @@ -724,25 +653,12 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { it.live.skipIf(windowsHost)("refreshes Claude usage after redeeming a reset", () => Effect.gen(function* () { - for (const accounts of [ - [], - [ - { email: "test@example.com", organization_uuid: "other-org" }, - { email: "test@example.com" }, - ], - ]) { - const { before, outcome, after, direct, viaHub } = yield* redeemClaudeReset({ - result: "reset", - usageFailsAfterClaim: false, - hub: { accounts }, - }); - expect(before.usageLimits?.windows[0]?.usedPercent).toBe(100); - expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); - expect(outcome).toMatchObject({ _tag: "Success", success: "reset" }); - expect(after.usageLimits?.windows[0]?.usedPercent).toBe(0); - expect(direct).toContain("/api/organizations/fake-org/reset_rate_limits"); - expect(viaHub.every((call) => call === "auth-files")).toBe(true); - } + const { outcome, after } = yield* redeemClaudeReset({ + result: "reset", + usageFailsAfterClaim: false, + }); + expect(outcome).toMatchObject({ _tag: "Success", success: "reset" }); + expect(after.usageLimits?.windows[0]?.usedPercent).toBe(0); }), ); @@ -758,72 +674,6 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), ); - it.live.skipIf(windowsHost)( - "reads and redeems a Claude login only through the usage source holding it", - () => - Effect.gen(function* () { - const { before, outcome, after, direct, viaHub } = yield* redeemClaudeReset({ - result: "reset", - usageFailsAfterClaim: false, - hub: { accounts: [{ email: "TEST@example.com", organization_uuid: "fake-org" }] }, - }); - expect(before.usageLimits?.windows[0]?.usedPercent).toBe(100); - expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); - expect(outcome).toMatchObject({ _tag: "Success", success: "reset" }); - expect(after.usageLimits?.windows[0]?.usedPercent).toBe(0); - expect(direct).toEqual([]); - expect(viaHub).toContain( - "https://api.anthropic.com/api/organizations/fake-org/reset_rate_limits", - ); - expect(viaHub).toContain("reset-quota"); - }), - ); - - it.live.skipIf(windowsHost)( - "never reads Claude directly for a login no usage source holds when sources are required", - () => - Effect.gen(function* () { - for (const hub of [undefined, { accounts: [{ email: "test@example.com" }] }]) { - const { before, outcome, direct } = yield* redeemClaudeReset({ - result: "reset", - usageFailsAfterClaim: false, - usageSourceOnly: true, - ...(hub ? { hub } : {}), - }); - expect(before.usageLimits?.unavailable).toMatchObject({ - reason: "probeFailed", - message: "No usage source holds this Claude login.", - }); - expect(outcome).toMatchObject({ _tag: "Success", success: "noCredit" }); - expect(direct).toEqual([]); - } - }), - ); - - it.live.skipIf(windowsHost)( - "shows a usage source failure instead of reading Claude directly", - () => - Effect.gen(function* () { - for (const failure of [{ usageStatus: 503 }, { listStatus: 500 }]) { - const { before, outcome, direct } = yield* redeemClaudeReset({ - result: "reset", - usageFailsAfterClaim: false, - hub: { - accounts: [{ email: "test@example.com", organization_uuid: "fake-org" }], - ...failure, - }, - }); - expect(before.usageLimits?.unavailable).toMatchObject({ - reason: "probeFailed", - message: expect.any(String), - }); - expect(before.usageLimits?.resetCredits).toBeUndefined(); - expect(outcome).toMatchObject({ _tag: "Success", success: "noCredit" }); - expect(direct).toEqual([]); - } - }), - ); - const makeClaudeCacheFixture = Effect.fnUntraced(function* ( state: "ready" | "signed-out" | "usage-failed", ) { diff --git a/apps/server/src/provider/claudeResetCredits.ts b/apps/server/src/provider/claudeResetCredits.ts index 090fb441a0b72..0a932fac70b29 100644 --- a/apps/server/src/provider/claudeResetCredits.ts +++ b/apps/server/src/provider/claudeResetCredits.ts @@ -12,9 +12,9 @@ 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}$/; +export const PROGRAM = "cedar_ember"; +export const GRANT_ID = /^[a-z0-9_-]{1,40}$/; +export 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({ @@ -22,10 +22,7 @@ const Credentials = Schema.Struct({ }); const Config = Schema.Struct({ oauthAccount: Schema.optional( - Schema.Struct({ - emailAddress: Schema.optional(Schema.String), - organizationUuid: Schema.optional(Schema.String), - }), + Schema.Struct({ organizationUuid: Schema.optional(Schema.String) }), ), }); const Grant = Schema.Struct({ @@ -45,7 +42,7 @@ const UsageResponse = Schema.Struct({ cedar_ember: Schema.optional(Schema.NullOr(Schema.Unknown)), }); const decodeCedarEmber = Schema.decodeUnknownOption(CedarEmber); -const ClaimResponse = Schema.Struct({ +export const ClaimResponse = Schema.Struct({ result: Schema.Literals([ "reset", "already_used", @@ -55,7 +52,6 @@ const ClaimResponse = Schema.Struct({ "unavailable", ]), }); -const decodeClaimResponse = Schema.decodeUnknownEffect(ClaimResponse); const RESET_CREDIT_FAILURES = { malformedCredit: "Claude returned a malformed reset credit.", @@ -69,7 +65,7 @@ const RESET_CREDIT_FAILURES = { requestFailed: "Claude could not redeem the reset.", } as const; -class ClaudeResetCreditError extends Schema.TaggedError()( +export class ClaudeResetCreditError extends Schema.TaggedError()( "ClaudeResetCreditError", { reason: Schema.Literals( @@ -176,18 +172,12 @@ export const readClaudeResetCredits = Effect.fn("readClaudeResetCredits")( Effect.orElseSucceed(() => undefined), ); -export const readClaudeLogin = (accountConfigPath: string) => +export const readClaudeOrganizationId = (accountConfigPath: string) => readJson(Config, accountConfigPath).pipe( - Effect.map((config) => ({ - email: config.oauthAccount?.emailAddress?.trim() || undefined, - organizationId: config.oauthAccount?.organizationUuid?.trim() || undefined, - })), - Effect.orElseSucceed(() => ({ email: undefined, organizationId: undefined })), + Effect.map((config) => config.oauthAccount?.organizationUuid?.trim() || undefined), + Effect.orElseSucceed(() => undefined), ); -export const readClaudeOrganizationId = (accountConfigPath: string) => - readClaudeLogin(accountConfigPath).pipe(Effect.map((login) => login.organizationId)); - export const claudeAccountConfigPath = Effect.fn("claudeAccountConfigPath")(function* ( configDir: string | undefined, ) { @@ -197,7 +187,7 @@ export const claudeAccountConfigPath = Effect.fn("claudeAccountConfigPath")(func : path.join(yield* HostProcess.HomeDirectory, ".claude.json"); }); -const CLAIM_OUTCOMES = { +export const CLAIM_OUTCOMES = { reset: "reset", not_limited: "nothingToReset", already_used: "alreadyRedeemed", @@ -205,38 +195,6 @@ 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; @@ -244,7 +202,9 @@ export const consumeClaudeResetCredit = Effect.fn("consumeClaudeResetCredit")(fu readonly grantId: string; readonly requestId: string; }) { - const claim = yield* claudeClaimBody(input.grantId, input.requestId); + if (!GRANT_ID.test(input.grantId) || !REQUEST_ID.test(input.requestId)) { + return yield* new ClaudeResetCreditError({ reason: "malformedCredit" }); + } const token = yield* readAccessToken(input.configDir).pipe( Effect.mapError((cause) => new ClaudeResetCreditError({ reason: "loginUnreadable", cause })), ); @@ -263,20 +223,36 @@ export const consumeClaudeResetCredit = Effect.fn("consumeClaudeResetCredit")(fu `/api/organizations/${encodeURIComponent(organization)}/reset_rate_limits`, API_BASE, ), - ).pipe(withClaudeHeaders(token, input.version), HttpClientRequest.bodyJsonUnsafe(claim)), + ).pipe( + withClaudeHeaders(token, input.version), + HttpClientRequest.bodyJsonUnsafe({ + program: PROGRAM, + grant_id: input.grantId, + request_id: input.requestId, + }), + ), ) .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); + 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]; }); diff --git a/apps/server/src/usage/cliproxyApi.test.ts b/apps/server/src/usage/cliproxyApi.test.ts index 7fb3dbedf37f4..9bdde7f6bb204 100644 --- a/apps/server/src/usage/cliproxyApi.test.ts +++ b/apps/server/src/usage/cliproxyApi.test.ts @@ -1,8 +1,6 @@ import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; import { describe, expect, it } from "@effect/vitest"; -import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; -import * as Fiber from "effect/Fiber"; import * as Schema from "effect/Schema"; import * as TestClock from "effect/testing/TestClock"; import { HttpClient, HttpClientError, HttpClientResponse } from "effect/http"; @@ -54,13 +52,11 @@ function fixture( (typeof accounts)[number] & { label?: string; disabled?: boolean; - organization_uuid?: string; id_token: { chatgpt_account_id: string; plan_type?: string; chatgpt_plan_type?: string }; } >; upstream?: (request: RequestBody) => { status: number; body: unknown }; cooldownStatus?: number; - redeemDelay?: Duration.Input; } = {}, ) { const requests: Array<{ path: string; body?: RequestBody }> = []; @@ -113,13 +109,7 @@ function fixture( request, Response.json({ status_code: upstream.status, body: encodeJson(upstream.body) }), ); - }).pipe( - Effect.delay( - request.method === "POST" && request.url.endsWith("/api-call") - ? (options.redeemDelay ?? 0) - : 0, - ), - ), + }), ); return { requests, @@ -324,28 +314,14 @@ describe("CLIProxyAPI built-in management API", () => { }), ); - it.effect("maps Claude scoped windows and reset credits without a scheduler plugin", () => + it.effect("maps Claude scoped windows 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 hub sets its own client headers. upstream: (request) => ({ status: request.header?.["User-Agent"] === undefined ? 200 : 400, 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: [ @@ -368,149 +344,6 @@ 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("finds a Claude login only by its exact email and organization", () => - Effect.gen(function* () { - const claude = { ...accounts[0]!, provider: "claude", organization_uuid: "org-1" }; - const login = { email: "FIRST@example.com", organizationId: "org-1" }; - for (const [hubAccounts, expected] of [ - [[{ ...claude, organization_uuid: "org-2" }, claude], "first.json"], - [[{ ...claude, organization_uuid: "org-2" }], undefined], - [[{ ...accounts[0]!, provider: "claude" }], undefined], - [[{ ...claude, disabled: true }], undefined], - [[claude, { ...claude, id: "copy.json" }], undefined], - ] as const) { - const api = yield* fixture({ accounts: [...hubAccounts] }).api; - expect((yield* api.findClaudeLogin([config], login))?.account.id).toBe(expected); - } - const test = fixture({ accounts: [claude] }); - const api = yield* test.api; - expect( - yield* api.findClaudeLogin( - [ - { ...config, enabled: false }, - { ...config, managementKey: "" }, - ], - login, - ), - ).toBeUndefined(); - expect( - yield* api.findClaudeLogin([config], { ...login, organizationId: undefined }), - ).toBeUndefined(); - expect(test.requests).toEqual([]); - const unreadable = yield* Effect.flip( - (yield* unreachableHub( - (request) => - new HttpClientError.HttpClientError({ - reason: new HttpClientError.TransportError({ request }), - }), - )).findClaudeLogin([config], login), - ); - expect(unreadable._tag).toBe("UsageLimitSourceError"); - }), - ); - - 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(JSON.parse(redemption?.body?.data ?? "")).toEqual({ - program: "cedar_ember", - grant_id: "grant_a", - request_id: expect.stringMatching(/^[0-9a-f-]{36}$/), - }); - expect(test.requests.some((request) => request.path.endsWith("/reset-quota"))).toBe( - clearsCooldown, - ); - } - const twice = answer(200, { result: "reset" }); - const api = yield* twice.api; - yield* api.consume(config, "first.json", "grant_a"); - yield* api.consume(config, "first.json", "grant_a"); - const requestIds = twice.requests.flatMap((request) => - request.body?.data ? [JSON.parse(request.body.data).request_id] : [], - ); - expect(new Set(requestIds).size).toBe(2); - 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("waits longer for a redeem than for a read", () => - Effect.gen(function* () { - const claude = { ...accounts[0]!, provider: "claude", organization_uuid: "org-1" }; - for (const account of [accounts[0]!, claude]) { - const api = yield* fixture({ - accounts: [account], - upstream: (request) => ({ - status: 200, - body: request.url?.endsWith("/consume") ? { code: "reset" } : { result: "reset" }, - }), - redeemDelay: "29 seconds", - }).api; - const redeem = yield* Effect.forkChild(api.consume(config, "first.json", "grant_a")); - yield* TestClock.adjust("29 seconds"); - expect((yield* Fiber.join(redeem)).outcome).toBe("reset"); - } - }), - ); - - 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 47066bf5f8981..8d2e4de47e014 100644 --- a/apps/server/src/usage/cliproxyApi.ts +++ b/apps/server/src/usage/cliproxyApi.ts @@ -1,7 +1,6 @@ import { ProviderDriverKind, UsageLimitSourceError, - type ProviderConsumeResetCreditOutcome, type ProviderConsumeResetCreditResult, type UsageLimitSourceAccount, type UsageLimitSourceConfig, @@ -9,22 +8,16 @@ import { import * as Cause from "effect/Cause"; import * as Crypto from "effect/Crypto"; import * as DateTime from "effect/DateTime"; -import * as Duration from "effect/Duration"; 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"; +import * as ClaudeHub from "../fork/claudeUsageSource/claudeHub.ts"; const AuthFile = Schema.Struct({ id: Schema.String, @@ -63,7 +56,6 @@ 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( @@ -97,7 +89,6 @@ 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)); @@ -145,16 +136,8 @@ 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, @@ -185,7 +168,6 @@ export const makeCliproxyApi = Effect.gen(function* () { config: UsageLimitSourceConfig, path: string, body?: unknown, - timeout: Duration.Input = "15 seconds", ) { const url = yield* Effect.try({ try: () => @@ -203,7 +185,7 @@ export const makeCliproxyApi = Effect.gen(function* () { .pipe( Effect.flatMap(HttpClientResponse.filterStatusOk), Effect.flatMap((response) => response.json), - Effect.timeout(timeout), + Effect.timeout(ClaudeHub.managementTimeout(body)), Effect.mapError( (error) => new UsageLimitSourceError({ detail: describeManagementFailure(error) }), ), @@ -211,19 +193,13 @@ export const makeCliproxyApi = Effect.gen(function* () { return response; }); - const authFiles = Effect.fn("CliproxyApi.authFiles")( - function* (config: UsageLimitSourceConfig) { - const response = yield* management(config, "auth-files"); - return (yield* decodeAuthFiles(response)).files; - }, - Effect.mapError((error) => - isUsageLimitSourceError(error) - ? error - : new UsageLimitSourceError({ detail: "The hub could not list accounts." }), - ), - ); + const authFiles = Effect.fn("CliproxyApi.authFiles")(function* (config: UsageLimitSourceConfig) { + const response = yield* management(config, "auth-files"); + return (yield* decodeAuthFiles(response)).files; + }); + const claude = yield* ClaudeHub.makeClaudeHub(management, authFiles); - const apiResponse = Effect.fn("CliproxyApi.apiResponse")(function* ( + const apiCall = Effect.fn("CliproxyApi.apiCall")(function* ( config: UsageLimitSourceConfig, account: typeof AuthFile.Type, url: string, @@ -244,26 +220,14 @@ export const makeCliproxyApi = Effect.gen(function* () { Authorization: "Bearer $TOKEN$", "anthropic-beta": "oauth-2025-04-20", }; - // A redeem waits on the hub's own upstream call, which can take longer than a read. - const raw = yield* management( - config, - "api-call", - { - auth_index: account.auth_index, - method: data === undefined ? "GET" : "POST", - url, - header, - ...(data === undefined ? {} : { data: yield* encodeJson(data) }), - }, - data === undefined ? undefined : "30 seconds", - ); - return yield* decodeApiResponse(raw); - }); - - const apiCall = Effect.fn("CliproxyApi.apiCall")(function* ( - ...args: Parameters - ) { - const response = yield* apiResponse(...args); + const raw = yield* management(config, "api-call", { + auth_index: account.auth_index, + method: data === undefined ? "GET" : "POST", + url, + header, + ...(data === undefined ? {} : { data: yield* encodeJson(data) }), + }); + const response = yield* decodeApiResponse(raw); if (response.status_code < 200 || response.status_code >= 300) { return yield* new UsageLimitSourceError({ detail: `The provider refused the hub request (HTTP ${response.status_code}).`, @@ -289,48 +253,6 @@ 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), - ), - }; - }, - Effect.mapError((error) => - isUsageLimitSourceError(error) - ? error - : new UsageLimitSourceError({ detail: "The hub returned an unexpected usage response." }), - ), - ); - const readAccount = Effect.fn("CliproxyApi.readAccount")(function* ( config: UsageLimitSourceConfig, account: typeof AuthFile.Type, @@ -347,15 +269,34 @@ export const makeCliproxyApi = Effect.gen(function* () { }; const read = Effect.gen(function* () { if (account.provider === "claude") { - const { response, resetCredits } = yield* claudeUsage(config, account); - return { + const body = yield* apiCall(config, account, ClaudeHub.CLAUDE_USAGE_URL); + 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 yield* claude.withResetCredits(body, { ...base, plan: "Claude Subscription", - usageLimits: { - ...claudeUsageResponseToLimits({ checkedAt, response }).limits, - ...(resetCredits ? { resetCredits } : {}), - }, - }; + 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, + }); } const body = yield* apiCall(config, account, `${CODEX_BASE}/usage`); const usage = yield* decodeCodexUsage(body); @@ -416,7 +357,13 @@ export const makeCliproxyApi = Effect.gen(function* () { const readAccounts = Effect.fn("CliproxyApi.readAccounts")(function* ( config: UsageLimitSourceConfig, ): Effect.fn.Return, UsageLimitSourceError> { - const accounts = yield* authFiles(config); + const accounts = yield* authFiles(config).pipe( + Effect.mapError((error) => + isUsageLimitSourceError(error) + ? error + : new UsageLimitSourceError({ detail: "The hub could not list accounts." }), + ), + ); return yield* Effect.forEach( accounts.filter( (account) => @@ -427,69 +374,6 @@ export const makeCliproxyApi = Effect.gen(function* () { ); }); - 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 source account holding a directly signed-in Claude login, if exactly one source has it. */ - const findClaudeLogin = Effect.fn("CliproxyApi.findClaudeLogin")(function* ( - sources: ReadonlyArray, - login: { readonly email: string | undefined; readonly organizationId: string | undefined }, - ) { - const { email, organizationId } = login; - if (!email || !organizationId) return undefined; - for (const config of sources) { - if (!config.enabled || !config.managementKey) continue; - const matches = (yield* authFiles(config)).filter( - (account) => - account.provider === "claude" && - !account.disabled && - account.email?.toLowerCase() === email.toLowerCase() && - account.organization_uuid === organizationId, - ); - 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, accountId: string, @@ -497,37 +381,32 @@ 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" && account.provider !== "claude") - ) { + if (account?.provider === "claude") return yield* claude.consume(config, account, creditId); + if (!account || account.disabled || account.provider !== "codex") { return yield* new UsageLimitSourceError({ detail: "The hub account is missing or disabled.", }); } - const outcome = - account.provider === "claude" - ? // A Claude grant can hold several resets, so each claim needs its own request id. - yield* claimClaude(config, account, creditId, yield* crypto.randomUUIDv4()).pipe( - Effect.catchTags({ - ClaudeResetCreditError: (error) => - Effect.fail(new UsageLimitSourceError({ detail: error.message })), - }), - ) - : CODEX_CLAIM_OUTCOMES[ - (yield* decodeConsumeResponse( - 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, - }), - )).code - ]; + 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]; if (outcome !== "reset" && outcome !== "alreadyRedeemed") return { outcome }; - const cleared = yield* clearCooldown(config, account).pipe(Effect.result); + const cleared = yield* management(config, "reset-quota", { + auth_index: account.auth_index, + }).pipe(Effect.result); return { outcome, ...(cleared._tag === "Failure" @@ -548,5 +427,5 @@ export const makeCliproxyApi = Effect.gen(function* () { ), ); }); - return { readAccounts, consume, findClaudeLogin, claudeUsage, claimClaudeLogin }; + return { readAccounts, consume, claude }; }); From 2ab9b5fe79e52de1e36e8606fa79c537ae829876 Mon Sep 17 00:00:00 2001 From: Renfei Zhou Date: Sun, 1 Nov 2026 12:13:02 +0000 Subject: [PATCH 7/8] fix(server): Claude claims through a usage source send a JSON content type The direct claim and the Codex source path both send Content-Type: application/json; the Claude source path did not, so a hub that forwards request headers could send the claim body untyped. Co-Authored-By: Claude Opus 5.5 --- .../src/fork/claudeUsageSource/claudeHub.test.ts | 1 + apps/server/src/fork/claudeUsageSource/claudeHub.ts | 11 +++++++++-- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts b/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts index 36048b22918ae..f7d6534f8b8c3 100644 --- a/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts +++ b/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts @@ -181,6 +181,7 @@ describe("Claude through a CLIProxyAPI hub", () => { "https://api.anthropic.com/api/organizations/org-1/reset_rate_limits", ); expect(redemption?.body?.method).toBe("POST"); + expect(redemption?.body?.header?.["Content-Type"]).toBe("application/json"); expect(JSON.parse(redemption?.body?.data ?? "")).toEqual({ program: "cedar_ember", grant_id: "grant_a", diff --git a/apps/server/src/fork/claudeUsageSource/claudeHub.ts b/apps/server/src/fork/claudeUsageSource/claudeHub.ts index c4ac606638c9e..bce37f5d758ed 100644 --- a/apps/server/src/fork/claudeUsageSource/claudeHub.ts +++ b/apps/server/src/fork/claudeUsageSource/claudeHub.ts @@ -90,7 +90,11 @@ export const makeClaudeHub = Effect.fn("makeClaudeHub")(function* management(config, "reset-quota", { auth_index: account.auth_index }); - /** The source account holding a directly signed-in Claude login, if exactly one source has it. */ + /** + * The source account holding a directly signed-in Claude login, if exactly one source has it. + * A source that cannot list its accounts fails the lookup; it never counts as no match. + */ const findLogin = Effect.fn("ClaudeHub.findLogin")(function* ( sources: ReadonlyArray, login: ClaudeLogin, From 3b790be0b4173e9759aa9754583eb2213abd7402 Mon Sep 17 00:00:00 2001 From: Renfei Zhou Date: Sun, 1 Nov 2026 12:17:19 +0000 Subject: [PATCH 8/8] fix(server): Claude usage through a source keeps monthly spend Upstream now maps Claude monthly spend from usage reads. The source read asked the usage endpoint to skip spend and dropped spend and extra usage from the answer, so hub accounts and logins held by a source lost the Monthly spend row that direct logins show. Co-Authored-By: Claude Opus 5.5 --- .../src/fork/claudeUsageSource/claudeHub.test.ts | 2 +- .../src/fork/claudeUsageSource/claudeHub.ts | 15 ++++++++++++++- .../claudeUsageSource/claudeLoginSource.test.ts | 6 ++++++ 3 files changed, 21 insertions(+), 2 deletions(-) diff --git a/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts b/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts index f7d6534f8b8c3..0e0e1f66cd9b0 100644 --- a/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts +++ b/apps/server/src/fork/claudeUsageSource/claudeHub.test.ts @@ -111,7 +111,7 @@ describe("Claude through a CLIProxyAPI hub", () => { 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", + "https://api.anthropic.com/api/oauth/usage?cedar_ember=1", ); }), ); diff --git a/apps/server/src/fork/claudeUsageSource/claudeHub.ts b/apps/server/src/fork/claudeUsageSource/claudeHub.ts index bce37f5d758ed..833b15c2ec51a 100644 --- a/apps/server/src/fork/claudeUsageSource/claudeHub.ts +++ b/apps/server/src/fork/claudeUsageSource/claudeHub.ts @@ -35,6 +35,17 @@ 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)), + spend: Schema.optional(Schema.Unknown), + extra_usage: Schema.optional( + Schema.NullOr( + Schema.Struct({ + is_enabled: Schema.Boolean, + monthly_limit: Schema.NullOr(Schema.Number), + used_credits: Schema.NullOr(Schema.Number), + utilization: Schema.NullOr(Schema.Number), + }), + ), + ), limits: Schema.optional( Schema.Array( Schema.Struct({ @@ -61,7 +72,7 @@ const encodeJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown)); const isUsageLimitSourceError = Schema.is(UsageLimitSourceError); const CLAUDE_API = "https://api.anthropic.com/api"; -export const CLAUDE_USAGE_URL = `${CLAUDE_API}/oauth/usage?cedar_ember=1&skip_spend=1`; +export const CLAUDE_USAGE_URL = `${CLAUDE_API}/oauth/usage?cedar_ember=1`; /** A redeem waits on the hub's own call to the provider, which can take longer than a read. */ export const managementTimeout = (body: unknown) => @@ -147,6 +158,8 @@ export const makeClaudeHub = Effect.fn("makeClaudeHub")(function* { hub: { accounts: [{ email: "TEST@example.com", organization_uuid: "fake-org" }] }, }); expect(before.usageLimits?.windows[0]?.usedPercent).toBe(100); + expect(before.usageLimits?.windows.map((window) => window.id)).toContain("monthly_spend"); expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); expect(outcome).toMatchObject({ _tag: "Success", success: "reset" }); expect(after.usageLimits?.windows[0]?.usedPercent).toBe(0);