@ymys4ever/opencode-throughput-v2 4.0.1 → 4.0.2

package/src/benchmark.ts

@@ -1,112 +0,0 @@
-import type { LogEntry } from "./types.js"
-import { aggregateAt } from "./core/stats.js"
-import { formatMs, formatNum } from "./format/entry.js"
-import { createLogStore, type LogStore } from "./io/log-store.js"
-
-export interface BenchmarkDeps {
-  logStore?: LogStore
-}
-
-export async function executeBenchmark(
-  argsRaw: unknown,
-  deps?: BenchmarkDeps
-): Promise<{ content: string }> {
-  const args = (argsRaw ?? {}) as { model?: string; last?: number }
-  const store = deps?.logStore ?? createLogStore()
-
-  let entries: LogEntry[]
-  let skipped = 0
-  try {
-    const read = store.read()
-    entries = read.entries
-    skipped = read.skipped
-  } catch (e) {
-    return {
-      content: `Failed to read log file: ${e instanceof Error ? e.message : String(e)}`,
-    }
-  }
-
-  if (entries.length === 0) {
-    return {
-      content:
-        "No benchmark data yet. The throughput plugin needs to process at least one LLM response before stats are available.",
-    }
-  }
-
-  const keyword = args.model?.toLowerCase()
-  const filtered = keyword
-    ? entries.filter(
-        (l: LogEntry) =>
-          l.model.toLowerCase().includes(keyword) ||
-          l.modelID.toLowerCase().includes(keyword)
-      )
-    : entries
-
-  if (keyword && filtered.length === 0) {
-    return { content: `No entries match filter: ${args.model}` }
-  }
-
-  // Defensive last: only a positive integer is honored, otherwise ignored.
-  const last =
-    args.last !== undefined && Number.isInteger(args.last) && args.last >= 1 ? args.last : undefined
-  const sliced = last ? filtered.slice(-last) : filtered
-
-  const byModel = new Map<string, LogEntry[]>()
-  for (const entry of sliced) {
-    const arr = byModel.get(entry.model) ?? []
-    arr.push(entry)
-    byModel.set(entry.model, arr)
-  }
-
-  const statsByModel = aggregateAt(sliced, Date.now())
-
-  const lines: string[] = []
-  lines.push(`## Model Performance Benchmark`)
-  lines.push(`Total requests: ${sliced.length}`)
-  if (args.model) lines.push(`Filter: ${args.model}`)
-  lines.push(``)
-
-  for (const [model, modelEntries] of byModel) {
-    const s = statsByModel.get(model)
-    if (!s) continue
-    lines.push(`### ${model}`)
-    lines.push(`  Requests: ${modelEntries.length}`)
-    lines.push(``)
-    lines.push(`  **Latency:**`)
-    lines.push(
-      `    TTFT:  avg ${formatMs(s.avgTTFT)} | min ${formatMs(s.minTTFT)} | max ${formatMs(s.maxTTFT)}`
-    )
-    lines.push(
-      `    Total: avg ${formatMs(s.avgLatency)} | min ${formatMs(s.minLatency)} | max ${formatMs(s.maxLatency)}`
-    )
-    lines.push(``)
-    lines.push(`  **Throughput:**`)
-    lines.push(`    TPS:  avg ${formatNum(s.avgTPS)} | max ${formatNum(s.maxTPS)}`)
-    lines.push(``)
-    lines.push(`  **Tokens:**`)
-    lines.push(`    Input:     ${formatNum(s.totalInputTokens)}`)
-    lines.push(`    Output:    ${formatNum(s.totalOutputTokens)}`)
-    lines.push(`    Reasoning: ${formatNum(s.totalReasoningTokens)}`)
-    lines.push(`    Cache R/W: ${formatNum(s.totalCacheReadTokens)} / ${formatNum(s.totalCacheWriteTokens)}`)
-    lines.push(``)
-    lines.push(`  **Cost:** $${s.totalCost.toFixed(4)}`)
-
-    if (modelEntries.length <= 5) {
-      lines.push(``)
-      lines.push(`  Recent entries:`)
-      for (const e of modelEntries) {
-        lines.push(
-          `    ${e.ts} | ${formatMs(e.ttft_ms)} TTFT | ${formatNum(e.tps)} tok/s | ${formatMs(e.latency_ms)} | cost $${e.cost.toFixed(4)}`
-        )
-      }
-    }
-
-    lines.push(``)
-  }
-
-  if (skipped > 0) {
-    lines.push(`(${skipped} corrupt lines ignored)`)
-  }
-
-  return { content: lines.join("\n") }
-}

