@danypops/jittor 0.11.0 → 0.12.1

package/docs/USAGE_PRIOR_ART.md

@@ -1,64 +0,0 @@
-# Token-usage TUI prior art
-
-Research performed before implementing Jittor's `/jittor usage` frontend.
-
-## Local agent implementations
-
-### Claude Code
-
-`~/Repositories/claude/src/components/Stats.tsx` contains the strongest terminal chart precedent:
-
-- `generateTokenChart()` renders daily model-token series with an eight-row `asciichart` plot.
-- Width adapts to the terminal and is capped near 52 columns.
-- The top three models receive distinct theme colors.
-- The X axis places three or four date labels at even positions.
-- The Y axis abbreviates values as `k` and `M`.
-
-`~/Repositories/claude/src/utils/heatmap.ts` adds a GitHub-style activity view using percentile-derived `░▒▓█` intensity. `src/components/design-system/ProgressBar.tsx` uses eighth-cell Unicode blocks (`▏▎▍▌▋▊▉█`) for fractional precision.
-
-Useful decisions: adaptive width, short axes, bounded series count, theme colors, Unicode partial cells. The Jittor requirement is a histogram rather than Claude's line chart, so only the layout and scaling ideas are reused.
-
-### OpenCode
-
-`~/Repositories/opencode/packages/stats/core/src/domain/home.ts` keeps usage projection in the domain layer. It defines explicit ranges (`1D`, `1W`, `2W`, `1M`, `2M`, `3M`, `YTD`, `ALL`), computes date windows, creates deterministic buckets, and formats range-appropriate labels.
-
-Useful decision: range/window/bucket projection is separate from rendering and data access.
-
-### Codex
-
-`~/Repositories/codex` exposes turn-level `last` and `total` token usage plus account rate-limit snapshots. Its TUI focuses on compact totals and quota state; no reusable historical token histogram was found.
-
-Useful decision: finalized turn usage is the durable accounting point. Jittor already records Pi assistant usage on `message_end`.
-
-### Cline
-
-Cline tracks accumulated input/output/cache/cost values and presents context/cost in its status area. Its local CLI sources did not contain a historical terminal histogram comparable to the requested chart.
-
-Useful decision: preserve input, output, cache-read, and cache-write categories rather than collapsing accounting at ingestion.
-
-## Pi extensions
-
-Registry and package-source review covered:
-
-- `@pi-vault/pi-usage@0.6.0`: polished framed/tabbed dashboard, Today/This Week/Last Week/All Time tables, live provider quotas, width-safe theme adapters. It has no historical vertical token histogram.
-- `@sreetej510/pi-usage@0.1.20`: `/usage` provider quota reports, cache, retries, statusline, and 20-cell `█░` quota bars.
-- `@narumitw/pi-codex-usage@0.20.0`: Codex 5-hour/weekly quota bars and compact statusline.
-- `@alexanderfortin/pi-token-usage@0.3.0`: session-file aggregation and table/export overlay, but no chart.
-
-Useful decisions: native `registerCommand`, `ctx.ui.custom`, width-bounded rendering, theme-derived colors, keyboard refresh/range navigation, and daemon/cache-backed data rather than synchronous file scans in render.
-
-## OpenRouter visual reference
-
-OpenRouter's authenticated web dashboard is not distributed as reusable terminal source. Its relevant visual grammar is a compact time-bucket histogram with colored model/provider series, readable axes, totals, and a legend. Jittor reproduces that grammar with Unicode blocks rather than copying web implementation details.
-
-## Jittor design
-
-Jittor combines the best applicable patterns:
-
-1. Pure domain projection in `src/domain/usage.ts`.
-2. Explicit `24h`, `7d`, `30d`, and `90d` windows.
-3. Provider/model-preserving series and input/output/cache totals.
-4. Vertically scaled, colored, stacked Unicode bars with fractional top blocks.
-5. Width-safe X/Y axes and provider/model legend.
-6. Native `/jittor usage` panel with Left/Right range switching and refresh.
-7. Data access only through authenticated daemon `metrics.query`; the extension never opens SQLite or reads provider credentials.

