@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.34

package/plugins/session-metrics/attribution.mjs

@@ -0,0 +1,30 @@
+// Charge model calls a plugin makes for a session (review, memory, session cards,
+// /doctor) to that session's cost ledger without putting the session on the wire:
+// a `sessionId` request option also drives session-log delivery, provider cache
+// affinity and agent-only prompt shaping, which these calls must not trigger. The
+// ledger middleware runs when the caller iterates the stream, so it reads the charge
+// from the caller's async context.
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const charges = new AsyncLocalStorage();
+
+/** Run `fn` with its model calls charged to `sessionId` under `purpose`; no session runs it uncharged. */
+export function chargeTo(sessionId, purpose, fn) {
+  return sessionId ? charges.run({ sessionId, purpose }, fn) : fn();
+}
+
+/** The charge of the model call being iterated, if any. */
+export function currentCharge() {
+  return charges.getStore();
+}
+
+/** Charge a live child request to its ancestors once, with the original session first. */
+export function metricRecipients(agents, sessionId) {
+  const recipients = new Set([sessionId]);
+  let child = agents?.get(sessionId);
+  while (child?.session.header.origin === 'subagent' && child.session.header.parentSession && !recipients.has(child.session.header.parentSession)) {
+    recipients.add(child.session.header.parentSession);
+    child = agents.get(child.session.header.parentSession);
+  }
+  return recipients;
+}

package/plugins/session-metrics/balance.mjs

@@ -0,0 +1,81 @@
+import { OPENROUTER_API, parseOpenRouterCredits, parseOpenRouterKeyRemaining } from '../providers/openrouter-account.mjs';
+
+export { parseOpenRouterCredits, parseOpenRouterKeyRemaining };
+
+// Remaining provider balance, refreshed on a long cache. DeepSeek's response
+// also carries the trusted clock: its `Date` header anchors peak/off-peak pricing
+// without a second network call. OpenRouter has no peak window. Its account
+// credits (`/credits`) are documented as management-only but are served to
+// inference keys too; a key refused them falls back to its own remaining limit (`/key`).
+const SOURCES = {
+  'deepseek-official': { env: 'DEEPSEEK_API_KEY', clock: true, requests: ({ key }) => [{ url: 'https://api.deepseek.com/user/balance', key, parse: body => parseBalance(body) }] },
+  openrouter: { env: 'OPENROUTER_API_KEY', managementEnv: 'OPENROUTER_MANAGEMENT_KEY', clock: false, requests: ({ key, managementKey }) => [
+    { url: `${OPENROUTER_API}/credits`, key: managementKey ?? key, parse: parseOpenRouterCredits },
+    { url: `${OPENROUTER_API}/key`, key, parse: parseOpenRouterKeyRemaining },
+  ] },
+};
+export const BALANCE_PROVIDERS = Object.freeze(Object.keys(SOURCES));
+const CACHE_MS = 5 * 60 * 1000;
+const RETRY_MS = 60 * 1000;
+const snapshots = new Map();
+let clock = { anchor: null, skewMs: 0 };
+const snapshotOf = provider => snapshots.get(provider) ?? { balance: null, fetchedAt: 0, pending: false };
+
+/** Best-effort positive USD balance from a `/user/balance` body. */
+export function parseBalance(body) {
+  const infos = Array.isArray(body?.balance_infos) ? body.balance_infos : [];
+  const usd = infos.find(info => String(info?.currency ?? '').toUpperCase() === 'USD') ?? infos[0];
+  const total = Number(usd?.total_balance);
+  if (!Number.isFinite(total) || total < 0) return null;
+  return body?.is_available === false ? null : total;
+}
+
+export function balanceNow(provider = 'deepseek-official') { return snapshotOf(provider).balance; }
+/** Clock anchored to the last DeepSeek balance response's `Date` header, else the local one. */
+export function trustedNow() {
+  const local = Date.now();
+  return clock.anchor === null ? local : local + clock.skewMs;
+}
+
+/** Refresh one provider at most once per cache window; never throws into the render path. */
+export async function refreshBalance(options = {}) {
+  const provider = options.provider ?? 'deepseek-official';
+  const source = SOURCES[provider];
+  if (!source) return null;
+  const snapshot = snapshotOf(provider);
+  const key = options.key ?? process.env[source.env];
+  const managementKey = options.managementKey ?? (source.managementEnv ? process.env[source.managementEnv] : undefined);
+  const requests = source.requests({ key, managementKey }).filter(request => request.key);
+  const mode = managementKey ? 'management' : 'key';
+  const now = Date.now();
+  // A newly added (or removed) management key changes the source; it is read at once.
+  if (snapshot.pending || snapshot.mode === mode && now - snapshot.fetchedAt < CACHE_MS) return snapshot.balance;
+  const retrySoon = () => Date.now() - (CACHE_MS - RETRY_MS);
+  if (requests.length === 0) { snapshots.set(provider, { ...snapshot, mode, fetchedAt: retrySoon(), pending: false }); return snapshot.balance; }
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== 'function') return snapshot.balance;
+  snapshots.set(provider, { ...snapshot, pending: true });
+  try {
+    let response, body, request;
+    for (request of requests) {
+      response = await fetchImpl(request.url, { headers: { Authorization: `Bearer ${request.key}`, Accept: 'application/json' } });
+      body = await response.json();
+      // A key refused this reading falls through to the next source.
+      if (response.ok || (response.status !== 401 && response.status !== 403)) break;
+    }
+    const header = source.clock ? response.headers?.get?.('date') : null;
+    const anchor = header ? Date.parse(header) : NaN;
+    const parsed = response.ok ? request.parse(body) : null;
+    if (Number.isFinite(anchor)) clock = { anchor, skewMs: anchor - Date.now() };
+    snapshots.set(provider, {
+      mode,
+      balance: parsed === null && response.ok ? null : parsed ?? snapshot.balance,
+      fetchedAt: parsed === null ? retrySoon() : Date.now(),
+      pending: false,
+    });
+  } catch {
+    // A transient failure keeps the last known balance and retries sooner.
+    snapshots.set(provider, { ...snapshot, mode, fetchedAt: retrySoon(), pending: false });
+  }
+  return snapshotOf(provider).balance;
+}

