@underactive/pi-topping 0.9.1 → 0.10.0

package/README.md

@@ -6,11 +6,11 @@ We garnish our pies. It seemed rude not to extend Pi the same courtesy. This is
 
 ![Example of pi-topping's decorated user prompt](https://raw.githubusercontent.com/underactive/pi-topping/main/media/demo_user_prompt.png)
 
-**“Working” Loader** — animated spinner (with color choice), randomized activity word, optional word packs, shimmer, token activity monitor with an adjustable full-scale rate, elapsed timer, output token display, live output-token rate, and the response model when it meaningfully differs from the selected model — all arrangeable left to right. During a blocking extension prompt, the loader switches to a stable dim waiting line with a pulsing indicator, then resumes afterward.
+**“Working” Loader** — animated spinner (with color choice), randomized activity word, optional word packs, shimmer, token activity monitor with an adjustable full-scale rate, elapsed timer, output token display, live output-token rate, and the response model when it meaningfully differs from the selected model — all arrangeable left to right. For raw Responses-API stream events, it can also include Ramp Router's gateway backend as `<model> via <backend>`, or just `via <backend>` when the served model restates the selection (requires Pi ≥0.99.0). Under a Pi virtual model such as pi-topping-autorouter's `litellm-auto/auto`, the response model is the routed physical model. During a blocking extension prompt, the loader switches to a stable dim waiting line with a pulsing indicator, then resumes afterward.
 
 ![Demo of pi-topping's shimmering activity word, scrolling activity meter, elapsed timer, token count, and token rate](https://raw.githubusercontent.com/underactive/pi-topping/main/media/demo.gif)
 
-**Completion Marker** — end-of-turn marker with icon, randomized verb (or `Worked`; matching past tense when Randomize "Worked" text is on), token consumption display, and optional marker-style, border-style, and border-color decorations spanning the full terminal width. It can append the response model when it differs from the selected model, with its own color option. The default `elite` style trails the summary with tapering dashes; `bookend` fills the remaining width to a closing corner glyph. Hooks into Pi's `agent_settled` event.
+**Completion Marker** — end-of-turn marker with icon, randomized verb (or `Worked`; matching past tense when Randomize "Worked" text is on), token consumption display, and optional marker-style, border-style, and border-color decorations spanning the full terminal width. It can append the response model when it differs from the selected model, with its own color option. It can also append per-call service-tier counts (e.g. `flex tier ×3`), but only for calls whose provider reports a tier; this requires Pi ≥0.99.0. The default `elite` style trails the summary with tapering dashes; `bookend` fills the remaining width to a closing corner glyph. Hooks into Pi's `agent_settled` event.
 
 ![Example of pi-topping's completion marker](https://raw.githubusercontent.com/underactive/pi-topping/main/media/demo_completion_marker.png)
 
@@ -86,6 +86,7 @@ Run `/topping-settings` (TUI only) to customize your toppings. Settings persist
 ║    [■] Randomize “Worked” text                        ON      ║
 ║    [■] Tokens spent                                   ON      ║
 ║    [■] Mid-turn inputs                                ON      ║
+║    [■] Service tier                                   ON      ║
 ║    [■] Response model                                 ON      ║
 ║    [■] Response model color                      ‹ muted ›    ║
 ║    [■] Response model dimmed                         OFF      ║
@@ -109,7 +110,7 @@ Run `/topping-settings` (TUI only) to customize your toppings. Settings persist
 ╟───────────────────────────────────────────────────────────────╢
 ║  ↑↓ move  PgUp/PgDn page  ←→ select                           ║
 ║  ␣ toggle  ⏎ apply  esc cancel                                ║
-╚═══════════════════════════════════════════════════════[ 9/57 ]╝
+╚═══════════════════════════════════════════════════════[ 9/58 ]╝
 ```
 
 ### Word packs
@@ -147,7 +148,7 @@ restarts the cycle.
 
 The token activity monitor reaches full `⣿` at or above its configurable upper bound (80 tps by default), with lower levels scaled proportionally to that bound. In `/topping-settings`, `←`/`→` cycle through presets spanning 10–1000 tps, and `␣` (Space) lets you enter any whole number from 10–1000. Invalid typed entries show an inline error and keep the editor open without changing the current value; invalid hand-edited `meterUpperBoundTps` values in `settings.json` revert to 80 on load.
 
-The response model is captured from assistant responses, displayed as its sanitized value with no label only when it meaningfully differs from the selected model, and defaults to the final loader detail after output tokens. While pi-topping-statusline embeds the loader in its status bar, the model slides out tail first from behind its separator over 0.3 seconds when it first appears in a run, like that bar's embedded status; elsewhere it appears at once, and a different model replacing it always swaps in place. Equivalent local paths and decorated filenames are suppressed. Its loader display can be hidden, recolored, permanently dimmed, or reordered. The independent **Response model footer** option is disabled by default; when enabled, the final model appears under the editor after settlement, remains visible for 3 seconds, fades through five theme-aware shades over 0.5 seconds, then clears. New work cancels the pending fade. When the active provider is `switchyard`, the loader and footer hold/fade use NVIDIA green (`#84c51a`, matching pi-topping-statusline) regardless of the configured Response model color; the dim setting still applies.
+The response model is captured from assistant responses and raw Responses-API stream events (Pi ≥0.99.0), displayed as its sanitized value with no label only when it meaningfully differs from the selected model, and defaults to the final loader detail after output tokens. When Ramp Router reports a gateway backend in the raw event, the label can include it as `<model> via <backend>`, or `via <backend>` alone when the served model restates the selection. Under a Pi virtual model such as pi-topping-autorouter's `litellm-auto/auto`, it is the routed physical model: taken from the router's `pi-topping-autorouter:routed-model` announcement when present, which arrives before the first token (announcements for `direct` routes such as compaction are ignored), and otherwise from the assistant message's model. There only a failed route, which reports the virtual model itself, is hidden, and a bare routed id never displaces a provider-reported decorated form of itself such as a dated name. While pi-topping-statusline embeds the loader in its status bar, the model slides out tail first from behind its separator over 0.3 seconds when it first appears in a run, like that bar's embedded status; elsewhere it appears at once, and a different model replacing it always swaps in place. Equivalent local paths and decorated filenames are suppressed. Its loader display can be hidden, recolored, permanently dimmed, or reordered. The independent **Response model footer** option is disabled by default; when enabled, the final model appears under the editor after settlement, remains visible for 3 seconds, fades through five theme-aware shades over 0.5 seconds, then clears. New work cancels the pending fade. When the active provider is `switchyard`, the loader and footer hold/fade use NVIDIA green (`#84c51a`, matching pi-topping-statusline) regardless of the configured Response model color; the dim setting still applies.
 
 ## Requirements
 
@@ -163,13 +164,14 @@ npm test
 npm run typecheck
 ```
 
-Tests cover the word/shimmer rendering, prompt box and completion marker rendering, activity meter behavior and its configurable upper bound, timer resets, settings persistence and schema migrations, word-pack parsing, loading, and default-text selection, response-model loader and footer behavior, the `menu.ts` component and its typed number entry, the settings menu wiring end to end, and the `/topping-setup` command's install and uninstall flows.
+Tests cover the word/shimmer rendering, prompt box and completion marker rendering, activity meter behavior and its configurable upper bound, timer resets, settings persistence and schema migrations, word-pack parsing, loading, and default-text selection, response-model loader and footer behavior, served-model and service-tier extraction, the `menu.ts` component and its typed number entry, the settings menu wiring end to end, and the `/topping-setup` command's install and uninstall flows.
 
 ## Limitations
 
 - Token counts are a streaming word-count estimate, not an exact tokenizer count — they self-correct when each message finishes, so you'll see a small jump at that point.
 - Elapsed time normally starts when you submit a prompt; for auto-continuations without that event, it starts slightly later instead.
 - If another extension also customizes the working message, whichever one runs last wins.
+- Service-tier details and Responses-API served-model/backend labels depend on Pi's `provider_stream_event`; raw events require Pi ≥0.99.0 and are unavailable on older Pi hosts and SDK adapters that do not expose them.
 
 ## Author
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@underactive/pi-topping",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "A Pi extension that adds quality of life improvements to Pi's UX: a high-vis user prompt, a shimmering working loader with token activity meter and elapsed timer, and an end-of-turn completion marker",
   "keywords": ["pi-package", "pi-extension"],
   "license": "MIT",
@@ -30,8 +30,8 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "1.0.0",
-    "@earendil-works/pi-tui": "1.0.0",
+    "@earendil-works/pi-coding-agent": "1.0.3",
+    "@earendil-works/pi-tui": "1.0.3",
     "@types/node": "^24.0.0",
     "typescript": "^5.9.3"
   },

package/src/autorouter-feed.ts

@@ -0,0 +1,49 @@
+import { isPlainObject, sanitizedText } from "./util.ts";
+
+/**
+ * Event-bus channel on which pi-topping-autorouter announces the physical model it routed
+ * a request to, before Pi sends that request (so before `message_start`). Payload:
+ *
+ * ```json
+ * {
+ *   "version": 1,
+ *   "provider": "openai-codex",
+ *   "modelId": "gpt-5.6-sol",
+ *   "model": "openai-codex/gpt-5.6-sol",
+ *   "name": "GPT-5.6 Sol",
+ *   "thinkingLevel": "high",
+ *   "reason": "user",
+ *   "cause": "jev_classifier",
+ *   "tier": "COMPLEX",
+ *   "ts": 1790000000000
+ * }
+ * ```
+ *
+ * `reason` is Pi's route reason: `user`, `continuation`, `retry`, or `direct`. `direct` routes
+ * serve compaction summaries and other extensions' side requests, not the chat response.
+ * `tier` may be absent. Shared with pi-topping-autorouter.
+ */
+export const ROUTED_MODEL_CHANNEL = "pi-topping-autorouter:routed-model";
+
+const ROUTE_REASONS = ["user", "continuation", "retry", "direct"] as const;
+export type RouteReason = (typeof ROUTE_REASONS)[number];
+
+export interface RoutedModelAnnouncement {
+	provider: string;
+	modelId: string;
+	reason: RouteReason;
+}
+
+function isRouteReason(value: string): value is RouteReason {
+	return ROUTE_REASONS.some((reason) => reason === value);
+}
+
+/** The sanitized provider, model id, and route reason of a ROUTED_MODEL_CHANNEL announcement, or undefined if malformed. */
+export function routedModelAnnouncement(data: unknown): RoutedModelAnnouncement | undefined {
+	if (!isPlainObject(data) || data.version !== 1) return undefined;
+	const provider = sanitizedText(data.provider);
+	const modelId = sanitizedText(data.modelId);
+	const reason = sanitizedText(data.reason);
+	if (!provider || !modelId || !isRouteReason(reason)) return undefined;
+	return { provider, modelId, reason };
+}

package/src/loader-message.ts

@@ -3,7 +3,7 @@ import { buildWorkingMessage, DEFAULT_WORKING_WORD, dimAttribute, fadeThemeColor
 import { getResponseModelColorizer } from "./nvidia-green.ts";
 import type { DecoratorSettings } from "./settings.ts";
 
-type Features = Pick<DecoratorSettings["features"], "substituteDefaultMessage" | "elapsedTime" | "outputTokens" | "tokenRate" | "responseModel">;
+type Features = Pick<DecoratorSettings["features"], "substituteDefaultMessage" | "elapsedTime" | "outputTokens" | "tokenRate">;
 type Decorations = Pick<DecoratorSettings["decorations"], "shimmer" | "shimmerInverted" | "shimmerDirection" | "shimmerSpeed" | "tokenActivityMonitor" | "meterColor" | "meterDimmed" | "tokenRateColor" | "tokenRateDimmed" | "responseModelColor" | "responseModelDimmed" | "spinnerColor">;
 interface LoaderParts {
 	spinnerAtMs?: number;

package/src/preview.ts

@@ -5,6 +5,7 @@ import { DEFAULT_WORKING_WORD, dimAttribute, ELAPSED_INTERVAL_MS, formatTokenRat
 import { buildLoaderMessage } from "./loader-message.ts";
 import { getResponseModelColorizer } from "./nvidia-green.ts";
 import { buildCompletionMarkerContent, buildCompletionMarkerLine, buildPromptBoxLines } from "./prompt-decorator.ts";
+import { formatServiceTierSummary } from "./service-tier.ts";
 import { DEFAULT_SETTINGS, fromCycleDirection, fromCycleMeterUpperBound, fromCycleSpeed, isBorderStyle, isDoneMarkerBorderColor, isDoneMarkerBorderStyle, isDoneMarkerStyle, isPromptBorderColor, isSpinnerColor, isThinkingLevelColor, LOADER_ORDER_ID, MENU_ENTRIES, parseLoaderOrder } from "./settings.ts";
 import { isWordPackEnabled, selectWorkingTextSelection, WORD_PACK_MENU_PREFIX, wordPacksPath, type WordPack } from "./word-packs.ts";
 // Simulated load for the menu preview: a 2.4s cosine wave peaking at 46 tps for the meter,
@@ -143,6 +144,7 @@ export class PreviewRenderer {
 		const details: string[] = [];
 		if (values.doneMarkerTokens === true) details.push("↓ 949 tokens");
 		if (values.doneMarkerInputs === true) details.push("2 mid-turn inputs");
+		if (values.doneMarkerServiceTier === true) details.push(formatServiceTierSummary([{ tier: "flex", calls: 3 }]));
 		let model = "";
 		if (values.doneMarkerModel === true) {
 			const color = isThinkingLevelColor(values.doneMarkerModelColor) ? values.doneMarkerModelColor : DEFAULT_SETTINGS.decorations.doneMarkerModelColor;

package/src/prompt-decorator.ts

@@ -96,7 +96,6 @@ export function buildPromptBoxLines(
 	const thinkingLevel = isThinkingLevel(options.thinkingLevel) ? options.thinkingLevel : undefined;
 	const border = getThinkingLevelColorizer(theme, borderColor, thinkingLevel);
 	const iconColor = (text: string) => theme.fg("text", text);
-	const label = (text: string) => theme.fg("customMessageLabel", text);
 	const muted = (text: string) => theme.fg("dim", text);
 	const bodyText = (text: string) => theme.fg("customMessageText", text);
 	const time = options.showTimestamp === false || !submittedAt

package/src/served-model.ts

@@ -0,0 +1,19 @@
+import { isPlainObject, sanitizedText } from "./util.ts";
+
+export interface ServedModelReport {
+	model: string;
+	backend?: string;
+}
+
+/** Extract the served model and optional gateway backend from a raw Responses stream event. */
+export function servedModelOf(data: unknown): ServedModelReport | undefined {
+	try {
+		if (!isPlainObject(data) || !isPlainObject(data.response)) return undefined;
+		const model = sanitizedText(data.response.model) || undefined;
+		if (!model) return undefined;
+		const backend = sanitizedText(data.provider);
+		return { model, ...(backend ? { backend } : {}) };
+	} catch {
+		return undefined;
+	}
+}

package/src/service-tier.ts

@@ -0,0 +1,86 @@
+import { isPlainObject, sanitizedText } from "./util.ts";
+
+/** Provider calls that reported one service tier during a run. */
+export interface ServiceTierCount {
+	tier: string;
+	calls: number;
+}
+
+/** Sanitize a provider-supplied tier into a short, safe display label. */
+export function sanitizeServiceTier(raw: unknown): string | undefined {
+	let tier = sanitizedText(raw);
+	if (tier.length > 32) {
+		let end = 0;
+		let characters = 0;
+		for (const character of tier) {
+			if (characters === 32) break;
+			end += character.length;
+			characters++;
+		}
+		tier = tier.slice(0, end);
+	}
+	return tier || undefined;
+}
+
+/**
+ * Return the first sanitized tier reported in a raw provider stream event, without throwing.
+ * OpenAI chat-completions uses `service_tier`; Responses uses `response.service_tier`;
+ * Anthropic reports `message.usage.service_tier` at `message_start` and
+ * `usage.service_tier` at `message_delta`. `serviceTier` covers camel-case adapters.
+ */
+export function serviceTierOf(data: unknown): string | undefined {
+	try {
+		if (!isPlainObject(data)) return undefined;
+		const direct = sanitizeServiceTier(data.service_tier) ?? sanitizeServiceTier(data.serviceTier);
+		if (direct) return direct;
+		if (isPlainObject(data.response)) {
+			const responseTier = sanitizeServiceTier(data.response.service_tier);
+			if (responseTier) return responseTier;
+		}
+		if (isPlainObject(data.usage)) {
+			const usageTier = sanitizeServiceTier(data.usage.service_tier);
+			if (usageTier) return usageTier;
+		}
+		if (isPlainObject(data.message) && isPlainObject(data.message.usage)) {
+			return sanitizeServiceTier(data.message.usage.service_tier);
+		}
+		return undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Increment a tier's provider-call count, appending new tiers in first-seen order. */
+export function recordServiceTierCall(counts: ServiceTierCount[], tier: string): void {
+	const existing = counts.find((entry) => entry.tier === tier);
+	if (existing) existing.calls++;
+	else counts.push({ tier, calls: 1 });
+}
+
+/** Validate persisted tier counts, dropping malformed entries and merging sanitized duplicates. */
+export function serviceTierCountsOf(raw: unknown): ServiceTierCount[] {
+	if (!Array.isArray(raw)) return [];
+	const counts: ServiceTierCount[] = [];
+	for (const item of raw) {
+		if (!isPlainObject(item)) continue;
+		const tier = sanitizeServiceTier(item.tier);
+		const calls = item.calls;
+		if (!tier || typeof calls !== "number" || !Number.isSafeInteger(calls) || calls <= 0) continue;
+		const existing = counts.find((entry) => entry.tier === tier);
+		if (existing) {
+			const sum = existing.calls + calls;
+			if (Number.isSafeInteger(sum)) existing.calls = sum;
+		} else {
+			counts.push({ tier, calls });
+		}
+	}
+	return counts;
+}
+
+/** Format the ordered summary of provider calls that reported a tier. */
+export function formatServiceTierSummary(counts: readonly ServiceTierCount[]): string {
+	if (counts.length === 0) return "";
+	const totalCalls = counts.reduce((total, entry) => total + entry.calls, 0);
+	if (totalCalls === 1) return `${counts[0]!.tier} tier`;
+	return counts.map(({ tier, calls }) => `${tier} tier ×${calls}`).join(", ");
+}

package/src/session.ts

@@ -14,6 +14,7 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import { Text, type Component } from "@earendil-works/pi-tui";
 import { ActivityMeter, rateToLevel, TokRateTracker } from "./activity-meter.ts";
+import { ROUTED_MODEL_CHANNEL, routedModelAnnouncement } from "./autorouter-feed.ts";
 import {
 	dimAttribute,
 	getThinkingLevelColorizer,
@@ -46,7 +47,9 @@ import { announcesEmbedded, STATUSLINE_EMBED_CHANNEL } from "./statusline-embed.
 import { announceMissingToppingsOnce, type MissingToppingsEntryData, renderMissingToppingsEntry, SETUP_ENTRY_TYPE } from "./toppings.ts";
 import { PreviewRenderer } from "./preview.ts";
 import { buildCompletionMarkerContent, buildCompletionMarkerLine, PROMPT_BOX_TYPE, promptBoxRenderer, type PromptBoxDetails } from "./prompt-decorator.ts";
-import { isPlainObject, modelsResemble, stripControlChars } from "./util.ts";
+import { isPlainObject, modelsResemble, sanitizedText, stripControlChars } from "./util.ts";
+import { formatServiceTierSummary, recordServiceTierCall, serviceTierCountsOf, serviceTierOf, type ServiceTierCount } from "./service-tier.ts";
+import { servedModelOf } from "./served-model.ts";
 import { loadBundledWordPacks, loadUserWordPacks, pickWorkingTextSelection, type WorkingTextSelection, type WordPack } from "./word-packs.ts";
 
 type MessageStartEvent = Extract<ExtensionEvent, { type: "message_start" }>;
@@ -55,10 +58,13 @@ type MessageEndEvent = Extract<ExtensionEvent, { type: "message_end" }>;
 type ToolExecutionStartEvent = Extract<ExtensionEvent, { type: "tool_execution_start" }>;
 type UIPromptStartEvent = Extract<ExtensionEvent, { type: "ui_prompt_start" }>;
 type UIPromptEndEvent = Extract<ExtensionEvent, { type: "ui_prompt_end" }>;
+type ProviderStreamEvent = Extract<ExtensionEvent, { type: "provider_stream_event" }>;
 type UIPromptKind = UIPromptStartEvent["kind"];
 
 const DONE_ENTRY_TYPE = "pi-topping-done";
 const RESPONSE_MODEL_STATUS_KEY = "pi-topping-response-model";
+/** Pi's `VIRTUAL_MODEL_API` for extension-registered virtual models; Pi does not export it from its public index. */
+const VIRTUAL_MODEL_API = "pi-virtual";
 const WAITING_LABELS: Record<UIPromptKind, string> = {
 	select: "Waiting for selection",
 	confirm: "Waiting for confirmation",
@@ -77,10 +83,26 @@ interface DoneEntryData {
 	elapsedMs: number;
 	tokens?: number;
 	midTurnInputs?: number;
+	serviceTiers?: ServiceTierCount[];
 	thinkingLevel?: ThinkingLevel;
 	model?: string;
 }
 
+/** A response model as one source reports it, for `updateResponseModel`. */
+interface ResponseModelReport {
+	raw: unknown;
+	/**
+	 * True for a bare routed model id (a router announcement or, under a virtual selection, the
+	 * message's `model`) rather than a provider-reported value. A weak value never displaces a
+	 * decorated form of itself the provider already reported, such as a dated name.
+	 */
+	weak: boolean;
+	/** The message's own provider when `raw` is its `model`, to recognize a failed route. */
+	provider?: string;
+	backend?: string;
+	routedId?: string;
+}
+
 interface SessionState {
 	startTime: number;
 	workingText: WorkingTextSelection;
@@ -92,6 +114,12 @@ interface SessionState {
 	lastTokenRateSampledAt: number;
 	lastTokenRateTotal: number;
 	responseModel: string;
+	served: { model: string; backend: string; routedId: string } | null;
+	/** The backend companion to the last raw response-model report. */
+	lastResponseModelBackend: string | undefined | typeof NOT_SENT;
+	/** The tier reported by the in-flight provider call, added to counts at its assistant message_end. */
+	pendingServiceTier: string;
+	serviceTiers: ServiceTierCount[];
 	/** Last raw responseModel value seen, or the NOT_SENT sentinel before the first call. */
 	lastResponseModelRaw: unknown;
 	responseModelHoldTimer: ReturnType<typeof setTimeout> | null;
@@ -134,6 +162,10 @@ function makeFreshState(): SessionState {
 		lastTokenRateSampledAt: 0,
 		lastTokenRateTotal: 0,
 		responseModel: "",
+		served: null,
+		lastResponseModelBackend: NOT_SENT,
+		pendingServiceTier: "",
+		serviceTiers: [],
 		lastResponseModelRaw: NOT_SENT,
 		responseModelHoldTimer: null,
 		responseModelFadeTimer: null,
@@ -155,10 +187,6 @@ function waitingLabel(waiting: NonNullable<SessionState["waiting"]>): string {
 	return title ? `Waiting: ${title}` : WAITING_LABELS[waiting.kind];
 }
 
-function responseModelOf(message: unknown): unknown {
-	return isPlainObject(message) ? message.responseModel : undefined;
-}
-
 /** Owns mutable extension state and Pi lifecycle registrations. */
 export class SessionManager {
 	#counter = new StreamingWordCounter();
@@ -246,7 +274,7 @@ export class SessionManager {
 		if (this.usable(ctx) && event.message.role === "assistant") {
 			this.#state.liveTokens = 0;
 			this.#counter.reset();
-			this.updateResponseModel(responseModelOf(event.message));
+			this.updateResponseModel(this.responseModelOf(event.message));
 		}
 	};
 
@@ -260,14 +288,15 @@ export class SessionManager {
 		) {
 			this.#state.liveTokens += this.#counter.count(assistantEvent.delta, assistantEvent.type);
 		}
-		const rawResponseModel = (assistantEvent as { partial?: { responseModel?: unknown } } | undefined)?.partial?.responseModel
-			?? responseModelOf(event.message);
+		const rawResponseModel = this.responseModelOf((assistantEvent as { partial?: unknown } | undefined)?.partial)
+			?? this.responseModelOf(event.message);
 		this.updateResponseModel(rawResponseModel);
 	};
 
 	#onMessageEnd = async (event: MessageEndEvent, ctx: ExtensionContext): Promise<void> => {
 		this.#currentCtx = ctx;
 		if (!this.usable(ctx) || event.message.role !== "assistant") return;
+		this.commitServiceTierCall();
 
 		const rawTokens = event.message.usage?.output;
 		const exactTokens =
@@ -282,9 +311,25 @@ export class SessionManager {
 		}
 		this.#state.liveTokens = 0;
 		this.#counter.reset();
-		this.updateResponseModel(responseModelOf(event.message));
+		this.updateResponseModel(this.responseModelOf(event.message));
 	};
 
+	#onProviderStreamEvent = (event: ProviderStreamEvent, ctx: ExtensionContext): void => {
+		if (!this.usable(ctx) || !this.#state.busy) return;
+		const tier = serviceTierOf(event.data);
+		if (tier) this.#state.pendingServiceTier = tier;
+		const served = servedModelOf(event.data);
+		if (served) {
+			this.updateResponseModel({ raw: served.model, weak: false, provider: event.provider, backend: served.backend });
+		}
+	};
+
+	private commitServiceTierCall(): void {
+		if (!this.#state.pendingServiceTier) return;
+		recordServiceTierCall(this.#state.serviceTiers, this.#state.pendingServiceTier);
+		this.#state.pendingServiceTier = "";
+	}
+
 	#onToolExecutionStart = async (_e: ToolExecutionStartEvent, ctx: ExtensionContext): Promise<void> => {
 		this.#currentCtx = ctx;
 		if (this.usable(ctx)) {
@@ -314,6 +359,7 @@ export class SessionManager {
 	#onAgentSettled = async (_e: AgentSettledEvent, ctx: ExtensionContext): Promise<void> => {
 		this.#currentCtx = ctx;
 		if (!this.usable(ctx)) return;
+		this.commitServiceTierCall();
 
 		const hadPrompt = !!this.#state.startTime;
 		const elapsedMs = hadPrompt ? Date.now() - this.#state.startTime : 0;
@@ -338,6 +384,7 @@ export class SessionManager {
 				elapsedMs,
 				tokens: this.#state.confirmTokens,
 				midTurnInputs: this.#state.midTurnInputs,
+				...(this.#state.serviceTiers.length ? { serviceTiers: this.#state.serviceTiers.map((count) => ({ ...count })) } : {}),
 				thinkingLevel: ctx.thinkingLevel,
 				model: this.#state.responseModel || undefined,
 			});
@@ -362,9 +409,13 @@ export class SessionManager {
 		if (features.doneMarkerInputs && typeof entry.data.midTurnInputs === "number" && Number.isInteger(entry.data.midTurnInputs) && entry.data.midTurnInputs > 0) {
 			details.push(`${entry.data.midTurnInputs} mid-turn input${entry.data.midTurnInputs === 1 ? "" : "s"}`);
 		}
+		if (features.doneMarkerServiceTier) {
+			const summary = formatServiceTierSummary(serviceTierCountsOf(entry.data.serviceTiers));
+			if (summary) details.push(summary);
+		}
 		const icon = features.doneMarkerIcon ? theme.fg("text", this.#settings.decorations.useNerdFont ? "" : "π") : "";
 		const thinkingLevel = isThinkingLevel(entry.data.thinkingLevel) ? entry.data.thinkingLevel : undefined;
-		const rawModel = typeof entry.data.model === "string" ? stripControlChars(entry.data.model).trim() : "";
+		const rawModel = sanitizedText(entry.data.model);
 		const modelColored = features.doneMarkerModel && rawModel
 			? getThinkingLevelColorizer(theme, this.#settings.decorations.doneMarkerModelColor, thinkingLevel)(rawModel)
 			: "";
@@ -399,6 +450,7 @@ export class SessionManager {
 		this.#pi.on("message_start", this.#onMessageStart);
 		this.#pi.on("message_update", this.#onMessageUpdate);
 		this.#pi.on("message_end", this.#onMessageEnd);
+		this.#pi.on("provider_stream_event", this.#onProviderStreamEvent);
 		this.#pi.on("tool_execution_start", this.#onToolExecutionStart);
 		this.#pi.on("agent_settled", this.#onAgentSettled);
 		this.#pi.on("ui_prompt_start", this.#onUIPromptStart);
@@ -407,6 +459,13 @@ export class SessionManager {
 		this.#pi.events.on(STATUSLINE_EMBED_CHANNEL, (data) => {
 			this.#loaderInStatusline = announcesEmbedded(data);
 		});
+		this.#pi.events.on(ROUTED_MODEL_CHANNEL, (data) => {
+			// Direct routes serve compaction and other extensions' side requests; a route while idle
+			// is such a background request too, and must not leave a stale model for the next turn.
+			const announcement = routedModelAnnouncement(data);
+			if (!announcement || announcement.reason === "direct" || !this.#state.busy) return;
+			this.updateResponseModel({ raw: announcement.modelId, weak: true, provider: announcement.provider, routedId: announcement.modelId });
+		});
 		this.#pi.registerEntryRenderer<DoneEntryData>(DONE_ENTRY_TYPE, (entry, _o, theme) => this.#renderDoneEntry(entry, theme));
 		this.#pi.registerEntryRenderer<MissingToppingsEntryData>(SETUP_ENTRY_TYPE, (entry, _o, theme) => renderMissingToppingsEntry(entry, theme));
 		this.#pi.registerMessageRenderer<PromptBoxDetails>(PROMPT_BOX_TYPE, promptBoxRenderer);
@@ -475,25 +534,63 @@ export class SessionManager {
 		}
 	}
 
-	private updateResponseModel(raw: unknown): void {
-		if (raw === this.#state.lastResponseModelRaw) return;
-		this.#state.lastResponseModelRaw = raw;
-		const responseModel = typeof raw === "string" ? stripControlChars(raw).trim() : "";
-		const selectedModel = this.#currentCtx?.model?.id;
-		if (responseModel && modelsResemble(selectedModel, responseModel)) {
+	/**
+	 * The response model a message reports. Under a virtual selection Pi stamps the routed
+	 * physical model on the message's `model` instead, so fall back to that as a weak value;
+	 * a failed route leaves the virtual model itself there, which `restatesSelection` hides.
+	 */
+	private responseModelOf(message: unknown): ResponseModelReport | undefined {
+		if (!isPlainObject(message)) return undefined;
+		if (message.responseModel !== undefined) {
+			return { raw: message.responseModel, weak: false, routedId: sanitizedText(message.model) || undefined };
+		}
+		if (this.#currentCtx?.model?.api !== VIRTUAL_MODEL_API) return undefined;
+		return { raw: message.model, weak: true, provider: typeof message.provider === "string" ? message.provider : undefined };
+	}
+
+	/**
+	 * Whether a response model merely restates the selected model. Under a virtual selection
+	 * the routed model is always another model, so only a failed route, which leaves the
+	 * virtual model itself on the message, is hidden; a resemblance check would also hide a
+	 * routed model whose id contains the virtual id, such as openrouter's `auto`.
+	 */
+	private restatesSelection(report: ResponseModelReport, responseModel: string): boolean {
+		const selected = this.#currentCtx?.model;
+		if (!selected) return false;
+		if (selected.api === VIRTUAL_MODEL_API) return report.provider === selected.provider && responseModel === selected.id;
+		return modelsResemble(selected.id, responseModel);
+	}
+
+	private updateResponseModel(report: ResponseModelReport | undefined): void {
+		const backendReport = report?.backend;
+		if (report?.raw === this.#state.lastResponseModelRaw && backendReport === this.#state.lastResponseModelBackend) return;
+		this.#state.lastResponseModelRaw = report?.raw;
+		this.#state.lastResponseModelBackend = backendReport;
+		if (!report) return;
+		const model = sanitizedText(report.raw);
+		if (!model) return;
+		const backend = report.backend ?? (model === this.#state.served?.model ? this.#state.served.backend : "");
+		const showBackend = !!backend && backend !== report.provider;
+		const restates = this.restatesSelection(report, model);
+		const display = restates ? (showBackend ? `via ${backend}` : "") : (showBackend ? `${model} via ${backend}` : model);
+		if (!display) {
 			if (this.#state.responseModel) {
 				this.#state.responseModel = "";
 				this.stopResponseModelSlide();
 				this.tick();
 			}
+			this.#state.served = null;
 			return;
 		}
-		if (responseModel && responseModel !== this.#state.responseModel) {
+		if (report.weak && model === this.#state.served?.routedId) return;
+		const changed = display !== this.#state.responseModel;
+		if (changed) {
 			// A model replacing one already shown swaps in place; only an appearing one slides out.
 			if (!this.#state.responseModel) this.startResponseModelSlide();
-			this.#state.responseModel = responseModel;
-			this.tick();
+			this.#state.responseModel = display;
 		}
+		this.#state.served = { model, backend, routedId: report.routedId ?? model };
+		if (changed) this.tick();
 	}
 
 	/**
@@ -601,7 +698,11 @@ export class SessionManager {
 		state.confirmTokens = 0;
 		state.liveTokens = 0;
 		state.responseModel = "";
+		state.served = null;
+		state.pendingServiceTier = "";
+		state.serviceTiers = [];
 		state.lastResponseModelRaw = NOT_SENT;
+		state.lastResponseModelBackend = NOT_SENT;
 		state.activityMeter.reset();
 		resetTokenRateState(state);
 		state.midTurnInputs = 0;

package/src/settings.ts

@@ -119,6 +119,7 @@ export interface DecoratorSettings {
 		randomizeDoneMarker: boolean;
 		doneMarkerTokens: boolean;
 		doneMarkerInputs: boolean;
+		doneMarkerServiceTier: boolean;
 		doneMarkerModel: boolean;
 		includeDefaultWorkingText: boolean;
 	};
@@ -128,7 +129,7 @@ export interface DecoratorSettings {
 
 export const DEFAULT_SETTINGS: DecoratorSettings = {
 	decorations: { animatedSpinner: true, shimmer: true, shimmerInverted: false, shimmerDirection: "ltr", shimmerDirectionEnabled: true, shimmerSpeed: "normal", shimmerSpeedEnabled: true, tokenActivityMonitor: true, meterDirection: "rtl", meterDirectionEnabled: true, decorateUserPrompt: true, borderColor: "thinking-level", borderColorEnabled: true, borderStyle: "double", borderStyleEnabled: true, doneMarkerBorderStyle: "none", doneMarkerBorderColor: "thinking-level", doneMarkerStyle: "elite", doneMarkerModelColor: "muted", doneMarkerModelDimmed: false, spinnerColor: "thinking-level", spinnerColorEnabled: true, meterColor: "accent", meterColorEnabled: true, meterDimmed: false, meterUpperBoundTps: DEFAULT_METER_UPPER_BOUND_TPS, tokenRateColor: "warning", tokenRateDimmed: false, responseModelColor: "accent", responseModelDimmed: false, promptIcon: true, promptTimestamp: true, promptProvider: true, promptModel: true, useNerdFont: true },
-	features: { substituteDefaultMessage: true, elapsedTime: true, outputTokens: true, tokenRate: true, responseModel: true, responseModelFooter: false, doneMarker: true, doneMarkerIcon: true, randomizeDoneMarker: true, doneMarkerTokens: true, doneMarkerInputs: true, doneMarkerModel: true, includeDefaultWorkingText: true },
+	features: { substituteDefaultMessage: true, elapsedTime: true, outputTokens: true, tokenRate: true, responseModel: true, responseModelFooter: false, doneMarker: true, doneMarkerIcon: true, randomizeDoneMarker: true, doneMarkerTokens: true, doneMarkerInputs: true, doneMarkerServiceTier: true, doneMarkerModel: true, includeDefaultWorkingText: true },
 	loaderOrder: [...DEFAULT_LOADER_ORDER],
 	wordPacks: {},
 };
@@ -231,6 +232,7 @@ export const MENU_ENTRIES: readonly MenuEntry[] = [
 	{ id: "randomizeDoneMarker", label: "Randomize “Worked” text", section: "Completion Marker", group: "features", key: "randomizeDoneMarker" },
 	{ id: "doneMarkerTokens", label: "Tokens spent", section: "Completion Marker", group: "features", key: "doneMarkerTokens" },
 	{ id: "doneMarkerInputs", label: "Mid-turn inputs", section: "Completion Marker", group: "features", key: "doneMarkerInputs" },
+	{ id: "doneMarkerServiceTier", label: "Service tier", section: "Completion Marker", group: "features", key: "doneMarkerServiceTier" },
 	{ id: "doneMarkerModel", label: "Response model", section: "Completion Marker", group: "features", key: "doneMarkerModel" },
 	{ id: "doneMarkerModelColor", label: "Response model color", section: "Completion Marker", group: "decorations", key: "doneMarkerModelColor", cycleValues: THINKING_LEVEL_COLOR_VALUES, cycleValueLabels: THINKING_LEVEL_CYCLE_LABELS },
 	{ id: "doneMarkerModelDimmed", label: "Response model dimmed", section: "Completion Marker", group: "decorations", key: "doneMarkerModelDimmed" },

package/src/util.ts

@@ -8,6 +8,10 @@ export function stripControlChars(text: string): string {
 	return text.replace(/[\p{Cc}\p{Cf}]/gu, "");
 }
 
+export function sanitizedText(value: unknown): string {
+	return typeof value === "string" ? stripControlChars(value).trim() : "";
+}
+
 /** True when a reported response model appears to be a decorated form of the selected model. */
 export function modelsResemble(selectedModel?: string, responseModel?: string): boolean {
 	if (!selectedModel || !responseModel) return false;