The best way to control Claude Code, Codex and more from any computer or phone
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
}