@devries-cameron20 / t3code Mirror · read-only / commits / 0d10c36ded
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 22:00 UTC

fix(server): older probes no longer overwrite live usage limits (#18723)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Julius Marminge <julius0216@outlook.com>

vivek committed Oct 20, 2026 at 10:37 UTC 0d10c36ded035425e8eb8a372f886cee55e49091
5 files changed +158 -3
apps/server/src/provider/ClaudeCapabilitiesProbe.test.ts
+1
@@ -308,6 +308,7 @@ it.layer(NodeServices.layer)("Claude capability probe SDK boundary", (it) => {
308 rate_limits_available: true,
309 rate_limits: { five_hour: { utilization: 12, resets_at: "2026-07-18T14:39:00Z" } },
310 },
311 + usageCheckedAt: "1970-01-01T00:00:00.000Z",
312 });
313
314 const invocation = JSON.parse(yield* fs.readFileString(invocationPath)) as {
apps/server/src/provider/ClaudeProvider.ts
+9 -3
@@ -265,6 +265,7 @@ export type ClaudeCapabilitiesProbe = {
265 * otherwise successful response mean the account has none (API key).
266 */
267 readonly usage?: Pick<SDKControlGetUsageResponse, "rate_limits_available" | "rate_limits">;
268 + readonly usageCheckedAt?: string;
269 };
270
271 function parseClaudeInitializationCommands(
@@ -385,6 +386,7 @@ const probeClaudeCapabilities = (
386 // Usage has its own deadline so a slow optional request cannot discard initialization.
387 // Only the rate limits are read, so skip the local transcript scan that fills
388 // `behaviors`: with a few GB of transcripts it outlasts the deadline.
389 + const usageCheckedAt = DateTime.formatIso(yield* DateTime.now);
390 const usageResult = includeUsage
391 ? yield* Effect.tryPromise(() =>
392 q.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET({ skipBehaviors: true }),
@@ -413,7 +415,7 @@ const probeClaudeCapabilities = (
415 apiKeySource: account?.apiKeySource,
416 apiProvider: account?.apiProvider,
417 slashCommands: parseClaudeInitializationCommands(init.commands),
416 - ...(usage ? { usage } : {}),
418 + ...(usage ? { usage, usageCheckedAt } : {}),
419 } satisfies ClaudeCapabilitiesProbe;
420 }),
421 ),
@@ -654,14 +656,18 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
656 }) ??
657 apiProviderAuthMetadata(capabilities.apiProvider) ??
658 (customApiEndpoint ? { type: "customEndpoint", label: "Custom API endpoint" } : undefined);
659 + const usageCheckedAt = capabilities.usageCheckedAt ?? checkedAt;
660 const usageLimits = !capabilities.usage
661 ? makeUnavailableUsageLimits({ checkedAt, reason: "probeFailed" })
662 : scopedLimitNames
663 ? yield* recordClaudeUsageResponse(scopedLimitNames, {
664 response: capabilities.usage,
662 - checkedAt,
665 + checkedAt: usageCheckedAt,
666 })
664 - : claudeUsageResponseToLimits({ response: capabilities.usage, checkedAt }).limits;
667 + : claudeUsageResponseToLimits({
668 + response: capabilities.usage,
669 + checkedAt: usageCheckedAt,
670 + }).limits;
671 const resetCredits =
672 resolveResetCredits &&
673 capabilities.subscriptionType &&
apps/server/src/provider/ProviderRegistry.test.ts
+110
@@ -1,3 +1,5 @@
1 +import * as ClaudeSdk from "@anthropic-ai/claude-agent-sdk";
2 +import { vi } from "vite-plus/test";
3 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
4 import * as CodexInstallation from "./CodexInstallation.ts";
5 import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
@@ -8,6 +10,7 @@ import * as DateTime from "effect/DateTime";
10 import * as Deferred from "effect/Deferred";
11 import * as Effect from "effect/Effect";
12 import * as Path from "effect/Path";
13 +import * as FileSystem from "effect/FileSystem";
14 import * as Exit from "effect/Exit";
15 import * as Fiber from "effect/Fiber";
16 import * as Layer from "effect/Layer";
@@ -42,6 +45,10 @@ import { applyServerSettingsPatch } from "@t3tools/shared/serverSettings";
45
46 import { checkCodexProviderStatus, type CodexAppServerProviderSnapshot } from "./CodexProvider.ts";
47 import { checkClaudeProviderStatus } from "./ClaudeProvider.ts";
48 +import { ClaudeDriver } from "./Drivers/ClaudeDriver.ts";
49 +import { ClaudeAgentSdkQueryRunner } from "../orchestration-v2/Adapters/ClaudeAdapterV2.ts";
50 +import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
51 +import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
52 import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
53 import * as AntigravityInstallation from "./AntigravityInstallation.ts";
54 import * as ModelManifest from "./ModelManifest.ts";
@@ -75,6 +82,8 @@ import {
82 makeManualOnlyProviderMaintenanceCapabilities,
83 makeProviderMaintenanceCapabilities,
84 } from "@t3tools/provider-core/server/maintenanceResolver";
85 +vi.mock("@anthropic-ai/claude-agent-sdk", { spy: true });
86 +
87 const decodeServerProvider = Schema.decodeSync(ServerProvider);
88 const encodeServerProvider = Schema.encodeSync(ServerProvider);
89 const decodeServerSettings = Schema.decodeSync(ServerSettings);
@@ -3985,6 +3994,107 @@ it.layer(
3994 });
3995
3996 describe("checkClaudeProviderStatus", () => {
3997 + it.effect("keeps live usage through a refresh of cached Claude capabilities", () =>
3998 + Effect.gen(function* () {
3999 + const fs = yield* FileSystem.FileSystem;
4000 + const homePath = yield* fs.makeTempDirectoryScoped({ prefix: "t3-claude-usage-cache-" });
4001 + const initializationStarted = yield* Deferred.make<void>();
4002 + const usageStarted = yield* Deferred.make<void>();
4003 + const initialization = Promise.withResolvers<ClaudeSdk.SDKControlInitializeResponse>();
4004 + const usage = Promise.withResolvers<ClaudeSdk.SDKControlGetUsageResponse>();
4005 + const query = vi.spyOn(ClaudeSdk, "query").mockImplementation(
4006 + () =>
4007 + ({
4008 + initializationResult: () => {
4009 + Deferred.doneUnsafe(initializationStarted, Effect.void);
4010 + return initialization.promise;
4011 + },
4012 + usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET: () => {
4013 + Deferred.doneUnsafe(usageStarted, Effect.void);
4014 + return usage.promise;
4015 + },
4016 + }) as ReturnType<typeof ClaudeSdk.query>,
4017 + );
4018 + yield* Effect.addFinalizer(() => Effect.sync(() => query.mockRestore()));
4019 +
4020 + const instance = yield* ClaudeDriver.create({
4021 + instanceId: ProviderInstanceId.make("claude-usage-cache"),
4022 + displayName: undefined,
4023 + environment: [],
4024 + enabled: true,
4025 + config: { ...defaultClaudeSettings, homePath },
4026 + });
4027 + yield* Deferred.await(initializationStarted);
4028 + yield* TestClock.adjust("1 second");
4029 + const usageCheckedAt = DateTime.formatIso(yield* DateTime.now);
4030 + initialization.resolve({
4031 + account: { subscriptionType: "max", tokenSource: "oauth" },
4032 + commands: [],
4033 + agents: [],
4034 + output_style: "default",
4035 + available_output_styles: [],
4036 + models: [],
4037 + });
4038 + yield* Deferred.await(usageStarted);
4039 + yield* TestClock.adjust("1 second");
4040 + usage.resolve({
4041 + rate_limits_available: true,
4042 + rate_limits: { five_hour: { utilization: 12, resets_at: null } },
4043 + } as ClaudeSdk.SDKControlGetUsageResponse);
4044 +
4045 + const first = yield* instance.snapshot.refresh;
4046 + assert.strictEqual(first.status, "ready");
4047 + const firstWindow = first.usageLimits?.windows[0];
4048 + assert.isDefined(firstWindow);
4049 + assert.strictEqual(firstWindow?.usedPercent, 12);
4050 +
4051 + yield* TestClock.adjust("1 second");
4052 + const liveCheckedAt = DateTime.formatIso(yield* DateTime.now);
4053 + yield* instance.snapshot.applyUsageLimits({
4054 + checkedAt: liveCheckedAt,
4055 + windows: [{ ...firstWindow!, usedPercent: 95 }],
4056 + });
4057 + const live = yield* instance.snapshot.getSnapshot;
4058 + yield* TestClock.adjust("1 second");
4059 + const refreshCheckedAt = DateTime.formatIso(yield* DateTime.now);
4060 + const refreshed = yield* instance.snapshot.refresh;
4061 +
4062 + assert.strictEqual(query.mock.calls.length, 1);
4063 + assert.strictEqual(refreshed.checkedAt, refreshCheckedAt);
4064 + assert.deepStrictEqual(refreshed.usageLimits, live.usageLimits);
4065 + assert.strictEqual(refreshed.usageLimits?.checkedAt, liveCheckedAt);
4066 + assert.strictEqual(refreshed.usageLimits?.windows[0]?.usedPercent, 95);
4067 + assert.strictEqual(first.usageLimits?.checkedAt, usageCheckedAt);
4068 + }).pipe(
4069 + Effect.provide(
4070 + Layer.mergeAll(
4071 + TestProviderHost.layer({ runBackgroundWork: false }),
4072 + ServerConfig.layerTest(process.cwd(), { prefix: "t3-claude-usage-cache-" }),
4073 + IdAllocator.layer,
4074 + McpProviderSessions.layer,
4075 + ResetCreditCoordinator.layerTest,
4076 + ProviderLatestVersions.layer,
4077 + Layer.succeed(
4078 + ProviderEventLoggers.ProviderEventLoggers,
4079 + ProviderEventLoggers.NoOpProviderEventLoggers,
4080 + ),
4081 + Layer.mock(ClaudeAgentSdkQueryRunner)({
4082 + open: () => Effect.die("Usage probing must not start a conversation"),
4083 + }),
4084 + ).pipe(
4085 + Layer.provideMerge(
4086 + layerMockSpawner((args) => {
4087 + if (args.join(" ") === "--version") {
4088 + return { stdout: "2.1.288\n", stderr: "", code: 0 };
4089 + }
4090 + throw new Error(`Unexpected args: ${args.join(" ")}`);
4091 + }),
4092 + ),
4093 + ),
4094 + ),
4095 + ),
4096 + );
4097 +
4098 it.effect("returns ready when claude is installed and authenticated", () =>
4099 Effect.gen(function* () {
4100 const status = yield* checkClaudeProviderStatus(
packages/provider-core/src/server/usageLimits.test.ts
+29
@@ -85,6 +85,35 @@ describe("applyUsageLimitsUpdate", () => {
85 });
86
87 describe("resolveUsageLimitsAfterProbe", () => {
88 + it("uses read order for windows while taking metadata from the successful probe", () => {
89 + const live = {
90 + checkedAt: "2026-09-03T12:00:05.000Z",
91 + windows: [
92 + { ...session, usedPercent: 95 },
93 + { ...weekly, usedPercent: 70 },
94 + ],
95 + resetCredits: { availableCount: 2 },
96 + externalUsage: { label: "Old dashboard", url: "https://example.com/old" },
97 + };
98 + const probed = {
99 + ...published,
100 + windows: [{ ...session, usedPercent: 0 }],
101 + resetCredits: { availableCount: 1 },
102 + externalUsage: { label: "Usage dashboard", url: "https://example.com/usage" },
103 + };
104 +
105 + expect(resolveUsageLimitsAfterProbe({ published: live, probed })).toEqual({
106 + ...probed,
107 + checkedAt: live.checkedAt,
108 + windows: live.windows,
109 + });
110 +
111 + const sameTime = { ...probed, checkedAt: live.checkedAt };
112 + const newer = { ...probed, checkedAt: "2026-09-03T12:00:06.000Z" };
113 + expect(resolveUsageLimitsAfterProbe({ published: live, probed: sameTime })).toEqual(sameTime);
114 + expect(resolveUsageLimitsAfterProbe({ published: live, probed: newer })).toEqual(newer);
115 + });
116 +
117 it("keeps the last good windows through a failed probe but not an unsupported one", () => {
118 const failed = { checkedAt, windows: [], unavailable: { reason: "probeFailed" as const } };
119 const unsupported = { checkedAt, windows: [], unavailable: { reason: "unsupported" as const } };
packages/provider-core/src/server/usageLimits.ts
+9
@@ -109,5 +109,14 @@ export function resolveUsageLimitsAfterProbe(input: {
109 if (probed?.unavailable?.reason === "probeFailed" && published && !published.unavailable) {
110 return published;
111 }
112 + if (
113 + published &&
114 + probed &&
115 + !published.unavailable &&
116 + !probed.unavailable &&
117 + Date.parse(published.checkedAt) > Date.parse(probed.checkedAt)
118 + ) {
119 + return { ...probed, checkedAt: published.checkedAt, windows: published.windows };
120 + }
121 return probed;
122 }