@rejacky/opencode-insights 0.1.9 → 0.1.11

package/README.md

@@ -91,12 +91,33 @@ The `uninstall` command removes plugin config entries and local Insights data; i
 
 ## What You Get
 
-- Live TPS, average TPS, and average TTFT in the OpenCode session prompt zone.
+- Configurable live metrics in the OpenCode session prompt zone.
+- A collapsible session-wide `Token Usage` sidebar showing total tokens, response count, input/output/reasoning usage, cache read/write usage, and aggregate cache rate. It loads completed responses already present in the session and continues updating live.
 - Subagent status (running, done, failed, elapsed time, and token/context usage) in the sidebar.
 - Local capture of OpenCode hook/event data without redaction.
 - A local web viewer for reconstructed sessions, user turns, hidden request context, system/messages transforms, and assistant thinking/response sequences.
 - Native OpenCode footer components (project directory and version) remain visible — the plugin does not override `sidebar_footer` or `home_prompt_right` slots.
 
+The right sidebar contains two independent plugin sections: `Token Usage` and `Subagents`. Click either section header to collapse or expand it. Token usage is aggregated across the full session; prompt-right `used` and `cache` values continue to represent the latest completed assistant response.
+
+## TUI Metrics Configuration
+
+On TUI startup, Insights creates a configuration file beside its database:
+
+```text
+~/.opencode-insights/config.json
+```
+
+With a custom database path, the configuration file is created in that database's directory. The default keeps the prompt-right display compact:
+
+```json
+{
+  "promptRightMetrics": ["tps", "avg", "used", "cache"]
+}
+```
+
+`promptRightMetrics` controls both the fields and their order. Supported values are `tps`, `avg`, `ttft`, `used`, `cache`, `input`, `output`, and `reasoning`. Values that are not recognized are ignored; an empty or invalid configuration uses the default. Restart OpenCode after editing this file.
+
 ## Open The Viewer
 
 Start the local web viewer and open it in your browser:

package/dist/capture-BIiGg2nW.d.ts

