opencode-tui-stats 0.4.1 → 0.4.3

package/dist/tui.js

@@ -0,0 +1,949 @@
+// @bun
+// tui.tsx
+import { createComponent as _$createComponent } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { effect as _$effect } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createTextNode as _$createTextNode } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { insertNode as _$insertNode } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { insert as _$insert } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { memo as _$memo } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { setProp as _$setProp } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createElement as _$createElement } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { For, Show, createEffect, createMemo, createSignal, onCleanup } from "opentui:runtime-module:solid-js";
+
+// tracker.ts
+var STREAM_WINDOW_MS = 5000;
+var LIVE_STALE_MS = 1500;
+var SINGLE_SAMPLE_MS = 1000;
+var PART_CACHE_LIMIT = 1024;
+var DEDUP_WINDOW_LIMIT = 64;
+var MESSAGE_MODEL_LIMIT = 256;
+var SESSION_LIMIT = 64;
+var SUBTREE_LIMIT = 64;
+var MODEL_ROW_LIMIT = 4;
+function emptyStats() {
+  return {
+    cacheRead: 0,
+    cachePrompt: 0,
+    cost: 0,
+    steps: 0,
+    retries: 0,
+    lastAttempt: 0
+  };
+}
+function emptyAggregate() {
+  return {
+    cacheRead: 0,
+    cachePrompt: 0,
+    cost: 0,
+    steps: 0,
+    totalTokens: 0,
+    totalDurationMs: 0,
+    totalTtftMs: 0,
+    stepCount: 0,
+    lastAt: 0
+  };
+}
+function modelKey(providerID, modelID) {
+  return `${providerID}/${modelID}`;
+}
+function estimateTokens(delta) {
+  return Math.max(1, Math.ceil(Buffer.byteLength(delta, "utf8") / 5));
+}
+function formatRate(value) {
+  if (!Number.isFinite(value) || value <= 0)
+    return;
+  if (value >= 100)
+    return Math.round(value).toString();
+  if (value >= 10)
+    return value.toFixed(1);
+  return value.toFixed(2);
+}
+function formatTtft(value) {
+  if (!Number.isFinite(value) || value < 0)
+    return;
+  return `${value.toFixed(1)}s`;
+}
+function activeDuration(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[samples.length - 1].at);
+  return Math.max(duration, SINGLE_SAMPLE_MS);
+}
+function averageRate(average) {
+  if (!average || average.totalTokens <= 0 || average.totalDurationMs <= 0)
+    return;
+  return formatRate(average.totalTokens / (average.totalDurationMs / 1000));
+}
+function averageTtft(average) {
+  if (!average || average.stepCount <= 0)
+    return;
+  return formatTtft(average.totalTtftMs / average.stepCount / 1000);
+}
+function cacheText(stats) {
+  if (!stats || stats.cachePrompt <= 0)
+    return;
+  return `${(stats.cacheRead / stats.cachePrompt * 100).toFixed(1)}%`;
+}
+function costText(stats) {
+  if (!stats || stats.steps <= 0)
+    return;
+  return `$${stats.cost.toFixed(4)}`;
+}
+function boundedAdd(set, key, limit) {
+  if (set.has(key))
+    return;
+  if (set.size >= limit) {
+    const oldest = set.values().next().value;
+    if (oldest !== undefined)
+      set.delete(oldest);
+  }
+  set.add(key);
+}
+function boundedSet(map, key, value, limit) {
+  if (map.has(key))
+    return;
+  if (map.size >= limit) {
+    const oldest = map.keys().next().value;
+    if (oldest !== undefined)
+      map.delete(oldest);
+  }
+  map.set(key, value);
+}
+var lastInternals;
+function createTracker(api, onChange) {
+  const tracker = {
+    samples: {},
+    timings: {},
+    averages: {},
+    stats: {},
+    dedup: {},
+    models: {},
+    parentOf: {}
+  };
+  const partDecisions = new Map;
+  const mounted = new Set;
+  const order = [];
+  const listeners = [];
+  const bump = () => onChange();
+  const clearLive = (sessionID) => {
+    if (!tracker.samples[sessionID]?.length)
+      return;
+    delete tracker.samples[sessionID];
+    bump();
+  };
+  const clearTimings = (sessionID) => {
+    let changed = false;
+    for (const [messageID, timing] of Object.entries(tracker.timings)) {
+      if (timing.sessionID !== sessionID)
+        continue;
+      delete tracker.timings[messageID];
+      changed = true;
+    }
+    if (changed)
+      bump();
+  };
+  const evictSession = (sessionID) => {
+    delete tracker.stats[sessionID];
+    delete tracker.averages[sessionID];
+    delete tracker.samples[sessionID];
+    delete tracker.dedup[sessionID];
+    delete tracker.models[sessionID];
+    delete tracker.parentOf[sessionID];
+    clearTimings(sessionID);
+  };
+  const touchSession = (sessionID) => {
+    const at = order.indexOf(sessionID);
+    if (at !== -1)
+      order.splice(at, 1);
+    order.push(sessionID);
+    let index = 0;
+    while (order.length > SESSION_LIMIT && index < order.length) {
+      const candidate = order[index];
+      if (mounted.has(candidate)) {
+        index += 1;
+        continue;
+      }
+      order.splice(index, 1);
+      evictSession(candidate);
+    }
+  };
+  const touchModel = (models, key) => {
+    const at = models.order.indexOf(key);
+    if (at !== -1)
+      models.order.splice(at, 1);
+    models.order.push(key);
+    if (!models.aggregates[key])
+      models.aggregates[key] = emptyAggregate();
+  };
+  const prune = (now = Date.now()) => {
+    let changed = false;
+    for (const [sessionID, samples] of Object.entries(tracker.samples)) {
+      const next = samples.filter((sample) => now - sample.at <= STREAM_WINDOW_MS);
+      if (next.length === samples.length)
+        continue;
+      changed = true;
+      if (next.length > 0)
+        tracker.samples[sessionID] = next;
+      else
+        delete tracker.samples[sessionID];
+    }
+    if (changed)
+      bump();
+  };
+  const appendSample = (sessionID, messageID, sample) => {
+    touchSession(sessionID);
+    tracker.samples[sessionID] = [...(tracker.samples[sessionID] ?? []).filter((item) => sample.at - item.at <= STREAM_WINDOW_MS), sample];
+    const timing = tracker.timings[messageID];
+    if (timing && timing.firstResponseAt === undefined)
+      timing.firstResponseAt = sample.at;
+    bump();
+  };
+  const sessionLiveRate = (sessionID, key) => {
+    const frozen = {
+      value: tracker.models[sessionID]?.lastRate[key],
+      live: false
+    };
+    const status = api.state.session.status(sessionID);
+    if (!status || status.type === "idle")
+      return frozen;
+    const now = Date.now();
+    const mapping = tracker.models[sessionID]?.messageModels;
+    const samples = (tracker.samples[sessionID] ?? []).filter((sample) => now - sample.at <= STREAM_WINDOW_MS && mapping?.get(sample.messageID) === key);
+    const last = samples[samples.length - 1];
+    if (!last || now - last.at > LIVE_STALE_MS)
+      return frozen;
+    const tokens = samples.reduce((sum, sample) => sum + sample.tokens, 0);
+    const value = formatRate(tokens / (activeDuration(samples, now) / 1000));
+    if (value === undefined)
+      return frozen;
+    const models = tracker.models[sessionID];
+    if (models)
+      models.lastRate[key] = value;
+    return {
+      value,
+      live: true
+    };
+  };
+  const resolveParent = (sessionID) => {
+    if (sessionID in tracker.parentOf)
+      return;
+    const info = api.state.session.get(sessionID);
+    if (!info)
+      return;
+    tracker.parentOf[sessionID] = info.parentID;
+  };
+  const rememberParent = (sessionID, parentID) => {
+    if (sessionID in tracker.parentOf && tracker.parentOf[sessionID] === parentID)
+      return;
+    tracker.parentOf[sessionID] = parentID;
+    bump();
+  };
+  const knownSessions = () => {
+    const ids = new Set(Object.keys(tracker.models));
+    for (const id of Object.keys(tracker.stats))
+      ids.add(id);
+    for (const id of Object.keys(tracker.averages))
+      ids.add(id);
+    return ids;
+  };
+  const descendants = (sessionID) => {
+    const children = new Map;
+    for (const [child, parent] of Object.entries(tracker.parentOf)) {
+      if (!parent)
+        continue;
+      const siblings = children.get(parent);
+      if (siblings)
+        siblings.push(child);
+      else
+        children.set(parent, [child]);
+    }
+    const seen = new Set([sessionID]);
+    const found = [];
+    const queue = [sessionID];
+    while (queue.length > 0 && found.length < SUBTREE_LIMIT) {
+      const current = queue.shift();
+      for (const child of children.get(current) ?? []) {
+        if (seen.has(child))
+          continue;
+        seen.add(child);
+        found.push(child);
+        queue.push(child);
+        if (found.length >= SUBTREE_LIMIT)
+          break;
+      }
+    }
+    return found;
+  };
+  const mergeAggregate = (target, source) => {
+    target.cacheRead += source.cacheRead;
+    target.cachePrompt += source.cachePrompt;
+    target.cost += source.cost;
+    target.steps += source.steps;
+    target.totalTokens += source.totalTokens;
+    target.totalDurationMs += source.totalDurationMs;
+    target.totalTtftMs += source.totalTtftMs;
+    target.stepCount += source.stepCount;
+    target.lastAt = Math.max(target.lastAt, source.lastAt);
+  };
+  const sessionModelAt = (sessionID) => {
+    const models = tracker.models[sessionID];
+    if (!models)
+      return 0;
+    let at = 0;
+    for (const key of models.order) {
+      const aggregate = models.aggregates[key];
+      if (aggregate && aggregate.lastAt > at)
+        at = aggregate.lastAt;
+    }
+    return at;
+  };
+  const liveRateFor = (sessions, key) => {
+    let latest;
+    for (const sessionID of sessions) {
+      const aggregate = tracker.models[sessionID]?.aggregates[key];
+      if (!aggregate)
+        continue;
+      if (!latest || aggregate.lastAt >= latest.at)
+        latest = {
+          sessionID,
+          at: aggregate.lastAt
+        };
+    }
+    if (!latest)
+      return {
+        live: false
+      };
+    return sessionLiveRate(latest.sessionID, key);
+  };
+  const modelRows = (sessionID) => {
+    for (const id of knownSessions())
+      resolveParent(id);
+    const subtree = [sessionID, ...descendants(sessionID)];
+    const retries = tracker.stats[sessionID]?.retries ?? 0;
+    let cacheRead = 0;
+    let cachePrompt = 0;
+    for (const id of subtree) {
+      const stats = tracker.stats[id];
+      if (!stats)
+        continue;
+      cacheRead += stats.cacheRead;
+      cachePrompt += stats.cachePrompt;
+    }
+    const cache = cacheText({
+      cacheRead,
+      cachePrompt
+    });
+    const sessions = subtree.filter((id) => tracker.models[id]).sort((left, right) => sessionModelAt(left) - sessionModelAt(right));
+    if (sessions.length === 0)
+      return {
+        rows: [],
+        overflow: 0,
+        retries,
+        cache
+      };
+    const order2 = [];
+    const aggregates = {};
+    const subagentModels = new Set;
+    for (const id of sessions) {
+      const models = tracker.models[id];
+      for (const key of models.order) {
+        const aggregate = models.aggregates[key];
+        if (!aggregate)
+          continue;
+        let merged = aggregates[key];
+        if (!merged) {
+          merged = emptyAggregate();
+          aggregates[key] = merged;
+          order2.push(key);
+        }
+        mergeAggregate(merged, aggregate);
+        if (id !== sessionID)
+          subagentModels.add(key);
+      }
+    }
+    let active;
+    for (const id of sessions)
+      active = tracker.models[id].active ?? active;
+    const recency = [...order2].reverse();
+    const ordered = active && active in aggregates ? [active, ...recency.filter((key) => key !== active)] : recency;
+    const visible = ordered.slice(0, MODEL_ROW_LIMIT);
+    const overflow = Math.max(0, ordered.length - visible.length);
+    const rows = visible.map((key) => {
+      const aggregate = aggregates[key];
+      const isActive = key === active;
+      const tps = isActive ? liveRateFor(subtree, key) : {
+        value: undefined,
+        live: false
+      };
+      return {
+        key,
+        label: key,
+        active: isActive,
+        subagent: subagentModels.has(key),
+        tps: tps.value,
+        tpsLive: tps.live,
+        avg: averageRate(aggregate),
+        ttft: averageTtft(aggregate),
+        cache: cacheText(aggregate),
+        cost: costText(aggregate)
+      };
+    });
+    return {
+      rows,
+      overflow,
+      retries,
+      cache
+    };
+  };
+  listeners.push(api.event.on("message.part.delta", (event) => {
+    if (event.properties.field !== "text")
+      return;
+    const {
+      sessionID,
+      messageID,
+      partID
+    } = event.properties;
+    let counted = partDecisions.get(partID);
+    if (counted === undefined) {
+      const part = api.state.part(messageID).find((item) => item.id === partID);
+      if (!part)
+        return;
+      counted = part.type === "text" || part.type === "reasoning";
+      boundedSet(partDecisions, partID, counted, PART_CACHE_LIMIT);
+    }
+    if (!counted)
+      return;
+    appendSample(sessionID, messageID, {
+      at: Date.now(),
+      messageID,
+      tokens: estimateTokens(event.properties.delta)
+    });
+  }));
+  listeners.push(api.event.on("message.updated", (event) => {
+    const info = event.properties.info;
+    if (info.role !== "assistant")
+      return;
+    const sessionID = event.properties.sessionID;
+    const key = modelKey(info.providerID, info.modelID);
+    const models = tracker.models[sessionID] ?? (tracker.models[sessionID] = {
+      order: [],
+      aggregates: {},
+      messageModels: new Map,
+      lastRate: {}
+    });
+    touchModel(models, key);
+    models.active = key;
+    models.aggregates[key] = {
+      ...models.aggregates[key],
+      lastAt: Date.now()
+    };
+    boundedSet(models.messageModels, info.id, key, MESSAGE_MODEL_LIMIT);
+    if (!info.time.completed) {
+      const existing = tracker.timings[info.id];
+      tracker.timings[info.id] = {
+        sessionID,
+        requestStartAt: info.time.created,
+        firstResponseAt: existing?.firstResponseAt,
+        lastToolCallAt: existing?.lastToolCallAt
+      };
+      bump();
+      return;
+    }
+    const seen = tracker.dedup[sessionID] ?? (tracker.dedup[sessionID] = new Set);
+    if (!seen.has(info.id)) {
+      boundedAdd(seen, info.id, DEDUP_WINDOW_LIMIT);
+      touchSession(sessionID);
+      const stats = tracker.stats[sessionID] ?? emptyStats();
+      const cacheRead = info.tokens.cache.read;
+      const cacheWrite = info.tokens.cache.write;
+      tracker.stats[sessionID] = {
+        ...stats,
+        cacheRead: stats.cacheRead + cacheRead,
+        cachePrompt: stats.cachePrompt + info.tokens.input + cacheRead + cacheWrite,
+        cost: stats.cost + info.cost,
+        steps: stats.steps + 1
+      };
+      const aggregate = models.aggregates[key] ?? emptyAggregate();
+      models.aggregates[key] = {
+        ...aggregate,
+        cacheRead: aggregate.cacheRead + cacheRead,
+        cachePrompt: aggregate.cachePrompt + info.tokens.input + cacheRead + cacheWrite,
+        cost: aggregate.cost + info.cost,
+        steps: aggregate.steps + 1
+      };
+    }
+    const timing = tracker.timings[info.id];
+    if (timing?.sessionID === sessionID && timing.firstResponseAt !== undefined) {
+      const tokens = info.tokens.output + info.tokens.reasoning;
+      const endAt = info.finish === "tool-calls" ? timing.lastToolCallAt : info.time.completed;
+      const durationMs = endAt !== undefined ? Math.max(endAt - timing.firstResponseAt, 1) : undefined;
+      if (tokens > 0 && durationMs !== undefined) {
+        const totals = tracker.averages[sessionID] ?? {
+          totalTokens: 0,
+          totalDurationMs: 0,
+          totalTtftMs: 0,
+          stepCount: 0
+        };
+        tracker.averages[sessionID] = {
+          totalTokens: totals.totalTokens + tokens,
+          totalDurationMs: totals.totalDurationMs + durationMs,
+          totalTtftMs: totals.totalTtftMs + Math.max(timing.firstResponseAt - timing.requestStartAt, 0),
+          stepCount: totals.stepCount + 1
+        };
+        const aggregate = models.aggregates[key] ?? emptyAggregate();
+        models.aggregates[key] = {
+          ...aggregate,
+          totalTokens: aggregate.totalTokens + tokens,
+          totalDurationMs: aggregate.totalDurationMs + durationMs,
+          totalTtftMs: aggregate.totalTtftMs + Math.max(timing.firstResponseAt - timing.requestStartAt, 0),
+          stepCount: aggregate.stepCount + 1
+        };
+      }
+    }
+    delete tracker.timings[info.id];
+    prune(info.time.completed);
+    bump();
+  }));
+  listeners.push(api.event.on("message.part.updated", (event) => {
+    const part = event.properties.part;
+    if (part.type !== "tool")
+      return;
+    if (part.state.status === "running" || part.state.status === "completed" || part.state.status === "error") {
+      clearLive(part.sessionID);
+    }
+    const timing = tracker.timings[part.messageID];
+    if (!timing)
+      return;
+    if (part.state.status === "pending") {
+      if (timing.firstResponseAt === undefined)
+        timing.firstResponseAt = Date.now();
+      bump();
+      return;
+    }
+    if (part.state.status === "running") {
+      timing.lastToolCallAt = part.state.time.start;
+      bump();
+    }
+  }));
+  listeners.push(api.event.on("session.status", (event) => {
+    const {
+      sessionID,
+      status
+    } = event.properties;
+    const type = status.type;
+    if (type === "idle")
+      clearTimings(sessionID);
+    const stats = tracker.stats[sessionID] ?? emptyStats();
+    if (type === "retry") {
+      const attempt = status.attempt;
+      if (attempt <= stats.lastAttempt)
+        return;
+      touchSession(sessionID);
+      tracker.stats[sessionID] = {
+        ...stats,
+        retries: stats.retries + (attempt - stats.lastAttempt),
+        lastAttempt: attempt
+      };
+      bump();
+      return;
+    }
+    if (stats.lastAttempt === 0)
+      return;
+    touchSession(sessionID);
+    tracker.stats[sessionID] = {
+      ...stats,
+      lastAttempt: 0
+    };
+    bump();
+  }));
+  listeners.push(api.event.on("session.idle", (event) => {
+    clearTimings(event.properties.sessionID);
+  }));
+  listeners.push(api.event.on("session.created", (event) => {
+    rememberParent(event.properties.info.id, event.properties.info.parentID);
+  }));
+  listeners.push(api.event.on("session.updated", (event) => {
+    rememberParent(event.properties.info.id, event.properties.info.parentID);
+  }));
+  const timer = setInterval(() => {
+    prune();
+    bump();
+  }, 1000);
+  const internals = {
+    sizes: () => ({
+      parts: partDecisions.size,
+      dedup: Object.values(tracker.dedup).reduce((sum, set) => sum + set.size, 0),
+      stats: Object.keys(tracker.stats).length,
+      averages: Object.keys(tracker.averages).length,
+      timings: Object.keys(tracker.timings).length,
+      mounted: mounted.size
+    }),
+    partDecision: (partID) => partDecisions.get(partID),
+    hasStats: (sessionID) => (sessionID in tracker.stats),
+    dedupSize: (sessionID) => tracker.dedup[sessionID]?.size ?? 0,
+    retries: (sessionID) => tracker.stats[sessionID]?.retries ?? 0,
+    mounted: () => [...mounted],
+    activeModel: (sessionID) => tracker.models[sessionID]?.active
+  };
+  lastInternals = internals;
+  return {
+    modelRows,
+    mountSession(sessionID) {
+      mounted.add(sessionID);
+    },
+    unmountSession(sessionID) {
+      mounted.delete(sessionID);
+    },
+    prune,
+    internals,
+    dispose() {
+      for (const unsubscribe of listeners)
+        unsubscribe();
+      listeners.length = 0;
+      clearInterval(timer);
+      mounted.clear();
+      if (lastInternals === internals)
+        lastInternals = undefined;
+    }
+  };
+}
+var lastPanelController;
+function setLastPanelController(controller) {
+  lastPanelController = controller;
+}
+function clearLastPanelController(controller) {
+  if (lastPanelController === controller)
+    lastPanelController = undefined;
+}
+
+// tui.tsx
+var DETAIL_INDENT = "   ";
+var RATE_CELL = 4;
+var TTFT_CELL = 6;
+var CACHE_CELL = 6;
+function splitLabel(label) {
+  const slash = label.indexOf("/");
+  if (slash <= 0)
+    return {
+      provider: "",
+      model: label
+    };
+  const provider = label.slice(0, slash);
+  const model = label.slice(slash + 1);
+  if (model.toLowerCase().startsWith(provider.toLowerCase()))
+    return {
+      provider: "",
+      model
+    };
+  return {
+    provider: `${provider}/`,
+    model
+  };
+}
+function rateCell(value) {
+  return value === undefined ? "\u2014" : `${value.padStart(RATE_CELL)}t/s`;
+}
+function ttftCell(value) {
+  return (value ?? "\u2014").padEnd(TTFT_CELL);
+}
+function cacheCell(value) {
+  if (value === undefined)
+    return "\u2014".padStart(CACHE_CELL);
+  const percent = value.endsWith("%") ? value.slice(0, -1) : value;
+  return `${percent.padStart(5)}%`;
+}
+function ModelRowView(props) {
+  let pressed;
+  const handleMouseDown = (event) => {
+    pressed = {
+      x: event.x,
+      y: event.y
+    };
+  };
+  const handleMouseUp = (event) => {
+    const start = pressed;
+    pressed = undefined;
+    if (start && (start.x !== event.x || start.y !== event.y))
+      return;
+    props.onToggle();
+  };
+  const theme = () => props.api.theme.current;
+  const parts = () => splitLabel(props.row.label);
+  return (() => {
+    var _el$ = _$createElement("box"), _el$2 = _$createElement("text"), _el$3 = _$createElement("span"), _el$4 = _$createElement("span"), _el$8 = _$createElement("span");
+    _$insertNode(_el$, _el$2);
+    _$setProp(_el$, "flexDirection", "column");
+    _$setProp(_el$, "onMouseDown", handleMouseDown);
+    _$setProp(_el$, "onMouseUp", handleMouseUp);
+    _$insertNode(_el$2, _el$3);
+    _$insertNode(_el$2, _el$4);
+    _$insertNode(_el$2, _el$8);
+    _$setProp(_el$2, "wrapMode", "none");
+    _$setProp(_el$2, "truncate", true);
+    _$insert(_el$3, () => props.row.active ? "\u25CF " : "  ");
+    _$insert(_el$4, () => `${props.expanded ? "\u25BC" : "\u25B6"} `);
+    _$insert(_el$2, _$createComponent(Show, {
+      get when() {
+        return props.row.subagent;
+      },
+      get children() {
+        var _el$5 = _$createElement("span");
+        _$insertNode(_el$5, _$createTextNode(`\u21B3 `));
+        _$effect((_$p) => _$setProp(_el$5, "style", {
+          fg: theme().textMuted
+        }, _$p));
+        return _el$5;
+      }
+    }), _el$8);
+    _$insert(_el$2, _$createComponent(Show, {
+      get when() {
+        return parts().provider;
+      },
+      get children() {
+        var _el$7 = _$createElement("span");
+        _$insert(_el$7, () => parts().provider);
+        _$effect((_$p) => _$setProp(_el$7, "style", {
+          fg: theme().text,
+          dim: true
+        }, _$p));
+        return _el$7;
+      }
+    }), _el$8);
+    _$insert(_el$8, () => parts().model);
+    _$insert(_el$, _$createComponent(Show, {
+      get when() {
+        return props.expanded;
+      },
+      get children() {
+        return [(() => {
+          var _el$9 = _$createElement("text"), _el$0 = _$createElement("span");
+          _$insertNode(_el$9, _el$0);
+          _$setProp(_el$9, "wrapMode", "none");
+          _$setProp(_el$9, "truncate", true);
+          _$insert(_el$0, () => `${DETAIL_INDENT}AVG ${rateCell(props.row.avg)}`);
+          _$insert(_el$9, _$createComponent(Show, {
+            get when() {
+              return props.row.tps !== undefined;
+            },
+            get children() {
+              return [(() => {
+                var _el$1 = _$createElement("span");
+                _$insertNode(_el$1, _$createTextNode(` \xB7 TPS `));
+                _$effect((_$p) => _$setProp(_el$1, "style", {
+                  fg: theme().textMuted
+                }, _$p));
+                return _el$1;
+              })(), (() => {
+                var _el$11 = _$createElement("span");
+                _$insert(_el$11, () => rateCell(props.row.tps));
+                _$effect((_$p) => _$setProp(_el$11, "style", {
+                  fg: theme().textMuted,
+                  dim: !props.row.tpsLive
+                }, _$p));
+                return _el$11;
+              })()];
+            }
+          }), null);
+          _$effect((_p$) => {
+            var _v$ = theme().textMuted, _v$2 = {
+              fg: theme().textMuted
+            };
+            _v$ !== _p$.e && (_p$.e = _$setProp(_el$9, "fg", _v$, _p$.e));
+            _v$2 !== _p$.t && (_p$.t = _$setProp(_el$0, "style", _v$2, _p$.t));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined
+          });
+          return _el$9;
+        })(), (() => {
+          var _el$12 = _$createElement("text");
+          _$setProp(_el$12, "wrapMode", "none");
+          _$setProp(_el$12, "truncate", true);
+          _$insert(_el$12, () => `${DETAIL_INDENT}TTFT ${ttftCell(props.row.ttft)} \xB7 CACHE ${cacheCell(props.row.cache)}`);
+          _$effect((_$p) => _$setProp(_el$12, "fg", theme().textMuted, _$p));
+          return _el$12;
+        })(), (() => {
+          var _el$13 = _$createElement("text");
+          _$setProp(_el$13, "wrapMode", "none");
+          _$setProp(_el$13, "truncate", true);
+          _$insert(_el$13, () => `${DETAIL_INDENT}${props.row.cost ?? "\u2014"}`);
+          _$effect((_$p) => _$setProp(_el$13, "fg", theme().textMuted, _$p));
+          return _el$13;
+        })()];
+      }
+    }), null);
+    _$effect((_p$) => {
+      var _v$3 = {
+        fg: theme().success
+      }, _v$4 = {
+        fg: theme().textMuted
+      }, _v$5 = {
+        fg: theme().text
+      };
+      _v$3 !== _p$.e && (_p$.e = _$setProp(_el$3, "style", _v$3, _p$.e));
+      _v$4 !== _p$.t && (_p$.t = _$setProp(_el$4, "style", _v$4, _p$.t));
+      _v$5 !== _p$.a && (_p$.a = _$setProp(_el$8, "style", _v$5, _p$.a));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined
+    });
+    return _el$;
+  })();
+}
+function ModelPanelView(props) {
+  let mounted;
+  const initialActive = props.tracker.internals.activeModel(props.sessionID);
+  const [expanded, setExpanded] = createSignal(new Set(initialActive ? [initialActive] : []));
+  let seededActive = initialActive;
+  let lastSession = props.sessionID;
+  const panel = createMemo(() => {
+    props.revision();
+    const sessionID = props.sessionID;
+    if (mounted !== sessionID) {
+      if (mounted !== undefined)
+        props.tracker.unmountSession(mounted);
+      props.tracker.mountSession(sessionID);
+      mounted = sessionID;
+    }
+    return props.tracker.modelRows(sessionID);
+  });
+  createEffect(() => {
+    props.revision();
+    const sessionID = props.sessionID;
+    const active = props.tracker.internals.activeModel(sessionID);
+    if (sessionID !== lastSession) {
+      lastSession = sessionID;
+      seededActive = active;
+      setExpanded(new Set(active ? [active] : []));
+      return;
+    }
+    if (active && active !== seededActive) {
+      seededActive = active;
+      setExpanded(new Set([active]));
+    }
+  });
+  const toggle = (key) => {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      if (next.has(key))
+        next.delete(key);
+      else
+        next.add(key);
+      return next;
+    });
+    props.api.renderer?.requestRender?.();
+  };
+  const controller = {
+    toggle,
+    isExpanded: (key) => expanded().has(key)
+  };
+  setLastPanelController(controller);
+  onCleanup(() => {
+    if (mounted !== undefined)
+      props.tracker.unmountSession(mounted);
+    clearLastPanelController(controller);
+  });
+  return (() => {
+    var _el$14 = _$createElement("box"), _el$15 = _$createElement("text"), _el$16 = _$createElement("b"), _el$21 = _$createElement("text");
+    _$insertNode(_el$14, _el$15);
+    _$insertNode(_el$14, _el$21);
+    _$setProp(_el$14, "flexDirection", "column");
+    _$insertNode(_el$15, _el$16);
+    _$setProp(_el$15, "wrapMode", "none");
+    _$setProp(_el$15, "truncate", true);
+    _$insertNode(_el$16, _$createTextNode(`Model-Performance \xB7 observed`));
+    _$insert(_el$14, _$createComponent(Show, {
+      get when() {
+        return panel().rows.length === 0;
+      },
+      get children() {
+        var _el$18 = _$createElement("text");
+        _$insertNode(_el$18, _$createTextNode(`\u2014`));
+        _$setProp(_el$18, "wrapMode", "none");
+        _$setProp(_el$18, "truncate", true);
+        _$effect((_$p) => _$setProp(_el$18, "fg", props.api.theme.current.textMuted, _$p));
+        return _el$18;
+      }
+    }), _el$21);
+    _$insert(_el$14, _$createComponent(For, {
+      get each() {
+        return panel().rows;
+      },
+      children: (row) => _$createComponent(ModelRowView, {
+        get api() {
+          return props.api;
+        },
+        row,
+        get expanded() {
+          return expanded().has(row.key);
+        },
+        onToggle: () => toggle(row.key)
+      })
+    }), _el$21);
+    _$insert(_el$14, _$createComponent(Show, {
+      get when() {
+        return panel().overflow > 0;
+      },
+      get children() {
+        var _el$20 = _$createElement("text");
+        _$setProp(_el$20, "wrapMode", "none");
+        _$setProp(_el$20, "truncate", true);
+        _$insert(_el$20, () => `+${panel().overflow} more models`);
+        _$effect((_$p) => _$setProp(_el$20, "fg", props.api.theme.current.textMuted, _$p));
+        return _el$20;
+      }
+    }), _el$21);
+    _$setProp(_el$21, "wrapMode", "none");
+    _$setProp(_el$21, "truncate", true);
+    _$insert(_el$21, () => `Session CACHE ${panel().cache ?? "\u2014"}${panel().retries > 0 ? ` \xB7 retries ${panel().retries}` : ""}`);
+    _$effect((_p$) => {
+      var _v$6 = props.api.theme.current.text, _v$7 = props.api.theme.current.textMuted;
+      _v$6 !== _p$.e && (_p$.e = _$setProp(_el$15, "fg", _v$6, _p$.e));
+      _v$7 !== _p$.t && (_p$.t = _$setProp(_el$21, "fg", _v$7, _p$.t));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined
+    });
+    return _el$14;
+  })();
+}
+var tui = async (api) => {
+  const [revision, setRevision] = createSignal(0);
+  const tracker = createTracker(api, () => setRevision((value) => value + 1));
+  api.lifecycle.onDispose(() => tracker.dispose());
+  api.slots.register({
+    slots: {
+      sidebar_footer(_context, props) {
+        return _$createComponent(ModelPanelView, {
+          api,
+          get sessionID() {
+            return props.session_id;
+          },
+          tracker,
+          revision
+        });
+      }
+    }
+  });
+};
+var plugin = {
+  id: "opencode-tui-stats",
+  tui
+};
+var tui_default = plugin;
+export {
+  tui_default as default
+};