package/extension/src/benchmark-tui.ts

@@ -1,109 +0,0 @@
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
-import {
-	BENCHMARK_TUI_MAX_CANDIDATES,
-	BENCHMARK_TUI_MAX_PROVENANCE_PER_CANDIDATE,
-	MODEL_RANKING_DEFAULT_CONTEXT_WEIGHT,
-	MODEL_RANKING_DEFAULT_COST_WEIGHT,
-	MODEL_RANKING_DEFAULT_LATENCY_WEIGHT,
-	MODEL_RANKING_DEFAULT_QUALITY_WEIGHT,
-	MODEL_RANKING_DEFAULT_RELIABILITY_WEIGHT,
-} from "../../src/constants.ts";
-import type { ModelTaskDomain, ModelTaskType } from "../../src/domain/model-observation.ts";
-import type { ModelCandidate, ModelRankingResult, RankedModel, UtilityComponentName } from "../../src/domain/model-ranking.ts";
-import { sessionSecretField } from "./session-identity.ts";
-
-export interface BenchmarkPanelClient {
-	call(operation: string, input: unknown): Promise<any>;
-}
-
-interface BenchmarkTheme {
-	fg(color: string, text: string): string;
-	bold(text: string): string;
-}
-
-type BenchmarkPanelAction = "refresh" | "close";
-
-const COMPONENT_LABELS: Record<UtilityComponentName, string> = { quality: "Q", cost: "$", latency: "L", context: "C", reliability: "R" };
-
-function componentText(item: RankedModel): string {
-	return item.components.map((component) => `${COMPONENT_LABELS[component.name]} ${component.score === null ? "?" : component.score.toFixed(3)}`).join(" · ");
-}
-
-function candidateLines(item: RankedModel, index: number, currentIdentity: string): string[] {
-	const current = item.identity.startsWith(`${currentIdentity}:`);
-	const localSamples = item.components.find((component) => component.name === "reliability")?.evidenceCount ?? 0;
-	const provenance = item.provenance.slice(0, BENCHMARK_TUI_MAX_PROVENANCE_PER_CANDIDATE).map((source) => `${source.sourceId}@${source.revision} ${source.freshness}`).join(" · ");
-	return [
-		` ${index + 1}. ${item.identity}${index === 0 ? "  recommended" : ""}${current ? "  current" : ""}`,
-		`    utility ${item.utility === null ? "?" : item.utility.toFixed(3)} · confidence ${(item.confidence * 100).toFixed(0)}% · ${componentText(item)}`,
-		`    local n=${localSamples}${provenance ? ` · ${provenance}` : " · no external provenance"}`,
-	];
-}
-
-export function renderBenchmarkView(result: ModelRankingResult, currentIdentity: string, width: number, theme: BenchmarkTheme): string[] {
-	const safeWidth = Math.max(1, width);
-	const shown = result.ranked.slice(0, BENCHMARK_TUI_MAX_CANDIDATES);
-	const currentIndex = result.ranked.findIndex((item) => item.identity.startsWith(`${currentIdentity}:`));
-	const recommended = result.ranked[0];
-	const reason = recommended && currentIndex > 0
-		? `Recommendation differs from current: ${recommended.identity} ranks #1; current ranks #${currentIndex + 1}.`
-		: recommended && currentIndex === 0 ? "Current model is the top recommendation." : "Current model is outside the ranked candidates.";
-	const lines = [
-		theme.fg("borderMuted", "─".repeat(safeWidth)),
-		theme.bold("Jittor Benchmark Recommendations"),
-		result.scopeAuthority === "exact-session" ? "Scope: exact session" : "Scope: available models · ADVISORY (exact session scope unavailable)",
-		`Domain: ${result.domain} · Type: ${result.type} · evidence ${result.completeness}`,
-		reason,
-		...shown.flatMap((item, index) => candidateLines(item, index, currentIdentity)),
-		...(result.ranked.length > shown.length ? [` … ${result.ranked.length - shown.length} more candidates omitted`] : []),
-		...(result.scopeWarning ? [result.scopeWarning] : []),
-		theme.fg("dim", "r refresh · Esc close"),
-		theme.fg("borderMuted", "─".repeat(safeWidth)),
-	];
-	return lines.map((line) => truncateToWidth(line, safeWidth, "…"));
-}
-
-export async function showBenchmarkPanel(
-	ctx: ExtensionCommandContext,
-	client: BenchmarkPanelClient,
-	candidates: ModelCandidate[],
-	currentIdentity: string,
-	domain: ModelTaskDomain,
-	type: ModelTaskType,
-): Promise<void> {
-	for (;;) {
-		const session_id = ctx.sessionManager.getSessionId();
-		const result = await client.call("models.rank", {
-			candidates,
-			session_id,
-			...sessionSecretField(session_id),
-			scopeAuthority: "available-models",
-			domain,
-			type,
-			budgetPressure: 0,
-			weights: {
-				quality: MODEL_RANKING_DEFAULT_QUALITY_WEIGHT,
-				cost: MODEL_RANKING_DEFAULT_COST_WEIGHT,
-				latency: MODEL_RANKING_DEFAULT_LATENCY_WEIGHT,
-				context: MODEL_RANKING_DEFAULT_CONTEXT_WEIGHT,
-				reliability: MODEL_RANKING_DEFAULT_RELIABILITY_WEIGHT,
-			},
-			sourceIds: ["openrouter-models", "lmarena-hf", "artificial-analysis-direct", "openrouter-design-arena"],
-		}) as ModelRankingResult;
-		if (ctx.mode !== "tui") {
-			ctx.ui.notify(renderBenchmarkView(result, currentIdentity, 100, { fg: (_color, text) => text, bold: (text) => text }).join("\n"), "info");
-			return;
-		}
-		const action = await ctx.ui.custom<BenchmarkPanelAction>((_tui, theme, _keybindings, done) => ({
-			invalidate() {},
-			render(width: number): string[] { return renderBenchmarkView(result, currentIdentity, width, theme); },
-			handleInput(data: string): void {
-				if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) done("close");
-				else if (data === "r") done("refresh");
-			},
-		}));
-		if (!action || action === "close") return;
-		await client.call("benchmark.refresh", { force: true });
-	}
-}

