feat: add token usage tracker with status bar display

- Add TokenUsageTracker class for session-scoped token counting
- Add status bar item showing real-time token usage
- Wire tracker into DeepSeekChatProvider and accumulate usage data
- Replace charsPerToken heuristic with improved estimateTokens() using
  character-class batching for more accurate token estimation
- Reset tracker when API key is cleared

Author: necto-cms

src/extension.ts

@@ -3,6 +3,7 @@ import { WALKTHROUGH_ID, WELCOME_SHOWN_KEY } from './consts';
 import { t } from './i18n';
 import { logger } from './logger';
 import { DeepSeekChatProvider } from './provider';
+import { TokenUsageTracker, createStatusBarItem } from './tokenUsage';
 
 let activeProvider: DeepSeekChatProvider | undefined;
 
@@ -20,7 +21,13 @@ export function activate(context: vscode.ExtensionContext) {
 	);
 
 	try {
-		const provider = new DeepSeekChatProvider(context);
+		// Create session-scoped token usage tracker.
+		const tokenUsageTracker = new TokenUsageTracker();
+
+		// Create and register the status bar item (pushed into subscriptions).
+		createStatusBarItem(context, tokenUsageTracker);
+
+		const provider = new DeepSeekChatProvider(context, tokenUsageTracker);
 		activeProvider = provider;
 
 		context.subscriptions.push(

src/provider/index.ts

@@ -5,6 +5,7 @@ import { getApiModelId, getBaseUrl, getMaxTokens } from '../config';
 import { MODELS } from '../consts';
 import { t } from '../i18n';
 import { logger } from '../logger';
+import type { TokenUsageTracker } from '../tokenUsage';
 import type { DeepSeekToolCall, ModelDefinition } from '../types';
 import { type ReasoningEntry, pruneReasoningCache } from './cache';
 import { convertMessages, convertTools, countMessageChars } from './convert';
@@ -75,8 +76,12 @@ export class DeepSeekChatProvider implements vscode.LanguageModelChatProvider {
 	 */
 	private charsPerToken = 4.0;
 
-	constructor(context: vscode.ExtensionContext) {
+	/** Session-scoped token usage tracker. */
+	private readonly tokenUsageTracker: TokenUsageTracker;
+
+	constructor(context: vscode.ExtensionContext, tokenUsageTracker: TokenUsageTracker) {
 		this.authManager = new AuthManager(context);
+		this.tokenUsageTracker = tokenUsageTracker;
 
 		context.subscriptions.push(
 			this.onDidChangeLanguageModelChatInformationEmitter,
@@ -111,6 +116,7 @@ export class DeepSeekChatProvider implements vscode.LanguageModelChatProvider {
 	}
 
 	async clearApiKey(): Promise<void> {
+		this.tokenUsageTracker.reset();
 		await this.authManager.deleteApiKey();
 		this.onDidChangeLanguageModelChatInformationEmitter.fire();
 		vscode.window.showInformationMessage(t('auth.removed'));
@@ -279,6 +285,9 @@ export class DeepSeekChatProvider implements vscode.LanguageModelChatProvider {
 					},
 
 					onUsage: (usage) => {
+						// Accumulate into the session-scoped tracker.
+						this.tokenUsageTracker.add(usage);
+
 						// Calibrate chars-per-token ratio from real API usage data.
 						if (totalRequestChars > 0 && usage.prompt_tokens > 0) {
 							const observedRatio = totalRequestChars / usage.prompt_tokens;
@@ -308,20 +317,21 @@ export class DeepSeekChatProvider implements vscode.LanguageModelChatProvider {
 		_token: vscode.CancellationToken,
 	): Promise<number> {
 		if (typeof text === 'string') {
-			return Math.max(1, Math.ceil(text.length / this.charsPerToken));
+			return Math.max(1, estimateTokens(text));
 		}
 
 		if (!text?.content || !Array.isArray(text.content)) {
 			return 1;
 		}
 
-		let total = 0;
+		// Flatten all text parts into a single string before estimating.
+		let combined = '';
 		for (const part of text.content) {
 			if (part instanceof vscode.LanguageModelTextPart) {
-				total += part.value.length;
+				combined += part.value;
 			}
 		}
-		return Math.max(1, Math.ceil(total / this.charsPerToken));
+		return Math.max(1, estimateTokens(combined));
 	}
 }
 
@@ -390,6 +400,65 @@ function toChatInfo(m: ModelDefinition, hasApiKey: boolean): ModelPickerChatInfo
 	};
 }
 
+/**
+ * Estimate tokens for a string using character-class heuristics.
+ *
+ * DeepSeek V4 uses a cl100k_base-compatible tokenizer.
+ * Heuristic breakdown by character class:
+ *   - Alphanumeric/underscore (code identifiers): ~3.5 chars per token
+ *   - Whitespace/newlines: ~0.3 tokens each
+ *   - Punctuation/operators: ~1 token each
+ *   - Non-ASCII (CJK, emoji, etc): ~1.5 chars per token
+ */
+function estimateTokens(str: string): number {
+	let tokens = 0;
+	let i = 0;
+	while (i < str.length) {
+		const code = str.charCodeAt(i);
+		if (
+			(code >= 65 && code <= 90) ||   // A-Z
+			(code >= 97 && code <= 122) ||  // a-z
+			(code >= 48 && code <= 57) ||   // 0-9
+			code === 95                      // _
+		) {
+			// Run of identifier chars — batch them
+			let run = 1;
+			while (i + run < str.length) {
+				const c2 = str.charCodeAt(i + run);
+				if (
+					(c2 >= 65 && c2 <= 90) ||
+					(c2 >= 97 && c2 <= 122) ||
+					(c2 >= 48 && c2 <= 57) ||
+					c2 === 95
+				) {
+					run++;
+				} else {
+					break;
+				}
+			}
+			tokens += Math.ceil(run / 3.5);
+			i += run;
+		} else if (code === 32 || code === 9) {
+			// Space or tab
+			tokens += 0.3;
+			i++;
+		} else if (code === 10 || code === 13) {
+			// Newline or carriage return
+			tokens += 0.4;
+			i++;
+		} else if (code < 128) {
+			// ASCII punctuation / operators
+			tokens += 1;
+			i++;
+		} else {
+			// Non-ASCII: consume 1-2 chars, count as ~0.7 tokens
+			tokens += 0.7;
+			i++;
+		}
+	}
+	return Math.ceil(tokens);
+}
+
 function getConfiguredThinkingEffort(options: ModelConfigurationOptions): ThinkingEffort {
 	const configuredEffort =
 		options.modelConfiguration?.reasoningEffort ?? options.configuration?.reasoningEffort;

src/tokenUsage.ts

@@ -0,0 +1,173 @@
+import vscode from 'vscode';
+import { MODELS } from './consts';
+import { logger } from './logger';
+
+/**
+ * Usage data returned by the DeepSeek API for a single response.
+ */
+export interface DeepSeekUsage {
+	readonly prompt_tokens: number;
+	readonly completion_tokens: number;
+	readonly total_tokens: number;
+	readonly prompt_cache_hit_tokens?: number;
+	readonly prompt_cache_miss_tokens?: number;
+}
+
+/**
+ * Accumulated token summary for the current session.
+ */
+export interface TokenSummary {
+	promptTokens: number;
+	completionTokens: number;
+	totalTokens: number;
+	cacheHitTokens: number;
+	cacheMissTokens: number;
+}
+
+/**
+ * Session-scoped token usage accumulator.
+ *
+ * Collects DeepSeek API `usage` data across all requests and provides
+ * running totals consumed by the status bar display.
+ */
+export class TokenUsageTracker {
+	private promptTokens = 0;
+	private completionTokens = 0;
+	private cacheHitTokens = 0;
+	private cacheMissTokens = 0;
+
+	/** Called after each `add()` to notify the status bar. */
+	private onUpdate: (() => void) | undefined;
+
+	/**
+	 * Register a callback that fires after every usage update.
+	 * Typically set by `createStatusBarItem` to repaint the bar.
+	 */
+	setOnUpdate(callback: () => void): void {
+		this.onUpdate = callback;
+	}
+
+	/**
+	 * Accumulate a single API response's usage into the session totals.
+	 */
+	add(usage: DeepSeekUsage): void {
+		this.promptTokens += usage.prompt_tokens;
+		this.completionTokens += usage.completion_tokens;
+		this.cacheHitTokens += usage.prompt_cache_hit_tokens ?? 0;
+		this.cacheMissTokens += usage.prompt_cache_miss_tokens ?? 0;
+
+		this.onUpdate?.();
+	}
+
+	/**
+	 * Reset all session counters to zero.
+	 */
+	reset(): void {
+		this.promptTokens = 0;
+		this.completionTokens = 0;
+		this.cacheHitTokens = 0;
+		this.cacheMissTokens = 0;
+
+		this.onUpdate?.();
+	}
+
+	/**
+	 * Return the current accumulated totals.
+	 */
+	getSummary(): TokenSummary {
+		return {
+			promptTokens: this.promptTokens,
+			completionTokens: this.completionTokens,
+			totalTokens: this.promptTokens + this.completionTokens,
+			cacheHitTokens: this.cacheHitTokens,
+			cacheMissTokens: this.cacheMissTokens,
+		};
+	}
+}
+
+// ---- Locale-aware number formatting ----
+
+const nf = new Intl.NumberFormat();
+
+function fmt(n: number): string {
+	return nf.format(n);
+}
+
+// ---- Status bar item factory ----
+
+/**
+ * Determine the warning threshold colour for the status bar based on
+ * total (prompt + completion) usage relative to the model context limit.
+ *
+ * We use the first model's `maxInputTokens` (all current models share the
+ * same 1,048,576 limit) as the reference ceiling.
+ */
+const CONTEXT_LIMIT = MODELS[0]?.maxInputTokens ?? 1_048_576;
+
+/**
+ * Create and register a VS Code status bar item that displays the current
+ * session's token usage.
+ *
+ * The returned item is already pushed into `context.subscriptions` and will
+ * be automatically disposed when the extension deactivates.
+ */
+export function createStatusBarItem(
+	context: vscode.ExtensionContext,
+	tracker: TokenUsageTracker,
+): vscode.StatusBarItem {
+	const item = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+	item.name = 'DeepSeek Token Usage';
+	item.command = 'deepseek-copilot.showLogs';
+
+	function update(): void {
+		const s = tracker.getSummary();
+
+		// Hide when no tokens have been consumed yet.
+		if (s.totalTokens === 0) {
+			item.hide();
+			return;
+		}
+
+		item.text = `🧠 ${fmt(s.totalTokens)} / ${fmt(CONTEXT_LIMIT)} tok`;
+
+		item.tooltip = new vscode.MarkdownString(
+			[
+				'**DeepSeek Token Usage (this session)**',
+				'',
+				`| | |`,
+				`|---|---:|`,
+				`| Prompt tokens | ${fmt(s.promptTokens)} |`,
+				`| Completion tokens | ${fmt(s.completionTokens)} |`,
+				`| **Total tokens** | **${fmt(s.totalTokens)}** |`,
+				`| | |`,
+				`| Context limit | ${fmt(CONTEXT_LIMIT)} |`,
+				`| Cache hit tokens | ${fmt(s.cacheHitTokens)} |`,
+			].join('\n'),
+		);
+		item.tooltip.isTrusted = true;
+
+		// Color thresholds
+		const ratio = s.totalTokens / CONTEXT_LIMIT;
+		if (ratio > 0.95) {
+			item.backgroundColor = new vscode.ThemeColor('statusBarItem.errorBackground');
+		} else if (ratio > 0.80) {
+			item.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
+		} else {
+			item.backgroundColor = undefined;
+		}
+
+		item.show();
+	}
+
+	// Wire the tracker update callback to our status bar repaint.
+	tracker.setOnUpdate(() => update());
+
+	// Initial paint (hidden state — no tokens yet).
+	update();
+
+	context.subscriptions.push(item);
+
+	logger.info('Token usage status bar created');
+
+	return item;
+}