Skip to content

Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.

feat(agent-providers): report each turn's token usage per model

Petr Bauch22fc79bc7f60
diff --git a/console/apps/switch-console-desktop/src/main/core/agent-runtime/impl/provider-agent-status.test.ts b/console/apps/switch-console-desktop/src/main/core/agent-runtime/impl/provider-agent-status.test.ts
index 3f48f9eba..0087b57a7 100644
--- a/console/apps/switch-console-desktop/src/main/core/agent-runtime/impl/provider-agent-status.test.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agent-runtime/impl/provider-agent-status.test.ts
@@ -27,15 +27,15 @@ describe('toAgentEvent', () => {
});
it('reports a finished turn as completed', () => {
- expect(statusOf({ type: 'turn.completed', turnId: 't1', outcome: 'completed' })).toBe(
- 'completed'
- );
+ expect(
+ statusOf({ type: 'turn.completed', turnId: 't1', outcome: 'completed', usage: [] })
+ ).toBe('completed');
});
it('reports an interrupted turn as completed, not as a failure', () => {
- expect(statusOf({ type: 'turn.completed', turnId: 't1', outcome: 'interrupted' })).toBe(
- 'completed'
- );
+ expect(
+ statusOf({ type: 'turn.completed', turnId: 't1', outcome: 'interrupted', usage: [] })
+ ).toBe('completed');
});
/**
@@ -44,7 +44,13 @@ describe('toAgentEvent', () => {
*/
it('reports a failed turn as an error, carrying its reason', () => {
const agentEvent = toAgentEvent(
- event({ type: 'turn.completed', turnId: 't1', outcome: 'error', message: 'model refused' }),
+ event({
+ type: 'turn.completed',
+ turnId: 't1',
+ outcome: 'error',
+ message: 'model refused',
+ usage: [],
+ }),
PARAMS
);
expect(agentEvent).toMatchObject({ type: 'error', payload: { message: 'model refused' } });
diff --git a/console/packages/agent-providers/src/antigravity/antigravity-adapter.ts b/console/packages/agent-providers/src/antigravity/antigravity-adapter.ts
index 38767613b..bca4aef54 100644
--- a/console/packages/agent-providers/src/antigravity/antigravity-adapter.ts
+++ b/console/packages/agent-providers/src/antigravity/antigravity-adapter.ts
@@ -582,7 +582,13 @@ export class AntigravityAdapter implements ProviderAdapter {
}
this.cancelApprovals(state);
state.turn = null;
- this.emit(state, { type: 'turn.completed', turnId, outcome, ...(message ? { message } : {}) });
+ this.emit(state, {
+ type: 'turn.completed',
+ turnId,
+ outcome,
+ ...(message ? { message } : {}),
+ usage: [],
+ });
if (!state.turn)
this.emit(state, {
type: 'session.state.changed',
@@ -627,6 +633,7 @@ export class AntigravityAdapter implements ProviderAdapter {
turnId: input.turnId,
outcome: 'error',
message: reason,
+ usage: [],
});
this.sessions.delete(id);
this.emit(state, { type: 'session.state.changed', status: 'stopped' });
diff --git a/console/packages/agent-providers/src/claude/claude-adapter.test.ts b/console/packages/agent-providers/src/claude/claude-adapter.test.ts
index d4f3cb876..8b8e2da34 100644
--- a/console/packages/agent-providers/src/claude/claude-adapter.test.ts
+++ b/console/packages/agent-providers/src/claude/claude-adapter.test.ts
@@ -461,6 +461,80 @@ describe('ClaudeAdapter event translation', () => {
});
});
+function modelUsage(input: number, output: number, cacheRead = 0, cacheWrite = 0) {
+ return {
+ inputTokens: input,
+ outputTokens: output,
+ cacheReadInputTokens: cacheRead,
+ cacheCreationInputTokens: cacheWrite,
+ webSearchRequests: 0,
+ costUSD: 0,
+ contextWindow: 200_000,
+ maxOutputTokens: 32_000,
+ };
+}
+
+describe('ClaudeAdapter token usage', () => {
+ it("reports each turn's share of the session's running totals, per model", async () => {
+ const { sdk, adapter, recorder } = await startSession();
+ const query = sdk.latest();
+
+ await adapter.sendTurn({ sessionId: SESSION, turnId: 'turn-1', text: 'one' });
+ const [first] = await query.waitForSent(1);
+ query.emit(
+ resultMessage([String(first?.uuid)], {
+ modelUsage: { opus: modelUsage(100, 20, 1000, 50), haiku: modelUsage(5, 1) },
+ })
+ );
+ const one = await recorder.waitFor('turn.completed', (e) => e.turnId === 'turn-1', 1_000);
+ expect(one.usage).toEqual([
+ {
+ model: 'opus',
+ inputTokens: 100,
+ outputTokens: 20,
+ cacheReadTokens: 1000,
+ cacheWriteTokens: 50,
+ },
+ { model: 'haiku', inputTokens: 5, outputTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 },
+ ]);
+
+ await adapter.sendTurn({ sessionId: SESSION, turnId: 'turn-2', text: 'two' });
+ const sent = await query.waitForSent(2);
+ query.emit(
+ resultMessage([String(sent[1]?.uuid)], {
+ modelUsage: { opus: modelUsage(130, 25, 1500, 50), haiku: modelUsage(5, 1) },
+ })
+ );
+ const two = await recorder.waitFor('turn.completed', (e) => e.turnId === 'turn-2', 1_000);
+ expect(two.usage).toEqual([
+ {
+ model: 'opus',
+ inputTokens: 30,
+ outputTokens: 5,
+ cacheReadTokens: 500,
+ cacheWriteTokens: 0,
+ },
+ ]);
+ });
+
+ it('counts spend from a result that did not close the turn', async () => {
+ const { sdk, adapter, recorder } = await startSession();
+ await adapter.sendTurn({ sessionId: SESSION, turnId: 'turn-1', text: 'count' });
+ const query = sdk.latest();
+ const [first] = await query.waitForSent(1);
+ await adapter.sendTurn({ sessionId: SESSION, turnId: 'turn-2', text: 'stop' });
+ const sent = await query.waitForSent(2);
+
+ query.emit(resultMessage([String(first?.uuid)], { modelUsage: { opus: modelUsage(10, 1) } }));
+ query.emit(resultMessage([String(sent[1]?.uuid)], { modelUsage: { opus: modelUsage(25, 3) } }));
+
+ const done = await recorder.waitFor('turn.completed', () => true, 1_000);
+ expect(done.usage).toEqual([
+ { model: 'opus', inputTokens: 25, outputTokens: 3, cacheReadTokens: 0, cacheWriteTokens: 0 },
+ ]);
+ });
+});
+
describe('ClaudeAdapter turn attribution', () => {
it('opens a turn on send and closes it on the matching result', async () => {
const { sdk, adapter, recorder } = await startSession();
diff --git a/console/packages/agent-providers/src/claude/claude-adapter.ts b/console/packages/agent-providers/src/claude/claude-adapter.ts
index 933efcb6b..4a819bc12 100644
--- a/console/packages/agent-providers/src/claude/claude-adapter.ts
+++ b/console/packages/agent-providers/src/claude/claude-adapter.ts
@@ -32,10 +32,12 @@ import type {
ItemStatus,
ProviderItem,
ProviderRuntimeEvent,
+ TokenUsage,
TurnOutcome,
UserInputAnswers,
UserInputQuestion,
} from '../events';
+import { CumulativeUsage, mergeUsage } from '../usage';
import {
approvalContent,
isRecord,
@@ -169,6 +171,13 @@ interface SessionState {
streamMessageId: string | null;
stopping: boolean;
exited: boolean;
+ /**
+ * The SDK's per-model totals run for the whole query, so a turn's spend is
+ * the difference from the last result. Anything spent between turns
+ * (compaction) lands on the next turn to end rather than being dropped.
+ */
+ usage: CumulativeUsage;
+ unreportedUsage: TokenUsage[];
}
/** An async iterable the adapter pushes into for the life of the session. */
@@ -374,6 +383,8 @@ export class ClaudeAdapter implements ProviderAdapter {
streamMessageId: null,
stopping: false,
exited: false,
+ usage: new CumulativeUsage(),
+ unreportedUsage: [],
};
this.sessions.set(input.sessionId, session);
this.emit(session, { type: 'session.state.changed', status: 'starting' });
@@ -619,6 +630,7 @@ export class ClaudeAdapter implements ProviderAdapter {
}
private handleMessage(session: SessionState, message: SDKMessage): void {
+ if (message.type === 'result') this.recordUsage(session, message);
if (session.compaction) {
if (message.type === 'system' && message.subtype === 'compact_boundary')
session.compaction.boundary = true;
@@ -819,6 +831,27 @@ export class ClaudeAdapter implements ProviderAdapter {
}
}
+ private recordUsage(session: SessionState, result: SDKResultMessage): void {
+ const totals = new Map(
+ Object.entries(result.modelUsage ?? {}).map(([model, counts]) => [
+ model,
+ {
+ inputTokens: counts.inputTokens,
+ outputTokens: counts.outputTokens,
+ cacheReadTokens: counts.cacheReadInputTokens,
+ cacheWriteTokens: counts.cacheCreationInputTokens,
+ },
+ ])
+ );
+ session.unreportedUsage = mergeUsage(session.unreportedUsage, session.usage.advance(totals));
+ }
+
+ private takeUsage(session: SessionState): TokenUsage[] {
+ const usage = session.unreportedUsage;
+ session.unreportedUsage = [];
+ return usage;
+ }
+
private handleResult(session: SessionState, result: SDKResultMessage): void {
const turn = session.turn;
if (!turn) return;
@@ -852,6 +885,7 @@ export class ClaudeAdapter implements ProviderAdapter {
turnId: turn.turnId,
outcome,
...(message ? { message } : {}),
+ usage: this.takeUsage(session),
raw: { source: 'claude', payload: result },
});
this.emit(session, { type: 'session.state.changed', status: 'ready' });
@@ -1011,6 +1045,7 @@ export class ClaudeAdapter implements ProviderAdapter {
turnId: turn.turnId,
outcome: 'interrupted',
message: reason,
+ usage: this.takeUsage(session),
});
}
diff --git a/console/packages/agent-providers/src/codex/codex-adapter.test.ts b/console/packages/agent-providers/src/codex/codex-adapter.test.ts
index 6d0ab26c7..4e93ea6da 100644
--- a/console/packages/agent-providers/src/codex/codex-adapter.test.ts
+++ b/console/packages/agent-providers/src/codex/codex-adapter.test.ts
@@ -223,6 +223,96 @@ describe('CodexAdapter', () => {
});
});
+ it("reports each turn's share of the thread's running token total", async () => {
+ const { adapter, server, events } = await start();
+ const breakdown = (input: number, cached: number, output: number) => ({
+ totalTokens: input + output,
+ inputTokens: input,
+ cachedInputTokens: cached,
+ cacheWriteInputTokens: 0,
+ outputTokens: output,
+ reasoningOutputTokens: 0,
+ });
+ const usageUpdate = (turnId: string, input: number, cached: number, output: number) => ({
+ threadId: THREAD,
+ turnId,
+ tokenUsage: {
+ total: breakdown(input, cached, output),
+ last: breakdown(input, cached, output),
+ modelContextWindow: null,
+ },
+ });
+ let native = 0;
+ server.replyAlways('turn/start', () => ({
+ turn: { id: `native-${++native}`, status: 'inProgress' },
+ }));
+
+ await adapter.sendTurn({ sessionId: 'session-1', turnId: 'caller-1', text: 'one' });
+ server.notify('turn/started', turnNotification('native-1', 'inProgress'));
+ server.notify('thread/tokenUsage/updated', usageUpdate('native-1', 100, 60, 10));
+ server.notify('turn/completed', turnNotification('native-1', 'completed'));
+ await vi.waitFor(() => expect(eventsOf(events, 'turn.completed')).toHaveLength(1));
+
+ await adapter.setModel('session-1', { id: 'gpt-x', options: {} });
+ await adapter.sendTurn({ sessionId: 'session-1', turnId: 'caller-2', text: 'two' });
+ server.notify('turn/started', turnNotification('native-2', 'inProgress'));
+ server.notify('thread/tokenUsage/updated', usageUpdate('native-2', 150, 90, 14));
+ server.notify('turn/completed', turnNotification('native-2', 'completed'));
+ await vi.waitFor(() => expect(eventsOf(events, 'turn.completed')).toHaveLength(2));
+
+ expect(eventsOf(events, 'turn.completed').map((event) => event.usage)).toEqual([
+ [{ model: '', inputTokens: 40, outputTokens: 10, cacheReadTokens: 60, cacheWriteTokens: 0 }],
+ [
+ {
+ model: 'gpt-x',
+ inputTokens: 20,
+ outputTokens: 4,
+ cacheReadTokens: 30,
+ cacheWriteTokens: 0,
+ },
+ ],
+ ]);
+ });
+
+ it("counts a resumed thread from its first report, not from the thread's history", async () => {
+ const { adapter, server, events } = await start();
+ const breakdown = (input: number, output: number) => ({
+ totalTokens: input + output,
+ inputTokens: input,
+ cachedInputTokens: 0,
+ outputTokens: output,
+ reasoningOutputTokens: 0,
+ });
+ server.replyAlways('turn/start', () => ({ turn: { id: 'native-1', status: 'inProgress' } }));
+
+ await adapter.sendTurn({ sessionId: 'session-1', turnId: 'caller-1', text: 'one' });
+ server.notify('turn/started', turnNotification('native-1', 'inProgress'));
+ server.notify('thread/tokenUsage/updated', {
+ threadId: THREAD,
+ turnId: 'native-1',
+ tokenUsage: {
+ total: breakdown(5000, 900),
+ last: breakdown(120, 30),
+ modelContextWindow: null,
+ },
+ });
+ server.notify('thread/tokenUsage/updated', {
+ threadId: THREAD,
+ turnId: 'native-1',
+ tokenUsage: {
+ total: breakdown(5200, 950),
+ last: breakdown(200, 50),
+ modelContextWindow: null,
+ },
+ });
+ server.notify('turn/completed', turnNotification('native-1', 'completed'));
+ await vi.waitFor(() => expect(eventsOf(events, 'turn.completed')).toHaveLength(1));
+
+ expect(eventsOf(events, 'turn.completed')[0]?.usage).toEqual([
+ { model: '', inputTokens: 320, outputTokens: 80, cacheReadTokens: 0, cacheWriteTokens: 0 },
+ ]);
+ });
+
it('binds a turn even when turn/started arrives before the turn/start response', async () => {
const { adapter, server, events } = await start();
server.on('message', (message: FakeJsonRpcMessage) => {
diff --git a/console/packages/agent-providers/src/codex/codex-adapter.ts b/console/packages/agent-providers/src/codex/codex-adapter.ts
index 0282a7f5c..25c425b11 100644
--- a/console/packages/agent-providers/src/codex/codex-adapter.ts
+++ b/console/packages/agent-providers/src/codex/codex-adapter.ts
@@ -19,6 +19,7 @@ import type {
ProviderRuntimeEvent,
RequestType,
SessionStatus,
+ TokenUsage,
TurnOutcome,
UserInputAnswers,
UserInputQuestion,
@@ -29,6 +30,7 @@ import {
noopLogger,
type ProviderLogger,
} from '../transport/stdio-json-rpc';
+import { CumulativeUsage, mergeUsage, type UsageCounts } from '../usage';
import { featureArgs, mcpServerConfigArgs } from './config-args';
import { mapCodexItem } from './item-mapping';
import {
@@ -37,6 +39,8 @@ import {
CODEX_SERVER_NOTIFICATIONS,
CODEX_SERVER_REQUESTS,
type CodexAskForApproval,
+ type CodexThreadTokenUsageUpdatedNotification,
+ type CodexTokenUsageBreakdown,
type CodexCommandExecutionApprovalParams,
type CodexDeltaNotification,
type CodexErrorNotification,
@@ -104,6 +108,15 @@ interface CodexSessionState {
deltaBuffers: Map<string, string>;
stopping: boolean;
exited: boolean;
+ /**
+ * Codex reports one running total for the thread and never names the
+ * model, so a turn's spend is the difference from the last report,
+ * attributed to the model selected at the time (empty for the default).
+ * A resumed thread's total includes everything spent before this process
+ * opened it, so counting starts from the first report less its last call.
+ */
+ usage: CumulativeUsage;
+ unreportedUsage: TokenUsage[];
}
interface ThreadModeConfig {
@@ -260,6 +273,8 @@ export class CodexAdapter implements ProviderAdapter {
deltaBuffers: new Map(),
stopping: false,
exited: false,
+ usage: new CumulativeUsage(),
+ unreportedUsage: [],
};
this.sessions.set(input.sessionId, state);
this.registerHandlers(state);
@@ -559,6 +574,23 @@ export class CodexAdapter implements ProviderAdapter {
});
});
+ client.onNotification(CODEX_SERVER_NOTIFICATIONS.threadTokenUsageUpdated, (params) => {
+ const payload = params as CodexThreadTokenUsageUpdatedNotification;
+ if (!this.isOwnThread(state, payload.threadId)) return;
+ const { total, last } = payload.tokenUsage;
+ if (!state.usage.started) {
+ state.usage.startFrom(
+ new Map([['', subtractCodexUsage(codexCounts(total), codexCounts(last))]])
+ );
+ }
+ const spent = state.usage.advance(new Map([['', codexCounts(total)]]));
+ const model = state.model ?? '';
+ state.unreportedUsage = mergeUsage(
+ state.unreportedUsage,
+ spent.map((entry) => ({ ...entry, model }))
+ );
+ });
+
client.onNotification(CODEX_SERVER_NOTIFICATIONS.turnStarted, (params) => {
const payload = params as CodexTurnNotification;
if (!this.isOwnThread(state, payload.threadId)) return;
@@ -614,6 +646,7 @@ export class CodexAdapter implements ProviderAdapter {
turnId,
outcome,
...(message ? { message } : {}),
+ usage: this.takeUsage(state),
raw: { source: CODEX_SERVER_NOTIFICATIONS.turnCompleted, payload },
});
});
@@ -866,6 +899,12 @@ export class CodexAdapter implements ProviderAdapter {
this.finishSession(state, reason);
}
+ private takeUsage(state: CodexSessionState): TokenUsage[] {
+ const usage = state.unreportedUsage;
+ state.unreportedUsage = [];
+ return usage;
+ }
+
private finishSession(state: CodexSessionState, reason: string): void {
state.compaction?.reject(new Error(reason));
if (state.exited) return;
@@ -878,6 +917,7 @@ export class CodexAdapter implements ProviderAdapter {
turnId,
outcome: state.stopping ? 'interrupted' : 'error',
message: reason,
+ usage: this.takeUsage(state),
});
}
this.emit(state, { type: 'session.state.changed', status: 'stopped' });
@@ -914,3 +954,21 @@ export class CodexAdapter implements ProviderAdapter {
export function createCodexAdapter(options: CodexAdapterOptions = {}): CodexAdapter {
return new CodexAdapter(options);
}
+
+function codexCounts(breakdown: CodexTokenUsageBreakdown): UsageCounts {
+ return {
+ inputTokens: breakdown.inputTokens - breakdown.cachedInputTokens,
+ outputTokens: breakdown.outputTokens,
+ cacheReadTokens: breakdown.cachedInputTokens,
+ cacheWriteTokens: breakdown.cacheWriteInputTokens ?? 0,
+ };
+}
+
+function subtractCodexUsage(total: UsageCounts, last: UsageCounts): UsageCounts {
+ return {
+ inputTokens: Math.max(0, total.inputTokens - last.inputTokens),
+ outputTokens: Math.max(0, total.outputTokens - last.outputTokens),
+ cacheReadTokens: Math.max(0, total.cacheReadTokens - last.cacheReadTokens),
+ cacheWriteTokens: Math.max(0, total.cacheWriteTokens - last.cacheWriteTokens),
+ };
+}
diff --git a/console/packages/agent-providers/src/codex/protocol.ts b/console/packages/agent-providers/src/codex/protocol.ts
index 32c56b69a..cf02d951f 100644
--- a/console/packages/agent-providers/src/codex/protocol.ts
+++ b/console/packages/agent-providers/src/codex/protocol.ts
@@ -25,6 +25,7 @@ export const CODEX_SERVER_NOTIFICATIONS = {
threadStatusChanged: 'thread/status/changed',
turnStarted: 'turn/started',
turnCompleted: 'turn/completed',
+ threadTokenUsageUpdated: 'thread/tokenUsage/updated',
itemStarted: 'item/started',
itemCompleted: 'item/completed',
agentMessageDelta: 'item/agentMessage/delta',
@@ -130,6 +131,31 @@ export interface CodexTurnNotification {
turn: CodexTurn;
}
+/**
+ * Token counts as Codex reports them. `cachedInputTokens` is a part of
+ * `inputTokens`, and `reasoningOutputTokens` a part of `outputTokens`.
+ * `cacheWriteInputTokens` is absent from Codex builds that predate it.
+ */
+export interface CodexTokenUsageBreakdown {
+ totalTokens: number;
+ inputTokens: number;
+ cachedInputTokens: number;
+ cacheWriteInputTokens?: number;
+ outputTokens: number;
+ reasoningOutputTokens: number;
+}
+
+/** `total` runs for the whole thread; `last` is the most recent model call. */
+export interface CodexThreadTokenUsageUpdatedNotification {
+ threadId: string;
+ turnId: string;
+ tokenUsage: {
+ total: CodexTokenUsageBreakdown;
+ last: CodexTokenUsageBreakdown;
+ modelContextWindow: number | null;
+ };
+}
+
export interface CodexItemNotification {
threadId: string;
turnId: string;
diff --git a/console/packages/agent-providers/src/cursor/cursor-adapter.ts b/console/packages/agent-providers/src/cursor/cursor-adapter.ts
index 5d6050421..c07df702f 100644
--- a/console/packages/agent-providers/src/cursor/cursor-adapter.ts
+++ b/console/packages/agent-providers/src/cursor/cursor-adapter.ts
@@ -639,7 +639,13 @@ export class CursorAdapter implements ProviderAdapter {
}
this.cancelApprovals(state);
state.turn = null;
- this.emit(state, { type: 'turn.completed', turnId, outcome, ...(message ? { message } : {}) });
+ this.emit(state, {
+ type: 'turn.completed',
+ turnId,
+ outcome,
+ ...(message ? { message } : {}),
+ usage: [],
+ });
if (!state.turn)
this.emit(state, {
type: 'session.state.changed',
@@ -689,6 +695,7 @@ export class CursorAdapter implements ProviderAdapter {
turnId: input.turnId,
outcome: 'error',
message: reason,
+ usage: [],
});
this.sessions.delete(id);
this.emit(state, { type: 'session.state.changed', status: 'stopped' });
diff --git a/console/packages/agent-providers/src/events.ts b/console/packages/agent-providers/src/events.ts
index 5b21d9612..a5c0f591c 100644
--- a/console/packages/agent-providers/src/events.ts
+++ b/console/packages/agent-providers/src/events.ts
@@ -83,13 +83,36 @@ interface EventBase {
raw?: { source: string; payload: unknown };
}
+/**
+ * Tokens one model consumed. `model` is the provider's own id, or empty when
+ * the provider runs its default without naming it. Cache reads and writes are
+ * counted apart from `inputTokens` because they are priced apart.
+ */
+export interface TokenUsage {
+ model: string;
+ inputTokens: number;
+ outputTokens: number;
+ cacheReadTokens: number;
+ cacheWriteTokens: number;
+}
+
export type ProviderRuntimeEvent = EventBase &
(
| { type: 'session.started'; nativeSessionId: string }
| { type: 'session.state.changed'; status: SessionStatus; message?: string }
| { type: 'session.exited'; reason: string }
| { type: 'turn.started'; turnId: string }
- | { type: 'turn.completed'; turnId: string; outcome: TurnOutcome; message?: string }
+ /**
+ * `usage` is what the turn spent, one entry per model. Empty when the
+ * provider reports nothing — not a claim that the turn was free.
+ */
+ | {
+ type: 'turn.completed';
+ turnId: string;
+ outcome: TurnOutcome;
+ message?: string;
+ usage: TokenUsage[];
+ }
| { type: 'item.started'; turnId: string; item: ProviderItem }
| { type: 'item.updated'; turnId: string; item: ProviderItem }
| { type: 'item.completed'; turnId: string; item: ProviderItem }
diff --git a/console/packages/agent-providers/src/index.ts b/console/packages/agent-providers/src/index.ts
index 43cf87e93..e187b9694 100644
--- a/console/packages/agent-providers/src/index.ts
+++ b/console/packages/agent-providers/src/index.ts
@@ -26,6 +26,7 @@ export type {
ProviderRuntimeEventType,
RequestType,
SessionStatus,
+ TokenUsage,
TurnOutcome,
UserInputAnswers,
UserInputQuestion,
diff --git a/console/packages/agent-providers/src/opencode/fake-transport.ts b/console/packages/agent-providers/src/opencode/fake-transport.ts
index 6e6f81f48..654b2d4de 100644
--- a/console/packages/agent-providers/src/opencode/fake-transport.ts
+++ b/console/packages/agent-providers/src/opencode/fake-transport.ts
@@ -43,12 +43,25 @@ export function sessionStatus(sessionID: string, status: 'busy' | 'idle'): Openc
return opencodeEvent('session.status', { sessionID, status: { type: status } });
}
+export interface FakeTokens {
+ input: number;
+ output: number;
+ reasoning: number;
+ cache: { read: number; write: number };
+}
+
+const NO_TOKENS: FakeTokens = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+
+/** Assistant messages always carry a model and a token count, as OpenCode's do. */
export function messageUpdated(
sessionID: string,
id: string,
- role: 'user' | 'assistant'
+ role: 'user' | 'assistant',
+ tokens: FakeTokens = NO_TOKENS,
+ model = { providerID: 'opencode', modelID: 'big-pickle' }
): OpencodeEvent {
- return opencodeEvent('message.updated', { sessionID, info: { id, role } });
+ const info = role === 'assistant' ? { id, role, ...model, tokens } : { id, role };
+ return opencodeEvent('message.updated', { sessionID, info });
}
export function textPart(
diff --git a/console/packages/agent-providers/src/opencode/opencode-adapter.test.ts b/console/packages/agent-providers/src/opencode/opencode-adapter.test.ts
index 80774a754..f2f57a18b 100644
--- a/console/packages/agent-providers/src/opencode/opencode-adapter.test.ts
+++ b/console/packages/agent-providers/src/opencode/opencode-adapter.test.ts
@@ -56,6 +56,98 @@ async function setup(
}
describe('OpencodeAdapter turn lifecycle', () => {
+ it("reports the turn's tokens per model, counting a streamed message once", async () => {
+ const { adapter, session, recorder } = await setup();
+ const tokens = (input: number, output: number, reasoning: number, read: number) => ({
+ input,
+ output,
+ reasoning,
+ cache: { read, write: 0 },
+ });
+
+ await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hello' });
+ session.push(sessionStatus(NATIVE, 'busy'));
+ session.push(messageUpdated(NATIVE, 'msg1', 'assistant', tokens(10, 2, 0, 100)));
+ session.push(messageUpdated(NATIVE, 'msg1', 'assistant', tokens(10, 8, 3, 100)));
+ session.push(
+ messageUpdated(NATIVE, 'msg2', 'assistant', tokens(4, 1, 0, 0), {
+ providerID: 'anthropic',
+ modelID: 'haiku',
+ })
+ );
+ session.push(sessionStatus(NATIVE, 'idle'));
+ const one = await recorder.waitFor('turn.completed', (event) => event.turnId === 't1', 1_000);
+
+ await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't2', text: 'again' });
+ session.push(sessionStatus(NATIVE, 'busy'));
+ session.push(messageUpdated(NATIVE, 'msg3', 'assistant', tokens(5, 5, 0, 110)));
+ session.push(sessionStatus(NATIVE, 'idle'));
+ const two = await recorder.waitFor('turn.completed', (event) => event.turnId === 't2', 1_000);
+
+ expect(one.usage).toEqual([
+ {
+ model: 'opencode/big-pickle',
+ inputTokens: 10,
+ outputTokens: 11,
+ cacheReadTokens: 100,
+ cacheWriteTokens: 0,
+ },
+ {
+ model: 'anthropic/haiku',
+ inputTokens: 4,
+ outputTokens: 1,
+ cacheReadTokens: 0,
+ cacheWriteTokens: 0,
+ },
+ ]);
+ expect(two.usage).toEqual([
+ {
+ model: 'opencode/big-pickle',
+ inputTokens: 5,
+ outputTokens: 5,
+ cacheReadTokens: 110,
+ cacheWriteTokens: 0,
+ },
+ ]);
+ });
+
+ it("counts what a subagent's child session spends, and nothing from unrelated sessions", async () => {
+ const { adapter, session, recorder } = await setup();
+ const tokens = (input: number, output: number) => ({
+ input,
+ output,
+ reasoning: 0,
+ cache: { read: 0, write: 0 },
+ });
+ const sessionCreated = (id: string, parentID?: string) =>
+ opencodeEvent('session.created', {
+ sessionID: id,
+ info: { id, ...(parentID ? { parentID } : {}) },
+ });
+
+ await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hello' });
+ session.push(sessionStatus(NATIVE, 'busy'));
+ session.push(messageUpdated(NATIVE, 'msg1', 'assistant', tokens(10, 2)));
+ session.push(sessionCreated('ses_child', NATIVE));
+ session.push(sessionCreated('ses_grandchild', 'ses_child'));
+ session.push(sessionCreated('ses_other'));
+ session.push(messageUpdated('ses_child', 'msg2', 'assistant', tokens(7, 3)));
+ session.push(messageUpdated('ses_grandchild', 'msg3', 'assistant', tokens(1, 1)));
+ session.push(messageUpdated('ses_other', 'msg4', 'assistant', tokens(1000, 1000)));
+ session.push(sessionStatus(NATIVE, 'idle'));
+ const one = await recorder.waitFor('turn.completed', (event) => event.turnId === 't1', 1_000);
+
+ expect(one.usage).toEqual([
+ {
+ model: 'opencode/big-pickle',
+ inputTokens: 18,
+ outputTokens: 6,
+ cacheReadTokens: 0,
+ cacheWriteTokens: 0,
+ },
+ ]);
+ });
+
it('completes a turn on the idle that follows the prompt busy', async () => {
const { adapter, session, recorder } = await setup();
await adapter.sendTurn({ sessionId: 'switch-session', turnId: 't1', text: 'hello' });
diff --git a/console/packages/agent-providers/src/opencode/opencode-adapter.ts b/console/packages/agent-providers/src/opencode/opencode-adapter.ts
index 8bebed097..fed9816f5 100644
--- a/console/packages/agent-providers/src/opencode/opencode-adapter.ts
+++ b/console/packages/agent-providers/src/opencode/opencode-adapter.ts
@@ -20,15 +20,18 @@ import type {
ProviderRuntimeEvent,
RequestType,
SessionStatus,
+ TokenUsage,
TurnOutcome,
UserInputAnswers,
UserInputQuestion,
} from '../events';
+import { CumulativeUsage } from '../usage';
import { buildConfigFile, parseModelId, permissionRulesFor } from './config';
import type { OpencodeSkill } from './server';
import {
createHttpTransport,
type OpencodeEvent,
+ type OpencodeMessage,
type OpencodePermissionReply,
type OpencodeSessionTransport,
type OpencodeTransport,
@@ -91,6 +94,18 @@ interface SessionRecord {
suppressAbortError: boolean;
interrupting: boolean;
messageRoles: Map<string, string>;
+ /**
+ * The latest token count of every assistant message, keyed by message id.
+ * OpenCode updates a message's count as it streams, so the per-model sums
+ * only grow and a turn's spend is their growth since the last turn ended.
+ */
+ messageUsage: Map<string, TokenUsage>;
+ /**
+ * Sessions OpenCode spawned under this one for subagents. Their events are
+ * otherwise ignored, but what they spend is this session's spend.
+ */
+ childSessions: Set<string>;
+ usage: CumulativeUsage;
partTypes: Map<string, string>;
emittedText: Map<string, string>;
items: Map<string, ProviderItem>;
@@ -173,6 +188,9 @@ export class OpencodeAdapter implements ProviderAdapter {
transport,
stopping: false,
exited: false,
+ messageUsage: new Map(),
+ childSessions: new Set(),
+ usage: new CumulativeUsage(),
awaitingBusy: false,
suppressAbortError: false,
interrupting: false,
@@ -443,7 +461,18 @@ export class OpencodeAdapter implements ProviderAdapter {
private async handleEvent(record: SessionRecord, event: OpencodeEvent): Promise<void> {
const properties = (event as { properties?: Record<string, unknown> }).properties ?? {};
const sessionId = properties['sessionID'];
- if (typeof sessionId === 'string' && sessionId !== record.nativeSessionId) return;
+ if (event.type === 'session.created' || event.type === 'session.updated') {
+ const parentId = event.properties.info.parentID;
+ if (parentId === record.nativeSessionId || (parentId && record.childSessions.has(parentId))) {
+ record.childSessions.add(event.properties.info.id);
+ }
+ }
+ if (typeof sessionId === 'string' && sessionId !== record.nativeSessionId) {
+ if (record.childSessions.has(sessionId) && event.type === 'message.updated') {
+ this.recordMessageUsage(record, event.properties.info);
+ }
+ return;
+ }
switch (event.type) {
case 'session.status':
@@ -452,9 +481,12 @@ export class OpencodeAdapter implements ProviderAdapter {
case 'session.idle':
this.handleStatus(record, 'idle', event);
return;
- case 'message.updated':
- record.messageRoles.set(event.properties.info.id, event.properties.info.role);
+ case 'message.updated': {
+ const info = event.properties.info;
+ record.messageRoles.set(info.id, info.role);
+ this.recordMessageUsage(record, info);
return;
+ }
case 'message.part.updated':
this.handlePart(record, event.properties.part, event);
return;
@@ -740,6 +772,35 @@ export class OpencodeAdapter implements ProviderAdapter {
record.awaitingBusy = false;
}
+ private recordMessageUsage(record: SessionRecord, info: OpencodeMessage): void {
+ if (info.role !== 'assistant') return;
+ record.messageUsage.set(info.id, {
+ model: `${info.providerID}/${info.modelID}`,
+ inputTokens: info.tokens.input,
+ outputTokens: info.tokens.output + info.tokens.reasoning,
+ cacheReadTokens: info.tokens.cache.read,
+ cacheWriteTokens: info.tokens.cache.write,
+ });
+ }
+
+ private takeUsage(record: SessionRecord): TokenUsage[] {
+ const totals = new Map<string, Omit<TokenUsage, 'model'>>();
+ for (const { model, ...counts } of record.messageUsage.values()) {
+ const sum = totals.get(model) ?? {
+ inputTokens: 0,
+ outputTokens: 0,
+ cacheReadTokens: 0,
+ cacheWriteTokens: 0,
+ };
+ sum.inputTokens += counts.inputTokens;
+ sum.outputTokens += counts.outputTokens;
+ sum.cacheReadTokens += counts.cacheReadTokens;
+ sum.cacheWriteTokens += counts.cacheWriteTokens;
+ totals.set(model, sum);
+ }
+ return record.usage.advance(totals);
+ }
+
private completeTurn(
record: SessionRecord,
turnId: string,
@@ -767,6 +828,7 @@ export class OpencodeAdapter implements ProviderAdapter {
type: 'turn.completed',
outcome,
...(message !== undefined ? { message } : {}),
+ usage: this.takeUsage(record),
},
turnId,
raw
diff --git a/console/packages/agent-providers/src/opencode/transport.ts b/console/packages/agent-providers/src/opencode/transport.ts
index 440b0c0c7..8c7d59ed8 100644
--- a/console/packages/agent-providers/src/opencode/transport.ts
+++ b/console/packages/agent-providers/src/opencode/transport.ts
@@ -1,10 +1,16 @@
-import { createOpencodeClient, type Event, type OpencodeClient } from '@opencode-ai/sdk/v2';
+import {
+ createOpencodeClient,
+ type Event,
+ type Message,
+ type OpencodeClient,
+} from '@opencode-ai/sdk/v2';
import type { ModelChoice } from '@switch-console/shared/session-v1';
import { ProviderSessionError, ProviderUnavailableError } from '../adapter';
import type { OpencodeConfigFile, OpencodePermissionRule } from './config';
import { type OpencodeSkill, startOpencodeServer, stopOpencodeServer } from './server';
export type OpencodeEvent = Event;
+export type OpencodeMessage = Message;
export type OpencodePermissionReply = 'once' | 'always' | 'reject';
diff --git a/console/packages/agent-providers/src/usage.test.ts b/console/packages/agent-providers/src/usage.test.ts
new file mode 100644
index 000000000..913656713
--- /dev/null
+++ b/console/packages/agent-providers/src/usage.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import { CumulativeUsage, mergeUsage } from './usage';
+
+const counts = (input: number, output = 0, cacheRead = 0, cacheWrite = 0) => ({
+ inputTokens: input,
+ outputTokens: output,
+ cacheReadTokens: cacheRead,
+ cacheWriteTokens: cacheWrite,
+});
+
+describe('CumulativeUsage', () => {
+ it('reports the growth of each model since the last report', () => {
+ const usage = new CumulativeUsage();
+ expect(usage.advance(new Map([['m', counts(10, 5, 2, 1)]]))).toEqual([
+ { model: 'm', ...counts(10, 5, 2, 1) },
+ ]);
+ expect(
+ usage.advance(
+ new Map([
+ ['m', counts(15, 5, 2, 1)],
+ ['n', counts(3)],
+ ])
+ )
+ ).toEqual([
+ { model: 'm', ...counts(5) },
+ { model: 'n', ...counts(3) },
+ ]);
+ });
+
+ it('takes a total that went down as a restart and counts it all', () => {
+ const usage = new CumulativeUsage();
+ usage.advance(new Map([['m', counts(100, 50)]]));
+ expect(usage.advance(new Map([['m', counts(7, 60)]]))).toEqual([
+ { model: 'm', ...counts(7, 60) },
+ ]);
+ });
+
+ it('ignores a zeroed report so the next real total is not counted twice', () => {
+ const usage = new CumulativeUsage();
+ usage.advance(new Map([['m', counts(100)]]));
+ expect(usage.advance(new Map([['m', counts(0)]]))).toEqual([]);
+ expect(usage.advance(new Map())).toEqual([]);
+ expect(usage.advance(new Map([['m', counts(120)]]))).toEqual([{ model: 'm', ...counts(20) }]);
+ });
+
+ it('reports nothing for a model that did not move', () => {
+ const usage = new CumulativeUsage();
+ usage.advance(new Map([['m', counts(10)]]));
+ expect(usage.advance(new Map([['m', counts(10)]]))).toEqual([]);
+ });
+});
+
+describe('mergeUsage', () => {
+ it('adds entries for the same model and keeps others apart', () => {
+ expect(
+ mergeUsage(
+ [{ model: 'm', ...counts(1, 1) }],
+ [
+ { model: 'm', ...counts(2, 0, 3) },
+ { model: 'n', ...counts(4) },
+ ]
+ )
+ ).toEqual([
+ { model: 'm', ...counts(3, 1, 3) },
+ { model: 'n', ...counts(4) },
+ ]);
+ });
+});
diff --git a/console/packages/agent-providers/src/usage.ts b/console/packages/agent-providers/src/usage.ts
new file mode 100644
index 000000000..10fd90ad5
--- /dev/null
+++ b/console/packages/agent-providers/src/usage.ts
@@ -0,0 +1,70 @@
+import type { TokenUsage } from './events';
+
+export type UsageCounts = Omit<TokenUsage, 'model'>;
+type Counts = UsageCounts;
+
+const FIELDS = ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens'] as const;
+
+function spent(counts: Counts): boolean {
+ return FIELDS.some((field) => counts[field] > 0);
+}
+
+/**
+ * Turns a provider's running per-model totals into what was spent since the
+ * last call.
+ *
+ * A total that went down means the provider started counting again (a resumed
+ * session, a cleared conversation), so the new total is all new spend. A
+ * report with nothing in it at all is ignored rather than taken as a reset:
+ * providers send zeroed totals on a crash, and treating that as a restart
+ * would count the next real total twice.
+ */
+export class CumulativeUsage {
+ private baseline = new Map<string, Counts>();
+ private hasStarted = false;
+
+ /** Whether any totals have been taken yet. */
+ get started(): boolean {
+ return this.hasStarted;
+ }
+
+ /**
+ * Treats `totals` as already counted, for a provider whose first report
+ * includes spend from before this process was watching.
+ */
+ startFrom(totals: ReadonlyMap<string, Counts>): void {
+ this.baseline = new Map(totals);
+ this.hasStarted = true;
+ }
+
+ advance(totals: ReadonlyMap<string, Counts>): TokenUsage[] {
+ if (![...totals.values()].some(spent)) return [];
+ const usage: TokenUsage[] = [];
+ for (const [model, total] of totals) {
+ const before = this.baseline.get(model);
+ const reset = before !== undefined && FIELDS.some((field) => total[field] < before[field]);
+ const delta: TokenUsage = { model, ...total };
+ if (before && !reset) {
+ for (const field of FIELDS) delta[field] = total[field] - before[field];
+ }
+ if (spent(delta)) usage.push(delta);
+ }
+ this.baseline = new Map(totals);
+ this.hasStarted = true;
+ return usage;
+ }
+}
+
+/** Adds `more` into `into`, one entry per model. */
+export function mergeUsage(into: TokenUsage[], more: readonly TokenUsage[]): TokenUsage[] {
+ const byModel = new Map(into.map((entry) => [entry.model, { ...entry }]));
+ for (const entry of more) {
+ const existing = byModel.get(entry.model);
+ if (!existing) {
+ byModel.set(entry.model, { ...entry });
+ continue;
+ }
+ for (const field of FIELDS) existing[field] += entry[field];
+ }
+ return [...byModel.values()];
+}