opencode-tps-meter 0.1.0

package/dist/index.js

@@ -0,0 +1,832 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  default: () => TpsMeterPlugin
+});
+// OpenCode compatibility: unwrap plugin function from getter
+module.exports = exports_src.default();
+
+// src/constants.ts
+var MIN_TPS_ELAPSED_MS = 250;
+var DEFAULT_ROLLING_WINDOW_MS = 1000;
+var MAX_BUFFER_SIZE = 100;
+var MIN_WINDOW_DURATION_SECONDS = 0.1;
+var DEFAULT_UPDATE_INTERVAL_MS = 50;
+var MIN_TOAST_INTERVAL_MS = 150;
+var DEFAULT_TOAST_DURATION_MS = 20000;
+var FINAL_STATS_DURATION_MS = 2000;
+var MAX_MESSAGE_AGE_MS = 5 * 60 * 1000;
+var CLEANUP_INTERVAL_MS = 30000;
+var CHARS_DIV_4 = 4;
+var CHARS_DIV_3 = 3;
+var WORDS_DIV_0_75 = 0.75;
+var DEFAULT_SLOW_TPS_THRESHOLD = 10;
+var DEFAULT_FAST_TPS_THRESHOLD = 50;
+var INVALID_FINISH_REASONS = new Set(["tool-calls", "unknown"]);
+var COUNTABLE_PART_TYPES = new Set(["text", "reasoning"]);
+
+// src/tracker.ts
+function createTracker(options = {}) {
+  let startTime = Date.now();
+  let totalTokens = 0;
+  let buffer = [];
+  const sessionId = options.sessionId;
+  const windowMs = typeof options.rollingWindowMs === "number" && options.rollingWindowMs > 0 ? options.rollingWindowMs : DEFAULT_ROLLING_WINDOW_MS;
+  function pruneBuffer(now) {
+    const cutoff = now - windowMs;
+    let validStartIndex = 0;
+    while (validStartIndex < buffer.length && buffer[validStartIndex].timestamp < cutoff) {
+      validStartIndex++;
+    }
+    if (validStartIndex > 0) {
+      buffer = buffer.slice(validStartIndex);
+    }
+    if (buffer.length > MAX_BUFFER_SIZE) {
+      buffer = buffer.slice(-MAX_BUFFER_SIZE);
+    }
+  }
+  return {
+    recordTokens(count, timestamp) {
+      const ts = timestamp ?? Date.now();
+      totalTokens += count;
+      buffer.push({ timestamp: ts, count });
+      pruneBuffer(ts);
+    },
+    getInstantTPS() {
+      if (buffer.length === 0) {
+        return 0;
+      }
+      const now = Date.now();
+      const cutoff = now - windowMs;
+      let tokensInWindow = 0;
+      let oldestTimestamp = now;
+      let newestTimestamp = 0;
+      for (const entry of buffer) {
+        if (entry.timestamp >= cutoff) {
+          tokensInWindow += entry.count;
+          if (entry.timestamp < oldestTimestamp) {
+            oldestTimestamp = entry.timestamp;
+          }
+          if (entry.timestamp > newestTimestamp) {
+            newestTimestamp = entry.timestamp;
+          }
+        }
+      }
+      if (tokensInWindow === 0) {
+        return 0;
+      }
+      const windowDurationMs = newestTimestamp - oldestTimestamp;
+      const windowDurationSeconds = windowDurationMs / 1000;
+      const effectiveDuration = Math.max(windowDurationSeconds, MIN_WINDOW_DURATION_SECONDS);
+      return tokensInWindow / effectiveDuration;
+    },
+    getAverageTPS() {
+      const elapsedSeconds = (Date.now() - startTime) / 1000;
+      if (elapsedSeconds === 0) {
+        return 0;
+      }
+      return totalTokens / elapsedSeconds;
+    },
+    getTotalTokens() {
+      return totalTokens;
+    },
+    getElapsedMs() {
+      return Date.now() - startTime;
+    },
+    getSessionId() {
+      return sessionId;
+    },
+    reset() {
+      startTime = Date.now();
+      totalTokens = 0;
+      buffer = [];
+    },
+    getBufferSize() {
+      return buffer.length;
+    },
+    getMaxBufferSize() {
+      return MAX_BUFFER_SIZE;
+    },
+    getWindowMs() {
+      return windowMs;
+    }
+  };
+}
+
+// src/ui.ts
+function createUIManager(client, config) {
+  const uiConfig = {
+    updateIntervalMs: config?.updateIntervalMs ?? 50,
+    format: config?.format ?? "compact",
+    showAverage: config?.showAverage ?? true,
+    showInstant: config?.showInstant ?? true,
+    showTotalTokens: config?.showTotalTokens ?? true,
+    showElapsed: config?.showElapsed ?? false,
+    enableColorCoding: config?.enableColorCoding ?? false,
+    slowTpsThreshold: config?.slowTpsThreshold ?? 10,
+    fastTpsThreshold: config?.fastTpsThreshold ?? 50
+  };
+  let flushTimer = null;
+  let lastFlushAt = 0;
+  let lastToastAt = 0;
+  let lastToastMessage = "";
+  let pendingState = null;
+  let lastDisplayedState = null;
+  function formatElapsedTime(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return `${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+  }
+  function formatNumberWithCommas(num) {
+    return num.toLocaleString("en-US");
+  }
+  function formatDisplay(state) {
+    const parts = [];
+    if (uiConfig.showInstant || uiConfig.showAverage) {
+      const tpsParts = [];
+      if (uiConfig.showInstant) {
+        tpsParts.push(`TPS: ${state.instantTps.toFixed(1)}`);
+      }
+      if (uiConfig.showAverage) {
+        tpsParts.push(`(avg ${state.avgTps.toFixed(1)})`);
+      }
+      parts.push(tpsParts.join(" "));
+    }
+    if (uiConfig.showTotalTokens) {
+      parts.push(`tokens: ${formatNumberWithCommas(state.totalTokens)}`);
+    }
+    if (uiConfig.showElapsed) {
+      parts.push(formatElapsedTime(state.elapsedMs));
+    }
+    return parts.join(" | ");
+  }
+  function getColorVariant(instantTps, isFinal) {
+    if (isFinal) {
+      return "success";
+    }
+    if (!uiConfig.enableColorCoding) {
+      return "info";
+    }
+    if (instantTps < uiConfig.slowTpsThreshold) {
+      return "error";
+    }
+    if (instantTps > uiConfig.fastTpsThreshold) {
+      return "success";
+    }
+    return "warning";
+  }
+  function display(message, isFinal = false, instantTps = 0) {
+    const minToastIntervalMs = Math.max(MIN_TOAST_INTERVAL_MS, uiConfig.updateIntervalMs * 3);
+    const toastDuration = Math.max(DEFAULT_TOAST_DURATION_MS, minToastIntervalMs * 20);
+    const now = Date.now();
+    if (!isFinal) {
+      if (message === lastToastMessage || now - lastToastAt < minToastIntervalMs) {
+        return;
+      }
+    }
+    const variant = getColorVariant(instantTps, isFinal);
+    let displayed = false;
+    if (client.tui?.showToast) {
+      try {
+        const result = client.tui.showToast({
+          body: {
+            title: "TPS Meter",
+            message,
+            variant,
+            duration: isFinal ? 2000 : toastDuration
+          }
+        });
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {});
+        }
+        displayed = true;
+      } catch {}
+    }
+    if (!displayed && client.tui?.publish) {
+      try {
+        const result = client.tui.publish({
+          body: {
+            type: "tui.toast.show",
+            properties: {
+              title: "TPS Meter",
+              message,
+              variant,
+              duration: isFinal ? FINAL_STATS_DURATION_MS : toastDuration
+            }
+          }
+        });
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {});
+        }
+        displayed = true;
+      } catch {}
+    }
+    if (!displayed && client.toast?.success && client.toast?.info) {
+      try {
+        if (isFinal) {
+          client.toast.success(message, { duration: FINAL_STATS_DURATION_MS });
+        } else {
+          client.toast.info(message, { duration: toastDuration });
+        }
+        displayed = true;
+      } catch {}
+    }
+    if (displayed) {
+      lastToastAt = now;
+      lastToastMessage = message;
+    }
+  }
+  function flushPendingUpdate() {
+    if (pendingState) {
+      const formatted = formatDisplay(pendingState);
+      display(formatted, false, pendingState.instantTps);
+      lastDisplayedState = { ...pendingState };
+      pendingState = null;
+    }
+  }
+  function scheduleFlush() {
+    if (flushTimer) {
+      return;
+    }
+    const now = Date.now();
+    const delay = lastFlushAt === 0 ? 0 : Math.max(0, uiConfig.updateIntervalMs - (now - lastFlushAt));
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      lastFlushAt = Date.now();
+      flushPendingUpdate();
+    }, delay);
+  }
+  return {
+    updateDisplay(instantTps, avgTps, totalTokens, elapsedMs) {
+      pendingState = {
+        instantTps,
+        avgTps,
+        totalTokens,
+        elapsedMs
+      };
+      scheduleFlush();
+    },
+    showFinalStats(totalTokens, avgTps, elapsedMs) {
+      flushPendingUpdate();
+      lastToastMessage = "";
+      const state = {
+        instantTps: 0,
+        avgTps,
+        totalTokens,
+        elapsedMs
+      };
+      const formatted = formatDisplay(state);
+      display(formatted, true);
+    },
+    clear() {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      flushPendingUpdate();
+      pendingState = null;
+      lastDisplayedState = null;
+    },
+    setUpdateInterval(ms) {
+      uiConfig.updateIntervalMs = ms;
+      lastFlushAt = 0;
+    }
+  };
+}
+
+// src/tokenCounter.ts
+function countByChars(text, divisor) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  return Math.ceil(text.length / divisor);
+}
+function countByWords(text, divisor) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return 0;
+  }
+  const wordCount = trimmed.split(/\s+/).length;
+  return Math.ceil(wordCount / divisor);
+}
+function createCounter(algorithm) {
+  const strategies = {
+    heuristic: (text) => countByChars(text, CHARS_DIV_4),
+    word: (text) => countByWords(text, WORDS_DIV_0_75),
+    code: (text) => countByChars(text, CHARS_DIV_3)
+  };
+  return {
+    count(text) {
+      return strategies[algorithm](text);
+    }
+  };
+}
+function createTokenizer(algorithm = "heuristic") {
+  return createCounter(algorithm);
+}
+
+// src/config.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var defaultConfig = {
+  enabled: true,
+  updateIntervalMs: DEFAULT_UPDATE_INTERVAL_MS,
+  rollingWindowMs: DEFAULT_ROLLING_WINDOW_MS,
+  showAverage: true,
+  showInstant: true,
+  showTotalTokens: true,
+  showElapsed: false,
+  format: "compact",
+  minVisibleTPS: 0,
+  fallbackTokenHeuristic: "chars_div_4",
+  enableColorCoding: false,
+  slowTpsThreshold: DEFAULT_SLOW_TPS_THRESHOLD,
+  fastTpsThreshold: DEFAULT_FAST_TPS_THRESHOLD
+};
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value) && isFinite(value) && value >= 0;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function mergeConfig(partial, defaults) {
+  const updateIntervalMs = isNumber(partial.updateIntervalMs) ? clamp(partial.updateIntervalMs, 10, 5000) : defaults.updateIntervalMs;
+  const rollingWindowMs = isNumber(partial.rollingWindowMs) ? clamp(partial.rollingWindowMs, 100, 30000) : defaults.rollingWindowMs;
+  const minVisibleTPS = isNumber(partial.minVisibleTPS) ? clamp(partial.minVisibleTPS, 0, 1e4) : defaults.minVisibleTPS;
+  let slowTpsThreshold = isNumber(partial.slowTpsThreshold) ? clamp(partial.slowTpsThreshold, 0, 1e4) : defaults.slowTpsThreshold;
+  let fastTpsThreshold = isNumber(partial.fastTpsThreshold) ? clamp(partial.fastTpsThreshold, 0, 1e4) : defaults.fastTpsThreshold;
+  if (slowTpsThreshold >= fastTpsThreshold) {
+    slowTpsThreshold = defaults.slowTpsThreshold;
+    fastTpsThreshold = defaults.fastTpsThreshold;
+  }
+  return {
+    enabled: isBoolean(partial.enabled) ? partial.enabled : defaults.enabled,
+    updateIntervalMs,
+    rollingWindowMs,
+    showAverage: isBoolean(partial.showAverage) ? partial.showAverage : defaults.showAverage,
+    showInstant: isBoolean(partial.showInstant) ? partial.showInstant : defaults.showInstant,
+    showTotalTokens: isBoolean(partial.showTotalTokens) ? partial.showTotalTokens : defaults.showTotalTokens,
+    showElapsed: isBoolean(partial.showElapsed) ? partial.showElapsed : defaults.showElapsed,
+    format: isString(partial.format) && ["compact", "verbose", "minimal"].includes(partial.format) ? partial.format : defaults.format,
+    minVisibleTPS,
+    fallbackTokenHeuristic: isString(partial.fallbackTokenHeuristic) && ["chars_div_4", "chars_div_3", "words_div_0_75"].includes(partial.fallbackTokenHeuristic) ? partial.fallbackTokenHeuristic : defaults.fallbackTokenHeuristic,
+    enableColorCoding: isBoolean(partial.enableColorCoding) ? partial.enableColorCoding : defaults.enableColorCoding,
+    slowTpsThreshold,
+    fastTpsThreshold
+  };
+}
+function loadConfigFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    return null;
+  }
+}
+function loadEnvConfig() {
+  const envConfig = {};
+  if (process.env.TPS_METER_ENABLED !== undefined) {
+    envConfig.enabled = process.env.TPS_METER_ENABLED === "true";
+  }
+  if (process.env.TPS_METER_UPDATE_INTERVAL_MS !== undefined) {
+    const val = parseInt(process.env.TPS_METER_UPDATE_INTERVAL_MS, 10);
+    if (!isNaN(val))
+      envConfig.updateIntervalMs = val;
+  }
+  if (process.env.TPS_METER_ROLLING_WINDOW_MS !== undefined) {
+    const val = parseInt(process.env.TPS_METER_ROLLING_WINDOW_MS, 10);
+    if (!isNaN(val))
+      envConfig.rollingWindowMs = val;
+  }
+  if (process.env.TPS_METER_SHOW_AVERAGE !== undefined) {
+    envConfig.showAverage = process.env.TPS_METER_SHOW_AVERAGE === "true";
+  }
+  if (process.env.TPS_METER_SHOW_INSTANT !== undefined) {
+    envConfig.showInstant = process.env.TPS_METER_SHOW_INSTANT === "true";
+  }
+  if (process.env.TPS_METER_SHOW_TOTAL_TOKENS !== undefined) {
+    envConfig.showTotalTokens = process.env.TPS_METER_SHOW_TOTAL_TOKENS === "true";
+  }
+  if (process.env.TPS_METER_SHOW_ELAPSED !== undefined) {
+    envConfig.showElapsed = process.env.TPS_METER_SHOW_ELAPSED === "true";
+  }
+  if (process.env.TPS_METER_FORMAT !== undefined) {
+    const val = process.env.TPS_METER_FORMAT;
+    if (["compact", "verbose", "minimal"].includes(val)) {
+      envConfig.format = val;
+    }
+  }
+  if (process.env.TPS_METER_MIN_VISIBLE_TPS !== undefined) {
+    const val = parseFloat(process.env.TPS_METER_MIN_VISIBLE_TPS);
+    if (!isNaN(val))
+      envConfig.minVisibleTPS = val;
+  }
+  if (process.env.TPS_METER_FALLBACK_HEURISTIC !== undefined) {
+    const val = process.env.TPS_METER_FALLBACK_HEURISTIC;
+    if (["chars_div_4", "chars_div_3", "words_div_0_75"].includes(val)) {
+      envConfig.fallbackTokenHeuristic = val;
+    }
+  }
+  if (process.env.TPS_METER_ENABLE_COLOR_CODING !== undefined) {
+    envConfig.enableColorCoding = process.env.TPS_METER_ENABLE_COLOR_CODING === "true";
+  }
+  if (process.env.TPS_METER_SLOW_TPS_THRESHOLD !== undefined) {
+    const val = parseFloat(process.env.TPS_METER_SLOW_TPS_THRESHOLD);
+    if (!isNaN(val))
+      envConfig.slowTpsThreshold = val;
+  }
+  if (process.env.TPS_METER_FAST_TPS_THRESHOLD !== undefined) {
+    const val = parseFloat(process.env.TPS_METER_FAST_TPS_THRESHOLD);
+    if (!isNaN(val))
+      envConfig.fastTpsThreshold = val;
+  }
+  return envConfig;
+}
+function loadConfigSync() {
+  let mergedConfig = {};
+  const projectConfigPath = path.join(process.cwd(), ".opencode", "tps-meter.json");
+  const projectConfig = loadConfigFile(projectConfigPath);
+  if (projectConfig) {
+    mergedConfig = { ...mergedConfig, ...projectConfig };
+  }
+  const homeDir = os.homedir();
+  const globalConfigPath = path.join(homeDir, ".config", "opencode", "tps-meter.json");
+  const globalConfig = loadConfigFile(globalConfigPath);
+  if (globalConfig) {
+    mergedConfig = { ...mergedConfig, ...globalConfig };
+  }
+  const envConfig = loadEnvConfig();
+  mergedConfig = { ...mergedConfig, ...envConfig };
+  return mergeConfig(mergedConfig, defaultConfig);
+}
+
+// src/index.ts
+function stringifyValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null || value === undefined) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function extractToolStateText(state) {
+  if (!state) {
+    return "";
+  }
+  const parts = [];
+  if (typeof state.raw === "string") {
+    parts.push(state.raw);
+  }
+  if (typeof state.output === "string") {
+    parts.push(state.output);
+  }
+  if (typeof state.error === "string") {
+    parts.push(state.error);
+  }
+  if (state.input && typeof state.input === "object") {
+    parts.push(stringifyValue(state.input));
+  }
+  if (typeof state.title === "string") {
+    parts.push(state.title);
+  }
+  return parts.filter((value) => value.length > 0).join(`
+`);
+}
+function extractPartText(part) {
+  if (!part || typeof part !== "object") {
+    return "";
+  }
+  if (!part.type || typeof part.type !== "string") {
+    return stringifyValue(part);
+  }
+  switch (part.type) {
+    case "text":
+    case "reasoning":
+      return part.text ?? "";
+    case "subtask":
+      return [part.prompt, part.description, part.command].filter((value) => typeof value === "string" && value.length > 0).join(`
+`);
+    case "tool":
+      return extractToolStateText(part.state);
+    case "file":
+      return [
+        part.source?.text?.value,
+        part.filename,
+        part.url,
+        part.source?.path,
+        part.source?.name,
+        part.source?.uri
+      ].filter((value) => typeof value === "string" && value.length > 0).join(`
+`);
+    case "snapshot":
+    case "step-start":
+      return part.snapshot ?? "";
+    case "step-finish":
+      return [part.reason, part.snapshot].filter((value) => typeof value === "string" && value.length > 0).join(`
+`);
+    case "patch":
+      return Array.isArray(part.files) ? part.files.join(`
+`) : "";
+    case "agent":
+      return [part.name, part.source?.text?.value].filter((value) => typeof value === "string" && value.length > 0).join(`
+`);
+    case "retry":
+      return stringifyValue(part.error);
+    case "compaction":
+      return part.auto ? "compaction:auto" : "compaction";
+    default:
+      return stringifyValue(part);
+  }
+}
+function TpsMeterPlugin(context) {
+  const safeContext = context || {};
+  const logger = safeContext.logger || {
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {}
+  };
+  let config;
+  try {
+    config = loadConfigSync();
+  } catch (error) {
+    logger.warn("[TpsMeter] Failed to load config, using defaults:", error instanceof Error ? error.message : String(error));
+    config = defaultConfig;
+  }
+  if (!config.enabled) {
+    logger.debug("[TpsMeter] Plugin disabled by configuration");
+    return {};
+  }
+  const trackers = new Map;
+  const partTextCache = new Map;
+  const messageTokenCache = new Map;
+  const messageRoleCache = new Map;
+  const messageFirstTokenCache = new Map;
+  const activeMessageCache = new Map;
+  const resolvedConfig = config;
+  const ui = createUIManager(safeContext.client || {}, resolvedConfig);
+  const tokenizer = createTokenizer(resolvedConfig.fallbackTokenHeuristic === "words_div_0_75" ? "word" : resolvedConfig.fallbackTokenHeuristic === "chars_div_3" ? "code" : "heuristic");
+  logger.info("[TpsMeter] Plugin initialized and ready");
+  function getOrCreateTracker(sessionId) {
+    let tracker = trackers.get(sessionId);
+    if (!tracker) {
+      tracker = createTracker({
+        sessionId,
+        rollingWindowMs: resolvedConfig.rollingWindowMs
+      });
+      trackers.set(sessionId, tracker);
+      logger.debug(`[TpsMeter] Created tracker for session: ${sessionId}`);
+    }
+    return tracker;
+  }
+  function cleanup() {
+    logger.debug("[TpsMeter] Cleaning up all trackers and UI");
+    trackers.clear();
+    messageRoleCache.clear();
+    messageFirstTokenCache.clear();
+    activeMessageCache.clear();
+    ui.clear();
+  }
+  function handleMessagePartUpdated(event) {
+    const part = event.properties.part;
+    let delta = event.properties.delta;
+    if (!part) {
+      return;
+    }
+    if (!COUNTABLE_PART_TYPES.has(part.type)) {
+      return;
+    }
+    const sessionId = part.sessionID || "default";
+    const partText = extractPartText(part);
+    if (!delta && partText.length > 0) {
+      const sessionCache = partTextCache.get(sessionId) || new Map;
+      partTextCache.set(sessionId, sessionCache);
+      const cacheKey = `${part.messageID}:${part.id}:${part.type}`;
+      const previousText = sessionCache.get(cacheKey) || "";
+      if (partText.startsWith(previousText)) {
+        delta = partText.slice(previousText.length);
+      } else {
+        delta = partText;
+      }
+      sessionCache.set(cacheKey, partText);
+    }
+    if (!delta || delta.length === 0) {
+      return;
+    }
+    const roleCache = messageRoleCache.get(sessionId);
+    const role = roleCache?.get(part.messageID);
+    if (role !== "assistant") {
+      return;
+    }
+    const tracker = getOrCreateTracker(sessionId);
+    const messageId = part.messageID;
+    const activeMessageId = activeMessageCache.get(sessionId);
+    if (activeMessageId !== messageId) {
+      tracker.reset();
+      activeMessageCache.set(sessionId, messageId);
+    }
+    const now = Date.now();
+    cleanupStaleMessages(now);
+    const firstTokenCache = messageFirstTokenCache.get(sessionId) || new Map;
+    messageFirstTokenCache.set(sessionId, firstTokenCache);
+    let firstTokenAt = firstTokenCache.get(messageId);
+    if (firstTokenAt === undefined) {
+      firstTokenAt = now;
+      firstTokenCache.set(messageId, firstTokenAt);
+    }
+    const tokenCount = tokenizer.count(delta);
+    tracker.recordTokens(tokenCount, now);
+    const messageCache = messageTokenCache.get(sessionId) || new Map;
+    messageTokenCache.set(sessionId, messageCache);
+    const previousTokens = messageCache.get(messageId) ?? 0;
+    messageCache.set(messageId, previousTokens + tokenCount);
+    const instantTps = tracker.getInstantTPS();
+    const avgTps = tracker.getAverageTPS();
+    const totalTokens = tracker.getTotalTokens();
+    const elapsedMs = tracker.getElapsedMs();
+    const elapsedSinceFirstToken = Math.max(0, now - firstTokenAt);
+    if (elapsedSinceFirstToken >= MIN_TPS_ELAPSED_MS && instantTps >= resolvedConfig.minVisibleTPS) {
+      ui.updateDisplay(instantTps, avgTps, totalTokens, elapsedMs);
+    }
+    logger.debug(`[TpsMeter] Session ${sessionId}: +${tokenCount} tokens, TPS: ${instantTps.toFixed(1)} (avg: ${avgTps.toFixed(1)})`);
+  }
+  function handleMessageUpdated(event) {
+    const info = event.properties.info;
+    if (!info) {
+      return;
+    }
+    const roleCache = messageRoleCache.get(info.sessionID) || new Map;
+    messageRoleCache.set(info.sessionID, roleCache);
+    roleCache.set(info.id, info.role);
+    if (info.role === "assistant") {
+      const sessionId = info.sessionID;
+      const tracker = trackers.get(sessionId);
+      const sessionCache = partTextCache.get(sessionId);
+      const tokenCache = messageTokenCache.get(sessionId) || new Map;
+      messageTokenCache.set(sessionId, tokenCache);
+      const firstTokenCache = messageFirstTokenCache.get(sessionId) || new Map;
+      messageFirstTokenCache.set(sessionId, firstTokenCache);
+      const outputTokens = info.tokens?.output ?? 0;
+      const reasoningTokens = info.tokens?.reasoning ?? 0;
+      const reportedTokens = outputTokens + reasoningTokens;
+      const messageId = info.id;
+      const previous = tokenCache.get(messageId) ?? 0;
+      const nextTokens = Math.max(previous, reportedTokens);
+      tokenCache.set(messageId, nextTokens);
+      if (info.time?.completed && tracker) {
+        const completedAt = info.time?.completed ?? Date.now();
+        const createdAt = info.time?.created ?? completedAt;
+        const firstTokenAt = firstTokenCache.get(messageId) ?? createdAt;
+        const elapsedMs = Math.max(0, completedAt - firstTokenAt);
+        const cachedTokens = tokenCache.get(messageId) ?? 0;
+        const totalTokens = reportedTokens > 0 ? reportedTokens : cachedTokens;
+        const avgTps = elapsedMs > 0 ? totalTokens / (elapsedMs / 1000) : 0;
+        const hasValidFinish = info.finish !== undefined && info.finish !== null && !INVALID_FINISH_REASONS.has(info.finish);
+        const shouldShowFinalStats = hasValidFinish && totalTokens > 0 && elapsedMs >= MIN_TPS_ELAPSED_MS;
+        if (shouldShowFinalStats) {
+          ui.showFinalStats(totalTokens, avgTps, elapsedMs);
+          logger.info(`[TpsMeter] Session ${sessionId} complete: ${totalTokens} tokens in ${(elapsedMs / 1000).toFixed(1)}s (avg ${avgTps.toFixed(1)} TPS)`);
+        }
+      }
+      if (sessionCache) {
+        for (const key of sessionCache.keys()) {
+          if (key.startsWith(`${info.id}:`)) {
+            sessionCache.delete(key);
+          }
+        }
+      }
+      if (info.time?.completed) {
+        tokenCache.delete(messageId);
+        roleCache.delete(messageId);
+        firstTokenCache.delete(messageId);
+      }
+    }
+    if (info.error) {
+      logger.warn(`[TpsMeter] Message error for session: ${info.sessionID}`);
+    }
+  }
+  function handleSessionIdle(event) {
+    const sessionId = event.properties.sessionID || "default";
+    logger.debug(`[TpsMeter] Session idle: ${sessionId}`);
+    trackers.delete(sessionId);
+    partTextCache.delete(sessionId);
+    messageTokenCache.delete(sessionId);
+    messageRoleCache.delete(sessionId);
+    messageFirstTokenCache.delete(sessionId);
+    activeMessageCache.delete(sessionId);
+    if (trackers.size === 0) {
+      cleanup();
+    }
+  }
+  let lastCleanupTime = 0;
+  function cleanupStaleMessages(now) {
+    if (now - lastCleanupTime < CLEANUP_INTERVAL_MS) {
+      return;
+    }
+    lastCleanupTime = now;
+    let cleanedCount = 0;
+    for (const [sessionId, firstTokenCache] of messageFirstTokenCache) {
+      const tokenCache = messageTokenCache.get(sessionId);
+      const roleCache = messageRoleCache.get(sessionId);
+      for (const [messageId, firstTokenAt] of firstTokenCache) {
+        if (now - firstTokenAt > MAX_MESSAGE_AGE_MS) {
+          firstTokenCache.delete(messageId);
+          tokenCache?.delete(messageId);
+          roleCache?.delete(messageId);
+          cleanedCount++;
+        }
+      }
+    }
+    if (cleanedCount > 0) {
+      logger.debug(`[TpsMeter] Cleaned up ${cleanedCount} stale message entries`);
+    }
+  }
+  return {
+    event: async ({ event }) => {
+      try {
+        switch (event.type) {
+          case "message.part.updated":
+            handleMessagePartUpdated(event);
+            break;
+          case "message.updated":
+            handleMessageUpdated(event);
+            break;
+          case "session.idle":
+            handleSessionIdle(event);
+            break;
+          default:
+            break;
+        }
+      } catch (error) {
+        logger.error("[TpsMeter] Error handling event:", error instanceof Error ? error.message : String(error));
+      }
+    }
+  };
+}