diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts index e1fbcd30080fd..9fa34275161d0 100644 --- a/apps/server/src/provider/Drivers/ClaudeDriver.ts +++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts @@ -1,10 +1,12 @@ -import { ClaudeSettings, ProviderDriverKind } from "@t3tools/contracts"; +import { ClaudeSettings, ProviderDriverKind, UsageLimitSourceError } from "@t3tools/contracts"; import * as Cache from "effect/Cache"; +import * as DateTime from "effect/DateTime"; import * as Duration from "effect/Duration"; import * as Crypto from "effect/Crypto"; import * as Effect from "effect/Effect"; import * as Exit from "effect/Exit"; import * as FileSystem from "effect/FileSystem"; +import * as Option from "effect/Option"; import * as Path from "effect/Path"; import * as Ref from "effect/Ref"; import * as Schema from "effect/Schema"; @@ -15,6 +17,8 @@ import { makeClaudeTextGeneration } from "../../textGeneration/ClaudeTextGenerat import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions"; import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost"; import * as ServerConfig from "../../config.ts"; +import * as Settings from "../../serverSettings.ts"; +import { makeCliproxyApi } from "../../usage/cliproxyApi.ts"; import { expandHomePath } from "@t3tools/provider-core/server/pathExpansion"; import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers"; import { @@ -130,6 +134,16 @@ export const ClaudeDriver: ProviderDriver Effect.succeed([]), + onSome: (service) => + service.getSettings.pipe( + Effect.map((settings) => Object.values(settings.usageLimitSources)), + Effect.orElseSucceed(() => []), + ), + }); const catalogService = yield* ModelCatalog.ModelCatalog; const modelCatalog = catalogService .current(DRIVER_KIND) @@ -197,22 +211,55 @@ export const ClaudeDriver: ProviderDriver ({ capabilities, resetCredits: undefined }), + onSome: ({ response, resetCredits }) => ({ + capabilities: { ...capabilities, usage: response, usageCheckedAt }, + resetCredits, + }), + }); + }); + // Per-instance capabilities cache: keyed on binary + resolved HOME so // account-specific probes never share auth metadata across instances. // A transient miss may reuse the last account once, but its usage windows keep their age. const lastGoodCapabilities = yield* Ref.make(undefined); const capabilitiesProbeCache = yield* Cache.makeWith( () => - probeClaudeCapabilities(effectiveConfig, processEnv, stateDir).pipe( + probeClaudeCapabilities(effectiveConfig, processEnv, stateDir, false).pipe( Effect.flatMap((capabilities) => ClaudeResetCredits.readClaudeOrganizationId(accountConfigPath).pipe( - Effect.map((workspaceId) => ({ - _tag: "fresh" as const, - capabilities: - workspaceId === undefined ? capabilities : { ...capabilities, workspaceId }, - })), + Effect.map((workspaceId) => + workspaceId === undefined ? capabilities : { ...capabilities, workspaceId }, + ), ), ), + Effect.flatMap(withHubUsage), + Effect.map((entry) => ({ _tag: "fresh" as const, ...entry })), Effect.tap(({ capabilities }) => Ref.set(lastGoodCapabilities, capabilities)), Effect.catch((error) => Ref.getAndSet(lastGoodCapabilities, undefined).pipe( @@ -225,6 +272,7 @@ export const ClaudeDriver: ProviderDriver - ClaudeResetCredits.readClaudeResetCredits(configDir, version).pipe( - Effect.provideService(HttpClient.HttpClient, httpClient), - Effect.provideService(FileSystem.FileSystem, fileSystem), - Effect.provideService(Path.Path, path), + () => + Cache.get(capabilitiesProbeCache, capabilitiesCacheKey).pipe( + Effect.map((entry) => entry.resetCredits), + Effect.orElseSucceed(() => undefined), ), ), ), @@ -325,38 +372,37 @@ export const ClaudeDriver: ProviderDriver = Effect.fn( "ClaudeDriver.consumeResetCredit", )( function* () { const current = yield* snapshot.getSnapshot; const grantId = current.usageLimits?.resetCredits?.nextCreditId; - if (!grantId || !current.version) return "noCredit" as const; - const version = current.version; + const email = current.auth.email; + if (!grantId || !email) return "noCredit" as const; + const login = yield* hub.findClaudeLogin(yield* hubSources, { + email, + organizationId: current.auth.workspaceId, + }); + if (!login) { + return yield* new UsageLimitSourceError({ + detail: "No usage limit source holds this Claude login.", + }); + } return yield* resetCreditCoordinator.redeem( configDir, - (requestId) => - ClaudeResetCredits.consumeClaudeResetCredit({ - configDir, - accountConfigPath, - version, - grantId, - requestId, - }), + (requestId) => hub.claimClaudeLogin(login.config, login.account, grantId, requestId), ClaudeResetCredits.isSettledClaudeResetCreditFailure, ); }, - Effect.provideService(HttpClient.HttpClient, httpClient), - Effect.provideService(FileSystem.FileSystem, fileSystem), - Effect.provideService(Path.Path, path), Effect.mapError( (cause) => new ProviderDriverError({ driver: DRIVER_KIND, instanceId, detail: - cause._tag === "ClaudeResetCreditError" + cause._tag === "ClaudeResetCreditError" || cause._tag === "UsageLimitSourceError" ? cause.message : "Claude could not redeem the reset.", cause, diff --git a/apps/server/src/provider/ProviderInstanceRegistry.test.ts b/apps/server/src/provider/ProviderInstanceRegistry.test.ts index af3359ea7f27d..86adf9eb27336 100644 --- a/apps/server/src/provider/ProviderInstanceRegistry.test.ts +++ b/apps/server/src/provider/ProviderInstanceRegistry.test.ts @@ -17,6 +17,7 @@ import { SecretProviderId, SettingsSecretValue, type SecretReference, + UsageLimitSourceId, } from "@t3tools/contracts"; import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions"; import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions"; @@ -60,6 +61,62 @@ const layerTestHttpClient = Layer.succeed( ), ); +const decodeHubCall = Schema.decodeUnknownSync( + Schema.fromJsonString(Schema.Struct({ url: Schema.optional(Schema.String) })), +); + +// A t3switch hub holding the mock CLI's login. Claude usage and claims only go through it. +const claudeHub = (options: { + readonly accounts?: ReadonlyArray<{ readonly email: string; readonly organization_uuid: string }>; + readonly usage: Effect.Effect<{ readonly status: number; readonly body: unknown }>; + readonly claim?: Effect.Effect; +}) => + HttpClient.make((request) => + Effect.gen(function* () { + const json = (body: unknown) => HttpClientResponse.fromWeb(request, Response.json(body)); + const path = new URL(request.url).pathname; + if (path.endsWith("/auth-files")) { + const accounts = options.accounts ?? [ + { email: "test@example.com", organization_uuid: "fake-org" }, + ]; + return json({ + files: accounts.map((account, index) => ({ + id: `${index}.json`, + auth_index: `${index}`, + provider: "claude", + ...account, + })), + }); + } + if (path.endsWith("/reset-quota")) return json({}); + if (!path.endsWith("/api-call")) return json({ version: "0.0.0" }); + const call = decodeHubCall( + request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : "", + ); + const upstream = call.url?.endsWith("/reset_rate_limits") + ? { status: 200, body: yield* options.claim ?? Effect.die("unexpected claim") } + : yield* options.usage; + return json({ status_code: upstream.status, body: JSON.stringify(upstream.body) }); + }), + ); + +const withClaudeHub = (hub: HttpClient.HttpClient) => + Effect.provide( + Layer.mergeAll( + Layer.succeed(HttpClient.HttpClient, hub), + ServerSettings.layerTest({ + usageLimitSources: { + [UsageLimitSourceId.make("hub")]: { + kind: "cliproxy", + url: "http://hub.test", + managementKey: "hub-key", + enabled: true, + }, + }, + }), + ), + ); + // The mock CLIs from makeTildeProviderFixtures are scripts Windows cannot execute. const windowsHost = HostProcess.Platform.defaultValue() === "win32"; @@ -486,13 +543,7 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }, }); }, - usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET: async () => ({ - rate_limits_available: true, - rate_limits: { - five_hour: { utilization: 12, resets_at: "2026-07-18T14:39:00Z" }, - }, - }), - }) as ReturnType, + }) as unknown as ReturnType, ); yield* Effect.addFinalizer(() => Effect.sync(() => query.mockRestore())); @@ -509,7 +560,20 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), }, }, - }); + }).pipe( + withClaudeHub( + claudeHub({ + accounts: [ + { email: "account-a@example.com", organization_uuid: "org-a" }, + { email: "account-b@example.com", organization_uuid: "org-b" }, + ], + usage: Effect.succeed({ + status: 200, + body: { five_hour: { utilization: 12, resets_at: "2026-07-18T14:39:00Z" } }, + }), + }), + ), + ); const claude = yield* registry.getInstance(claudeId); expect(claude).toBeDefined(); @@ -587,36 +651,32 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; const fixtures = yield* makeTildeProviderFixtures(); - const marker = path.join(fixtures.claudeHomePath, "redeemed"); - yield* fs.writeFileString( - path.join(fixtures.claudeHomePath, ".credentials.json"), - '{"claudeAiOauth":{"accessToken":"fake-token"}}', - ); + let redeemed = false; yield* fs.writeFileString( path.join(fixtures.claudeHomePath, ".claude.json"), '{"oauthAccount":{"organizationUuid":"fake-org"}}', ); - const client = HttpClient.make((request) => - Effect.gen(function* () { - if (request.url.endsWith("/api/oauth/usage")) { - return HttpClientResponse.fromWeb( - request, - Response.json({ - cedar_ember: { - eligible: true, - next_grant_id: "grant_a", - grants: [{ id: "grant_a", resets_left: 1, usable_now: true }], + const hub = claudeHub({ + usage: Effect.sync(() => + redeemed && claim.usageFailsAfterClaim + ? { status: 503, body: {} } + : { + status: 200, + body: { + five_hour: { utilization: redeemed ? 0 : 100, resets_at: null }, + cedar_ember: { + eligible: true, + next_grant_id: "grant_a", + grants: [{ id: "grant_a", resets_left: 1, usable_now: true }], + }, }, - }), - ); - } - if (request.url.endsWith("/reset_rate_limits")) { - yield* fs.writeFileString(marker, "redeemed").pipe(Effect.orDie); - return HttpClientResponse.fromWeb(request, Response.json({ result: claim.result })); - } - return HttpClientResponse.fromWeb(request, Response.json({ version: "0.0.0" })); + }, + ), + claim: Effect.sync(() => { + redeemed = true; + return { result: claim.result }; }), - ); + }); const instanceId = ProviderInstanceId.make("claude_reset"); const { registry } = yield* makeProviderInstanceRegistry({ drivers: [ClaudeDriver], @@ -624,12 +684,6 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { [instanceId]: { driver: ProviderDriverKind.make("claudeAgent"), enabled: true, - environment: [ - { name: "T3_CLAUDE_RESET_MARKER", value: marker, sensitive: false }, - ...(claim.usageFailsAfterClaim - ? [{ name: "T3_CLAUDE_USAGE_FAILS_AFTER_CLAIM", value: "1", sensitive: false }] - : []), - ], config: makeClaudeConfig({ enabled: true, binaryPath: fixtures.claudeBinaryPath, @@ -637,7 +691,7 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), }, }, - }).pipe(Effect.provideService(HttpClient.HttpClient, client)); + }).pipe(withClaudeHub(hub)); const instance = yield* registry.getInstance(instanceId); expect(instance).toBeDefined(); const before = yield* instance!.snapshot.refresh; @@ -645,11 +699,7 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { expect(before.usageLimits?.resetCredits?.nextCreditId).toBe("grant_a"); const outcome = yield* instance!.consumeResetCredit!().pipe(Effect.result); return { outcome, after: yield* instance!.snapshot.getSnapshot }; - }).pipe( - // macOS logins live in the Keychain, where resets are never read. - Effect.provideService(HostProcess.Platform, "linux"), - Effect.provide(layerTest), - ); + }).pipe(Effect.provide(layerTest)); it.live.skipIf(windowsHost)("refreshes Claude usage after redeeming a reset", () => Effect.gen(function* () { @@ -691,18 +741,9 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { enabled: true, environment: [ { name: "T3_CLAUDE_PROBE_LOG", value: probeLog, sensitive: false }, - ...(state === "ready" - ? [] - : [ - { - name: - state === "signed-out" - ? "T3_CLAUDE_LOGIN_MARKER" - : "T3_CLAUDE_USAGE_FAILS_UNTIL", - value: recovered, - sensitive: false, - }, - ]), + ...(state === "signed-out" + ? [{ name: "T3_CLAUDE_LOGIN_MARKER", value: recovered, sensitive: false }] + : []), ], config: makeClaudeConfig({ enabled: true, @@ -711,7 +752,21 @@ describe("ProviderInstanceRegistry — multi-instance codex slice", () => { }), }, }, - }); + }).pipe( + withClaudeHub( + claudeHub({ + accounts: [{ email: "test@example.com", organization_uuid: "" }], + usage: fs.exists(recovered).pipe( + Effect.orDie, + Effect.map((exists) => + state === "usage-failed" && !exists + ? { status: 503, body: {} } + : { status: 200, body: { five_hour: { utilization: 10, resets_at: null } } }, + ), + ), + }), + ), + ); const instance = yield* registry.getInstance(instanceId); expect(instance).toBeDefined(); return { diff --git a/apps/server/src/provider/claudeResetCredits.test.ts b/apps/server/src/provider/claudeResetCredits.test.ts index 8db751657454c..7267cbe6815e8 100644 --- a/apps/server/src/provider/claudeResetCredits.test.ts +++ b/apps/server/src/provider/claudeResetCredits.test.ts @@ -1,11 +1,5 @@ -import * as NodeServices from "@effect/platform-node/NodeServices"; import { it as effectIt } from "@effect/vitest"; -import * as HostProcess from "@t3tools/shared/HostProcess"; import * as Effect from "effect/Effect"; -import * as FileSystem from "effect/FileSystem"; -import * as Path from "effect/Path"; -import * as Schema from "effect/Schema"; -import { HttpClient, HttpClientResponse, UrlParams } from "effect/http"; import { describe, expect, it } from "vite-plus/test"; import * as ClaudeResetCredits from "./claudeResetCredits.ts"; @@ -18,25 +12,6 @@ const grant = (overrides: Record) => ({ ...overrides, }); -const writeLogin = Effect.gen(function* () { - const fs = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - const directory = yield* fs.makeTempDirectoryScoped(); - yield* fs.writeFileString( - path.join(directory, ".credentials.json"), - '{"claudeAiOauth":{"accessToken":"oauth-token"}}', - ); - const accountConfigPath = path.join(directory, ".claude.json"); - yield* fs.writeFileString(accountConfigPath, '{"oauthAccount":{"organizationUuid":"org-1"}}'); - return { configDir: directory, accountConfigPath }; -}); - -const respond = (status: number, body: unknown) => - HttpClient.make((request) => - Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(body, { status }))), - ); -const refuseRequests = HttpClient.make(() => Effect.die("must not send a request")); - describe("claudeResetCreditsToContract", () => { it("counts live grants and pins the next usable one", () => { expect( @@ -87,132 +62,46 @@ describe("claudeResetCreditsToContract", () => { }); }); -effectIt.layer(NodeServices.layer)("readClaudeResetCredits", (it) => { - it.effect("reads the grants with the CLI's request", () => - Effect.gen(function* () { - const { configDir } = yield* writeLogin; - const client = HttpClient.make((request) => { - expect(request.method).toBe("GET"); - expect(request.url).toBe("https://api.anthropic.com/api/oauth/usage"); - expect(UrlParams.toString(request.urlParams)).toBe("cedar_ember=1&skip_spend=1"); - expect(request.headers.authorization).toBe("Bearer oauth-token"); - expect(request.headers["anthropic-beta"]).toBe("oauth-2025-04-20"); - expect(request.headers["user-agent"]).toBe("claude-cli/2.1.0 (external, cli)"); - return Effect.succeed( - HttpClientResponse.fromWeb( - request, - Response.json({ - cedar_ember: { eligible: true, next_grant_id: "grant_a", grants: [grant({})] }, - }), - ), - ); - }); - const credits = yield* ClaudeResetCredits.readClaudeResetCredits(configDir, "2.1.0").pipe( - Effect.provideService(HostProcess.Platform, "linux"), - Effect.provideService(HttpClient.HttpClient, client), - ); - expect(credits).toEqual({ availableCount: 1, nextCreditId: "grant_a" }); - }), - ); - - it.effect("reads nothing from keychain logins or failed requests", () => - Effect.gen(function* () { - const { configDir } = yield* writeLogin; - const darwin = yield* ClaudeResetCredits.readClaudeResetCredits(configDir, "2.1.0").pipe( - Effect.provideService(HostProcess.Platform, "darwin"), - Effect.provideService(HttpClient.HttpClient, refuseRequests), - ); - const limited = yield* ClaudeResetCredits.readClaudeResetCredits(configDir, "2.1.0").pipe( - Effect.provideService(HostProcess.Platform, "linux"), - Effect.provideService(HttpClient.HttpClient, respond(429, {})), - ); - expect([darwin, limited]).toEqual([undefined, undefined]); - }), - ); -}); - -const ClaimBody = Schema.fromJsonString( - Schema.Struct({ program: Schema.String, grant_id: Schema.String, request_id: Schema.String }), -); -const decodeClaimBody = Schema.decodeEffect(ClaimBody); - -const consume = (client: HttpClient.HttpClient, ids = { grantId: "grant_a", requestId: "r-1" }) => - Effect.gen(function* () { - const login = yield* writeLogin; - return yield* ClaudeResetCredits.consumeClaudeResetCredit({ - ...login, - version: "2.1.0", - ...ids, - }).pipe( - Effect.provideService(HostProcess.Platform, "linux"), - Effect.provideService(HttpClient.HttpClient, client), - Effect.result, - ); - }); - -effectIt.layer(NodeServices.layer)("consumeClaudeResetCredit", (it) => { - it.effect("claims the grant for the organization", () => - Effect.gen(function* () { - const client = HttpClient.make((request) => - Effect.gen(function* () { - expect(request.method).toBe("POST"); - expect(request.url).toBe( - "https://api.anthropic.com/api/organizations/org-1/reset_rate_limits", - ); - expect(request.headers.authorization).toBe("Bearer oauth-token"); - const body = - request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : ""; - expect(yield* decodeClaimBody(body)).toEqual({ - program: "cedar_ember", - grant_id: "grant_a", - request_id: "r-1", - }); - return HttpClientResponse.fromWeb(request, Response.json({ result: "reset" })); - }).pipe(Effect.orDie), - ); - expect(yield* consume(client)).toMatchObject({ _tag: "Success", success: "reset" }); - }), - ); - - it.effect("maps each answer to an outcome or a failure", () => +describe("claudeClaimOutcome", () => { + effectIt.effect("maps each answer to an outcome or a failure", () => Effect.gen(function* () { + const answer = (status: number, body: unknown) => + ClaudeResetCredits.claudeClaimOutcome(status, body).pipe(Effect.result); for (const [result, outcome] of [ + ["reset", "reset"], ["not_limited", "nothingToReset"], ["already_used", "alreadyRedeemed"], ["ineligible", "noCredit"], ] as const) { - expect(yield* consume(respond(200, { result }))).toMatchObject({ success: outcome }); + expect(yield* answer(200, { result })).toMatchObject({ success: outcome }); } - for (const client of [ - respond(200, { result: "cooldown" }), - respond(429, {}), - respond(401, {}), - ]) { - const result = yield* consume(client); + for (const [status, body, settled] of [ + [200, { result: "cooldown" }, true], + [429, undefined, true], + [401, undefined, true], + [500, undefined, false], + [200, { result: "unavailable" }, false], + ] as const) { + const result = yield* answer(status, body); expect(result).toMatchObject({ _tag: "Failure" }); if (result._tag === "Failure") { - expect(ClaudeResetCredits.isSettledClaudeResetCreditFailure(result.failure)).toBe(true); - } - } - for (const client of [respond(500, {}), respond(200, { result: "unavailable" })]) { - const unanswered = yield* consume(client); - expect(unanswered).toMatchObject({ _tag: "Failure" }); - if (unanswered._tag === "Failure") { - expect(ClaudeResetCredits.isSettledClaudeResetCreditFailure(unanswered.failure)).toBe( - false, + expect(ClaudeResetCredits.isSettledClaudeResetCreditFailure(result.failure)).toBe( + settled, ); } } }), ); - it.effect("refuses malformed ids without sending anything", () => + effectIt.effect("refuses malformed ids", () => Effect.gen(function* () { - for (const ids of [ - { grantId: "Bad Grant", requestId: "r-1" }, - { grantId: "grant_a", requestId: "has space" }, + for (const [grantId, requestId] of [ + ["Bad Grant", "r-1"], + ["grant_a", "has space"], ]) { - expect(yield* consume(refuseRequests, ids)).toMatchObject({ _tag: "Failure" }); + expect( + yield* ClaudeResetCredits.claudeClaimBody(grantId!, requestId!).pipe(Effect.result), + ).toMatchObject({ _tag: "Failure" }); } }), ); diff --git a/apps/server/src/provider/claudeResetCredits.ts b/apps/server/src/provider/claudeResetCredits.ts index 35973378edada..f77ff3737c5ba 100644 --- a/apps/server/src/provider/claudeResetCredits.ts +++ b/apps/server/src/provider/claudeResetCredits.ts @@ -9,17 +9,12 @@ import * as FileSystem from "effect/FileSystem"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; import * as Schema from "effect/Schema"; -import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"; -const API_BASE = "https://api.anthropic.com"; const PROGRAM = "cedar_ember"; const GRANT_ID = /^[a-z0-9_-]{1,40}$/; const REQUEST_ID = /^[A-Za-z0-9_-]{1,64}$/; const COMPLETE_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/; -const Credentials = Schema.Struct({ - claudeAiOauth: Schema.optional(Schema.Struct({ accessToken: Schema.optional(Schema.String) })), -}); const Config = Schema.Struct({ oauthAccount: Schema.optional( Schema.Struct({ organizationUuid: Schema.optional(Schema.String) }), @@ -38,9 +33,6 @@ const CedarEmber = Schema.Struct({ grants: Schema.optional(Schema.Array(Schema.Unknown)), next_grant_id: Schema.optional(Schema.NullOr(Schema.String)), }); -const UsageResponse = Schema.Struct({ - cedar_ember: Schema.optional(Schema.NullOr(Schema.Unknown)), -}); const decodeCedarEmber = Schema.decodeUnknownOption(CedarEmber); const ClaimResponse = Schema.Struct({ result: Schema.Literals([ @@ -52,11 +44,10 @@ const ClaimResponse = Schema.Struct({ "unavailable", ]), }); +const decodeClaimResponse = Schema.decodeUnknownEffect(ClaimResponse); const RESET_CREDIT_FAILURES = { malformedCredit: "Claude returned a malformed reset credit.", - loginUnreadable: "Claude could not read its login.", - accountUnreadable: "Claude could not read its account.", signedOut: "Sign in to Claude again to redeem resets.", rateLimited: "Claude is rate limiting resets. Try again soon.", coolingDown: "Claude resets are cooling down. Try again later.", @@ -134,44 +125,6 @@ const readJson = Effect.fn("claudeResetCredits.readJson")(function* - HttpClientRequest.setHeaders({ - authorization: `Bearer ${token}`, - "anthropic-beta": "oauth-2025-04-20", - "user-agent": `claude-cli/${version} (external, cli)`, - }); - -export const readClaudeResetCredits = Effect.fn("readClaudeResetCredits")( - function* (configDir: string, version: string) { - const token = yield* readAccessToken(configDir); - if (!token) return undefined; - const client = yield* HttpClient.HttpClient; - const response = yield* client.execute( - HttpClientRequest.get(`${API_BASE}/api/oauth/usage`, { - urlParams: { cedar_ember: "1", skip_spend: "1" }, - }).pipe(withClaudeHeaders(token, version)), - ); - const body = yield* HttpClientResponse.schemaBodyJson(UsageResponse)( - yield* HttpClientResponse.filterStatusOk(response), - ); - return claudeResetCreditsToContract( - body.cedar_ember, - DateTime.toEpochMillis(yield* DateTime.now), - ); - }, - Effect.timeout("10 seconds"), - Effect.orElseSucceed(() => undefined), -); - export const readClaudeOrganizationId = (accountConfigPath: string) => readJson(Config, accountConfigPath).pipe( Effect.map((config) => config.oauthAccount?.organizationUuid?.trim() || undefined), @@ -195,64 +148,34 @@ const CLAIM_OUTCOMES = { } as const satisfies Record; /** requestId is the claim's idempotency key. */ -export const consumeClaudeResetCredit = Effect.fn("consumeClaudeResetCredit")(function* (input: { - readonly configDir: string; - readonly accountConfigPath: string; - readonly version: string; - readonly grantId: string; - readonly requestId: string; -}) { - 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 })), - ); - const config = yield* readJson(Config, input.accountConfigPath).pipe( - Effect.mapError((cause) => new ClaudeResetCreditError({ reason: "accountUnreadable", cause })), - ); - const organization = config.oauthAccount?.organizationUuid?.trim(); - if (!token || !organization) { - return yield* new ClaudeResetCreditError({ reason: "signedOut" }); - } - const client = yield* HttpClient.HttpClient; - const response = yield* client - .execute( - HttpClientRequest.post( - new URL( - `/api/organizations/${encodeURIComponent(organization)}/reset_rate_limits`, - API_BASE, - ), - ).pipe( - withClaudeHeaders(token, input.version), - HttpClientRequest.bodyJsonUnsafe({ - program: PROGRAM, - grant_id: input.grantId, - request_id: input.requestId, - }), - ), - ) - .pipe( - Effect.timeout("25 seconds"), - Effect.mapError((cause) => new ClaudeResetCreditError({ reason: "requestFailed", cause })), - ); - if (response.status === 429) { +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 (response.status === 401 || response.status === 403) { + if (status === 401 || status === 403) { return yield* new ClaudeResetCreditError({ reason: "signedOut" }); } - const body = yield* HttpClientResponse.filterStatusOk(response).pipe( - Effect.flatMap(HttpClientResponse.schemaBodyJson(ClaimResponse)), - Effect.timeout("25 seconds"), + 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 (body.result === "cooldown") { + if (claim.result === "cooldown") { return yield* new ClaudeResetCreditError({ reason: "coolingDown" }); } // Unknown outcomes retain the request ID so retries address the same claim. - if (body.result === "unavailable") { + if (claim.result === "unavailable") { return yield* new ClaudeResetCreditError({ reason: "unconfirmed" }); } - return CLAIM_OUTCOMES[body.result]; + return CLAIM_OUTCOMES[claim.result]; }); diff --git a/apps/server/src/provider/testing/ProviderInstanceRegistryLive.fixture.mjs b/apps/server/src/provider/testing/ProviderInstanceRegistryLive.fixture.mjs index 5c4c84f2aa3e3..a46ca4394ddd4 100755 --- a/apps/server/src/provider/testing/ProviderInstanceRegistryLive.fixture.mjs +++ b/apps/server/src/provider/testing/ProviderInstanceRegistryLive.fixture.mjs @@ -18,56 +18,6 @@ const lines = NodeReadline.createInterface({ input: process.stdin }); lines.on("line", (line) => { const message = JSON.parse(line); if (message.type !== "control_request") return; - if (message.request?.subtype === "get_usage" && signedOut) { - process.stdout.write( - JSON.stringify({ - type: "control_response", - response: { - subtype: "success", - request_id: message.request_id, - response: { session: {}, rate_limits_available: false, rate_limits: null }, - }, - }) + "\n", - ); - return; - } - if (message.request?.subtype === "get_usage") { - const marker = process.env.T3_CLAUDE_RESET_MARKER; - const usageFailsUntil = process.env.T3_CLAUDE_USAGE_FAILS_UNTIL; - if ( - (usageFailsUntil && !NodeFS.existsSync(usageFailsUntil)) || - (process.env.T3_CLAUDE_USAGE_FAILS_AFTER_CLAIM && marker && NodeFS.existsSync(marker)) - ) { - process.stdout.write( - JSON.stringify({ - type: "control_response", - response: { subtype: "error", request_id: message.request_id, error: "usage failed" }, - }) + "\n", - ); - return; - } - process.stdout.write( - JSON.stringify({ - type: "control_response", - response: { - subtype: "success", - request_id: message.request_id, - response: { - session: {}, - subscription_type: "pro", - rate_limits_available: true, - rate_limits: { - five_hour: { - utilization: marker && NodeFS.existsSync(marker) ? 0 : 100, - resets_at: null, - }, - }, - }, - }, - }) + "\n", - ); - return; - } if (message.request?.subtype !== "initialize") return; process.stdout.write( JSON.stringify({ diff --git a/apps/server/src/usage/cliproxyApi.test.ts b/apps/server/src/usage/cliproxyApi.test.ts index 0119adfd940f3..17e0eacdc9123 100644 --- a/apps/server/src/usage/cliproxyApi.test.ts +++ b/apps/server/src/usage/cliproxyApi.test.ts @@ -1,10 +1,12 @@ import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; +import type { UsageLimitSourceConfig } from "@t3tools/contracts"; import { describe, expect, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import * as Schema from "effect/Schema"; import * as TestClock from "effect/testing/TestClock"; import { HttpClient, HttpClientError, HttpClientResponse } from "effect/http"; +import { isSettledClaudeResetCreditFailure } from "../provider/claudeResetCredits.ts"; import { makeCliproxyApi } from "./cliproxyApi.ts"; const config = { @@ -51,6 +53,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 +315,27 @@ 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. - upstream: (request) => ({ - status: request.header?.["User-Agent"]?.startsWith("claude-code/") ? 200 : 429, + 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 }, seven_day: { utilization: 50, resets_at: "2099-01-01T00:00:00Z" }, limits: [ @@ -342,9 +358,148 @@ 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); + } + }), + ); + + it.effect( + "finds a signed-in Claude login by email and organization and claims through the hub", + () => + Effect.gen(function* () { + const claude = (id: string, organization_uuid: string, disabled = false) => ({ + ...accounts[0]!, + id, + auth_index: id, + provider: "claude", + email: "Me@Example.com", + organization_uuid, + disabled, + }); + let answer: unknown = { result: "reset" }; + const test = fixture({ + accounts: [ + claude("personal.json", "org-1"), + claude("team.json", "org-2"), + claude("off.json", "org-3", true), + ], + upstream: () => ({ status: 200, body: answer }), + }); + const api = yield* test.api; + const find = ( + organizationId: string | undefined, + sources: ReadonlyArray = [config], + ) => api.findClaudeLogin(sources, { email: "me@example.com", organizationId }); + const login = (yield* find("org-2"))!; + expect(login.account.id).toBe("team.json"); + expect(yield* find(undefined)).toBeUndefined(); + expect(yield* find("org-3")).toBeUndefined(); + expect(yield* find("org-1", [{ ...config, enabled: false }])).toBeUndefined(); + + expect(yield* api.claimClaudeLogin(login.config, login.account, "grant_a", "r-1")).toBe( + "reset", + ); + const claim = test.requests.find((request) => request.body?.url); + expect(claim?.body?.url).toBe( + "https://api.anthropic.com/api/organizations/org-2/reset_rate_limits", + ); + expect(claim?.body?.data).toBe( + encodeJson({ program: "cedar_ember", grant_id: "grant_a", request_id: "r-1" }), + ); + expect( + test.requests + .filter((request) => request.path.endsWith("/reset-quota")) + .map((request) => request.body?.auth_index), + ).toEqual(["team.json"]); + + for (const [result, settled] of [ + ["cooldown", true], + ["unavailable", false], + ] as const) { + answer = { result }; + const error = yield* Effect.flip( + api.claimClaudeLogin(login.config, login.account, "grant_a", "r-1"), + ); + expect(isSettledClaudeResetCreditFailure(error)).toBe(settled); + } + }), + ); + it.effect("pins redemption to the displayed credit and clears only that account's cooldown", () => Effect.gen(function* () { const test = fixture(); diff --git a/apps/server/src/usage/cliproxyApi.ts b/apps/server/src/usage/cliproxyApi.ts index 91504d8002295..a57242c9c855f 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, @@ -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}).`, @@ -251,6 +275,44 @@ export const makeCliproxyApi = Effect.gen(function* () { .toSorted((a, b) => Date.parse(a.expires_at) - Date.parse(b.expires_at)); }); + /** Usage in the Claude SDK's get_usage shape, plus reset credits. */ + const claudeUsage = Effect.fn("CliproxyApi.claudeUsage")(function* ( + config: UsageLimitSourceConfig, + account: typeof AuthFile.Type, + ) { + const body = yield* apiCall( + config, + account, + `${CLAUDE_BASE}/oauth/usage?cedar_ember=1&skip_spend=1`, + ); + const usage = yield* decodeClaudeUsage(body); + const model_scoped = (usage.limits ?? []).flatMap((limit) => + limit.kind === "weekly_scoped" && limit.scope?.model && typeof limit.percent === "number" + ? [ + { + display_name: limit.scope.model.display_name, + utilization: limit.percent, + resets_at: limit.resets_at ?? null, + }, + ] + : [], + ); + return { + response: { + rate_limits_available: true, + rate_limits: { + five_hour: usage.five_hour ?? null, + seven_day: usage.seven_day ?? null, + model_scoped, + }, + }, + resetCredits: claudeResetCreditsToContract( + usage.cedar_ember, + DateTime.toEpochMillis(yield* DateTime.now), + ), + }; + }); + const readAccount = Effect.fn("CliproxyApi.readAccount")(function* ( config: UsageLimitSourceConfig, account: typeof AuthFile.Type, @@ -266,33 +328,14 @@ 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 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, - }, - ] - : [], - ); + 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, + usageLimits: { + ...claudeUsageResponseToLimits({ checkedAt, response }).limits, + ...(resetCredits ? { resetCredits } : {}), + }, }; } const body = yield* apiCall(config, account, `${CODEX_BASE}/usage`); @@ -371,6 +414,69 @@ 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 one enabled hub account holding a directly signed-in Claude login. */ + const findClaudeLogin = Effect.fn("CliproxyApi.findClaudeLogin")(function* ( + sources: ReadonlyArray, + login: { readonly email: string; readonly organizationId: string | undefined }, + ) { + for (const config of sources) { + if (!config.enabled || !config.managementKey) continue; + const files = yield* authFiles(config).pipe(Effect.orElseSucceed(() => [])); + const matches = files.filter( + (account) => + account.provider === "claude" && + !account.disabled && + account.email?.toLowerCase() === login.email.toLowerCase() && + (login.organizationId === undefined || + account.organization_uuid === login.organizationId), + ); + 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, @@ -378,31 +484,37 @@ 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* 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`, { + 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, - }).pipe(Effect.result); + const cleared = yield* clearCooldown(config, account).pipe(Effect.result); return { outcome, ...(cleared._tag === "Failure" @@ -423,5 +535,5 @@ export const makeCliproxyApi = Effect.gen(function* () { ), ); }); - return { readAccounts, consume }; + return { readAccounts, consume, findClaudeLogin, claudeUsage, claimClaudeLogin }; });