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, 09:30 UTC
fix(claude): retain measured usage after a steered query exits (#25200)
Co-authored-by: Aditya Garud <153842990+yashranaway@users.noreply.github.com>
maria committed
Oct 31, 2026 at 08:48 UTC
251834c161dc8caec3c046e3a427b185db76a5e4
3 files changed
+139
-46
apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
+29
-19
@@ -5235,11 +5235,16 @@ describe("ClaudeAdapterV2 background wake turns", () => {
5235
5236
it.effect.each(
5237
(["aborted_tools", "aborted_streaming"] as const).flatMap((terminalReason) =>
5238
- [true, false].map((steered) => ({ terminalReason, steered })),
5238
+ [
5239
+ { steered: false, queryExits: false },
5240
+ { steered: true, queryExits: false },
5241
+ { steered: true, queryExits: true },
5242
+ ].map((scenario) => ({ terminalReason, ...scenario })),
5243
),
5240
- )("handles $terminalReason with active steering=$steered", ({ terminalReason, steered }) =>
5244
+ )("handles $terminalReason (steered=$steered, exits=$queryExits)", (scenario) =>
5245
Effect.scoped(
5246
Effect.gen(function* () {
5247
+ const { terminalReason, steered, queryExits } = scenario;
5248
const harness = yield* makeWakeHarness;
5249
const idAllocator = yield* IdAllocator.IdAllocatorV2;
5250
const attemptId = RunAttemptId.make("attempt-steering-abort");
@@ -5271,8 +5276,7 @@ describe("ClaudeAdapterV2 background wake turns", () => {
5276
});
5277
assert.equal(harness.offeredMessages[1]?.priority, "now");
5278
}
5274
- yield* Queue.offer(
5275
- harness.sdkMessages,
5279
+ yield* harness.offerAndWait(
5280
makeResultFrame({
5281
uuid: "00000000-0000-4000-8000-000000000901",
5282
result: "",
@@ -5285,7 +5289,9 @@ describe("ClaudeAdapterV2 background wake turns", () => {
5289
},
5290
}),
5291
);
5288
- if (steered) {
5292
+ if (queryExits) {
5293
+ yield* Queue.shutdown(harness.sdkMessages);
5294
+ } else if (steered) {
5295
yield* Queue.offer(harness.sdkMessages, wakeAssistant);
5296
yield* Queue.offer(
5297
harness.sdkMessages,
@@ -5302,16 +5308,20 @@ describe("ClaudeAdapterV2 background wake turns", () => {
5308
);
5309
}
5310
const terminal = yield* Queue.take(harness.terminalReceipts);
5305
- assert.equal(terminal.status, steered ? "completed" : "interrupted");
5311
+ assert.equal(
5312
+ terminal.status,
5313
+ queryExits ? "failed" : steered ? "completed" : "interrupted",
5314
+ );
5315
if (steered) {
5307
- assert.isTrue(
5308
- harness.events.some(
5309
- (event) =>
5310
- event.type === "turn_item.updated" &&
5311
- event.turnItem.type === "assistant_message" &&
5312
- event.turnItem.text === WAKE_ASSISTANT_TEXT,
5313
- ),
5314
- );
5316
+ if (!queryExits)
5317
+ assert.isTrue(
5318
+ harness.events.some(
5319
+ (event) =>
5320
+ event.type === "turn_item.updated" &&
5321
+ event.turnItem.type === "assistant_message" &&
5322
+ event.turnItem.text === WAKE_ASSISTANT_TEXT,
5323
+ ),
5324
+ );
5325
const completed = harness.events.findLast(
5326
(event) => event.type === "provider_turn.updated",
5327
);
@@ -5321,12 +5331,12 @@ describe("ClaudeAdapterV2 background wake turns", () => {
5331
: undefined,
5332
{
5333
usageScope: "main_agent",
5324
- usageStatus: "complete",
5334
+ usageStatus: queryExits ? "partial" : "complete",
5335
hasSubagents: false,
5326
- inputTokens: 603 + 2847 + 11455,
5327
- outputTokens: 46,
5328
- cachedInputTokens: 11455,
5329
- cacheCreationTokens: 2847,
5336
+ inputTokens: queryExits ? 3100 : 603 + 2847 + 11455,
5337
+ outputTokens: queryExits ? 40 : 46,
5338
+ cachedInputTokens: queryExits ? 2000 : 11455,
5339
+ cacheCreationTokens: queryExits ? 500 : 2847,
5340
},
5341
);
5342
}
apps/server/src/provider/ClaudeTurnTokenUsage.ts
+21
-27
@@ -15,12 +15,10 @@ const BILLED_USAGE_FIELDS = [
15
] as const;
16
17
function addKnownCount(finalCount: unknown, earlierCounts: ReadonlyArray<unknown>): unknown {
18
- const known = finiteNonNegativeInteger(finalCount);
19
- if (known === undefined) return finalCount;
20
- return earlierCounts.reduce<number>(
21
- (sum, count) => sum + (finiteNonNegativeInteger(count) ?? 0),
22
- known,
23
- );
18
+ const counts = [finalCount, ...earlierCounts]
19
+ .map(finiteNonNegativeInteger)
20
+ .filter((count) => count !== undefined);
21
+ return counts.length === 0 ? finalCount : counts.reduce((sum, count) => sum + count, 0);
22
}
23
24
// Steering aborts the current segment; each SDK result reports only that segment's usage.
@@ -38,18 +36,16 @@ function withEarlierSegmentUsage(
36
);
37
}
38
const outputDetails = usage.output_tokens_details as Record<string, unknown> | undefined;
41
- if (outputDetails != null) {
42
- total.output_tokens_details = {
43
- ...outputDetails,
44
- thinking_tokens: addKnownCount(
45
- outputDetails.thinking_tokens,
46
- segments.map(
47
- (segment) =>
48
- (segment.output_tokens_details as Record<string, unknown> | undefined)?.thinking_tokens,
49
- ),
39
+ total.output_tokens_details = {
40
+ ...outputDetails,
41
+ thinking_tokens: addKnownCount(
42
+ outputDetails?.thinking_tokens,
43
+ segments.map(
44
+ (segment) =>
45
+ (segment.output_tokens_details as Record<string, unknown> | undefined)?.thinking_tokens,
46
),
51
- };
52
- }
47
+ ),
48
+ };
49
return total;
50
}
51
@@ -60,15 +56,7 @@ export function normalizeClaudeTurnTokenUsage(
56
earlierSegmentUsage: ReadonlyArray<unknown> = [],
57
): TurnTokenUsage {
58
const finalUsage = result?.usage as Record<string, unknown> | undefined;
63
- const usage = finalUsage && withEarlierSegmentUsage(finalUsage, earlierSegmentUsage);
64
- if (!usage) {
65
- return {
66
- usageStatus: "unavailable",
67
- usageScope: "main_agent",
68
- hasSubagents,
69
- };
70
- }
71
-
59
+ const usage = withEarlierSegmentUsage(finalUsage ?? {}, earlierSegmentUsage);
60
const uncachedInputTokens = finiteNonNegativeInteger(usage.input_tokens);
61
const cachedInputTokens = finiteNonNegativeInteger(usage.cache_read_input_tokens);
62
const cacheCreationTokens = finiteNonNegativeInteger(usage.cache_creation_input_tokens);
@@ -116,8 +104,14 @@ export function normalizeClaudeTurnTokenUsage(
104
if (
105
terminalStatus === "completed" &&
106
result?.subtype === "success" &&
107
+ finiteNonNegativeInteger(finalUsage?.input_tokens) !== undefined &&
108
+ finiteNonNegativeInteger(finalUsage?.output_tokens) !== undefined &&
109
inputTokens !== undefined &&
120
- rawOutputTokens !== undefined
110
+ rawOutputTokens !== undefined &&
111
+ BILLED_USAGE_FIELDS.every(
112
+ (field) =>
113
+ finalUsage?.[field] == null || finiteNonNegativeInteger(finalUsage[field]) !== undefined,
114
+ )
115
) {
116
return {
117
...commonUsage,
apps/server/src/provider/TurnTokenUsage.test.ts
+89
@@ -130,4 +130,93 @@ describe("billable native turn usage", () => {
130
),
131
).toMatchObject({ usageStatus: "partial", inputTokens: 4, outputTokens: 2 });
132
});
133
+
134
+ it.each(["failed", "interrupted", "completed"] as const)(
135
+ "retains measured Claude steering usage as partial after %s without final usage",
136
+ (status) => {
137
+ expect(
138
+ normalizeClaudeTurnTokenUsage(
139
+ status === "completed" ? { subtype: "success" } : undefined,
140
+ true,
141
+ status,
142
+ [
143
+ { input_tokens: 100, cache_read_input_tokens: 40, output_tokens: 20 },
144
+ { input_tokens: 5, cache_read_input_tokens: 2, output_tokens: 3 },
145
+ ],
146
+ ),
147
+ ).toEqual({
148
+ usageStatus: "partial",
149
+ usageScope: "main_agent",
150
+ hasSubagents: true,
151
+ inputTokens: 147,
152
+ cachedInputTokens: 42,
153
+ outputTokens: 23,
154
+ });
155
+ },
156
+ );
157
+
158
+ it.each([undefined, null, {}])(
159
+ "keeps unavailable Claude usage unavailable without measured segments (%s)",
160
+ (usage) => {
161
+ expect(
162
+ normalizeClaudeTurnTokenUsage({ subtype: "success", usage }, false, "completed")
163
+ .usageStatus,
164
+ ).toBe("unavailable");
165
+ },
166
+ );
167
+
168
+ it("retains measured thinking tokens without a final result", () => {
169
+ expect(
170
+ normalizeClaudeTurnTokenUsage(undefined, false, "failed", [
171
+ { input_tokens: 4, output_tokens: 3, output_tokens_details: { thinking_tokens: 2 } },
172
+ ]),
173
+ ).toMatchObject({
174
+ usageStatus: "partial",
175
+ inputTokens: 4,
176
+ outputTokens: 3,
177
+ reasoningTokens: 2,
178
+ });
179
+ });
180
+
181
+ it.each([undefined, null])(
182
+ "retains earlier cache counts when a steering segment reports %s",
183
+ (cache) => {
184
+ expect(
185
+ normalizeClaudeTurnTokenUsage(undefined, false, "failed", [
186
+ { input_tokens: 100, cache_read_input_tokens: 40, output_tokens: 20 },
187
+ { input_tokens: 5, cache_read_input_tokens: cache, output_tokens: 3 },
188
+ ]),
189
+ ).toMatchObject({
190
+ usageStatus: "partial",
191
+ inputTokens: 145,
192
+ cachedInputTokens: 40,
193
+ outputTokens: 23,
194
+ });
195
+ },
196
+ );
197
+
198
+ it.each(["cache_read_input_tokens", "cache_creation_input_tokens"])(
199
+ "keeps Claude usage partial when the final %s is invalid",
200
+ (field) => {
201
+ expect(
202
+ normalizeClaudeTurnTokenUsage(
203
+ { subtype: "success", usage: { input_tokens: 5, output_tokens: 3, [field]: -1 } },
204
+ false,
205
+ "completed",
206
+ [{ input_tokens: 100, output_tokens: 20, [field]: 40 }],
207
+ ),
208
+ ).toMatchObject({ usageStatus: "partial", inputTokens: 145, outputTokens: 23 });
209
+ },
210
+ );
211
+
212
+ it("adds Claude steering segments to the final measured result once", () => {
213
+ expect(
214
+ normalizeClaudeTurnTokenUsage(
215
+ { subtype: "success", usage: { input_tokens: 5, output_tokens: 3 } },
216
+ false,
217
+ "completed",
218
+ [{ input_tokens: 4, output_tokens: 2 }],
219
+ ),
220
+ ).toMatchObject({ usageStatus: "complete", inputTokens: 9, outputTokens: 5 });
221
+ });
222
});