package/src/core/events.ts

@@ -1,141 +0,0 @@
-import type { StepTracker, TerminalStepData } from "./step-tracker.js"
-import type { LogEntry } from "../types.js"
-
-/**
- * Event mapping for the throughput plugin — the single source of truth for
- * which session events are monitored and how each mutates the StepTracker.
- *
- * Type derivation strategy: the SDK's session-event union (V2Event and its
- * SessionStepStarted/SessionTextStarted/... members) lives in generated
- * types inside @opencode/client, a transitive dependency, and is not
- * re-exported from the @opencode/plugin public entry. A Pick/Extract
- * derivation would pin deep internal SDK paths, so ThroughputEvent below is
- * a hand-written minimal structural union mirroring the SDK shapes,
- * restricted to the fields this plugin actually consumes:
- * type / created / location.directory / data.sessionID /
- * data.assistantMessageID / data.model.{id,providerID} / data.started /
- * data.finish / data.cost / data.tokens.
- */
-
-export type ThroughputEvent =
-  | {
-      type: "session.step.started"
-      created: number
-      location?: { directory?: string }
-      data: {
-        sessionID: string
-        assistantMessageID: string
-        model: { id: string; providerID: string }
-        started: number
-      }
-    }
-  | {
-      type: "session.text.started"
-      created: number
-      location?: { directory?: string }
-      data: { sessionID: string; assistantMessageID: string }
-    }
-  | {
-      type: "session.reasoning.started"
-      created: number
-      location?: { directory?: string }
-      data: { sessionID: string; assistantMessageID: string }
-    }
-  | {
-      type: "session.step.streamed"
-      created: number
-      location?: { directory?: string }
-      data: { sessionID: string; assistantMessageID: string }
-    }
-  | {
-      type: "session.step.ended"
-      created: number
-      location?: { directory?: string }
-      data: TerminalStepData
-    }
-  | {
-      type: "session.step.failed"
-      created: number
-      location?: { directory?: string }
-      data: TerminalStepData
-    }
-  | {
-      type: "session.idle"
-      created: number
-      location?: { directory?: string }
-      data: { sessionID: string }
-    }
-
-/** Exactly the event types both entrypoints subscribe to. */
-export const SUBSCRIBED_EVENT_TYPES: readonly string[] = [
-  "session.step.started",
-  "session.text.started",
-  "session.reasoning.started",
-  "session.step.streamed",
-  "session.step.ended",
-  "session.step.failed",
-  "session.idle",
-] as const satisfies readonly ThroughputEvent["type"][]
-
-/**
- * normalizeEvent outcome. `malformed` is reserved for a future payload
- * pre-validation pass and is never produced today: known-type events are
- * passed through unvalidated (see normalizeEvent).
- */
-export type NormalizedEvent =
-  | { ok: true; event: ThroughputEvent }
-  | { ok: false; reason: "unknown" | "malformed" }
-
-/**
- * Dual-channel classification, NO payload validation (current semantics):
- * a known event type passes through as-is — a malformed payload throws
- * naturally inside applyThroughputEvent's property accesses and is caught
- * by the existing per-event onError boundary; anything else (unknown type,
- * non-object, missing type) is silently skipped, matching the previous
- * switch fall-through.
- */
-export function normalizeEvent(raw: unknown): NormalizedEvent {
-  if (typeof raw === "object" && raw != null && "type" in raw) {
-    const type = (raw as { type: unknown }).type
-    if (typeof type === "string" && SUBSCRIBED_EVENT_TYPES.includes(type)) {
-      return { ok: true, event: raw as ThroughputEvent }
-    }
-  }
-  return { ok: false, reason: "unknown" }
-}
-
-/**
- * Apply one known event to the tracker; returns the settled LogEntry for
- * terminal events (step.ended/failed), else null. Verbatim move of the
- * event switch previously duplicated in plugins/throughput.ts and
- * tui/controller.ts.
- */
-export function applyThroughputEvent(
-  tracker: StepTracker,
-  ev: ThroughputEvent,
-  deps: { recordedAt: number; abortTtlMs: number }
-): LogEntry | null {
-  switch (ev.type) {
-    case "session.step.started":
-      tracker.start(ev.data)
-      return null
-    case "session.text.started":
-    case "session.reasoning.started":
-      // Reasoning often streams before text; the first one wins.
-      tracker.markFirstOutput(ev.data.assistantMessageID, ev.created)
-      return null
-    // streamed = provider body fully consumed: the best TPS end boundary (tool time excluded); absent on older hosts -> terminal-event boundary (see buildLogEntry).
-    case "session.step.streamed":
-      tracker.markStreamed(ev.data.assistantMessageID, ev.created)
-      return null
-    case "session.step.ended":
-    case "session.step.failed":
-      return tracker.settle(ev.data.assistantMessageID, ev.created, ev.data, deps.recordedAt)
-    case "session.idle":
-      // Park instead of dropping so late terminal events can still settle.
-      tracker.parkSession(ev.data.sessionID, ev.created, deps.abortTtlMs)
-      return null
-  }
-  // Defensive only: unreachable for events that passed normalizeEvent.
-  return null
-}