package/extension/src/capabilities/codex-recovery.ts

@@ -1,127 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-	CODEX_RECOVERY_ATTEMPT_WINDOW_MS,
-	CODEX_RECOVERY_BASE_DELAY_MS,
-	CODEX_RECOVERY_JITTER_RATIO,
-	CODEX_RECOVERY_MAX_ATTEMPTS,
-	CODEX_RECOVERY_MAX_DELAY_MS,
-	MILLISECONDS_PER_MINUTE,
-	MILLISECONDS_PER_SECOND,
-} from "../../../src/constants.ts";
-import { CodexRecoveryPolicy, classifyCodexFailure, type CodexFailureKind, type CodexFailureMetadata } from "../../../src/domain/codex-recovery.ts";
-import type { CodexRecoveryControl } from "../settings.ts";
-import { headerValue } from "./http-headers.ts";
-
-export interface CodexRecoveryRuntime {
-	now(): number;
-	random(): number;
-	setTimeout(callback: () => void | Promise<void>, delayMs: number): unknown;
-	clearTimeout(handle: unknown): void;
-}
-
-export const SYSTEM_RECOVERY_RUNTIME: CodexRecoveryRuntime = {
-	now: Date.now,
-	random: Math.random,
-	setTimeout(callback, delayMs) { return setTimeout(() => { void callback(); }, delayMs); },
-	clearTimeout(handle) { clearTimeout(handle as ReturnType<typeof setTimeout>); },
-};
-
-/**
- * Codex's settled-turn hidden-retry recovery, as its own capability: tracks the most recent
- * Codex response (status/retry-after) across the current turn, classifies a finalized failure,
- * and schedules at most one bounded, jittered follow-up once Pi's own turn has genuinely
- * settled. Fully self-contained -- the only external dependencies are Pi's own message-send API,
- * the persisted on/off control, and a runtime the tests can fake (timers, randomness, clock).
- */
-export class CodexRecoveryCapability {
-	private readonly policy: CodexRecoveryPolicy;
-	private lastResponse: CodexFailureMetadata = {};
-	private timer: unknown;
-	private cooldown: { until: number; attempt: number; failureKind: CodexFailureKind } | undefined;
-
-	constructor(
-		private readonly pi: ExtensionAPI,
-		private readonly control: CodexRecoveryControl,
-		private readonly runtime: CodexRecoveryRuntime,
-	) {
-		this.policy = new CodexRecoveryPolicy({
-			baseDelayMs: CODEX_RECOVERY_BASE_DELAY_MS,
-			maxDelayMs: CODEX_RECOVERY_MAX_DELAY_MS,
-			maxAttempts: CODEX_RECOVERY_MAX_ATTEMPTS,
-			attemptWindowMs: CODEX_RECOVERY_ATTEMPT_WINDOW_MS,
-			jitterRatio: CODEX_RECOVERY_JITTER_RATIO,
-		}, runtime.random);
-	}
-
-	/** Clears the tracked response at the start of every new turn, before any Codex response for it has arrived. */
-	resetTurn(): void {
-		this.lastResponse = {};
-	}
-
-	notifyResponse(status: number, headers: Record<string, string>): void {
-		this.lastResponse = { status, ...(headerValue(headers, "retry-after") ? { retryAfter: headerValue(headers, "retry-after") } : {}) };
-	}
-
-	notifyMessageEnd(stopReason: string, errorMessage: string | undefined): void {
-		if (stopReason === "error") {
-			const failure = classifyCodexFailure(errorMessage, this.lastResponse);
-			if (this.control.isCodexRecoveryEnabled() && failure.transient) this.policy.observeFailure(failure, this.runtime.now());
-			else this.cancel(true);
-		} else if (stopReason !== "aborted") {
-			this.cancel(true);
-		}
-		this.lastResponse = {};
-	}
-
-	cancel(resetPolicy: boolean): void {
-		if (this.timer !== undefined) this.runtime.clearTimeout(this.timer);
-		this.timer = undefined;
-		this.cooldown = undefined;
-		if (resetPolicy) this.policy.cancel();
-	}
-
-	statusText(): string {
-		const now = this.runtime.now();
-		const state = this.policy.state(now);
-		const enabled = this.control.isCodexRecoveryEnabled();
-		const attempt = this.cooldown?.attempt ?? (state.pending ? state.attempts + 1 : state.attempts);
-		const phase = this.cooldown
-			? `cooldown ${Math.ceil(Math.max(0, this.cooldown.until - now) / MILLISECONDS_PER_SECOND)}s`
-			: state.pending ? "pending"
-				: state.attempts >= CODEX_RECOVERY_MAX_ATTEMPTS ? "exhausted"
-					: state.attempts > 0 ? "waiting" : "idle";
-		const failureKind = this.cooldown?.failureKind ?? state.lastFailureKind;
-		return [
-			`Codex recovery: ${enabled ? "on" : "off"}`,
-			phase,
-			`attempt ${attempt}/${CODEX_RECOVERY_MAX_ATTEMPTS}`,
-			`window ${CODEX_RECOVERY_ATTEMPT_WINDOW_MS / MILLISECONDS_PER_MINUTE}m`,
-			...(failureKind ? [failureKind] : []),
-		].join(" · ");
-	}
-
-	scheduleIfIdle(ctx: ExtensionContext): void {
-		if (!this.control.isCodexRecoveryEnabled() || this.timer !== undefined || !ctx.isIdle() || ctx.hasPendingMessages()) return;
-		const plan = this.policy.plan(this.runtime.now());
-		if (plan.action === "exhausted") {
-			this.policy.abandonFailure();
-			if (ctx.hasUI) ctx.ui.notify(`Jittor Codex recovery stopped: ${plan.reason}.`, "warning");
-			return;
-		}
-		if (plan.action !== "schedule") return;
-		this.cooldown = { until: this.runtime.now() + plan.delayMs, attempt: plan.attempt, failureKind: plan.failureKind };
-		this.timer = this.runtime.setTimeout(async () => {
-			this.timer = undefined;
-			this.cooldown = undefined;
-			if (!ctx.isIdle() || ctx.hasPendingMessages()) return;
-			const attempt = this.policy.recordAttempt(this.runtime.now());
-			if (!attempt) return;
-			this.pi.sendMessage({
-				customType: "jittor-codex-recovery",
-				content: `Retry the previous Codex request after a transient ${attempt.failureKind} failure. Automatic recovery attempt ${attempt.attempt} of ${CODEX_RECOVERY_MAX_ATTEMPTS}.`,
-				display: false,
-				details: { attempt: attempt.attempt, failureKind: attempt.failureKind },
-			}, { triggerTurn: true, deliverAs: "followUp" });
-		}, plan.delayMs);
-	}
-}