@@ -0,0 +1,148 @@
+type StreamSample = {
+    at: number;
+    tokens: number;
+};
+type MessageTiming = {
+    sessionID: string;
+    requestStartAt: number;
+    firstResponseAt?: number | undefined;
+    firstTokenAt?: number | undefined;
+    lastTokenAt?: number | undefined;
+    lastToolCallAt?: number | undefined;
+};
+type SessionAverage = {
+    totalTokens: number;
+    totalDurationMs: number;
+    totalTtftMs: number;
+    messageCount: number;
+};
+type AssistantResponseUsage = {
+    inputTokens?: number | undefined;
+    outputTokens?: number | undefined;
+    reasoningTokens?: number | undefined;
+    cacheReadTokens?: number | undefined;
+    cacheWriteTokens?: number | undefined;
+    finish?: string | undefined;
+};
+type SessionTokenUsage = {
+    inputTokens: number;
+    outputTokens: number;
+    reasoningTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    totalTokens: number;
+    responseCount: number;
+};
+type PromptRightMetric = "tps" | "avg" | "ttft" | "used" | "cache" | "input" | "output" | "reasoning";
+declare const DEFAULT_PROMPT_RIGHT_METRICS: PromptRightMetric[];
+type MetricsState = {
+    streamSamplesBySession: Record<string, StreamSample[]>;
+    messageTimingByID: Record<string, MessageTiming>;
+    sessionAverageByID: Record<string, SessionAverage>;
+    latestResponseUsageBySession: Record<string, AssistantResponseUsage>;
+    responseUsageByMessageID: Record<string, {
+        sessionID: string;
+        usage: AssistantResponseUsage;
+    }>;
+    sessionTokenUsageByID: Record<string, SessionTokenUsage>;
+};
+declare function createMetricsState(): MetricsState;
+declare function estimateStreamTokens(delta: string): number;
+declare function recordAssistantMessage(state: MetricsState, input: {
+    sessionID: string;
+    messageID: string;
+    createdAt: number;
+    completedAt?: number;
+    outputTokens?: number;
+    reasoningTokens?: number;
+    inputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    finish?: string;
+}): void;
+declare function recordAssistantDelta(state: MetricsState, input: {
+    sessionID: string;
+    messageID: string;
+    delta: string;
+    at: number;
+}): void;
+declare function recordToolActivity(state: MetricsState, sessionID: string, messageID: string, at?: number): void;
+declare function renderMetricsText(state: MetricsState, sessionID: string, options?: {
+    now?: number;
+    idle?: boolean;
+}): string;
+declare function renderResponseMetricsText(state: MetricsState, sessionID: string): string;
+declare function renderPromptRightMetricsText(state: MetricsState, sessionID: string, options?: {
+    now?: number;
+    idle?: boolean;
+    metrics?: PromptRightMetric[];
+}): string;
+declare function getSessionTokenUsage(state: MetricsState, sessionID: string): SessionTokenUsage | undefined;
+declare function renderSessionTokenUsage(state: MetricsState, sessionID: string): string;
+
+type CaptureKind = "chat.message" | "chat.params" | "chat.headers" | "experimental.chat.messages.transform" | "experimental.chat.system.transform" | "event" | "tool.execute.before" | "tool.execute.after";
+type CaptureRecord = {
+    id: string;
+    kind: CaptureKind;
+    timestamp: number;
+    sessionID?: string | undefined;
+    messageID?: string | undefined;
+    providerID?: string | undefined;
+    modelID?: string | undefined;
+    payload: Record<string, unknown>;
+};
+type CaptureStore = {
+    initialize?(): Promise<void>;
+    append(record: CaptureRecord): Promise<void>;
+    close?(): Promise<void>;
+};
+type InsightsOptions = {
+    dataDir?: unknown;
+    dbPath?: unknown;
+    retentionDays?: unknown;
+};
+type InsightsConfig = {
+    promptRightMetrics: PromptRightMetric[];
+};
+declare function defaultDataDir(): string;
+declare function resolveCapturePath(options?: InsightsOptions): string;
+declare function resolveInsightsConfigPath(options?: InsightsOptions): string;
+declare function readInsightsConfig(options?: InsightsOptions): Promise<InsightsConfig>;
+declare function normalizeChatMessageCapture(input: unknown, output: unknown, timestamp?: number): CaptureRecord;
+declare function normalizeChatParamsCapture(input: unknown, output: unknown, timestamp?: number): CaptureRecord;
+declare function normalizeChatHeadersCapture(input: unknown, output: unknown, timestamp?: number): CaptureRecord;
+declare function normalizeExperimentalChatMessagesTransformCapture(input: unknown, output: unknown, timestamp?: number): CaptureRecord;
+declare function normalizeExperimentalChatSystemTransformCapture(input: unknown, output: unknown, timestamp?: number): CaptureRecord;
+declare function normalizeEventCapture(event: unknown, timestamp?: number): CaptureRecord;
+declare function normalizeToolCapture(kind: "tool.execute.before" | "tool.execute.after", input: unknown, output: unknown, timestamp?: number): CaptureRecord;
+declare class JsonlCaptureStore implements CaptureStore {
+    private readonly path;
+    private readonly retentionMs;
+    constructor(path: string, retentionMs?: number | undefined);
+    initialize(): Promise<void>;
+    append(record: CaptureRecord): Promise<void>;
+    private pruneExpired;
+}
+interface SqliteDb {
+    all(sql: string, ...params: unknown[]): Record<string, unknown>[];
+    run(sql: string, ...params: unknown[]): void;
+    sync(): void;
+    close(): void;
+}
+declare function openDatabase(path: string, readonly?: boolean): Promise<SqliteDb | undefined>;
+declare function extractEventType(payload: Record<string, unknown>): string | null;
+declare class SqliteCaptureStore implements CaptureStore {
+    private readonly path;
+    private readonly retentionMs;
+    private db;
+    private fallbackStore;
+    constructor(path: string, retentionMs?: number | undefined);
+    initialize(): Promise<void>;
+    append(record: CaptureRecord): Promise<void>;
+    close(): Promise<void>;
+    private pruneExpired;
+}
+declare function createCaptureStore(options?: InsightsOptions): CaptureStore;
+declare function resolveRetentionDays(value: unknown): number;
+
+export { type AssistantResponseUsage as A, renderMetricsText as B, type CaptureRecord as C, DEFAULT_PROMPT_RIGHT_METRICS as D, renderPromptRightMetricsText as E, renderResponseMetricsText as F, renderSessionTokenUsage as G, resolveCapturePath as H, type InsightsConfig as I, JsonlCaptureStore as J, resolveInsightsConfigPath as K, resolveRetentionDays as L, type MessageTiming as M, type PromptRightMetric as P, type SessionAverage as S, type CaptureKind as a, type CaptureStore as b, type InsightsOptions as c, type MetricsState as d, type SessionTokenUsage as e, SqliteCaptureStore as f, type SqliteDb as g, type StreamSample as h, createCaptureStore as i, createMetricsState as j, defaultDataDir as k, estimateStreamTokens as l, extractEventType as m, getSessionTokenUsage as n, normalizeChatHeadersCapture as o, normalizeChatMessageCapture as p, normalizeChatParamsCapture as q, normalizeEventCapture as r, normalizeExperimentalChatMessagesTransformCapture as s, normalizeExperimentalChatSystemTransformCapture as t, normalizeToolCapture as u, openDatabase as v, readInsightsConfig as w, recordAssistantDelta as x, recordAssistantMessage as y, recordToolActivity as z };