package/src/core/log-codec.ts

@@ -1,90 +0,0 @@
-import type { LogEntry } from "../types.js"
-
-function isString(v: unknown): v is string {
-  return typeof v === "string"
-}
-
-function isFiniteNumber(v: unknown): v is number {
-  return typeof v === "number" && Number.isFinite(v)
-}
-
-/**
- * Decode one JSONL line into a LogEntry, or null when the line is corrupt.
- * Hard violations (-> null): non-string model/providerID/modelID/sessionID/messageID,
- * or a present-but-wrong-typed metric (ttft_ms/tps/latency_ms) or amount
- * (tokens/cost). Coercions: missing metrics -> null, missing amounts -> 0;
- * missing/non-string finish -> "error", missing ts -> "".
- */
-export function decodeLogLine(line: string): LogEntry | null {
-  let raw: unknown
-  try {
-    raw = JSON.parse(line)
-  } catch {
-    return null
-  }
-  if (typeof raw !== "object" || raw == null) return null
-  const o = raw as Record<string, unknown>
-
-  if (
-    !isString(o.model) ||
-    !isString(o.providerID) ||
-    !isString(o.modelID) ||
-    !isString(o.sessionID) ||
-    !isString(o.messageID)
-  ) {
-    return null
-  }
-
-  const metrics = [o.ttft_ms, o.tps, o.latency_ms]
-  const amounts = [
-    o.inputTokens,
-    o.outputTokens,
-    o.reasoningTokens,
-    o.cacheReadTokens,
-    o.cacheWriteTokens,
-    o.cost,
-  ]
-  const validMetric = (v: unknown): boolean => v == null || isFiniteNumber(v)
-  if (!metrics.every(validMetric) || !amounts.every(validMetric)) return null
-
-  // Coercion helpers: absence -> metric null / amount 0; validity checked above.
-  const metric = (v: unknown): number | null => (isFiniteNumber(v) ? v : null)
-  const amount = (v: unknown): number => (isFiniteNumber(v) ? v : 0)
-
-  return {
-    ts: isString(o.ts) ? o.ts : "",
-    model: o.model,
-    providerID: o.providerID,
-    modelID: o.modelID,
-    sessionID: o.sessionID,
-    messageID: o.messageID,
-    ttft_ms: metric(o.ttft_ms),
-    tps: metric(o.tps),
-    latency_ms: metric(o.latency_ms),
-    inputTokens: amount(o.inputTokens),
-    outputTokens: amount(o.outputTokens),
-    reasoningTokens: amount(o.reasoningTokens),
-    cacheReadTokens: amount(o.cacheReadTokens),
-    cacheWriteTokens: amount(o.cacheWriteTokens),
-    cost: amount(o.cost),
-    finish: isString(o.finish) ? o.finish : "error",
-  }
-}
-
-/** Decode full JSONL content; corrupt non-blank lines are counted, not fatal. */
-export function decodeLogContent(content: string): { entries: LogEntry[]; skipped: number } {
-  const entries: LogEntry[] = []
-  let skipped = 0
-  for (const line of content.split("\n")) {
-    if (!line.trim()) continue
-    const entry = decodeLogLine(line)
-    if (entry) entries.push(entry)
-    else skipped++
-  }
-  return { entries, skipped }
-}
-
-/** Encode one entry as a JSONL line (trailing newline included). */
-export function encodeLogEntry(entry: LogEntry): string {
-  return JSON.stringify(entry) + "\n"
-}