package/plugins/session-metrics/desktop-client.mjs

@@ -0,0 +1,62 @@
+globalThis.__ModuleLoader__.load({
+  id: '@toddzheng024/dscode-desktop',
+  factory: require => {
+    const { createElement: h, useState, useEffect, useRef } = require('react');
+    const money = (cost, partial = false) => cost === null || partial && cost === 0 ? 'Unknown' : `$${cost.toFixed(4)}${partial ? '+' : ''}`;
+    const percent = value => value === null ? 'Unknown' : `${value.toFixed(1)}%`;
+    const speed = value => value === null ? 'Unknown' : `${value.toFixed(1)} tokens/s`;
+    const control = { padding: '7px 10px', border: '1px solid #8886', borderRadius: 6, background: 'transparent', color: 'inherit', font: 'inherit' };
+    function Usage({ execute }) {
+      const [state, setState] = useState(null), [error, setError] = useState('');
+      const active = useRef(false), alive = useRef(true);
+      const refresh = async () => {
+        if (active.current) return; active.current = true;
+        try { const next = await execute(); if (alive.current) { setState(next); setError(''); } }
+        catch (error) { if (alive.current) { setState(null); setError(error.message); } }
+        finally { active.current = false; }
+      };
+      useEffect(() => { alive.current = true; void refresh(); const timer = setInterval(refresh, 1000);
+        return () => { alive.current = false; clearInterval(timer); }; }, []);
+      const fact = (label, value) => h('div', { key: label, style: { padding: 10, border: '1px solid #8884', borderRadius: 6 } },
+        h('dt', { style: { fontSize: 12, marginBottom: 5 } }, label), h('dd', { style: { margin: 0, fontVariantNumeric: 'tabular-nums' } }, value));
+      return h('section', { 'aria-label': 'DSCODE session usage', style: { padding: 16, height: '100%', overflow: 'auto', boxSizing: 'border-box' } },
+        h('h2', { style: { marginTop: 0 } }, 'Session usage'),
+        h('p', { style: { fontSize: 12 } }, 'Recorded model usage for this DSCODE session, including attributed child and background calls. Costs are estimates, not an invoice.'),
+        h('button', { type: 'button', style: control, onClick: refresh }, 'Refresh usage'),
+        error && h('p', { role: 'alert' }, error),
+        !state && !error && h('p', { role: 'status' }, 'Loading usage…'),
+        state && h('div', null,
+          h('p', { style: { overflowWrap: 'anywhere', fontSize: 12 } }, `${state.provider} / ${state.model}`),
+          h('p', { role: 'status' }, state.requestActive ? 'Model request in progress' : 'No active model request'),
+          h('dl', { style: { display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(140px, 1fr))', gap: 8 } },
+            fact('Recorded cost', money(state.cost, state.partial)), fact('Model calls', state.calls ?? 'Unknown'),
+            fact('Pending calls', state.pending ?? 'Unknown'), fact('Context estimate', percent(state.contextPercent)),
+            fact('Input cache share', percent(state.cachePercent)), fact('Smoothed request speed', speed(state.currentTps)),
+            fact('Session average speed', speed(state.averageTps)),
+            state.balance !== null && fact('Cached provider balance', money(state.balance)),
+            state.subscription && fact('Cached subscription usage', state.subscription),
+            state.budget && fact('Configured cost budget', `${money(state.budget.spent)} / ${money(state.budget.limit)} · ${state.budget.state}`)),
+          h('p', { style: { fontSize: 12 } }, 'Unknown means a reading or price is unavailable. + marks a partial cost. Pending calls have not settled. Cached account figures may lag the provider.'),
+          h('h3', null, 'Cost by turn'),
+          state.turns.length ? h('table', { style: { width: '100%', borderCollapse: 'collapse', textAlign: 'left', fontVariantNumeric: 'tabular-nums' } },
+            h('thead', null, h('tr', null, ...['Turn', 'Calls', 'Cost'].map(label => h('th', { key: label, style: { padding: 6 } }, label)))),
+            h('tbody', null, ...state.turns.map(row => h('tr', { key: row.turn }, h('td', { style: { padding: 6 } }, row.turn), h('td', { style: { padding: 6 } }, row.calls), h('td', { style: { padding: 6 } }, money(row.cost, row.partial))))))
+            : h('p', null, 'No turn costs recorded yet.'),
+          state.totalTurns > 50 && h('p', { style: { fontSize: 12 } }, `Showing the latest 50 of ${state.totalTurns} turns.`),
+          h('p', { style: { fontSize: 12 } }, `Cost outside recorded turn windows: ${money(state.unattributed, state.unattributedPartial)}`),
+          h('p', { style: { fontSize: 12 } }, 'Refreshes once per second while visible. Reading usage does not start the agent or request new account data.')));
+    }
+    function UsagePane({ sessionId, execute, useTabInfo }) { const { tab } = useTabInfo(); return tab.visible ? h(Usage, { key: sessionId, execute }) : null; }
+    const id = '@toddzheng024/dscode-metrics-desktop';
+    return { inject: ['slots', 'sidebarRightTabs', 'connection'], apply(ctx) {
+      ctx.effect(() => ctx.sidebarRightTabs.register({ id, kind: 'dscode-metrics', multiple: false, title: () => 'Session usage',
+        guide: [{ id: 'open', order: 33, title: () => 'Session usage', description: () => 'Inspect DSCODE cost, context, cache and request speed.' }] }), 'dscode-metrics.type');
+      ctx.effect(() => ctx.slots.inject('sidebar.right.pane.tab', () => ctx.slots.register({ name: 'sidebar.right.pane.tab', key: id,
+        inject: sessionId => ({ sessionId, execute: async () => {
+          const response = await ctx.connection.rpc.call('/api', 'dscode-metrics', { action: 'status', sessionId });
+          if (!response.ok) throw Error(response.error.message); return response.value;
+        } }),
+      }, UsagePane)), 'dscode-metrics.body');
+    } };
+  },
+});

package/plugins/session-metrics/desktop-host.mjs

@@ -0,0 +1,46 @@
+import { clientRequestSchema } from '@deepseek-ai/dsh-client-connection';
+import { footerFor, goFooterFact, grokFooterFact } from './view.mjs';
+import { balanceNow } from './balance.mjs';
+import { canonicalProvider } from '../providers/catalog.mjs';
+import { grokSubscriptionNow } from '../grok/billing.mjs';
+import { goUsageNow } from '../opencode-go/usage.mjs';
+
+const finite = value => Number.isFinite(value) ? value : null;
+/** Explicit metadata projection: no raw ledger, history, prompts or credentials. */
+export function desktopMetricsRequest(ctx, payload) {
+  if (payload?.action !== 'status' || typeof payload.sessionId !== 'string') throw Error('Choose a DSCODE session to view usage.');
+  const agent = ctx.agents.get(payload.sessionId);
+  if (!agent || ctx.agentPresets.composedPreset(agent.ctx) !== 'dscode') throw Error('Usage is available for an open DSCODE session.');
+  const route = agent.session.requestHeader()?.config ?? agent.options;
+  const provider = canonicalProvider(route.provider);
+  return footerFor(agent.id, {}, 0, provider, 'en', (summary, context, _columns, rates) => ({
+    sessionId: agent.id, provider: route.provider, model: route.model,
+    cost: finite(summary.cost), partial: summary.unknown === true, calls: finite(summary.calls), pending: finite(summary.pending),
+    contextPercent: finite(context), cachePercent: finite(summary.cache),
+    currentTps: finite(rates.current), averageTps: finite(rates.average), requestActive: rates.active === true,
+    balance: finite(balanceNow(provider)),
+    subscription: provider === 'grok' ? grokFooterFact(grokSubscriptionNow()) : provider === 'opencode-go' ? goFooterFact(goUsageNow()) : null,
+    turns: (summary.turns ?? []).slice(-50).reverse().map(turn => ({ turn: turn.turn, cost: finite(turn.cost), calls: turn.calls, partial: turn.unknown })),
+    totalTurns: summary.turns?.length ?? 0, unattributed: finite(summary.unattributed),
+    unattributedPartial: summary.unattributedUnknown === true,
+    budget: summary.budget ? { limit: finite(summary.budget.limit), spent: finite(summary.budget.spent), state: summary.budget.state } : null,
+    updatedAt: new Date().toISOString(),
+  }));
+}
+
+export const inject = ['agents', 'agentPresets', 'connection'];
+export function apply(ctx) {
+  ctx.effect(() => ctx.connection.fetch.register({ path: '/api/dscode-metrics', methods: ['POST'], requestBody: 'buffered',
+    fetch: async request => {
+      let body;
+      try { body = await request.json(); } catch { return new Response('Invalid JSON', { status: 400 }); }
+      const parsed = clientRequestSchema.safeParse(body);
+      if (!parsed.success || parsed.data.method !== 'dscode-metrics') return new Response('Invalid usage request', { status: 400 });
+      const { rpcId, payload } = parsed.data;
+      let result;
+      try { result = { ok: true, value: desktopMetricsRequest(ctx, payload) }; }
+      catch (error) { result = { ok: false, error: { code: 'dscode-metrics', message: error.message, details: {} } }; }
+      return Response.json({ type: 'server-response', rpcId, result }, { headers: { 'Cache-Control': 'no-store' } });
+    },
+  }), 'dscode metrics rpc');
+}

package/plugins/session-metrics/index.mjs

@@ -0,0 +1,97 @@
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+import { randomUUID } from 'node:crypto';
+import { appendMetric } from './store.mjs';
+import { estimateCost, priceVersionFor } from './pricing.mjs';
+import { setMetricSource } from './view.mjs';
+import { BALANCE_PROVIDERS, refreshBalance } from './balance.mjs';
+import { refreshOpenRouterModels } from '../openrouter/models.mjs';
+import { REPLAY_KIND } from '../openrouter/wire.mjs';
+import { providerSpec } from '../providers/catalog.mjs';
+import { createSmoothedRate } from './rate.mjs';
+import { currentCharge, metricRecipients } from './attribution.mjs';
+
+// Chunks that carry generated output; the first one marks time to first token.
+const OUTPUT_CHUNKS = new Set(['text-delta', 'reasoning-delta', 'tool-call-delta']);
+export const name = 'dscode-session-metrics';
+export const inject = ['llm', 'agents', 'tokenMeter', 'sessionProjections'];
+export function apply(ctx) {
+  const snapshots = new WeakMap();
+  const smoothedRate = createSmoothedRate();
+  const activeRequests = new WeakMap();
+  ctx.effect(() => setMetricSource(id => {
+    const agent = ctx.agents.get(id);
+    if (!agent) return undefined;
+    const session = agent.session;
+    const cached = snapshots.get(session);
+    const requestActive = (activeRequests.get(session) ?? 0) > 0;
+    if (cached?.seq === session.seq) return { ...cached.value, currentTps: smoothedRate.get(session), requestActive };
+    const state = ctx.sessionProjections.stateOf(session, 'contextPressure');
+    const measurement = ctx.tokenMeter.measure(session);
+    const value = { events: session.snapshotEvents(), used: measurement.totalTokens, capacity: state?.contextWindow };
+    snapshots.set(session, { seq: session.seq, value });
+    return { ...value, currentTps: smoothedRate.get(session), requestActive };
+  }));
+  const home = resolveDshHome();
+  // Remaining balance is best-effort decoration: resolve the key lazily (never
+  // inject the credentials service, so a missing one cannot fail startup), keep
+  // the request on a five-minute cache, and never let it reach the render path.
+  const credentials = ctx.get?.('credentials');
+  const refresh = () => Promise.all(BALANCE_PROVIDERS.map(async provider => {
+    try {
+      const spec = providerSpec(provider);
+      const secret = async ref => {
+        if (!ref) return undefined;
+        const resolved = await credentials?.resolve?.(ref);
+        return (typeof resolved === 'string' ? resolved : resolved?.value) || process.env[ref] || undefined;
+      };
+      // An OpenRouter management key, when stored, turns the balance into the account's credits.
+      const [key, managementKey] = await Promise.all([secret(spec.credentialRef), secret(spec.managementRef)]);
+      await refreshBalance({ provider, key, managementKey });
+      // The listing needs no key, but only a user with an OpenRouter key uses it; the adapter waits for it before its first call.
+      if (provider === 'openrouter' && key) await refreshOpenRouterModels({ home });
+    } catch {
+      /* balance stays unknown */
+    }
+  }));
+  refresh();
+  const balanceTimer = setInterval(refresh, 5 * 60 * 1000);
+  if (typeof balanceTimer.unref === 'function') balanceTimer.unref();
+  ctx.effect(() => () => clearInterval(balanceTimer));
+  const record = (id, entry) => { try { appendMetric(home, id, entry); } catch { ctx.logger.warn('Session cost telemetry could not be saved.'); } };
+  ctx.on('llm/stream', async function* (options, next) {
+    // Plugin calls made for a session carry no sessionId on the wire; they are charged through the async context.
+    const charge = options.sessionId ? undefined : currentCharge();
+    const sessionId = options.sessionId ?? charge?.sessionId;
+    if (!sessionId || !home) { yield* next(); return; }
+    const id = randomUUID(), time = Date.now();
+    const purpose = options.purpose ?? charge?.purpose ?? 'agent';
+    const recipients = metricRecipients(ctx.agents, sessionId);
+    const save = entry => { for (const recipient of recipients) record(recipient, { ...entry, sessionId }); };
+    save({ kind: 'start', id, time, provider: options.provider, model: options.model, purpose });
+    let usage, firstTokenTime, billed;
+    const liveSession = purpose === 'agent' ? ctx.agents.get(sessionId)?.session : undefined;
+    const settleRate = liveSession
+      ? smoothedRate.begin(liveSession, JSON.stringify([options.provider, options.model, options.reasoningEffort ?? null]))
+      : undefined;
+    if (liveSession) activeRequests.set(liveSession, (activeRequests.get(liveSession) ?? 0) + 1);
+    let completed = false;
+    try {
+      for await (const chunk of next()) {
+        if (chunk.type === 'usage') usage = chunk.usage;
+        else if (firstTokenTime === undefined && OUTPUT_CHUNKS.has(chunk.type)) firstTokenTime = Date.now();
+        // OpenRouter reports what it charged; the finish of its response carries it.
+        if (chunk.type === 'finish' && chunk.replayState?.response?.kind === REPLAY_KIND && Number.isFinite(chunk.replayState.response.cost)) billed = chunk.replayState.response.cost;
+        yield chunk;
+      }
+      completed = true;
+    } finally {
+      const endTime = Date.now();
+      if (liveSession) activeRequests.set(liveSession, (activeRequests.get(liveSession) ?? 1) - 1);
+      if (completed) settleRate?.({ start: time, end: endTime, outputTokens: usage?.outputTokens });
+      // `time` stays the start (it prices the call); `endTime` and `firstTokenTime` time it.
+      save({ kind: 'end', id, time, endTime, ...(firstTokenTime === undefined ? {} : { firstTokenTime }), usage: usage ?? null, ...(billed === undefined
+        ? { cost: estimateCost(options.provider, options.model, usage, time), priceVersion: priceVersionFor(options.provider, options.model) }
+        : { cost: billed, priceVersion: 'openrouter-billed' }) });
+    }
+  });
+}

package/plugins/session-metrics/pricing.mjs

@@ -0,0 +1,84 @@
+import { openRouterPriceVersion, openRouterRates } from '../openrouter/models.mjs';
+import { isOpenRouterRoute } from '../providers/catalog.mjs';
+
+// USD per million tokens. Snapshot of the official page opened 2026-09-11.
+// https://api-docs.deepseek.com/quick_start/pricing/
+export const PRICE_SOURCE = 'https://api-docs.deepseek.com/quick_start/pricing/';
+export const PRICE_VERSION = 'deepseek-2026-09-11';
+// OpenRouter calls carry their billed cost; an unbilled one is estimated from the live model listing (plugins/openrouter/models.mjs).
+// Until that table loads, the DeepSeek models keep these list prices from the pinned
+// pi-ai 0.85.1 catalog. OpenRouter bills no peak window. [cache read, input, output].
+export const OPENROUTER_PRICE_VERSION = 'openrouter-pi-ai-0.85.1';
+const OPENROUTER_PRICES = {
+  'deepseek/deepseek-v4-flash': [0.017052, 0.08526, 0.17052],
+  'deepseek/deepseek-v4-pro': [0.074196, 0.890358, 1.780716],
+  'deepseek/deepseek-v4-flash-vision-exp': [0.007, 0.22, 0.66],
+};
+
+/** The price table a ledger entry for this route is estimated with. */
+export function priceVersionFor(provider, model) {
+  if (!isOpenRouterRoute(provider)) return PRICE_VERSION;
+  return model !== undefined && openRouterRates(model) !== undefined ? openRouterPriceVersion() : OPENROUTER_PRICE_VERSION;
+}
+
+const promptTokens = usage => (usage.inputTokens ?? 0) + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+
+export function estimateCost(provider, model, usage, time) {
+  if (!usage || !Number.isFinite(time)) return null;
+  if (isOpenRouterRoute(provider)) {
+    // A model that lists no cache-read or cache-write price bills that input at the input rate.
+    const live = openRouterRates(model, promptTokens(usage));
+    if (live) return charge(usage, [live.cacheRead ?? live.input, live.input, live.output], live.cacheWrite ?? live.input);
+    return OPENROUTER_PRICES[model] ? charge(usage, OPENROUTER_PRICES[model]) : null;
+  }
+  if (provider !== 'deepseek-official') return null;
+  const rates = deepSeekRates(model, time);
+  if (!rates) return null;
+  const cost = charge(usage, rates);
+  return cost === null ? null : cost * (isPeak(time) ? 2 : 1);
+}
+
+/** DeepSeek list prices [cache read, input, output] at `time`, before the peak multiplier. */
+function deepSeekRates(model, time) {
+  // Earlier requests require an older price table; never back-price them at today's rate.
+  if (time < Date.UTC(2026, 8, 11)) return undefined;
+  const flash = ['deepseek-flash', 'deepseek-v4-flash', 'deepseek-v4-flash-vision-exp'].includes(model)
+    || model === 'deepseek-v4-pro' && time >= Date.UTC(2026, 8, 14, 4);
+  if (!flash && model !== 'deepseek-v4-pro') return undefined;
+  return flash ? [0.003, 0.15, 0.6] : [0.022, 0.66, 1.98];
+}
+
+/**
+ * Cache-read price over input price for a route, or undefined when the route is unpriced.
+ * A model that lists no cache-read price bills cached input at the input rate (1).
+ */
+export function cacheReadRatio(provider, model, time = Date.now()) {
+  let rates;
+  if (isOpenRouterRoute(provider)) {
+    const live = openRouterRates(model);
+    rates = live ? [live.cacheRead ?? live.input, live.input] : OPENROUTER_PRICES[model];
+  } else if (provider === 'deepseek-official') rates = deepSeekRates(model, time);
+  return rates && rates[1] > 0 ? rates[0] / rates[1] : undefined;
+}
+
+/** Cost in USD; cache writes need a write price, or the call stays unpriced. */
+function charge(usage, [read, input, output], write) {
+  const values = [usage.inputTokens, usage.outputTokens, usage.cacheReadTokens ?? 0, usage.cacheWriteTokens ?? 0];
+  if (!values.every(n => Number.isFinite(n) && n >= 0) || values[3] !== 0 && !Number.isFinite(write)) return null;
+  return (values[0] * input + values[1] * output + values[2] * read + values[3] * (write ?? 0)) / 1e6;
+}
+
+/**
+ * Peak/off-peak window in UTC: weekdays 01:00-04:00 and 06:00-10:00.
+ * @param time - Unix ms timestamp.
+ * @returns Whether that instant bills at the peak rate.
+ */
+export function isPeak(time) {
+  const date = new Date(time), day = date.getUTCDay(), hour = date.getUTCHours();
+  return day >= 1 && day <= 5 && (hour >= 1 && hour < 4 || hour >= 6 && hour < 10);
+}
+
+/** Footer marker for the billing window: fire for peak, snowflake for off-peak. */
+export function peakEmoji(time) {
+  return isPeak(time) ? '🔥' : '❄️';
+}

package/plugins/session-metrics/rate.mjs

@@ -0,0 +1,59 @@
+// Each valid completed request halves every older sample's weight.
+const DECAY = 0.5;
+
+/**
+ * Normalized exponential average of per-request TPS, from final API usage.
+ * New samples have weight 1; existing weights multiply by DECAY. Normalizing
+ * the startup weights keeps newer requests more influential from sample two.
+ * Idle time and unusable samples do not age the history.
+ */
+export function createSmoothedRate() {
+  const sessions = new WeakMap();
+  return {
+    begin(session, route) {
+      let state = sessions.get(session);
+      if (!state || state.route !== route) {
+        state = { route, weightedRate: 0, weight: 0 };
+        sessions.set(session, state);
+      }
+      // A late completion from an older model must not contaminate the new one.
+      return ({ start, end, outputTokens }) => {
+        if (sessions.get(session) !== state || !Number.isFinite(start) || !Number.isFinite(end)
+          || end <= start || !Number.isFinite(outputTokens) || outputTokens < 0) return;
+        const rate = outputTokens / ((end - start) / 1000);
+        if (!Number.isFinite(rate)) return;
+        state.weightedRate = state.weightedRate * DECAY + rate;
+        state.weight = state.weight * DECAY + 1;
+      };
+    },
+    get(session) {
+      const state = sessions.get(session);
+      return state?.weight > 0 ? state.weightedRate / state.weight : null;
+    },
+  };
+}
+
+// Output tokens per second of LLM call time: every settled assistant message's
+// exact output tokens over the time from its step's request start to its
+// settlement (first-token latency included, tool execution and user idle time
+// excluded). Only the root agent's own messages count, so parallel children do
+// not inflate the rate; an in-flight call contributes nothing until it settles.
+export function sessionAverageTps(events) {
+  const starts = new Map();
+  let callMs = 0, outputTokens = 0, known = 0, unknown = false;
+  for (const event of events) {
+    // Build the key only for the two event types that use it: the array carries every event.
+    if (event.type === 'step/start') starts.set(`${event.data?.turn}:${event.data?.step}`, event.time);
+    else if (event.type === 'assistant/message') {
+      const key = `${event.data?.turn}:${event.data?.step}`;
+      const start = starts.get(key);
+      starts.delete(key);
+      const output = event.data?.usage?.outputTokens;
+      if (start === undefined || !Number.isFinite(output) || output < 0) { unknown = true; continue; }
+      callMs += Math.max(0, event.time - start);
+      outputTokens += output;
+      known++;
+    }
+  }
+  return callMs > 0 && known > 0 && !unknown ? outputTokens / (callMs / 1000) : null;
+}

package/plugins/session-metrics/store.mjs

@@ -0,0 +1,75 @@
+import { appendFileSync, closeSync, mkdirSync, openSync, readFileSync, readSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+// The render path reads this once a second per session; keep the last few ledgers and
+// append to the parsed rows instead of re-reading and re-parsing the whole jsonl.
+const MAX_SESSIONS = 16;
+const cache = new Map();
+const parse = (line, onCorrupt) => { try { return [JSON.parse(line)]; } catch { onCorrupt(); return []; } };
+const readsAsJson = text => { try { JSON.parse(text); return true; } catch { return false; } };
+export const ledgerPath = (home, id) => join(home, 'session-metrics', createHash('sha256').update(id).digest('hex') + '.jsonl');
+export function appendMetric(home, id, entry) {
+  const path = ledgerPath(home, id);
+  mkdirSync(join(home, 'session-metrics'), { recursive: true, mode: 0o700 });
+  appendFileSync(path, JSON.stringify(entry) + '\n', { mode: 0o600, flush: true });
+}
+export function readMetrics(home, id) {
+  const path = ledgerPath(home, id);
+  try {
+    const st = statSync(path), key = `${st.mtimeMs}:${st.size}`;
+    const entry = cache.get(path);
+    if (entry?.key === key) return entry.value;
+    // Touching a key refreshes its recency; the oldest ledger is dropped past the cap.
+    if (entry) cache.delete(path);
+    let corrupt = false;
+    const onCorrupt = () => { corrupt = true; };
+    let value, offset = 0, pending = false;
+    if (entry && st.ino === entry.ino && st.dev === entry.dev && st.size > entry.size) {
+      // Append-only ledger: read just the bytes written since the last read (offset is a newline boundary).
+      const fd = openSync(path, 'r');
+      try {
+        const buffer = Buffer.allocUnsafe(st.size - entry.offset);
+        let filled = 0;
+        while (filled < buffer.length) {
+          const read = readSync(fd, buffer, filled, buffer.length - filled, entry.offset + filled);
+          if (read <= 0) break;
+          filled += read;
+        }
+        // A short read must never read as "the writer stopped here": fall back to the full
+        // parse below rather than caching an offset that would drop the unread bytes forever.
+        if (filled < buffer.length) throw Object.assign(new Error('short ledger read'), { code: 'ESHORTREAD' });
+        const tail = buffer.toString('utf8');
+        const lastNewline = tail.lastIndexOf('\n') + 1;
+        let complete = tail.slice(0, lastNewline);
+        const pendingLine = tail.slice(lastNewline);
+        // A fragment without a newline is either a torn write or a complete row this reader is
+        // simply early for; keep it only when it parses, and re-read it next time either way.
+        pending = pendingLine !== '' && readsAsJson(pendingLine);
+        if (pending) complete += pendingLine + '\n';
+        offset = entry.offset + Buffer.byteLength(tail.slice(0, lastNewline));
+        value = { rows: [...(entry.pending ? entry.value.rows.slice(0, -1) : entry.value.rows), ...complete.split('\n').filter(Boolean).flatMap(line => parse(line, onCorrupt))], corrupt: entry.value.corrupt || corrupt };
+      } finally { closeSync(fd); }
+    } else {
+      const raw = readFileSync(path);
+      const lastNewline = raw.lastIndexOf(0x0a) + 1;
+      let complete = raw.subarray(0, lastNewline);
+      const pendingLine = raw.subarray(lastNewline).toString('utf8');
+      pending = pendingLine !== '' && readsAsJson(pendingLine);
+      if (pending) complete = Buffer.concat([complete, Buffer.from(pendingLine + '\n')]);
+      offset = lastNewline;
+      value = { rows: complete.toString('utf8').split('\n').filter(Boolean).flatMap(line => parse(line, onCorrupt)), corrupt };
+    }
+    cache.set(path, { key, offset, value, pending, size: st.size, ino: st.ino, dev: st.dev });
+    while (cache.size > MAX_SESSIONS) cache.delete(cache.keys().next().value);
+    return value;
+  } catch (e) {
+    cache.delete(path);
+    if (e.code === 'ESHORTREAD') {
+      // Read it the simple way once; the next call starts from a fresh offset.
+      let corrupt = false;
+      const rows = readFileSync(path, 'utf8').split('\n').filter(Boolean).flatMap(line => parse(line, () => { corrupt = true; }));
+      return { rows, corrupt };
+    }
+    return { rows: [], corrupt: e.code !== 'ENOENT' };
+  }
+}