pi-llamacpp-infra 1.2.5 → 1.3.0

package/README.md

@@ -28,6 +28,7 @@ Anything else (vLLM, Ollama, cloud APIs…) is out of scope — use pi's built-i
 - **Long local generations** — discovered models are registered with up to **32,768 output tokens** (bounded by the model/server context) and llamacpp-infra OpenAI-compatible requests enforce a **20 minute** timeout floor so slow local runs don't get cut early by pi defaults
 - **Per-model metadata badges** — 👁️ vision (mmproj / modalities), 🚀 drafter (speculative decoding), 🗜️ quant tag from GGUF filename, 🧠 KV cache quantization (from server args or `/proc`)
 - **Live speed & metrics** — a constantly updating footer reading of the active model's prefill (⚡) and generation (🔥) token speed, measured straight from the stream (per token, ~10 updates/s); when pi is idle it also mirrors other clients the server's `/metrics` endpoint reports. Lives in the footer's status line, so no extra terminal row is taken. Works even without `--metrics`
+- **Energy cost (💰)** — local models report no per-token cost, so llamacpp-infra estimates the **electricity** the inference consumed: configure each machine's power draw (kW) and tariff (per kWh) once, and every assistant message carries a realistic `usage.cost.total` (kW × €/kWh × measured request time) — pi's native cost footer, session stats and any consumer reading usage (e.g. trimegisto agents) all show it. Currency selector: USD / EUR / GBP / CNY
 - **Thinking budgets** — llama.cpp accepts `thinking_budget_tokens` per request; configure budgets per thinking level (minimal/low/medium/high/xhigh/max) per model; models with budgets are registered with reasoning enabled
 - **Header warmup** — pre-caches the system prompt KV on llama.cpp-family servers so the first real request is faster
 - **LM Studio support** — uses LM Studio's OpenAI-compatible `/v1` API, enriches names/context/quant/vision from `/api/v1/models` (or legacy `/api/v0/models`), and avoids llama.cpp-only request fields
@@ -160,7 +161,8 @@ Everything is configurable through the UI, but the persisted file is `~/.pi/agen
       "label": "Local",
       "ports": [8000, 8001, 8002, 8080, 8081, 8082, 1234],
       "enabled": true,
-      "probeDs4": false
+      "probeDs4": false,
+      "costProfile": { "kW": 0.15, "ratePerKwh": 0.21, "label": "bruma 27B" }
     },
     {
       "id": "myserver",
@@ -184,7 +186,9 @@ Everything is configurable through the UI, but the persisted file is `~/.pi/agen
     "includeUnloadedRouterModels": false,
     "warmup": true,
     "metricsEnabled": true,