package/src/core/ownership.ts

@@ -1,13 +0,0 @@
-export type LocationLike = { location?: { directory?: string } }
-
-/**
- * Unified location-ownership policy for both entrypoints.
- * Loose semantics: dir == null || selfDir == null || dir === selfDir.
- * TODO: tighten `dir == null` to false once host broadcast behavior is verified.
- */
-export function makeOwns(selfDir: string | undefined): (ev: LocationLike) => boolean {
-  return (ev) => {
-    const dir = ev.location?.directory
-    return dir == null || selfDir == null || dir === selfDir
-  }
-}

package/src/core/stats.ts

@@ -1,105 +0,0 @@
-import type { LogEntry, ModelStats } from "../types.js"
-
-/**
- * Single source of truth for aggregation. One-pass fold; null metrics are
- * skipped (never 0-filled); no samples -> null (never Infinity). `now` is
- * stamped into every row's lastUpdated — the caller owns the clock, so this
- * module never reads the wall clock.
- */
-export function aggregateAt(entries: readonly LogEntry[], now: number): Map<string, ModelStats> {
-  const groups = new Map<string, GroupFold>()
-  for (const entry of entries) {
-    let g = groups.get(entry.model)
-    if (!g) {
-      g = {
-        count: 0,
-        ttft: newMetricFold(),
-        tps: newMetricFold(),
-        latency: newMetricFold(),
-        totalInputTokens: 0,
-        totalOutputTokens: 0,
-        totalReasoningTokens: 0,
-        totalCacheReadTokens: 0,
-        totalCacheWriteTokens: 0,
-        totalCost: 0,
-      }
-      groups.set(entry.model, g)
-    }
-    g.count++
-    // Each metric is folded independently; null samples are skipped entirely.
-    if (entry.ttft_ms != null) foldMetric(g.ttft, entry.ttft_ms)
-    if (entry.tps != null) foldMetric(g.tps, entry.tps)
-    if (entry.latency_ms != null) foldMetric(g.latency, entry.latency_ms)
-    // Token/cost fields are always non-null on disk; plain sums.
-    g.totalInputTokens += entry.inputTokens
-    g.totalOutputTokens += entry.outputTokens
-    g.totalReasoningTokens += entry.reasoningTokens
-    g.totalCacheReadTokens += entry.cacheReadTokens
-    g.totalCacheWriteTokens += entry.cacheWriteTokens
-    g.totalCost += entry.cost
-  }
-
-  const result = new Map<string, ModelStats>()
-  for (const [model, g] of groups) {
-    result.set(model, {
-      model,
-      count: g.count,
-      avgTTFT: metricAvg(g.ttft),
-      minTTFT: metricMin(g.ttft),
-      maxTTFT: metricMax(g.ttft),
-      avgTPS: metricAvg(g.tps),
-      maxTPS: metricMax(g.tps),
-      avgLatency: metricAvg(g.latency),
-      minLatency: metricMin(g.latency),
-      maxLatency: metricMax(g.latency),
-      totalInputTokens: g.totalInputTokens,
-      totalOutputTokens: g.totalOutputTokens,
-      totalReasoningTokens: g.totalReasoningTokens,
-      totalCacheReadTokens: g.totalCacheReadTokens,
-      totalCacheWriteTokens: g.totalCacheWriteTokens,
-      totalCost: g.totalCost,
-      lastUpdated: now,
-    })
-  }
-  return result
-}
-
-/** Running fold for one metric: sum/count/min/max tracked in a single pass. */
-type MetricFold = { sum: number; count: number; min: number; max: number }
-
-type GroupFold = {
-  count: number
-  ttft: MetricFold
-  tps: MetricFold
-  latency: MetricFold
-  totalInputTokens: number
-  totalOutputTokens: number
-  totalReasoningTokens: number
-  totalCacheReadTokens: number
-  totalCacheWriteTokens: number
-  totalCost: number
-}
-
-function newMetricFold(): MetricFold {
-  // min/max are only meaningful once count > 0; every read is guarded by count.
-  return { sum: 0, count: 0, min: Infinity, max: -Infinity }
-}
-
-function foldMetric(m: MetricFold, v: number): void {
-  m.sum += v
-  m.count++
-  if (v < m.min) m.min = v
-  if (v > m.max) m.max = v
-}
-
-function metricAvg(m: MetricFold): number | null {
-  return m.count > 0 ? m.sum / m.count : null
-}
-
-function metricMin(m: MetricFold): number | null {
-  return m.count > 0 ? m.min : null
-}
-
-function metricMax(m: MetricFold): number | null {
-  return m.count > 0 ? m.max : null
-}

