Skip to content

Commit 35fab5c

Browse files
committed
fix(claude): keep subagent usage out of context meter
1 parent 7e01d33 commit 35fab5c

2 files changed

Lines changed: 119 additions & 173 deletions

File tree

‎apps/server/src/provider/Layers/ClaudeAdapter.test.ts‎

Lines changed: 105 additions & 110 deletions
Original file line numberDiff line numberDiff line change
@@ -2100,10 +2100,10 @@ describe("ClaudeAdapterLive", () => {
21002100
return Effect.gen(function* () {
21012101
const adapter = yield* ClaudeAdapter;
21022102

2103-
const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 6).pipe(
2104-
Stream.runCollect,
2105-
Effect.forkChild,
2106-
);
2103+
const runtimeEventsFiber = yield* Stream.takeUntil(
2104+
adapter.streamEvents,
2105+
(event) => event.type === "task.progress",
2106+
).pipe(Stream.runCollect, Effect.forkChild);
21072107

21082108
yield* adapter.startSession({
21092109
threadId: THREAD_ID,
@@ -2287,15 +2287,15 @@ describe("ClaudeAdapterLive", () => {
22872287
);
22882288
});
22892289

2290-
it.effect("emits thread token usage updates from Claude task progress", () => {
2290+
it.effect("keeps Claude task progress usage out of the parent context window", () => {
22912291
const harness = makeHarness();
22922292
return Effect.gen(function* () {
22932293
const adapter = yield* ClaudeAdapter;
22942294

2295-
const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 6).pipe(
2296-
Stream.runCollect,
2297-
Effect.forkChild,
2298-
);
2295+
const runtimeEventsFiber = yield* Stream.takeUntil(
2296+
adapter.streamEvents,
2297+
(event) => event.type === "task.progress",
2298+
).pipe(Stream.runCollect, Effect.forkChild);
22992299

23002300
yield* adapter.startSession({
23012301
threadId: THREAD_ID,
@@ -2320,20 +2320,14 @@ describe("ClaudeAdapterLive", () => {
23202320
const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
23212321
const usageEvent = runtimeEvents.find((event) => event.type === "thread.token-usage.updated");
23222322
const progressEvent = runtimeEvents.find((event) => event.type === "task.progress");
2323-
assert.equal(usageEvent?.type, "thread.token-usage.updated");
2324-
if (usageEvent?.type === "thread.token-usage.updated") {
2325-
assert.deepEqual(usageEvent.payload, {
2326-
usage: {
2327-
usedTokens: 321,
2328-
lastUsedTokens: 321,
2329-
toolUses: 2,
2330-
durationMs: 654,
2331-
},
2332-
});
2333-
}
2323+
assert.equal(usageEvent, undefined);
23342324
assert.equal(progressEvent?.type, "task.progress");
2335-
if (usageEvent && progressEvent) {
2336-
assert.notStrictEqual(usageEvent.eventId, progressEvent.eventId);
2325+
if (progressEvent?.type === "task.progress") {
2326+
assert.deepEqual(progressEvent.payload.typedUsage, {
2327+
totalTokens: 321,
2328+
toolUses: 2,
2329+
durationMs: 654,
2330+
});
23372331
}
23382332
}).pipe(
23392333
Effect.provideService(Random.Random, makeDeterministicRandomService()),
@@ -2408,15 +2402,15 @@ describe("ClaudeAdapterLive", () => {
24082402
);
24092403
});
24102404

2411-
it.effect("clamps oversized Claude usage to the reported context window", () => {
2405+
it.effect("does not treat total-only Claude result usage as active context", () => {
24122406
const harness = makeHarness();
24132407
return Effect.gen(function* () {
24142408
const adapter = yield* ClaudeAdapter;
24152409

2416-
const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 7).pipe(
2417-
Stream.runCollect,
2418-
Effect.forkChild,
2419-
);
2410+
const runtimeEventsFiber = yield* Stream.takeUntil(
2411+
adapter.streamEvents,
2412+
(event) => event.type === "turn.completed",
2413+
).pipe(Stream.runCollect, Effect.forkChild);
24202414

24212415
yield* adapter.startSession({
24222416
threadId: THREAD_ID,
@@ -2454,103 +2448,104 @@ describe("ClaudeAdapterLive", () => {
24542448

24552449
const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
24562450
const usageEvent = runtimeEvents.find((event) => event.type === "thread.token-usage.updated");
2457-
assert.equal(usageEvent?.type, "thread.token-usage.updated");
2458-
if (usageEvent?.type === "thread.token-usage.updated") {
2459-
assert.deepEqual(usageEvent.payload, {
2460-
usage: {
2461-
usedTokens: 200000,
2462-
lastUsedTokens: 200000,
2463-
totalProcessedTokens: 535000,
2464-
maxTokens: 200000,
2465-
},
2466-
});
2467-
}
2451+
assert.equal(usageEvent, undefined);
24682452
}).pipe(
24692453
Effect.provideService(Random.Random, makeDeterministicRandomService()),
24702454
Effect.provide(harness.layer),
24712455
);
24722456
});
24732457

2474-
it.effect(
2475-
"preserves oversized Claude result totals after task progress snapshots are recorded",
2476-
() => {
2477-
const harness = makeHarness();
2478-
return Effect.gen(function* () {
2479-
const adapter = yield* ClaudeAdapter;
2458+
it.effect("keeps subagent totals out of parent context when the result is total-only", () => {
2459+
const harness = makeHarness();
2460+
return Effect.gen(function* () {
2461+
const adapter = yield* ClaudeAdapter;
24802462

2481-
const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 9).pipe(
2482-
Stream.runCollect,
2483-
Effect.forkChild,
2484-
);
2463+
const runtimeEventsFiber = yield* Stream.takeUntil(
2464+
adapter.streamEvents,
2465+
(event) => event.type === "turn.completed",
2466+
).pipe(Stream.runCollect, Effect.forkChild);
24852467

2486-
yield* adapter.startSession({
2487-
threadId: THREAD_ID,
2488-
provider: ProviderDriverKind.make("claudeAgent"),
2489-
runtimeMode: "full-access",
2490-
});
2468+
yield* adapter.startSession({
2469+
threadId: THREAD_ID,
2470+
provider: ProviderDriverKind.make("claudeAgent"),
2471+
runtimeMode: "full-access",
2472+
});
24912473

2492-
yield* adapter.sendTurn({
2493-
threadId: THREAD_ID,
2494-
input: "hello",
2495-
attachments: [],
2496-
});
2474+
yield* adapter.sendTurn({
2475+
threadId: THREAD_ID,
2476+
input: "hello",
2477+
attachments: [],
2478+
});
24972479

2498-
harness.query.emit({
2499-
type: "system",
2500-
subtype: "task_progress",
2501-
task_id: "task-usage-clamped",
2502-
description: "Thinking through the patch",
2503-
usage: {
2504-
total_tokens: 190000,
2505-
},
2506-
session_id: "sdk-session-task-usage-clamped",
2507-
uuid: "task-usage-progress-clamped",
2508-
} as unknown as SDKMessage);
2480+
harness.query.emit({
2481+
type: "system",
2482+
subtype: "task_progress",
2483+
task_id: "task-usage-clamped",
2484+
description: "Thinking through the patch",
2485+
usage: {
2486+
total_tokens: 190000,
2487+
},
2488+
session_id: "sdk-session-task-usage-clamped",
2489+
uuid: "task-usage-progress-clamped",
2490+
} as unknown as SDKMessage);
25092491

2510-
harness.query.emit({
2511-
type: "result",
2512-
subtype: "success",
2513-
is_error: false,
2514-
duration_ms: 1234,
2515-
duration_api_ms: 1200,
2516-
num_turns: 1,
2517-
result: "done",
2518-
stop_reason: "end_turn",
2519-
session_id: "sdk-session-result-usage-clamped-after-progress",
2520-
usage: {
2521-
total_tokens: 535000,
2522-
},
2523-
modelUsage: {
2524-
"claude-opus-4-6": {
2525-
contextWindow: 200000,
2526-
maxOutputTokens: 64000,
2527-
},
2492+
harness.query.emit({
2493+
type: "system",
2494+
subtype: "task_notification",
2495+
task_id: "task-usage-clamped",
2496+
status: "completed",
2497+
summary: "Task finished",
2498+
usage: {
2499+
total_tokens: 250000,
2500+
tool_uses: 100,
2501+
duration_ms: 900000,
2502+
},
2503+
session_id: "sdk-session-task-usage-clamped",
2504+
uuid: "task-usage-completed-clamped",
2505+
} as unknown as SDKMessage);
2506+
2507+
harness.query.emit({
2508+
type: "result",
2509+
subtype: "success",
2510+
is_error: false,
2511+
duration_ms: 1234,
2512+
duration_api_ms: 1200,
2513+
num_turns: 1,
2514+
result: "done",
2515+
stop_reason: "end_turn",
2516+
session_id: "sdk-session-result-usage-clamped-after-progress",
2517+
usage: {
2518+
total_tokens: 535000,
2519+
},
2520+
modelUsage: {
2521+
"claude-opus-4-6": {
2522+
contextWindow: 200000,
2523+
maxOutputTokens: 64000,
25282524
},
2529-
} as unknown as SDKMessage);
2530-
harness.query.finish();
2525+
},
2526+
} as unknown as SDKMessage);
2527+
harness.query.finish();
25312528

2532-
const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
2533-
const usageEvents = runtimeEvents.filter(
2534-
(event) => event.type === "thread.token-usage.updated",
2535-
);
2536-
const finalUsageEvent = usageEvents.at(-1);
2537-
assert.equal(finalUsageEvent?.type, "thread.token-usage.updated");
2538-
if (finalUsageEvent?.type === "thread.token-usage.updated") {
2539-
assert.deepEqual(finalUsageEvent.payload, {
2540-
usage: {
2541-
usedTokens: 190000,
2542-
lastUsedTokens: 190000,
2543-
totalProcessedTokens: 535000,
2544-
maxTokens: 200000,
2545-
},
2546-
});
2547-
}
2548-
}).pipe(
2549-
Effect.provideService(Random.Random, makeDeterministicRandomService()),
2550-
Effect.provide(harness.layer),
2529+
const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
2530+
const usageEvents = runtimeEvents.filter(
2531+
(event) => event.type === "thread.token-usage.updated",
25512532
);
2552-
},
2553-
);
2533+
assert.deepEqual(usageEvents, []);
2534+
const progressEvent = runtimeEvents.find((event) => event.type === "task.progress");
2535+
const completedEvent = runtimeEvents.find((event) => event.type === "task.completed");
2536+
assert.equal(progressEvent?.type, "task.progress");
2537+
assert.equal(completedEvent?.type, "task.completed");
2538+
if (progressEvent?.type === "task.progress") {
2539+
assert.equal(progressEvent.payload.typedUsage?.totalTokens, 190000);
2540+
}
2541+
if (completedEvent?.type === "task.completed") {
2542+
assert.equal(completedEvent.payload.typedUsage?.totalTokens, 250000);
2543+
}
2544+
}).pipe(
2545+
Effect.provideService(Random.Random, makeDeterministicRandomService()),
2546+
Effect.provide(harness.layer),
2547+
);
2548+
});
25542549

25552550
it.effect(
25562551
"emits completion only after turn result when assistant frames arrive before deltas",

‎apps/server/src/provider/Layers/ClaudeAdapter.ts‎

Lines changed: 14 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -575,46 +575,6 @@ function compactBoundaryTokenUsageSnapshot(
575575
});
576576
}
577577

578-
function normalizeClaudeTaskProgressTokenUsage(
579-
value: unknown,
580-
context: ClaudeSessionContext,
581-
): ThreadTokenUsageSnapshot | undefined {
582-
const totalTokens = claudeTotalProcessedTokens(value);
583-
if (totalTokens === undefined || totalTokens <= 0) {
584-
return undefined;
585-
}
586-
587-
const lastUsedTokens = context.lastKnownTokenUsage?.usedTokens;
588-
const activeTokens =
589-
lastUsedTokens !== undefined ? Math.max(totalTokens, lastUsedTokens) : totalTokens;
590-
if (lastUsedTokens !== undefined && activeTokens === lastUsedTokens) {
591-
return undefined;
592-
}
593-
594-
const usage = value as Record<string, unknown>;
595-
const snapshot = makeClaudeTokenUsageSnapshot({
596-
activeTokens,
597-
...(context.lastKnownContextWindow !== undefined
598-
? { contextWindow: context.lastKnownContextWindow }
599-
: {}),
600-
totalProcessedTokens: Math.max(
601-
totalTokens,
602-
context.lastKnownTotalProcessedTokens ?? totalTokens,
603-
),
604-
});
605-
if (!snapshot) {
606-
return undefined;
607-
}
608-
609-
const toolUses = finiteNonNegativeInteger(usage.tool_uses);
610-
const durationMs = finiteNonNegativeInteger(usage.duration_ms);
611-
return {
612-
...snapshot,
613-
...(toolUses !== undefined ? { toolUses } : {}),
614-
...(durationMs !== undefined ? { durationMs } : {}),
615-
};
616-
}
617-
618578
function asCanonicalTurnId(value: TurnId): TurnId {
619579
return value;
620580
}
@@ -2200,13 +2160,16 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
22002160
resultUsageRecord !== undefined &&
22012161
!resultHasActiveUsage &&
22022162
claudeTotalProcessedTokens(resultUsageRecord) !== undefined;
2203-
const resultIterationSnapshot = resultUsageRecord
2204-
? normalizeClaudeActiveTokenUsage(
2205-
resultUsageRecord,
2206-
maxTokens,
2207-
accumulatedTotalProcessedTokens ?? context.lastKnownTotalProcessedTokens,
2208-
)
2209-
: undefined;
2163+
// `total_tokens` alone is cumulative processed work, not the active
2164+
// parent context. Only input/output or an iteration can measure usage.
2165+
const resultIterationSnapshot =
2166+
resultHasActiveUsage && resultUsageRecord
2167+
? normalizeClaudeActiveTokenUsage(
2168+
resultUsageRecord,
2169+
maxTokens,
2170+
accumulatedTotalProcessedTokens ?? context.lastKnownTotalProcessedTokens,
2171+
)
2172+
: undefined;
22102173
const lastGoodUsage = context.lastKnownTokenUsage;
22112174
const usageSnapshot: ThreadTokenUsageSnapshot | undefined =
22122175
contextUsageSnapshot ??
@@ -3207,15 +3170,10 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
32073170
return;
32083171
}
32093172
case "task_progress": {
3210-
yield* emitThreadTokenUsage(
3211-
context,
3212-
normalizeClaudeTaskProgressTokenUsage(message.usage, context),
3213-
{
3214-
rawMethod: "claude/system/task_progress",
3215-
rawPayload: message,
3216-
},
3217-
);
32183173
const linkage = taskLinkageFor(context.taskAgents, message.task_id);
3174+
// Task usage includes child agents and whole workflows. Keep it on
3175+
// the task row; promoting it to the parent context makes the meter
3176+
// appear full as soon as cumulative child work exceeds the window.
32193177
const typedUsage = normalizeTaskUsage(message.usage);
32203178
// Phases ride on the coordinator's ONE progress row per tick. A
32213179
// separate phases-only row shared the stable ingestion activity id
@@ -3274,14 +3232,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
32743232
}
32753233
case "task_notification": {
32763234
context.liveTaskIds.delete(message.task_id);
3277-
yield* emitThreadTokenUsage(
3278-
context,
3279-
normalizeClaudeTaskProgressTokenUsage(message.usage, context),
3280-
{
3281-
rawMethod: "claude/system/task_notification",
3282-
rawPayload: message,
3283-
},
3284-
);
3235+
// Terminal task usage is still child-task usage, not parent context.
32853236
const typedUsage = normalizeTaskUsage(message.usage);
32863237
yield* offerRuntimeEvent({
32873238
...base,

0 commit comments

Comments
 (0)