-    "metricsPollMs": 5000
+    "metricsPollMs": 5000,
+    "currency": "eur",
+    "costTracking": true
   },
   "modelOptions": {
     "Qwen3.6-27B (myserver:8080)": {
@@ -210,6 +214,7 @@ Everything is configurable through the UI, but the persisted file is `~/.pi/agen
 | `enabled` | `true` | Whether to probe this server |
 | `probeDs4` | `false` | Opt-in: ping `/v1/chat/completions` for DwarfStar/ds4 servers |
 | `apiKey` | — | Optional bearer token sent on discovery and per-model requests |
+| `costProfile` | — | `{ kW, ratePerKwh }` energy-cost profile for this machine; enables 💰 estimation (see [Energy Cost](#energy-cost-)) |
 
 ### Settings
 
@@ -229,6 +234,8 @@ Everything is configurable through the UI, but the persisted file is `~/.pi/agen
 | `warmup` | `true` | Pre-cache system prompt KV on llama.cpp servers |
 | `metricsEnabled` | `true` | Show live speed & metrics in the footer for llamacpp-infra models |
 | `metricsPollMs` | `5000` | How often `/metrics` is fetched |
+| `currency` | `eur` | Display currency for energy costs: `usd` / `eur` / `gbp` / `cny` |
+| `costTracking` | `true` | Accumulate 💰 energy cost and inject it into `usage.cost.total` |
 
 ### Thinking budgets
 
@@ -258,6 +265,7 @@ When enabled, the speed reading appears in the footer's status line (no extra te
 🦙(12) ⚡ 420 t/s 🔥 38.1 t/s  (just after the answer ends)
 🦙(12) ⏸             (between turns)
 🦙(12) ▶2 ⚡ 150 t/s 🔥 18.0 t/s  (pi idle, server busy for other clients)
+🦙(12) ⏸ 💰3.2c      (energy cost of this session, after a turn)
 ```
 
 (`🦙(n)` is the extension's model-count status; both live on the same footer line, so no extra row is consumed.)
@@ -265,6 +273,41 @@ When enabled, the speed reading appears in the footer's status line (no extra te
 - **Client measurement (always, no `--metrics` needed)** — prefill speed = `prompt tokens ÷ (request → first token)` (pi's `usage.input`, OpenAI-style `prompt_tokens` as fallback); generation speed = a moving 1.5 s window over per-token arrival samples. Updated ~every 100 ms while a stream is live (throttled, and unchanged text is skipped, so the footer never churns).
 - **Server supplement (only when pi is idle)** — the poller fetches the server's Prometheus `/metrics` endpoint (or JSON `/stats`) every `metricsPollMs` (default 5 s). If the server reports other clients processing, their ⚡/🔥 rates are shown (`▶n`); when the server is idle, the plain `⏸` reading returns.
 
+## Energy Cost (💰)
+
+Cloud providers report their own per-message cost, so pi's native cost footer is always right for them. Local llama.cpp-family servers report nothing — so llamacpp-infra estimates the **electricity** the inference consumed and feeds it into the standard usage pipeline:
+
+```
+cost = (requestMs / 3_600_000) × kW × tariff
+```
+
+Every assistant message therefore carries a realistic `usage.cost.total`: pi's own cost display/session stats show it, and any consumer that reads usage (e.g. **trimegisto** sub-agents, which accumulate `usage.cost.total` per message into their dashboard) gets it for free — no per-tool cost logic needed anywhere else.
+
+### Setup
+
+```
+/llamacpp-infra config  →  💰 Energy cost
+```
+
+1. **Currency** — USD, EUR, GBP or CNY. It only changes the display unit; tariffs are stored per kWh in that currency.
+2. **Per-server power draw & tariff** — the power draw belongs to the *machine*, so every server (machine) gets one profile: `kW` during inference (e.g. `0.15` for 150 W — GPU TDP + idle draw is a good approximation) and the electricity price per kWh. All models served by that machine inherit it.
+
+Once set, each provider request is timed (`before_provider_request` → assistant `message_end`, partial/aborted requests included) and charged. The footer shows the session total as `💰` (e.g. `💰3.2c` = 3.2 euro-cents; `¢`/`c`/`p`/`分` per currency); enable/disable anytime from the same menu.
+
+> **Parallel agents & accuracy** — when several clients hammer the same server in parallel, each client's wall time is the server time it actually consumed (decode is interleaved), so the session total approximates the machine's inference energy. Good for cost visibility; not a metering-grade measurement.
+
+Config lives in `~/.pi/agent/llamacpp-infra.json`:
+
+```json
+{
+  "servers": [
+    { "id": "local", "host": "127.0.0.1", "ports": [8000, 8080, 8081], "enabled": true,
+      "costProfile": { "kW": 0.15, "ratePerKwh": 0.21, "label": "bruma 27B" } }
+  ],
+  "settings": { "currency": "eur", "costTracking": true }
+}
+```
+
 ## Architecture
 
 ```
@@ -280,6 +323,8 @@ llamacpp-infra/
     ├── registration.ts  # Scan → pi-model mapping + provider registration (lazy).
     ├── metrics.ts       # Server /metrics poller → ServerMetricsState (lazy; only if `metricsEnabled`).
     ├── speed.ts         # Client-side speed tracker + footer status line (lazy; only if `metricsEnabled`).
+    ├── cost.ts          # Cost profiles, currency formatting, energy math (static import; tiny).
+    ├── cost-tracker.ts  # Energy-cost tracker: times requests, accumulates, feeds usage.cost (static).
     ├── ui.ts            # /llamacpp-infra subcommands, menus, status, help (lazy).
     └── prompt-warmup.ts # Header warmup: capture + cache system prompt KV (lazy; only if `warmup`).
 ```
@@ -292,6 +337,7 @@ Module load profile:
 | `scan.ts` + `registration.ts` | First discovery (dynamic) | ~27 KB |
 | `prompt-warmup.ts` | Primed at load if `warmup` enabled; not loaded when disabled | ~15 KB; skipped entirely when `warmup` is OFF |
 | `metrics.ts` + `speed.ts` | Primed at load if `metricsEnabled`; not loaded when disabled | ~18 KB; skipped entirely when `metricsEnabled` is OFF |
+| `cost.ts` + `cost-tracker.ts` | Static at load (tiny; needed in sub-agent processes too, which never fire `session_start`) | ~4 KB |
 | `ui.ts` | First `/llamacpp-infra …` command (dynamic) | ~32 KB |
 
 Zero external npm dependencies (only pi's bundled `@earendil-works/pi-coding-agent` + Node built-ins).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-llamacpp-infra",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "description": "Discovery, metrics and control of llama.cpp-family servers for pi (llama.cpp, ZINC, DwarfStar/ds4, lucebox, LM Studio): scan machines (localhost, LAN, Tailscale), register models, live metrics, per-model thinking budgets, vision detection, native config UI.",
   "keywords": [
     "pi-package",

package/src/core.ts

@@ -20,6 +20,7 @@ export const CONFIG_FILE = "llamacpp-infra.json";
 export const MODELS_CACHE_FILE = "llamacpp-infra-models.json";
 export const LEGACY_CONFIG_FILE = "local-models.json";
 export const METRICS_STATUS_KEY = "llamacpp-infra-speed";
+export const COST_STATUS_KEY = "llamacpp-infra-cost";
 export const DEFAULT_API_KEY = "no-auth";
 export const THINKING_BUDGET_FIELD = "thinking_budget_tokens";
 export const DEFAULT_MAX_OUTPUT_TOKENS = 32_768;
@@ -41,6 +42,8 @@ export const DEFAULT_SETTINGS: SettingsConfig = {
 	metricsPollMs: 5000,
 	includeUnloadedRouterModels: false,
 	showBadgesInNames: true,
+	currency: "eur",
+	costTracking: true,
 };
 
 export const DEFAULT_SERVERS: ServerConfig[] = [
@@ -65,6 +68,50 @@ export function getConfigPath(): string {
 	return join(getAgentDir(), CONFIG_FILE);
 }
 
+/** Validate/normalize a raw cost profile from disk. */
+export function parseCostProfile(raw: unknown): import("./types.ts").CostProfile | undefined {
+	if (!raw || typeof raw !== "object") return undefined;
+	const r = raw as Record<string, unknown>;
+	const kW = typeof r.kW === "number" ? r.kW : parseFloat(String(r.kW ?? ""));
+	const rate = typeof r.ratePerKwh === "number" ? r.ratePerKwh : parseFloat(String(r.ratePerKwh ?? ""));
+	if (!Number.isFinite(kW) || kW <= 0 || !Number.isFinite(rate) || rate <= 0) return undefined;
+	const p: import("./types.ts").CostProfile = { kW, ratePerKwh: rate };
+	if (typeof r.label === "string" && r.label) p.label = r.label;
+	if (typeof r.host === "string" && r.host) p.host = r.host;
+	if (typeof r.pattern === "string" && r.pattern) p.pattern = r.pattern;
+	return p;
+}
+
+const CURRENCY_CODES = new Set(["usd", "eur", "gbp", "cny"]);
+
+/** Normalize a raw settings object onto the defaults (unknown keys dropped, bad values repaired). */
+export function normalizeSettings(raw: unknown): SettingsConfig {
+	const r = (raw && typeof raw === "object" ? raw : {}) as Record<string, unknown>;
+	const s: SettingsConfig = { ...DEFAULT_SETTINGS };
+	for (const key of Object.keys(DEFAULT_SETTINGS) as Array<keyof SettingsConfig>) {
+		const v = r[key];
+		if (typeof v === typeof DEFAULT_SETTINGS[key]) (s as Record<string, unknown>)[key] = v;
+	}
+	if (typeof r.currency === "string" && CURRENCY_CODES.has(r.currency as string)) s.currency = r.currency as SettingsConfig["currency"];
+	return s;
+}
+
+function normalizeServer(s: Record<string, unknown>): import("./types.ts").ServerConfig {
+	return {
+		id: String(s.id ?? "local"),
+		host: String(s.host ?? "127.0.0.1"),
+		...(typeof s.label === "string" && s.label ? { label: s.label } : {}),
+		ports: Array.isArray(s.ports) ? s.ports.filter((p): p is number => typeof p === "number") : [],
+		enabled: typeof s.enabled === "boolean" ? s.enabled : true,
+		...(s.probeDs4 === true ? { probeDs4: true } : {}),
+		...(typeof s.apiKey === "string" && s.apiKey ? { apiKey: s.apiKey } : {}),
+		...(() => {
+			const p = parseCostProfile(s.costProfile);
+			return p ? { costProfile: p } : {};
+		})(),
+	};
+}
+
 export function loadConfig(): InfraConfig {
 	const defaults: InfraConfig = {
 		servers: DEFAULT_SERVERS,
@@ -76,8 +123,10 @@ export function loadConfig(): InfraConfig {
 		try {
 			const raw = JSON.parse(readFileSync(path, "utf-8")) as Partial<InfraConfig>;
 			return {
-				servers: Array.isArray(raw.servers) ? raw.servers : defaults.servers,
-				settings: { ...DEFAULT_SETTINGS, ...(raw.settings ?? {}) },
+				servers: Array.isArray(raw.servers)
+					? raw.servers.map((s) => normalizeServer(s as Record<string, unknown>))
+					: defaults.servers,
+				settings: normalizeSettings(raw.settings),
 				modelOptions: raw.modelOptions ?? {},
 			};
 		} catch (err) {
@@ -90,8 +139,10 @@ export function loadConfig(): InfraConfig {
 		try {
 			const raw = JSON.parse(readFileSync(legacyPath, "utf-8")) as Partial<InfraConfig>;
 			const migrated: InfraConfig = {
-				servers: Array.isArray(raw.servers) ? raw.servers : defaults.servers,
-				settings: { ...DEFAULT_SETTINGS, ...(raw.settings ?? {}) },
+				servers: Array.isArray(raw.servers)
+					? raw.servers.map((s) => normalizeServer(s as Record<string, unknown>))
+					: defaults.servers,
+				settings: normalizeSettings(raw.settings),
 				modelOptions: raw.modelOptions ?? {},
 			};
 			debugLog(`migrated legacy config from ${legacyPath}`);

package/src/cost-tracker.ts

@@ -0,0 +1,147 @@
+// Energy-cost tracker: measures inference time of the active llamacpp-infra
+// model from pi's stream events and accumulates the electricity cost.
+//
+//   cost per request = (requestMs / 3_600_000) × kW × tariff
+//
+// Timing: before_provider_request → message_end (assistant). This covers
+// prefill + decode for one LLM call. Partial requests (errors/aborts) are
+// still charged for the time actually consumed.
+//
+// The tracker exposes the accumulated cost so the footer can show it
+// (⚡3.2¢) and the message_end hook can inject it into usage.cost, which pi
+// then displays in its native cost footer — no trimegisto required.
+
+import { COST_STATUS_KEY, debugLog } from "./core.ts";
+import { formatCost } from "./cost.ts";
+import type { CostProfile, Currency, ExtensionContext } from "./types.ts";
+
+
+export interface CostDeps {
+	/** Whether the extension is still active. */
+	isActive: () => boolean;
+	/** Whether the ctx has a UI. */
+	hasUI: (ctx: ExtensionContext | undefined) => boolean;
+	/** Whether the current session model belongs to this provider. */
+	isOurs: (ctx: ExtensionContext | undefined) => boolean;
+	/** Whether cost tracking is enabled in settings. */
+	enabled: () => boolean;
+	/** Display currency. */
+	currency: () => Currency;
+	/** Resolve the cost profile for the current model (null = no estimation). */
+	profileFor: (ctx: ExtensionContext | undefined) => CostProfile | null;
+}
+
+export interface CostSnapshot {
+	/** Accumulated cost for the current session (in the configured currency). */
+	total: number;
+	/** Accumulated inference time in ms. */
+	ms: number;
+	/** Whether a profile is active (estimation on). */
+	active: boolean;
+	/** In-flight request start (ms epoch) or 0. */
+	inFlight: number;
+}
+
+/** Render the accumulated cost as a compact footer suffix, e.g. "💰3.2¢". */
+export function formatCostSuffix(snap: CostSnapshot, currency: Currency): string {
+	if (!snap.active || snap.total <= 0) return "";
+	return `💰${formatCost(snap.total, currency)}`;
+}
+
+/** Push the cost line to pi's status footer (or clear it). */
+function renderCostStatus(ctx: ExtensionContext | undefined, snap: CostSnapshot, currency: Currency): void {
+	if (!ctx || !ctx.ui) return;
+	const text = formatCostSuffix(snap, currency);
+	try {
+		ctx.ui.setStatus(COST_STATUS_KEY, text || undefined);
+	} catch {
+		// ignore
+	}
+}
+
+export function createCostTracker(deps: CostDeps) {
+	let reqStartAt: number | undefined;
+	let totalMs = 0;
+	let totalCost = 0;
+	/** Live ctx for callbacks without one. */
+	let lastCtx: ExtensionContext | undefined;
+
+	function rememberCtx(ctx: ExtensionContext | undefined): void {
+		if (ctx && deps.hasUI(ctx)) lastCtx = ctx;
+	}
+
+	function reset(): void {
+		reqStartAt = undefined;
+		totalMs = 0;
+		totalCost = 0;
+	}
+
+	/** Charge a finished (or aborted) request; returns the cost of this request. */
+	function chargeRequest(ctx: ExtensionContext | undefined, endAt: number): number {
+		if (reqStartAt === undefined) return 0;
+		const ms = Math.max(0, endAt - reqStartAt);
+		reqStartAt = undefined;
+		const profile = deps.profileFor(ctx ?? lastCtx);
+		if (!profile || ms <= 0) return 0;
+		const cost = (ms / 3_600_000) * profile.kW * profile.ratePerKwh;
+		totalMs += ms;
+		totalCost += cost;
+		debugLog(`cost: +${ms}ms → +${cost.toFixed(6)} (session ${totalCost.toFixed(6)})`);
+		return cost;
+	}
+
+	return {
+		/** before_provider_request: a new LLM call starts. */
+		onRequest(ctx: ExtensionContext | undefined, at: number): void {
+			if (!deps.isActive()) return;
+			rememberCtx(ctx);
+			if (!deps.isOurs(ctx) || !deps.enabled()) {
+				reset();
+				return;
+			}
+			// A new request supersedes any uncharged one (shouldn't happen, but be safe).
+			if (reqStartAt !== undefined) chargeRequest(ctx, at);
+			reqStartAt = at;
+		},
+
+		/**
+		 * message_end (assistant): finalize the call and charge it.
+		 * Returns the cost of THIS request (0 when no profile/off), so callers
+		 * can add just the delta to usage.cost.total of that message.
+		 */
+		onMessageEnd(ctx: ExtensionContext | undefined, message: unknown, at: number): number {
+			if (!deps.isActive()) return 0;
+			rememberCtx(ctx);
+			if (!deps.isOurs(ctx)) return 0;
+			const role = (message as { role?: string } | undefined)?.role;
+			if (role !== "assistant") return 0;
+			const charged = chargeRequest(ctx, at);
+			renderCostStatus(ctx ?? lastCtx, this.snapshot(), deps.currency());
+			return charged;
+		},
+
+		/** turn_end: nothing more to do (requests are charged at message_end). */
+		onTurnEnd(_ctx: ExtensionContext | undefined): void {
+			// no-op: kept for API symmetry with the speed tracker
+		},
+
+		/** Current accumulated view. */
+		snapshot(): CostSnapshot {
+			const profile = deps.profileFor(lastCtx);
+			return {
+				total: totalCost,
+				ms: totalMs,
+				active: !!profile && totalCost > 0,
+				inFlight: reqStartAt ?? 0,
+			};
+		},
+
+		/** Reset the session accumulator (model switch / session start). */
+		reset(ctx?: ExtensionContext): void {
+			reset();
+			renderCostStatus(ctx ?? lastCtx, this.snapshot(), deps.currency());
+		},
+	};
+}
+
+export type CostTracker = ReturnType<typeof createCostTracker>;

package/src/cost.ts

@@ -0,0 +1,95 @@
+// Energy-cost estimation for local inference.
+//
+// Local servers report no per-token cost, so the honest cost is the
+// electricity the inference consumed:
+//
+//   cost = (inferenceMs / 3_600_000) × kW × tariff
+//
+// Profiles are configured per server (the power draw belongs to the machine,
+// not the model). The currency selector (settings.currency) only changes the
+// display unit — the stored tariff is always per kWh in the chosen currency.
+
+import type { Currency, CostProfile, ServerConfig } from "./types.ts";
+
+// ── Currency display ────────────────────────────────────────────────────────
+export const CURRENCIES: Array<{ code: Currency; symbol: string; cent: string; label: string }> = [
+	{ code: "usd", symbol: "$", cent: "¢", label: "USD ($)" },
+	{ code: "eur", symbol: "€", cent: "c", label: "EUR (€)" },
+	{ code: "gbp", symbol: "£", cent: "p", label: "GBP (£)" },
+	{ code: "cny", symbol: "¥", cent: "分", label: "CNY (¥)" },
+];
+
+export function currencySymbol(code: Currency | undefined): string {
+	return CURRENCIES.find((c) => c.code === code)?.symbol ?? "€";
+}
+
+/** Cent/fractional marker of a currency: $→¢, €→c, £→p, ¥→分. */
+export function currencyCent(code: Currency | undefined): string {
+	return CURRENCIES.find((c) => c.code === code)?.cent ?? "c";
+}
+
+/**
+ * Format an amount in the chosen currency, compact:
+ *   1.234  → "$1.23"      (≥ 1 unit: symbol + 2 decimals)
+ *   0.0315 → "3.2¢" (usd) / "3.2c" (eur) / "3.2p" (gbp) / "3.2分" (cny)
+ *   0.0004 → "0.4m¢"      (sub-cent: milli-units)
+ */
+export function formatCost(amount: number, code: Currency | undefined): string {
+	const sym = currencySymbol(code);
+	if (amount >= 1) return `${sym}${amount.toFixed(2)}`;
+	const cent = currencyCent(code);
+	if (amount >= 0.001) return `${(amount * 100).toFixed(1)}${cent}`;
+	return `${(amount * 1000).toFixed(1)}m${cent}`;
+}
+
+// ── Profile resolution ──────────────────────────────────────────────────────
+/**
+ * Find the cost profile that applies to a model, or null when none match.
+ *
+ * A profile is attached to a server (ServerConfig.costProfile): the power
+ * draw is a property of the machine, so all models served by that server
+ * share it. Resolution order:
+ *   1. server match (endpoint.serverId → ServerConfig.id)
+ *   2. host fallback: endpoint host equals the server's host (covers scans
+ *      whose serverId drifted from the config, e.g. cache boot)
+ *   3. per-profile `pattern`: substring match on the model id, for machines
+ *      that serve very different workloads (rare; kept for flexibility)
+ */
+export function resolveCostProfile(
+	model: { id?: string; endpoint?: { serverId?: string; host?: string } },
+	servers: ServerConfig[],
+): CostProfile | null {
+	if (!model?.id) return null;
+	const endpoint = model.endpoint;
+
+	// 1. Server id match (primary).
+	if (endpoint?.serverId) {
+		const srv = servers.find((s) => s.id === endpoint.serverId);
+		if (srv?.costProfile && srv.costProfile.kW > 0) return srv.costProfile;
+	}
+	// 2. Host fallback.
+	if (endpoint?.host) {
+		for (const srv of servers) {
+			if (srv.costProfile && srv.costProfile.kW > 0 && srv.host === endpoint.host) return srv.costProfile;
+		}
+	}
+	// 3. Model-id pattern (rare; only when explicitly set).
+	for (const srv of servers) {
+		const p = srv.costProfile;
+		if (p && p.kW > 0 && p.pattern && model.id.toLowerCase().includes(p.pattern.toLowerCase())) return p;
+	}
+	return null;
+}
+
+// ── Cost math ───────────────────────────────────────────────────────────────
+/** Energy cost (in the configured currency) of `ms` of inference. */
+export function energyCost(profile: CostProfile, ms: number): number {
+	if (!profile || ms <= 0) return 0;
+	const kwh = (ms / 3_600_000) * profile.kW;
+	return kwh * profile.ratePerKwh;
+}
+
+/** Format a profile for display, e.g. "0.15 kW @ 0.21 €/kWh". */
+export function formatProfile(p: CostProfile, code: Currency | undefined): string {
+	return `${p.kW} kW @ ${p.ratePerKwh} ${currencySymbol(code)}/kWh`;
+}

package/src/index.ts

@@ -23,6 +23,8 @@ import {
 	supportsThinkingBudget,
 } from "./core.ts";
 import { createLongTimeoutOpenAICompletionsStream } from "./runtime.ts";
+import { resolveCostProfile } from "./cost.ts";
+import { createCostTracker, type CostTracker } from "./cost-tracker.ts";
 
 export default function (pi: ExtensionAPI) {
 	const config = loadConfig();
@@ -77,6 +79,28 @@ export default function (pi: ExtensionAPI) {
 	let metricsApi: ReturnType<MetricsModule["createMetrics"]> | undefined;
 	let speedApi: ReturnType<SpeedModule["createSpeedTracker"]> | undefined;
 
+	/**
+	 * Energy-cost tracker. Created SYNCHRONOUSLY at factory time (not lazily
+	 * like the speed tracker) because cost must be measured inside sub-agent
+	 * processes too (`pi -p --no-session`), which never fire session_start:
+	 * the message_end hook needs it on the very first LLM call. Gating is done
+	 * via deps.enabled(), so toggling costTracking ON at runtime works.
+	 */
+	const costApi: CostTracker = createCostTracker({
+			isActive: () => extensionActive,
+			hasUI: ctxHasUI,
+			isOurs: (ctx) => {
+				try {
+					return ctx?.model?.provider === PROVIDER_NAME;
+				} catch {
+					return false;
+				}
+			},
+			enabled: () => config.settings.costTracking,
+			currency: () => config.settings.currency,
+			profileFor: (ctx) => costProfileFor(ctx),
+		});
+
 	// ── Internal state ────────────────────────────────────────────────────
 	let lastSignature: string | undefined;
 	let pollTimer: ReturnType<typeof setTimeout> | undefined;
@@ -102,6 +126,25 @@ export default function (pi: ExtensionAPI) {
 
 	const epKey = (host: string, port: number) => `${host}:${port}`;
 
+	/** Cost profile for the model a ctx is currently talking to (null = no estimation). */
+	function costProfileFor(ctx: ExtensionContext | undefined): import("./types.ts").CostProfile | null {
+		try {
+			const m = ctx?.model as { id?: string; provider?: string } | undefined;
+			if (!m?.id) return null;
+			const baseUrl = shared.modelBaseUrls.get(m.id);
+			const ep = shared.lastScan?.endpoints.find((e) => e.baseUrl === baseUrl);
+			return resolveCostProfile(
+				{
+					id: m.id,
+					endpoint: ep ? { serverId: ep.serverId, host: ep.host, port: ep.port } : undefined,
+				},
+				config.servers,
+			);
+		} catch {
+			return null;
+		}
+	}
+
 	function safeSystemPrompt(ctx: { getSystemPrompt?: () => string }): string | undefined {
 		try {
 			return ctx.getSystemPrompt?.();
@@ -309,9 +352,10 @@ export default function (pi: ExtensionAPI) {
 		if (config.settings.metricsEnabled) metricsApi.start(ctx);
 	}
 
-	// ── Live speed: per-call prefill timing (before id rewrite) ──────────
+	// ── Live speed + energy cost: per-call timing (before id rewrite) ─────
 	pi.on("before_provider_request", (_event, ctx) => {
 		speedApi?.onRequest(ctx, Date.now());
+		costApi?.onRequest(ctx, Date.now());
 		return undefined;
 	});
 
@@ -322,6 +366,21 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("message_end", (event, ctx) => {
 		speedApi?.onMessageEnd(ctx, event.message, Date.now());
+
+		// Inject the energy cost of THIS request into usage.cost.total so pi's
+		// native cost footer, session stats and any consumer reading usage
+		// (e.g. trimegisto agents, which accumulate usage.cost.total per
+		// message) see a realistic cost for local models. message_end fires
+		// before persistence, so mutating event.message in place is enough.
+		const msg = event.message as { role?: string; usage?: { cost?: { total?: number } } } | undefined;
+		if (msg?.role === "assistant" && config.settings.costTracking) {
+			const requestCost = costApi?.onMessageEnd(ctx, event.message, Date.now()) ?? 0;
+			if (requestCost > 0 && msg.usage?.cost) {
+				msg.usage.cost.total = (msg.usage.cost.total ?? 0) + requestCost;
+				return { message: event.message };
+			}
+		}
+		return undefined;
 	});
 
 	pi.on("turn_end", (_event, ctx) => {
@@ -530,10 +589,15 @@ export default function (pi: ExtensionAPI) {
 			w.warmer.warmupForModel(ctx.model, safeSystemPrompt(ctx), ctx.cwd);
 		}
 		currentThinkingLevel = ctx.thinkingLevel;
-		if (config.settings.metricsEnabled) {
-			await ensureSpeed().then((s) => s?.start(ctx));
-			const m = await ensureMetrics();
-			m.start(ctx);
+		try {
+			if (config.settings.metricsEnabled) {
+				await ensureSpeed().then((s) => s?.start(ctx));
+				const m = await ensureMetrics();
+				m.start(ctx);
+			}
+		} catch (err) {
+			// Tracking must never break session start (or spam the TUI with traces).
+			debugLog(`session_start tracking error ignored: ${err instanceof Error ? err.message : String(err)}`);
 		}
 		if (!ctxHasUI(ctx)) return;
 		void discoverAndRegister()
@@ -561,10 +625,16 @@ export default function (pi: ExtensionAPI) {
 			w.warmer.warmupForModel(event.model, safeSystemPrompt(ctx), ctx.cwd);
 		}
 		metricsApi?.resetForModelSwitch();
-		if (config.settings.metricsEnabled) {
-			await ensureSpeed().then((s) => s?.start(ctx));
-			const m = await ensureMetrics();
-			m.start(ctx);
+		costApi?.reset(ctx);
+		try {
+			if (config.settings.metricsEnabled) {
+				await ensureSpeed().then((s) => s?.start(ctx));
+				const m = await ensureMetrics();
+				m.start(ctx);
+			}
+		} catch (err) {
+			// Tracking must never break model switches (or spam the TUI with traces).
+			debugLog(`model_select tracking error ignored: ${err instanceof Error ? err.message : String(err)}`);
 		}
 	});
 

package/src/types.ts

@@ -2,6 +2,24 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
+export type Currency = "usd" | "eur" | "gbp" | "cny";
+
+/**
+ * Energy-cost profile for one machine: power draw during inference (kW) and
+ * electricity tariff (per kWh, in the configured currency). Cost of a request
+ * = (ms / 3_600_000) × kW × ratePerKwh. `host`/`pattern` refine matching when
+ * needed (they are optional; the serverId association is the primary key).
+ */
+export interface CostProfile {
+	label?: string;
+	/** Power draw during inference, in kilowatts. 0/absent = estimation off. */
+	kW: number;
+	/** Electricity tariff per kWh (in the configured currency). */
+	ratePerKwh: number;
+	host?: string;
+	pattern?: string;
+}
+
 /** One machine that may serve llama.cpp-family models on one or more ports. */
 export interface ServerConfig {
 	id: string;
@@ -11,6 +29,8 @@ export interface ServerConfig {
 	enabled: boolean;
 	probeDs4?: boolean;
 	apiKey?: string;
+	/** Energy-cost profile for this machine (kW + tariff). */
+	costProfile?: CostProfile;
 }
 
 /** Thinking budget (tokens) per pi thinking level, llama.cpp-style. */
@@ -41,6 +61,10 @@ export interface SettingsConfig {
 	metricsPollMs: number;
 	includeUnloadedRouterModels: boolean;
 	showBadgesInNames: boolean;
+	/** Display currency for energy costs (default: eur). */
+	currency: Currency;
+	/** Whether the footer shows accumulated energy cost (default: true). */
+	costTracking: boolean;
 }
 
 export interface InfraConfig {

package/src/ui.ts

@@ -19,6 +19,7 @@ import type {
 	ThinkingBudgets,
 } from "./types.ts";
 import { fetchModelsFromEndpoint, scanLocalServers } from "./scan.ts";
+import { CURRENCIES, formatProfile, currencySymbol } from "./cost.ts";
 
 // ── Small UI helpers ───────────────────────────────────────────────────────
 async function selectFrom<T>(
@@ -221,6 +222,11 @@ export async function showConfigMenu(ctx: ExtensionContext, deps: UiDeps): Promi
 			{ value: "models", label: "📋 Discovered models", description: `${shared.registeredCount} currently registered` },
 			{ value: "test", label: "🧪 Test connectivity", description: "probe every endpoint and show latency" },
 			{ value: "budgets", label: "🧠 Thinking budgets", description: `${budgetCount} model(s) with budgets` },
+			{
+				value: "cost",
+				label: `💰 Energy cost: ${config.settings.costTracking ? "ON" : "OFF"}`,
+				description: `currency ${currencySymbol(config.settings.currency)} · ${config.servers.filter((s) => s.costProfile && s.costProfile.kW > 0).length} server(s) with kW`,
+			},
 			{
 				value: "metrics",
 				label: `📈 Live speed & metrics: ${config.settings.metricsEnabled ? "ON" : "OFF"}`,
@@ -248,6 +254,9 @@ export async function showConfigMenu(ctx: ExtensionContext, deps: UiDeps): Promi
 			case "budgets":
 				await showThinkingBudgetsMenu(ctx, deps);
 				break;
+			case "cost":
+				await showCostMenu(ctx, deps);
+				break;
 			case "metrics":
 				await showMetricsMenu(ctx, deps);
 				break;
@@ -619,6 +628,105 @@ async function showMetricsMenu(ctx: ExtensionContext, deps: UiDeps): Promise<voi
 	}
 }
 
+// ── Energy-cost menu ────────────────────────────────────────────────────
+async function showCostMenu(ctx: ExtensionContext, deps: UiDeps): Promise<void> {
+	const config = shared.activeConfig!;
+	for (;;) {
+		const withKw = config.servers.filter((s) => s.costProfile && s.costProfile.kW > 0);
+		const action = await selectFrom(ctx, `💰 Energy cost (${currencySymbol(config.settings.currency)})`, [
+			{
+				value: "toggle",
+				label: config.settings.costTracking ? "🔴 Disable cost tracking" : "🟢 Enable cost tracking",
+				description: "accumulate electricity cost of local inference (footer + usage.cost)",
+			},
+			{
+				value: "currency",
+				label: `💱 Currency: ${CURRENCIES.find((c) => c.code === config.settings.currency)?.label ?? config.settings.currency}`,
+				description: "display unit for costs and tariffs",
+			},
+			{
+				value: "servers",
+				label: "🖥️ Per-server kW / tariff",
+				description: `${withKw.length} server(s) configured`,
+			},
+			{ value: "__back", label: "← Back", description: "" },
+		]);
+		if (action === undefined || action === "__back") return;
+
+		if (action === "toggle") {
+			config.settings.costTracking = !config.settings.costTracking;
+			saveConfig(config);
+			deps.updateStatusFooter(ctx);
+			ctx.ui.notify(`💰 Cost tracking: ${config.settings.costTracking ? "ON" : "OFF"}`, "info");
+		}
+		else if (action === "currency") {
+			const cur = await selectFrom(ctx, "💱 Select currency", CURRENCIES.map((c) => ({ value: c.code, label: c.label })));
+			if (cur) {
+				config.settings.currency = cur;
+				saveConfig(config);
+				ctx.ui.notify(`💱 Currency: ${CURRENCIES.find((c) => c.code === cur)?.label}`, "info");
+			}
+		}
+		else if (action === "servers") {
+			await showServerCostMenu(ctx, config);
+		}
+	}
+}
+
+async function showServerCostMenu(ctx: ExtensionContext, config: NonNullable<typeof shared.activeConfig>): Promise<void> {
+	for (;;) {
+		const items = config.servers.map((srv) => ({
+			value: srv.id,
+			label: `${srv.costProfile?.kW ? "💰" : "·"} ${serverLabel(srv)}`,
+			description: srv.costProfile?.kW ? formatProfile(srv.costProfile, config.settings.currency) : `${srv.host} — no kW set`,
+		}));
+		items.push({ value: "__back", label: "← Back", description: "" });
+		const picked = await selectFrom(ctx, "💰 Per-server energy cost — select a machine", items);
+		if (!picked || picked === "__back") return;
+		const srv = config.servers.find((s) => s.id === picked);
+		if (!srv) return;
+
+		const p = srv.costProfile;
+		const sub = await selectFrom(ctx, `💰 ${serverLabel(srv)} (${srv.host})`, [
+			{ value: "kW", label: p?.kW ? `⚡ Power draw: ${p.kW} kW` : "⚡ Set power draw (kW)", description: "W consumed during inference (e.g. 0.15 for 150 W)" },
+			{ value: "rate", label: p?.ratePerKwh ? `🧾 Tariff: ${p.ratePerKwh} ${currencySymbol(config.settings.currency)}/kWh` : `🧾 Set tariff (${currencySymbol(config.settings.currency)}/kWh)`, description: "electricity price per kWh" },
+			{ value: "label", label: p?.label ? `🏷️ Label: ${p.label}` : "🏷️ Set label", description: "optional, shown in menus" },
+			...(p?.kW ? [{ value: "clear", label: "🗑️ Remove cost profile", description: "stop estimating cost for this machine" }] : []),
+			{ value: "__back", label: "← Back", description: "" },
+		]);
+		if (!sub || sub === "__back") continue;
+
+		if (sub === "kW") {
+			const raw = await ctx.ui.input("⚡ Power draw in kW (e.g. 0.15 = 150 W)", p?.kW ? String(p.kW) : "0.15");
+			const kW = parseFloat(raw ?? "");
+			if (isNaN(kW) || kW <= 0) { ctx.ui.notify("❌ Invalid kW", "error"); continue; }
+			srv.costProfile = { ...(srv.costProfile ?? { ratePerKwh: 0.2 }), kW };
+			saveConfig(config);
+			ctx.ui.notify(`⚡ ${serverLabel(srv)}: ${kW} kW`, "info");
+		}
+		else if (sub === "rate") {
+			const raw = await ctx.ui.input(`🧾 Tariff in ${currencySymbol(config.settings.currency)}/kWh (e.g. 0.21)`, p?.ratePerKwh ? String(p.ratePerKwh) : "0.21");
+			const rate = parseFloat(raw ?? "");
+			if (isNaN(rate) || rate <= 0) { ctx.ui.notify("❌ Invalid tariff", "error"); continue; }
+			srv.costProfile = { ...(srv.costProfile ?? { kW: 0.15 }), ratePerKwh: rate };
+			saveConfig(config);
+			ctx.ui.notify(`🧾 ${serverLabel(srv)}: ${rate} ${currencySymbol(config.settings.currency)}/kWh`, "info");
+		}
+		else if (sub === "label") {
+			const raw = await ctx.ui.input("🏷️ Label", p?.label ?? "");
+			if (raw !== undefined) {
+				srv.costProfile = { ...(srv.costProfile ?? { kW: 0.15, ratePerKwh: 0.21 }), label: raw.trim() || undefined };
+				saveConfig(config);
+			}
+		}
+		else if (sub === "clear") {
+			delete srv.costProfile;
+			saveConfig(config);
+			ctx.ui.notify(`🗑️ ${serverLabel(srv)}: cost profile removed`, "info");
+		}
+	}
+}
+
 // ── Settings menu ──────────────────────────────────────────────────────────
 async function showSettingsMenu(ctx: ExtensionContext, deps: UiDeps): Promise<void> {
 	const config = shared.activeConfig!;