package/src/core/step-tracker.ts

@@ -1,204 +0,0 @@
-import type { LogEntry } from "../types.js"
-
-/** Canonical `providerID/modelID` key used to group entries per model. */
-export function getModelKey(providerID: string, modelID: string): string {
-  return `${providerID}/${modelID}`
-}
-
-// In-flight state for one assistant step, keyed externally by assistantMessageID.
-export type StepState = {
-  sessionID: string
-  started: number
-  providerID: string
-  modelID: string
-  modelKey: string
-  // Event time (ms epoch) of the first streamed text/reasoning output, if any.
-  firstOutput: number | null
-  // session.step.streamed time; null => TPS denominator falls back to terminal time.
-  streamEnded: number | null
-}
-
-export const ZERO_TOKENS = {
-  input: 0,
-  output: 0,
-  reasoning: 0,
-  cache: { read: 0, write: 0 },
-}
-
-export type TerminalStepData = {
-  sessionID: string
-  assistantMessageID: string
-  finish?: string
-  cost?: number
-  tokens?: { input: number; output: number; reasoning: number; cache: { read: number; write: number } }
-}
-
-/**
- * TPS rule: genEnd = streamEnded ?? eventAt; with firstOutput:
- * output/(genEnd - firstOutput)*1000; without firstOutput the full step span
- * approximates generation: output/(eventAt - started)*1000.
- * output <= 0 or genTime <= 0 -> null. ttft = firstOutput - started | null.
- * @param eventAt event time (ms epoch) of the terminal event; drives every metric.
- * @param recordedAt clock reading (ms epoch) taken when the entry is recorded;
- *   only `ts` derives from it (new Date(recordedAt).toISOString()), keeping
- *   this module free of wall-clock reads.
- */
-export function buildLogEntry(
-  state: StepState,
-  eventAt: number,
-  terminal: TerminalStepData,
-  recordedAt: number
-): LogEntry {
-  const tokens = terminal.tokens ?? ZERO_TOKENS
-  const latencyMs = eventAt - state.started
-  const ttftMs = state.firstOutput != null ? state.firstOutput - state.started : null
-
-  const genEnd = state.streamEnded ?? eventAt
-  const genTimeMs = state.firstOutput != null ? genEnd - state.firstOutput : eventAt - state.started
-  const tps = tokens.output > 0 && genTimeMs > 0 ? (tokens.output / genTimeMs) * 1000 : null
-
-  return {
-    ts: new Date(recordedAt).toISOString(),
-    model: state.modelKey,
-    providerID: state.providerID,
-    modelID: state.modelID,
-    sessionID: terminal.sessionID,
-    messageID: terminal.assistantMessageID,
-    ttft_ms: ttftMs,
-    tps,
-    latency_ms: latencyMs,
-    inputTokens: tokens.input,
-    outputTokens: tokens.output,
-    reasoningTokens: tokens.reasoning,
-    cacheReadTokens: tokens.cache.read,
-    cacheWriteTokens: tokens.cache.write,
-    cost: terminal.cost ?? 0,
-    finish: terminal.finish ?? "error",
-  }
-}
-
-/** Entry for a step that never reached a terminal event (parked and expired).
- *  `now` serves as both the event time (metrics) and the record time (ts). */
-export function buildAbortedEntry(state: StepState, assistantMessageID: string, now: number): LogEntry {
-  return buildLogEntry(state, now, { sessionID: state.sessionID, assistantMessageID, finish: "aborted" }, now)
-}
-
-/** In-flight state machine (no timers, no IO); parking = grace for late terminal events after session.idle.
- *  Active steps additionally carry a TTL: a step whose terminal event AND
- *  session.idle never arrive is evicted (recorded as finish:"aborted") once
- *  `now - started >= activeTtlMs`, exactly like a parked timeout. */
-export class StepTracker {
-  private active = new Map<string, StepState>()
-  private parked = new Map<string, { state: StepState; deadline: number }>()
-  private readonly activeTtlMs: number
-
-  /** @param options.activeTtlMs eviction window for active steps (default 600_000 = 10 min);
-   *  0 or negative disables active eviction entirely. */
-  constructor(options: { activeTtlMs?: number } = {}) {
-    const ttl = options.activeTtlMs ?? 600_000
-    this.activeTtlMs = ttl > 0 ? ttl : 0
-  }
-
-  start(data: {
-    sessionID: string
-    assistantMessageID: string
-    started: number
-    model: { id: string; providerID: string }
-  }): void {
-    this.active.set(data.assistantMessageID, {
-      sessionID: data.sessionID,
-      started: data.started,
-      providerID: data.model.providerID,
-      modelID: data.model.id,
-      modelKey: getModelKey(data.model.providerID, data.model.id),
-      firstOutput: null,
-      streamEnded: null,
-    })
-  }
-
-  /** Idempotent; the first output event wins. */
-  markFirstOutput(assistantMessageID: string, created: number): void {
-    const state = this.lookup(assistantMessageID)
-    if (state && state.firstOutput == null) state.firstOutput = created
-  }
-
-  /** Idempotent; the first streamed event wins. */
-  markStreamed(assistantMessageID: string, created: number): void {
-    const state = this.lookup(assistantMessageID)
-    if (state && state.streamEnded == null) state.streamEnded = created
-  }
-
-  /** Removes state and builds the final entry; unknown id -> null.
-   *  Checks active first, then parked (a late ended after idle lands normally).
-   *  `eventAt` drives the metrics; `recordedAt` (record time) drives ts. */
-  settle(assistantMessageID: string, eventAt: number, terminal: TerminalStepData, recordedAt: number): LogEntry | null {
-    const activeState = this.active.get(assistantMessageID)
-    if (activeState) {
-      this.active.delete(assistantMessageID)
-      return buildLogEntry(activeState, eventAt, terminal, recordedAt)
-    }
-    const parked = this.parked.get(assistantMessageID)
-    if (parked) {
-      this.parked.delete(assistantMessageID)
-      return buildLogEntry(parked.state, eventAt, terminal, recordedAt)
-    }
-    return null
-  }
-
-  /** Move a session's in-flight steps to parking with deadline = now + ttlMs. */
-  parkSession(sessionID: string, now: number, ttlMs: number): void {
-    const deadline = now + ttlMs
-    for (const [id, state] of this.active) {
-      if (state.sessionID === sessionID) {
-        this.parked.set(id, { state, deadline })
-        this.active.delete(id)
-      }
-    }
-  }
-
-  /** Remove and return steps whose deadline has passed: parked steps past
-   *  their parking deadline, and active steps past their TTL (same
-   *  semantics — the caller records both as finish:"aborted" via
-   *  buildAbortedEntry). Source is not distinguished in the result. */
-  collectExpired(now: number): Array<{ assistantMessageID: string; state: StepState }> {
-    const expired: Array<{ assistantMessageID: string; state: StepState }> = []
-    for (const [id, parked] of this.parked) {
-      if (parked.deadline <= now) {
-        expired.push({ assistantMessageID: id, state: parked.state })
-        this.parked.delete(id)
-      }
-    }
-    if (this.activeTtlMs > 0) {
-      for (const [id, state] of this.active) {
-        if (now - state.started >= this.activeTtlMs) {
-          expired.push({ assistantMessageID: id, state })
-          this.active.delete(id)
-        }
-      }
-    }
-    return expired
-  }
-
-  /** Earliest deadline among parked steps and active TTL expirations
-   *  (started + activeTtlMs); null when nothing is scheduled. Feeds the
-   *  pipeline's single flush timer, which then covers both sources. */
-  nextDeadline(): number | null {
-    let next: number | null = null
-    const consider = (deadline: number): void => {
-      if (next == null || deadline < next) next = deadline
-    }
-    for (const { deadline } of this.parked.values()) consider(deadline)
-    if (this.activeTtlMs > 0) {
-      for (const { started } of this.active.values()) consider(started + this.activeTtlMs)
-    }
-    return next
-  }
-
-  get size(): number {
-    return this.active.size + this.parked.size
-  }
-
-  private lookup(assistantMessageID: string): StepState | undefined {
-    return this.active.get(assistantMessageID) ?? this.parked.get(assistantMessageID)?.state
-  }
-}