Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.
Python agent-orchestrationaiai-agentschatopsdiscordlangchainmcpmicrosoft-teamsmulti-agentopen-sourceopenaiself-hostedslack
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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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'): Opencreturn 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.tsindex 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.tsindex 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,rawdiff --git a/console/packages/agent-providers/src/opencode/transport.ts b/console/packages/agent-providers/src/opencode/transport.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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()];+}