package/dist/{chunk-FGTKNB7T.js → chunk-3YLLHABZ.js}

@@ -1,3 +1,266 @@
+// src/metrics.ts
+var DEFAULT_PROMPT_RIGHT_METRICS = ["tps", "avg", "used", "cache"];
+var STREAM_WINDOW_MS = 5e3;
+var LIVE_STALE_MS = 1500;
+var SINGLE_SAMPLE_MS = 1e3;
+function createMetricsState() {
+  return {
+    streamSamplesBySession: {},
+    messageTimingByID: {},
+    sessionAverageByID: {},
+    latestResponseUsageBySession: {},
+    responseUsageByMessageID: {},
+    sessionTokenUsageByID: {}
+  };
+}
+function estimateStreamTokens(delta) {
+  return Math.max(1, Math.ceil(Buffer.byteLength(delta, "utf8") / 5));
+}
+function recordAssistantMessage(state, input) {
+  if (typeof input.completedAt !== "number") {
+    const existing = state.messageTimingByID[input.messageID];
+    state.messageTimingByID[input.messageID] = {
+      sessionID: input.sessionID,
+      requestStartAt: input.createdAt,
+      firstResponseAt: existing?.firstResponseAt,
+      firstTokenAt: existing?.firstTokenAt,
+      lastTokenAt: existing?.lastTokenAt,
+      lastToolCallAt: existing?.lastToolCallAt
+    };
+    return;
+  }
+  const usage = compactUsage({
+    inputTokens: input.inputTokens,
+    outputTokens: input.outputTokens,
+    reasoningTokens: input.reasoningTokens,
+    cacheReadTokens: input.cacheReadTokens,
+    cacheWriteTokens: input.cacheWriteTokens,
+    finish: input.finish
+  });
+  if (hasTokenUsage(usage)) {
+    state.latestResponseUsageBySession[input.sessionID] = usage;
+    state.responseUsageByMessageID[input.messageID] = { sessionID: input.sessionID, usage };
+    rebuildSessionTokenUsage(state, input.sessionID);
+  }
+  const timing = state.messageTimingByID[input.messageID];
+  if (timing?.sessionID === input.sessionID && typeof timing.firstResponseAt === "number") {
+    const totalTokens = (input.outputTokens ?? 0) + (input.reasoningTokens ?? 0);
+    const endAt = input.finish === "tool-calls" ? timing.lastToolCallAt : input.completedAt;
+    const durationMs = typeof endAt === "number" ? Math.max(endAt - timing.firstResponseAt, 1) : void 0;
+    const ttftMs = Math.max(timing.firstResponseAt - timing.requestStartAt, 0);
+    if (totalTokens > 0 && durationMs) {
+      const totals = state.sessionAverageByID[input.sessionID] ?? {
+        totalTokens: 0,
+        totalDurationMs: 0,
+        totalTtftMs: 0,
+        messageCount: 0
+      };
+      state.sessionAverageByID[input.sessionID] = {
+        totalTokens: totals.totalTokens + totalTokens,
+        totalDurationMs: totals.totalDurationMs + durationMs,
+        totalTtftMs: totals.totalTtftMs + ttftMs,
+        messageCount: totals.messageCount + 1
+      };
+    }
+  }
+  delete state.messageTimingByID[input.messageID];
+  pruneSamples(state, input.completedAt);
+}
+function recordAssistantDelta(state, input) {
+  const sample = {
+    at: input.at,
+    tokens: estimateStreamTokens(input.delta)
+  };
+  state.streamSamplesBySession[input.sessionID] = [
+    ...(state.streamSamplesBySession[input.sessionID] ?? []).filter((item) => input.at - item.at <= STREAM_WINDOW_MS),
+    sample
+  ];
+  const timing = state.messageTimingByID[input.messageID];
+  if (timing) {
+    state.messageTimingByID[input.messageID] = timing.firstTokenAt ? { ...timing, lastTokenAt: input.at } : {
+      ...timing,
+      firstResponseAt: timing.firstResponseAt ?? input.at,
+      firstTokenAt: input.at,
+      lastTokenAt: input.at
+    };
+  }
+}
+function recordToolActivity(state, sessionID, messageID, at = Date.now()) {
+  if (state.streamSamplesBySession[sessionID]?.length) {
+    delete state.streamSamplesBySession[sessionID];
+  }
+  const timing = state.messageTimingByID[messageID];
+  if (timing) {
+    state.messageTimingByID[messageID] = {
+      ...timing,
+      lastToolCallAt: at,
+      firstResponseAt: timing.firstResponseAt ?? at
+    };
+  }
+}
+function renderMetricsText(state, sessionID, options = {}) {
+  const live = liveTps(state, sessionID, options) ?? "-";
+  const avg = sessionAverage(state, sessionID) ?? "-";
+  const ttft = sessionTtft(state, sessionID) ?? "-";
+  return `TPS ${live} | AVG ${avg} | TTFT ${ttft}`;
+}
+function renderResponseMetricsText(state, sessionID) {
+  const usage = state.latestResponseUsageBySession[sessionID];
+  if (!usage || !hasTokenUsage(usage)) return "";
+  const used = sumTokens(usage);
+  const cacheRate = cacheReadRate(usage);
+  const parts = [
+    used === void 0 ? void 0 : `${formatTokenCount(used)} used`,
+    cacheRate === void 0 ? void 0 : `${formatPercent(cacheRate)} cache`,
+    usage.outputTokens === void 0 ? void 0 : `${formatTokenCount(usage.outputTokens)} out`,
+    usage.reasoningTokens === void 0 ? void 0 : `${formatTokenCount(usage.reasoningTokens)} think`
+  ].filter((part) => !!part);
+  return parts.join(" | ");
+}
+function renderPromptRightMetricsText(state, sessionID, options = {}) {
+  const usage = state.latestResponseUsageBySession[sessionID];
+  const used = usage ? sumTokens(usage) : void 0;
+  const cacheRate = usage ? cacheReadRate(usage) : void 0;
+  const values = {
+    tps: `TPS ${liveTps(state, sessionID, options) ?? "-"}`,
+    avg: `AVG ${sessionAverage(state, sessionID) ?? "-"}`,
+    ttft: `TTFT ${sessionTtft(state, sessionID) ?? "-"}`,
+    used: `${used === void 0 ? "-" : formatTokenCount(used)} used`,
+    cache: `${cacheRate === void 0 ? "-" : formatPercent(cacheRate)} cache`,
+    input: `${usage?.inputTokens === void 0 ? "-" : formatTokenCount(usage.inputTokens)} in`,
+    output: `${usage?.outputTokens === void 0 ? "-" : formatTokenCount(usage.outputTokens)} out`,
+    reasoning: `${usage?.reasoningTokens === void 0 ? "-" : formatTokenCount(usage.reasoningTokens)} think`
+  };
+  return (options.metrics?.length ? options.metrics : DEFAULT_PROMPT_RIGHT_METRICS).map((metric) => values[metric]).join(" | ");
+}
+function getSessionTokenUsage(state, sessionID) {
+  return state.sessionTokenUsageByID[sessionID];
+}
+function renderSessionTokenUsage(state, sessionID) {
+  const usage = getSessionTokenUsage(state, sessionID);
+  if (!usage) return "";
+  const cachePromptTokens = usage.inputTokens + usage.cacheReadTokens;
+  const cacheRate = cachePromptTokens > 0 ? usage.cacheReadTokens / cachePromptTokens * 100 : void 0;
+  return [
+    "Token Usage",
+    `${formatTokenCount(usage.totalTokens)} total \xB7 ${usage.responseCount} responses`,
+    `${formatTokenCount(usage.inputTokens)} input`,
+    `${formatTokenCount(usage.outputTokens)} output`,
+    `${formatTokenCount(usage.reasoningTokens)} reasoning`,
+    `${formatTokenCount(usage.cacheReadTokens)} cache read`,
+    `${formatTokenCount(usage.cacheWriteTokens)} cache write`,
+    `${cacheRate === void 0 ? "-" : formatPercent(cacheRate)} cache rate`
+  ].join("\n");
+}
+function pruneSamples(state, now = Date.now()) {
+  for (const [sessionID, samples] of Object.entries(state.streamSamplesBySession)) {
+    const next = samples.filter((sample) => now - sample.at <= STREAM_WINDOW_MS);
+    if (next.length > 0) state.streamSamplesBySession[sessionID] = next;
+    else delete state.streamSamplesBySession[sessionID];
+  }
+}
+function rebuildSessionTokenUsage(state, sessionID) {
+  const usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+    responseCount: 0
+  };
+  for (const response of Object.values(state.responseUsageByMessageID)) {
+    if (response.sessionID !== sessionID) continue;
+    usage.inputTokens += response.usage.inputTokens ?? 0;
+    usage.outputTokens += response.usage.outputTokens ?? 0;
+    usage.reasoningTokens += response.usage.reasoningTokens ?? 0;
+    usage.cacheReadTokens += response.usage.cacheReadTokens ?? 0;
+    usage.cacheWriteTokens += response.usage.cacheWriteTokens ?? 0;
+    usage.responseCount += 1;
+  }
+  usage.totalTokens = usage.inputTokens + usage.outputTokens + usage.reasoningTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
+  state.sessionTokenUsageByID[sessionID] = usage;
+}
+function sessionAverage(state, sessionID) {
+  const totals = state.sessionAverageByID[sessionID];
+  if (!totals || totals.totalTokens <= 0 || totals.totalDurationMs <= 0) return void 0;
+  return formatRate(totals.totalTokens / (totals.totalDurationMs / 1e3), "AVG");
+}
+function sessionTtft(state, sessionID) {
+  const totals = state.sessionAverageByID[sessionID];
+  if (!totals || totals.messageCount <= 0 || totals.totalTtftMs < 0) return void 0;
+  return formatTtft(totals.totalTtftMs / totals.messageCount / 1e3);
+}
+function liveTps(state, sessionID, options = {}) {
+  if (options.idle) return void 0;
+  const now = options.now ?? Date.now();
+  const samples = state.streamSamplesBySession[sessionID] ?? [];
+  const relevant = samples.filter((sample) => now - sample.at <= STREAM_WINDOW_MS);
+  if (relevant.length === 0) return void 0;
+  const lastSample = relevant.at(-1);
+  if (!lastSample || now - lastSample.at > LIVE_STALE_MS) return void 0;
+  const total = relevant.reduce((sum, sample) => sum + sample.tokens, 0);
+  const durationSeconds = activeDurationMs(relevant, now) / 1e3;
+  if (durationSeconds <= 0) return void 0;
+  return formatRate(total / durationSeconds, "TPS");
+}
+function activeDurationMs(samples, tailAt) {
+  if (samples.length === 0) return 0;
+  if (samples.length === 1) {
+    const tailDuration = tailAt ? Math.max(0, tailAt - samples[0].at) : SINGLE_SAMPLE_MS;
+    return Math.min(Math.max(tailDuration, 250), SINGLE_SAMPLE_MS);
+  }
+  let duration = 0;
+  for (let index = 1; index < samples.length; index++) {
+    duration += Math.max(0, samples[index].at - samples[index - 1].at);
+  }
+  if (tailAt) {
+    duration += Math.max(0, tailAt - samples.at(-1).at);
+  }
+  return Math.max(duration, SINGLE_SAMPLE_MS);
+}
+function formatRate(value, label) {
+  if (!Number.isFinite(value) || value <= 0) return void 0;
+  const suffix = label === "TPS" ? " TPS" : "";
+  if (value >= 100) return `${Math.round(value)}${suffix}`;
+  if (value >= 10) return `${value.toFixed(1)}${suffix}`;
+  return `${value.toFixed(2)}${suffix}`;
+}
+function formatTtft(value) {
+  if (!Number.isFinite(value) || value < 0) return void 0;
+  return `${value.toFixed(1)}s`;
+}
+function compactUsage(usage) {
+  return Object.fromEntries(Object.entries(usage).filter(([, value]) => value !== void 0));
+}
+function hasTokenUsage(usage) {
+  return [usage.inputTokens, usage.outputTokens, usage.reasoningTokens, usage.cacheReadTokens, usage.cacheWriteTokens].some(
+    (value) => typeof value === "number"
+  );
+}
+function sumTokens(usage) {
+  const values = [usage.inputTokens, usage.outputTokens, usage.reasoningTokens, usage.cacheReadTokens, usage.cacheWriteTokens].filter(
+    (value) => typeof value === "number"
+  );
+  return values.length ? values.reduce((sum, value) => sum + value, 0) : void 0;
+}
+function cacheReadRate(usage) {
+  if (typeof usage.cacheReadTokens !== "number") return void 0;
+  const promptTokens = (usage.inputTokens ?? 0) + usage.cacheReadTokens;
+  return promptTokens > 0 ? usage.cacheReadTokens / promptTokens * 100 : void 0;
+}
+function formatTokenCount(value) {
+  if (Math.abs(value) >= 1e6) return `${formatAbbreviatedTokenCount(value, 1e6)}m`;
+  if (Math.abs(value) >= 1e3) return `${formatAbbreviatedTokenCount(value, 1e3)}k`;
+  return String(Math.round(value));
+}
+function formatPercent(value) {
+  return `${(Math.round(value * 100) / 100).toFixed(2)}%`;
+}
+function formatAbbreviatedTokenCount(value, divisor) {
+  return (Math.round(value / divisor * 10) / 10).toFixed(1);
+}
+
 // src/capture.ts
 import { mkdir, appendFile, readFile, writeFile } from "fs/promises";
 import { existsSync, readFileSync } from "fs";