package/extension/src/capabilities/http-headers.ts

@@ -1,5 +0,0 @@
-/** Case-insensitive header lookup -- Pi's provider-response event headers are a plain Record, not a Headers instance. */
-export function headerValue(headers: Record<string, string>, name: string): string | undefined {
-	const expected = name.toLowerCase();
-	return Object.entries(headers).find(([key]) => key.toLowerCase() === expected)?.[1];
-}

package/extension/src/capabilities/local-run-telemetry.ts

@@ -1,104 +0,0 @@
-import { classifyTaskFromTools, modelRunMetrics, type ModelRunObservation } from "../../../src/domain/model-observation.ts";
-import type { MetricObservation } from "../../../src/domain/metric.ts";
-
-export interface ActiveLocalModelRun {
-	runId: string;
-	startedAt: number;
-	firstTokenAt: number | null;
-	providerResponses: number;
-	toolNames: string[];
-	toolCalls: number;
-	toolFailures: number;
-}
-
-/**
- * Content-free local model observations derived only from Pi's public lifecycle: TTFT, wall
- * latency, tool-loop counts and failures, and a bounded tool-name list used only to derive
- * domain/type classification -- never prompts, responses, tool arguments/results, or project
- * paths. Owns the one in-flight run plus the most recently completed one (for `/jittor outcome`).
- */
-export class LocalRunTelemetry {
-	private active: ActiveLocalModelRun | undefined;
-	private lastCompleted: ModelRunObservation | undefined;
-	private sequence = 0;
-
-	beginTurn(timestamp: number): void {
-		this.active = {
-			runId: `local-${timestamp}-${++this.sequence}`,
-			startedAt: timestamp,
-			firstTokenAt: null,
-			providerResponses: 0,
-			toolNames: [],
-			toolCalls: 0,
-			toolFailures: 0,
-		};
-	}
-
-	discardTurn(): void {
-		this.active = undefined;
-	}
-
-	onMessageUpdate(assistantMessageEventType: string): void {
-		if (!this.active || this.active.firstTokenAt !== null) return;
-		if (["text_delta", "thinking_delta", "toolcall_delta"].includes(assistantMessageEventType)) this.active.firstTokenAt = Date.now();
-	}
-
-	onToolExecutionEnd(toolName: string, isError: boolean): void {
-		if (!this.active) return;
-		this.active.toolCalls += 1;
-		if (isError) this.active.toolFailures += 1;
-		if (this.active.toolNames.length < 100) this.active.toolNames.push(toolName);
-	}
-
-	onProviderResponse(): void {
-		if (this.active) this.active.providerResponses += 1;
-	}
-
-	/** Finalizes the active run against a completed assistant turn_end message, returning metrics to record (empty if the message shape doesn't match a completed assistant turn). */
-	completeTurn(message: unknown, thinkingLevel: string): MetricObservation[] {
-		const active = this.active;
-		this.active = undefined;
-		if (!active || typeof message !== "object" || message === null || Array.isArray(message)) return [];
-		const value = message as Record<string, unknown>;
-		if (value["role"] !== "assistant" || typeof value["provider"] !== "string" || typeof value["model"] !== "string") return [];
-		const usage = typeof value["usage"] === "object" && value["usage"] !== null ? value["usage"] as Record<string, unknown> : {};
-		const amount = (name: string): number => typeof usage[name] === "number" && Number.isFinite(usage[name]) ? usage[name] as number : 0;
-		const cost = typeof usage["cost"] === "object" && usage["cost"] !== null && typeof (usage["cost"] as Record<string, unknown>)["total"] === "number"
-			? (usage["cost"] as Record<string, number>)["total"] ?? 0 : 0;
-		const stopReason = ["stop", "length", "toolUse", "error", "aborted"].includes(String(value["stopReason"]))
-			? value["stopReason"] as ModelRunObservation["stopReason"] : "unknown";
-		const completedAt = Math.max(Date.now(), active.firstTokenAt ?? active.startedAt, active.startedAt);
-		this.lastCompleted = {
-			runId: active.runId,
-			provider: value["provider"],
-			model: value["model"],
-			thinking: thinkingLevel,
-			...classifyTaskFromTools(active.toolNames),
-			startedAt: active.startedAt,
-			firstTokenAt: active.firstTokenAt,
-			completedAt,
-			inputTokens: amount("input"),
-			outputTokens: amount("output"),
-			cacheReadTokens: amount("cacheRead"),
-			cacheWriteTokens: amount("cacheWrite"),
-			costUsd: Number.isFinite(cost) && cost >= 0 ? cost : 0,
-			providerResponses: Math.max(1, active.providerResponses),
-			toolCalls: active.toolCalls,
-			toolFailures: active.toolFailures,
-			stopReason,
-			explicitOutcome: "unknown",
-		};
-		return modelRunMetrics(this.lastCompleted);
-	}
-
-	/** Builds the single outcome-accepted/outcome-accepted=0 metric for the most recently completed run, or null if none exists yet. */
-	explicitOutcomeMetric(explicitOutcome: "accepted" | "rejected"): MetricObservation | null {
-		if (!this.lastCompleted) return null;
-		return modelRunMetrics({ ...this.lastCompleted, explicitOutcome }).find((metric) => metric.metric === "outcome-accepted") ?? null;
-	}
-
-	reset(): void {
-		this.active = undefined;
-		this.lastCompleted = undefined;
-	}
-}

