@devries-cameron20 / t3code Mirror · read-only / commits / 251834c161
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, 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 });