@@ -62,6 +325,37 @@ function resolveCapturePath(options = {}) {
   const dataDir = typeof options.dataDir === "string" && options.dataDir.length > 0 ? options.dataDir : defaultDataDir();
   return join(dataDir, "insights.sqlite");
 }
+function resolveInsightsConfigPath(options = {}) {
+  return join(dirname(resolveCapturePath(options)), "config.json");
+}
+async function readInsightsConfig(options = {}) {
+  const path = resolveInsightsConfigPath(options);
+  if (!existsSync(path)) {
+    try {
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, `${JSON.stringify(defaultInsightsConfig(), null, 2)}
+`, "utf8");
+    } catch {
+      return defaultInsightsConfig();
+    }
+  }
+  try {
+    return insightsConfigFrom(JSON.parse(await readFile(path, "utf8")));
+  } catch {
+    return defaultInsightsConfig();
+  }
+}
+function defaultInsightsConfig() {
+  return { promptRightMetrics: [...DEFAULT_PROMPT_RIGHT_METRICS] };
+}
+function insightsConfigFrom(value) {
+  if (!isRecord(value) || !Array.isArray(value.promptRightMetrics)) return defaultInsightsConfig();
+  const metrics = value.promptRightMetrics.filter(isPromptRightMetric);
+  return metrics.length ? { promptRightMetrics: metrics } : defaultInsightsConfig();
+}
+function isPromptRightMetric(value) {
+  return value === "tps" || value === "avg" || value === "ttft" || value === "used" || value === "cache" || value === "input" || value === "output" || value === "reasoning";
+}
 function normalizeChatMessageCapture(input, output, timestamp = Date.now()) {
   const inputRecord = isRecord(input) ? input : {};
   const model = isRecord(inputRecord.model) ? inputRecord.model : void 0;
@@ -384,8 +678,21 @@ function retentionCutoff(now, retentionMs) {
 }
 
 export {
+  DEFAULT_PROMPT_RIGHT_METRICS,
+  createMetricsState,
+  estimateStreamTokens,
+  recordAssistantMessage,
+  recordAssistantDelta,
+  recordToolActivity,
+  renderMetricsText,
+  renderResponseMetricsText,
+  renderPromptRightMetricsText,
+  getSessionTokenUsage,
+  renderSessionTokenUsage,
   defaultDataDir,
   resolveCapturePath,
+  resolveInsightsConfigPath,
+  readInsightsConfig,
   normalizeChatMessageCapture,
   normalizeChatParamsCapture,
   normalizeChatHeadersCapture,

package/dist/{chunk-7M32TU5P.js → chunk-O5FFLPEQ.js}

@@ -1,149 +1,3 @@
-// src/metrics.ts
-var STREAM_WINDOW_MS = 5e3;
-var LIVE_STALE_MS = 1500;
-var SINGLE_SAMPLE_MS = 1e3;
-function createMetricsState() {
-  return {
-    streamSamplesBySession: {},
-    messageTimingByID: {},
-    sessionAverageByID: {}
-  };
-}
-function estimateStreamTokens(delta) {
-  return Math.max(1, Math.ceil(Buffer.byteLength(delta, "utf8") / 5));
-}
-function recordAssistantMessage(state, input) {
-  if (typeof input.completedAt !== "number") {
-    const existing = state.messageTimingByID[input.messageID];
-    state.messageTimingByID[input.messageID] = {
-      sessionID: input.sessionID,
-      requestStartAt: input.createdAt,
-      firstResponseAt: existing?.firstResponseAt,
-      firstTokenAt: existing?.firstTokenAt,
-      lastTokenAt: existing?.lastTokenAt,
-      lastToolCallAt: existing?.lastToolCallAt
-    };
-    return;
-  }
-  const timing = state.messageTimingByID[input.messageID];
-  if (timing?.sessionID === input.sessionID && typeof timing.firstResponseAt === "number") {
-    const totalTokens = (input.outputTokens ?? 0) + (input.reasoningTokens ?? 0);
-    const endAt = input.finish === "tool-calls" ? timing.lastToolCallAt : input.completedAt;
-    const durationMs = typeof endAt === "number" ? Math.max(endAt - timing.firstResponseAt, 1) : void 0;
-    const ttftMs = Math.max(timing.firstResponseAt - timing.requestStartAt, 0);
-    if (totalTokens > 0 && durationMs) {
-      const totals = state.sessionAverageByID[input.sessionID] ?? {
-        totalTokens: 0,
-        totalDurationMs: 0,
-        totalTtftMs: 0,
-        messageCount: 0
-      };
-      state.sessionAverageByID[input.sessionID] = {
-        totalTokens: totals.totalTokens + totalTokens,
-        totalDurationMs: totals.totalDurationMs + durationMs,
-        totalTtftMs: totals.totalTtftMs + ttftMs,
-        messageCount: totals.messageCount + 1
-      };
-    }
-  }
-  delete state.messageTimingByID[input.messageID];
-  pruneSamples(state, input.completedAt);
-}
-function recordAssistantDelta(state, input) {
-  const sample = {
-    at: input.at,
-    tokens: estimateStreamTokens(input.delta)
-  };
-  state.streamSamplesBySession[input.sessionID] = [
-    ...(state.streamSamplesBySession[input.sessionID] ?? []).filter((item) => input.at - item.at <= STREAM_WINDOW_MS),
-    sample
-  ];
-  const timing = state.messageTimingByID[input.messageID];
-  if (timing) {
-    state.messageTimingByID[input.messageID] = timing.firstTokenAt ? { ...timing, lastTokenAt: input.at } : {
-      ...timing,
-      firstResponseAt: timing.firstResponseAt ?? input.at,
-      firstTokenAt: input.at,
-      lastTokenAt: input.at
-    };
-  }
-}
-function recordToolActivity(state, sessionID, messageID, at = Date.now()) {
-  if (state.streamSamplesBySession[sessionID]?.length) {
-    delete state.streamSamplesBySession[sessionID];
-  }
-  const timing = state.messageTimingByID[messageID];
-  if (timing) {
-    state.messageTimingByID[messageID] = {
-      ...timing,
-      lastToolCallAt: at,
-      firstResponseAt: timing.firstResponseAt ?? at
-    };
-  }
-}
-function renderMetricsText(state, sessionID, options = {}) {
-  const live = liveTps(state, sessionID, options) ?? "-";
-  const avg = sessionAverage(state, sessionID) ?? "-";
-  const ttft = sessionTtft(state, sessionID) ?? "-";
-  return `TPS ${live} | AVG ${avg} | TTFT ${ttft}`;
-}
-function pruneSamples(state, now = Date.now()) {
-  for (const [sessionID, samples] of Object.entries(state.streamSamplesBySession)) {
-    const next = samples.filter((sample) => now - sample.at <= STREAM_WINDOW_MS);
-    if (next.length > 0) state.streamSamplesBySession[sessionID] = next;
-    else delete state.streamSamplesBySession[sessionID];
-  }
-}
-function sessionAverage(state, sessionID) {
-  const totals = state.sessionAverageByID[sessionID];
-  if (!totals || totals.totalTokens <= 0 || totals.totalDurationMs <= 0) return void 0;
-  return formatRate(totals.totalTokens / (totals.totalDurationMs / 1e3), "AVG");
-}
-function sessionTtft(state, sessionID) {
-  const totals = state.sessionAverageByID[sessionID];
-  if (!totals || totals.messageCount <= 0 || totals.totalTtftMs < 0) return void 0;
-  return formatTtft(totals.totalTtftMs / totals.messageCount / 1e3);
-}
-function liveTps(state, sessionID, options = {}) {
-  if (options.idle) return void 0;
-  const now = options.now ?? Date.now();
-  const samples = state.streamSamplesBySession[sessionID] ?? [];
-  const relevant = samples.filter((sample) => now - sample.at <= STREAM_WINDOW_MS);
-  if (relevant.length === 0) return void 0;
-  const lastSample = relevant.at(-1);
-  if (!lastSample || now - lastSample.at > LIVE_STALE_MS) return void 0;
-  const total = relevant.reduce((sum, sample) => sum + sample.tokens, 0);
-  const durationSeconds = activeDurationMs(relevant, now) / 1e3;
-  if (durationSeconds <= 0) return void 0;
-  return formatRate(total / durationSeconds, "TPS");
-}
-function activeDurationMs(samples, tailAt) {
-  if (samples.length === 0) return 0;
-  if (samples.length === 1) {
-    const tailDuration = tailAt ? Math.max(0, tailAt - samples[0].at) : SINGLE_SAMPLE_MS;
-    return Math.min(Math.max(tailDuration, 250), SINGLE_SAMPLE_MS);
-  }
-  let duration = 0;
-  for (let index = 1; index < samples.length; index++) {
-    duration += Math.max(0, samples[index].at - samples[index - 1].at);
-  }
-  if (tailAt) {
-    duration += Math.max(0, tailAt - samples.at(-1).at);
-  }
-  return Math.max(duration, SINGLE_SAMPLE_MS);
-}
-function formatRate(value, label) {
-  if (!Number.isFinite(value) || value <= 0) return void 0;
-  const suffix = label === "TPS" ? " TPS" : "";
-  if (value >= 100) return `${Math.round(value)}${suffix}`;
-  if (value >= 10) return `${value.toFixed(1)}${suffix}`;
-  return `${value.toFixed(2)}${suffix}`;
-}
-function formatTtft(value) {
-  if (!Number.isFinite(value) || value < 0) return void 0;
-  return `${value.toFixed(1)}s`;
-}
-
 // src/subagents.ts
 function createSubagentState() {
   return { children: {}, totalExecuted: 0 };
@@ -446,12 +300,6 @@ function isRecord(value) {
 }
 
 export {
-  createMetricsState,
-  estimateStreamTokens,
-  recordAssistantMessage,
-  recordAssistantDelta,
-  recordToolActivity,
-  renderMetricsText,
   createSubagentState,
   applySubagentEvent,
   renderSubagentStatus,

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as CaptureRecord } from './capture-BMWWI5GR.js';
+import { C as CaptureRecord } from './capture-BIiGg2nW.js';
 
 type HistoryMessage = {
     id: string;