package/extension/src/capabilities/provider-response-telemetry.ts

@@ -1,96 +0,0 @@
-import type { MetricObservation } from "../../../src/domain/metric.ts";
-import { hasAnthropicRateLimitHeaders, parseAnthropicRateLimitHeaders } from "../../../src/providers/anthropic-contracts.ts";
-import { parseCodexRateLimitHeaders } from "../../../src/providers/codex.ts";
-import { classifyGoogleVertexFailure, googleVertexFailureMetrics, type GoogleVertexFailureMetadata } from "../../../src/providers/google-vertex-contracts.ts";
-import { headerValue } from "./http-headers.ts";
-
-export interface ProviderTelemetryClient {
-	call(operation: string, input: unknown): Promise<any>;
-}
-
-async function recordMetrics(client: ProviderTelemetryClient, metrics: MetricObservation[]): Promise<void> {
-	if (metrics.length === 0) return;
-	await client.call("metrics.record_batch", { observations: metrics });
-}
-
-/**
- * Bounded telemetry derived directly from provider HTTP responses and finalized messages, for
- * every provider except Codex (whose response tracking is settled-turn-recovery's own concern --
- * see codex-recovery.ts). Anthropic and anthropic-vertex official rate-limit headers become
- * budget metrics; Google Vertex and anthropic-vertex failures become bounded, content-free
- * failure-count metrics classified from GCP's own `google.rpc.Status` shape. anthropic-vertex is
- * tracked distinctly from both google-vertex (different code path, different quota pool) and
- * direct anthropic (different transport), never conflated with either.
- */
-export class ProviderResponseTelemetry {
-	private lastGoogleVertexResponse: GoogleVertexFailureMetadata = {};
-	private lastAnthropicVertexResponse: GoogleVertexFailureMetadata = {};
-
-	resetTurn(): void {
-		this.lastGoogleVertexResponse = {};
-		this.lastAnthropicVertexResponse = {};
-	}
-
-	async handleProviderResponse(
-		client: ProviderTelemetryClient,
-		provider: string | undefined,
-		status: number,
-		headers: Record<string, string>,
-		notifySchemaDrift: (message: string) => void,
-	): Promise<void> {
-		if (provider === "anthropic") {
-			const parsedHeaders = new Headers(headers);
-			if (hasAnthropicRateLimitHeaders(parsedHeaders)) {
-				try {
-					await recordMetrics(client, parseAnthropicRateLimitHeaders(parsedHeaders, Date.now()).metrics);
-				} catch {
-					notifySchemaDrift("Anthropic telemetry schema drift");
-				}
-			}
-		}
-		if (provider === "anthropic-vertex") {
-			// Best-effort only: unverified whether this passthrough ever forwards Anthropic's own
-			// rate-limit headers. If it doesn't, hasAnthropicRateLimitHeaders is false and nothing is
-			// recorded -- the same honest default as every other unconfirmed signal in this module.
-			const parsedHeaders = new Headers(headers);
-			if (hasAnthropicRateLimitHeaders(parsedHeaders)) {
-				try {
-					await recordMetrics(client, parseAnthropicRateLimitHeaders(parsedHeaders, Date.now(), "anthropic-vertex").metrics);
-				} catch {
-					notifySchemaDrift("Anthropic-on-Vertex telemetry schema drift");
-				}
-			}
-			// Well-evidenced regardless of headers: GCP's own quota system fronts this transport, so the
-			// same failure classification as google-vertex applies below.
-			this.lastAnthropicVertexResponse = { status, ...(headerValue(headers, "retry-after") ? { retryAfter: headerValue(headers, "retry-after") } : {}) };
-		}
-		if (provider === "google-vertex") {
-			this.lastGoogleVertexResponse = { status, ...(headerValue(headers, "retry-after") ? { retryAfter: headerValue(headers, "retry-after") } : {}) };
-		}
-		if (Object.keys(headers).some((name) => name.toLowerCase().startsWith("x-codex-"))) {
-			try {
-				const updates = parseCodexRateLimitHeaders(new Headers(headers), Date.now());
-				await recordMetrics(client, updates.flatMap((update) => update.metrics));
-			} catch {
-				notifySchemaDrift("Codex telemetry schema drift");
-			}
-		}
-	}
-
-	async handleMessageEnd(client: ProviderTelemetryClient, provider: string | undefined, stopReason: string | undefined, errorMessage: string | undefined): Promise<void> {
-		if (provider === "google-vertex") {
-			if (stopReason === "error") {
-				const failure = classifyGoogleVertexFailure(errorMessage, this.lastGoogleVertexResponse);
-				await recordMetrics(client, googleVertexFailureMetrics(failure, Date.now())).catch(() => undefined);
-			}
-			this.lastGoogleVertexResponse = {};
-		}
-		if (provider === "anthropic-vertex") {
-			if (stopReason === "error") {
-				const failure = classifyGoogleVertexFailure(errorMessage, this.lastAnthropicVertexResponse);
-				await recordMetrics(client, googleVertexFailureMetrics(failure, Date.now(), "anthropic-vertex")).catch(() => undefined);
-			}
-			this.lastAnthropicVertexResponse = {};
-		}
-	}
-}