fix(native-chat): keep Claude's context ring after compaction when responses carry no usage

This commit is contained in:
Kelvin Amoaba
2026-11-12 09:44:47 +00:00
parent c32480d9e1
commit b962d90944
6 changed files with 152 additions and 35 deletions
@@ -28,12 +28,18 @@ const CONVERSATION_FRAME_TYPES = new Set(['assistant', 'user', 'stream_event'])
/** Null targets the newest journal turn when no turn was open at request time. */
export type ClaudeContextReportTarget = AgentJournalItemIdentity | null
export type ClaudeContextReportPart = 'report' | 'window'
/** `askedAt` returns with the answer to `recordReport`. */
export type ClaudeContextReportListener = (
target: ClaudeContextReportTarget,
askedAt: number
) => void
const STALE = Symbol('stale-window')
export class ClaudeContextFacts {
private activity = 0
/** Advances on every newer used count, written or held back; a report asked for earlier must not replace it. */
private usedCounts = 0
private mainModel: ClaudeMainThreadModel = { initModel: null, responseModel: null }
/** Null adopts the next response model; STALE blocks estimates until a fresh window arrives. */
private servedModel: string | null | typeof STALE = null
@@ -44,7 +50,7 @@ export class ClaudeContextFacts {
/** Check the journal before seeding a configured window hint. */
private journalMayLackWindow = true
private lastResponse: string | null = null
private readonly requestListeners = new Set<(target: ClaudeContextReportTarget) => void>()
private readonly requestListeners = new Set<ClaudeContextReportListener>()
constructor(
private readonly turn: ClaudeOpenTurn,
@@ -111,6 +117,7 @@ export class ClaudeContextFacts {
if (this.servedModel === STALE) {
// After a model change, only a configured hint can serve estimates before the report.
if (!hint) {
this.usedCounts += 1
return
}
window = hint
@@ -157,28 +164,25 @@ export class ClaudeContextFacts {
this.requestReport(settled)
}
/** Reports overtaken by activity retain only the window; full reports also replace usage. */
/** A report asked for before a newer used count retains only the window; otherwise it also replaces usage. */
recordReport(
target: ClaudeContextReportTarget,
report: AgentSessionContextReport,
part: ClaudeContextReportPart
askedAt: number
): void {
const window = { tokens: report.windowTokens, capturedAt: report.capturedAt }
this.servedModel = null
this.windowReported = true
// Before the first turn exists, retain the report's window for the first response.
this.windowHint = report.windowTokens
const contextUsage: AgentSessionContextUsage =
part === 'report' ? { used: { kind: 'report', ...report }, window } : { window }
writeAgentJournalTurnRow(
this.sink,
target === null ? { newest: true } : { identity: target },
{ contextUsage },
{ publish: true }
this.write(
askedAt === this.usedCounts ? { used: { kind: 'report', ...report }, window } : { window },
undefined,
target
)
}
subscribeReportRequests(listener: (target: ClaudeContextReportTarget) => void): () => void {
subscribeReportRequests(listener: ClaudeContextReportListener): () => void {
this.requestListeners.add(listener)
return () => this.requestListeners.delete(listener)
}
@@ -189,9 +193,12 @@ export class ClaudeContextFacts {
private write(
contextUsage: AgentSessionContextUsage,
windowIfNoneHeld?: AgentSessionContextWindow
windowIfNoneHeld?: AgentSessionContextWindow,
identity: ClaudeContextReportTarget = this.turn.identity
): void {
const identity = this.turn.identity
if (contextUsage.used) {
this.usedCounts += 1
}
const target: AgentJournalTurnRowTarget = identity ? { identity } : { newest: true }
// No later frame may arrive to publish this fact.
writeAgentJournalTurnRow(
@@ -213,7 +220,7 @@ export class ClaudeContextFacts {
private requestReport(target: ClaudeContextReportTarget): void {
for (const listener of this.requestListeners) {
listener(target)
listener(target, this.usedCounts)
}
}
}
@@ -0,0 +1,121 @@
import { mkdtemp, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, beforeEach, expect, it } from 'vitest'
import { selectStructuredAgentContextUsage } from '../../../shared/agent-session/structured-agent-session-context-usage'
import { claudeProviderHandle } from '../../../shared/agent-session/lifecycle/agent-session-provider-handle-encoding'
import { createTrackedJournalOpener } from '../../native-chat/agent-session-journal/store-lifecycle/journal-host-database-test-support'
import { createDeferredStructuredAgentSessionEventSink } from '../../native-chat/agent-session-wire/journal-ingress/structured-agent-session-event-sink'
import { testEventSinkLogging } from '../../native-chat/agent-session-wire/host/testing/structured-agent-session-logger-test-support'
import { createClaudeJournalTranslator } from '../structured/journal/claude-structured-journal-translation'
import { bindClaudeContextUsageCapture } from './claude-context-usage'
const journals = createTrackedJournalOpener()
let root: string
beforeEach(async () => {
root = await mkdtemp(join(tmpdir(), 'orca-claude-context-usage-'))
})
afterEach(async () => {
await journals.closeAll()
await rm(root, { recursive: true, force: true })
})
function frame(message: Record<string, unknown>, observedAt: number, startsTurn = false) {
return {
type: 'message' as const,
sessionId: 'orca-session',
observedAt,
...(startsTurn ? { startsTurn: true as const } : {}),
message: { session_id: 'claude-session', parent_tool_use_id: null, ...message }
}
}
// Gateways that convert OpenAI streams send usage only in message_delta, so Claude's frames carry zeros.
const responseWithoutUsage = (uuid: string, at: number) =>
frame(
{
type: 'assistant',
uuid,
message: {
role: 'assistant',
model: 'deepseek-v4.1-flash',
content: [{ type: 'text', text: uuid }],
usage: { input_tokens: 0, output_tokens: 0 }
}
},
at
)
it('shows the report after a compaction when responses carry no usage', async () => {
const journal = await journals.open({
identity: {
sessionId: 'orca-session',
workspaceId: 'workspace-1',
hostId: 'local',
agent: 'claude',
providerHandle: claudeProviderHandle('claude-session', null)
},
now: () => 9_000,
stateDirectory: join(root, 'orca-session')
})
const deferred = createDeferredStructuredAgentSessionEventSink(testEventSinkLogging())
const translator = createClaudeJournalTranslator({ sink: deferred.sink, coalesceMs: 0 })
deferred.bind({ journal, fence: 1, publish: () => {} })
const answers: ((value: unknown) => void)[] = []
const unbind = bindClaudeContextUsageCapture(
{ getContextUsage: () => new Promise((resolve) => answers.push(resolve)) },
translator,
{ now: () => 20_000 }
)
const settle = async (): Promise<void> => {
for (let index = 0; index < 4; index += 1) {
await Promise.resolve()
}
await expect(deferred.drained()).resolves.toEqual({ ok: true })
}
const ring = () => selectStructuredAgentContextUsage(journal.snapshot().items)
translator.handle(
frame({ type: 'system', subtype: 'init', uuid: 'init', model: 'deepseek-v4.1-flash' }, 900)
)
translator.handle(
frame(
{
type: 'user',
uuid: 'turn-a',
message: { role: 'user', content: [{ type: 'text', text: 'go' }] }
},
1_000,
true
)
)
translator.handle(responseWithoutUsage('reply-a', 2_000))
translator.handle(
frame(
{
type: 'system',
subtype: 'compact_boundary',
uuid: 'compact',
compact_metadata: { trigger: 'auto' }
},
3_000
)
)
translator.handle(responseWithoutUsage('reply-a2', 4_000))
await settle()
expect(ring()).toBeNull()
answers.at(-1)?.({
model: 'deepseek-v4.1-flash',
totalTokens: 40_000,
rawMaxTokens: 200_000,
categories: []
})
await settle()
expect(ring()).toMatchObject({ usedTokens: 40_000, windowTokens: 200_000, estimated: false })
unbind?.()
translator.dispose()
deferred.close()
})
@@ -175,10 +175,10 @@ export type ClaudeContextUsageReader = Pick<ClaudeStreamJsonConnection, 'getCont
export type ClaudeContextUsageTarget = Pick<
ClaudeJournalTranslator,
'subscribeContextUsageRequests' | 'recordContextReport' | 'contextActivity'
'subscribeContextUsageRequests' | 'recordContextReport'
>
/** Newer requests discard old answers; conversation activity invalidates only usage, not the window. */
/** Newer requests discard old answers; the translator decides whether a late answer still replaces usage. */
export function bindClaudeContextUsageCapture(
connection: ClaudeContextUsageReader,
translator: ClaudeContextUsageTarget | null,
@@ -189,9 +189,8 @@ export function bindClaudeContextUsageCapture(
}
let bound = true
let requests = 0
const unsubscribe = translator.subscribeContextUsageRequests((target) => {
const unsubscribe = translator.subscribeContextUsageRequests((target, askedAt) => {
const request = ++requests
const activity = translator.contextActivity
void connection
.getContextUsage({ timeoutMs: options.timeoutMs ?? CLAUDE_CONTEXT_USAGE_TIMEOUT_MS })
.then(
@@ -203,11 +202,7 @@ export function bindClaudeContextUsageCapture(
if (!report) {
return
}
if (activity !== translator.contextActivity) {
translator.recordContextReport(target, report, 'window')
return
}
translator.recordContextReport(target, report, 'report')
translator.recordContextReport(target, report, askedAt)
},
() => {}
)
@@ -154,8 +154,6 @@ export async function dispatchClaudeTurn(
: randomUUID())
const arm = () => {
++session.dispatchSequence
// Invalidate context reports requested before this send.
session.translator?.markContextActivity()
return waitForReplay(
session,
acceptsResult,
@@ -8,7 +8,7 @@ import type {
} from '../../../native-chat/agent-session-wire/journal-ingress/structured-agent-session-event-sink'
import type { ClaudeChildToolQueries } from '../../subagents/claude-child-tool-queries'
import type {
ClaudeContextReportPart,
ClaudeContextReportListener,
ClaudeContextReportTarget
} from '../../context-usage/claude-context-facts'
import type { ClaudeJournalPrompts } from './claude-structured-journal-prompts'
@@ -59,18 +59,15 @@ export type ClaudeJournalTranslator = {
retryPendingCancellations?: () => StructuredAgentSessionSinkAdmission
/** Streamed blocks awaiting final frames; settlement clears them. */
readonly pendingStreamedBlocks: number
/** Advances on conversation activity and accepted sends, invalidating older context requests. */
/** Advances on conversation activity; history catch-up refuses to finish past it. */
readonly contextActivity: number
/** Every final snapshot and turn settlement this acquisition tried was admitted. */
readonly finalOutputAdmitted: boolean
markContextActivity: () => void
subscribeContextUsageRequests: (
listener: (target: ClaudeContextReportTarget) => void
) => () => void
subscribeContextUsageRequests: (listener: ClaudeContextReportListener) => () => void
recordContextReport: (
target: ClaudeContextReportTarget,
report: AgentSessionContextReport,
part: ClaudeContextReportPart
askedAt: number
) => void
/** Defer context estimates until a model change yields a new window. */
modelMayHaveChanged: () => void
@@ -288,9 +288,8 @@ export function createClaudeJournalTranslator(
get finalOutputAdmitted() {
return coverage.admitted
},
markContextActivity: () => context.markActivity(),
subscribeContextUsageRequests: (listener) => context.subscribeReportRequests(listener),
recordContextReport: (target, report, part) => context.recordReport(target, report, part),
recordContextReport: (target, report, askedAt) => context.recordReport(target, report, askedAt),
modelMayHaveChanged: () => context.modelMayHaveChanged(),
modelWritten: (model) => context.modelWritten(model),
dispose: () => {