opencode-tweaks 0.0.0-stage → 0.4.1

package/src/tweaks/token-slots.tsx

@@ -0,0 +1,327 @@
+import type { Context, SlotMap } from "@opencode/plugin/tui/context"
+import { createEffect, createMemo, createSignal, onCleanup, Show, untrack } from "solid-js"
+import type { SettingsStore } from "./settings"
+import type { TokenInjector } from "./token-inject"
+import { tokensTweak } from "./tokens"
+import {
+  type CostDigits,
+  estimateCost,
+  footerMessage,
+  formatCost,
+  formatTokens,
+  isCostDigits,
+  type ModelPrice,
+  messagesCost,
+  priceFor,
+  replyTurnMessages,
+  sessionTokens,
+  type TokenCount,
+  type TokenMessage,
+  usageTokens,
+} from "./tokens-model"
+import type { TweakSetting } from "./types"
+
+function setting(id: string): TweakSetting {
+  const found = tokensTweak.settings.find((item) => item.id === id)
+  if (!found) throw new Error(`Tokens setting "${id}" is missing`)
+  return found
+}
+
+const ENABLED = setting("enabled")
+const PROMPT = setting("prompt")
+const TOTAL = setting("total")
+const SUBAGENTS = setting("subagents")
+const COUNT = setting("count")
+const PROMPT_COST = setting("promptCost")
+const TOTAL_COST = setting("totalCost")
+const COST_DIGITS = setting("costDigits")
+const ESTIMATE = setting("estimateCost")
+const FORMAT = setting("format")
+const TTFT = setting("ttft")
+
+/**
+ * The two counts, shared by both placements. The prompt count follows the open
+ * session because a prompt belongs to it. The total optionally follows the
+ * session tree, since a subagent's tokens belong to the turn its parent started.
+ */
+function useCounts(props: {
+  readonly context: Context
+  readonly store: SettingsStore
+  readonly sessionID: () => string | undefined
+}) {
+  const enabled = () => props.store.read(tokensTweak, ENABLED).value === true
+  const perPrompt = () => props.store.read(tokensTweak, PROMPT).value === true
+  const sessionTotal = () => props.store.read(tokensTweak, TOTAL).value === true
+  const subagents = () => props.store.read(tokensTweak, SUBAGENTS).value === true
+  const promptCost = () => props.store.read(tokensTweak, PROMPT_COST).value === true
+  const totalCost = () => props.store.read(tokensTweak, TOTAL_COST).value === true
+  const estimate = () => props.store.read(tokensTweak, ESTIMATE).value === true
+  const costDigits = (): CostDigits => {
+    const value = props.store.read(tokensTweak, COST_DIGITS).value
+    return isCostDigits(value) ? value : "auto"
+  }
+  const count = (): TokenCount => {
+    const value = props.store.read(tokensTweak, COUNT).value
+    return value === "generated" || value === "all" ? value : "new"
+  }
+  const style = () =>
+    props.store.read(tokensTweak, FORMAT).value === "exact" ? "exact" : "compact"
+
+  const messages = (sessionID: string) => props.context.data.session.message.list(sessionID) ?? []
+
+  const sessions = props.context.data.session
+
+  // List prices come from the model catalog the TUI already synced, so an
+  // estimate costs nothing but a lookup.
+  const prices = createMemo(() => {
+    const map = new Map<string, readonly ModelPrice[]>()
+    for (const model of props.context.data.location.model.list() ?? []) {
+      map.set(`${model.providerID}/${model.modelID}`, model.cost)
+    }
+    return map
+  })
+
+  /** The list price of a model at a context size, when the catalog knows it. */
+  function priceOf(
+    ref: { readonly providerID: string; readonly id: string } | undefined,
+    context: number,
+  ) {
+    if (!ref) return undefined
+    const list = prices().get(`${ref.providerID}/${ref.id}`)
+    return list ? priceFor(list, context) : undefined
+  }
+
+  const family = createMemo(() => {
+    const sessionID = props.sessionID()
+    if (!sessionID) return []
+
+    if (!subagents()) return [sessionID]
+
+    try {
+      const root = sessions.root(sessionID)
+      return [...new Set([root, ...sessions.family(root)])].filter((id) => id.length > 0)
+    } catch {
+      // A session the client has not synced yet still shows its own total.
+      return [sessionID]
+    }
+  })
+
+  // The transcript keeps only a window of messages, so the session's own
+  // counters are the only exact total for a long session.
+  const total = createMemo(() =>
+    family().reduce((sum, sessionID) => {
+      const usage = sessions.get(sessionID)?.tokens
+      return sum + (usage ? usageTokens(usage, count()) : 0)
+    }, 0),
+  )
+
+  // The inline figures describe the turn whose footer is on screen: the host
+  // draws one line per finished turn, so a prompt with no finished reply keeps
+  // the previous turn's figures on its own line.
+  const turn = createMemo(() => {
+    const sessionID = props.sessionID()
+    return sessionID ? replyTurnMessages(messages(sessionID)) : []
+  })
+
+  const prompt = createMemo(() => sessionTokens(turn(), count()))
+
+  // The footer the figures belong to, so the injector only writes them on that
+  // line and never on the older one while the host catches up.
+  const promptKey = createMemo(() => {
+    const sessionID = props.sessionID()
+    return sessionID ? footerMessage(messages(sessionID))?.id : undefined
+  })
+
+  // A reply that has not produced a counter yet is still empty, so it shows no
+  // figures rather than a zero cost.
+  const replied = createMemo(() =>
+    turn().some((message) => {
+      if (message.type !== "assistant") return false
+      if ((message.cost ?? 0) > 0) return true
+      return message.tokens ? usageTokens(message.tokens, "all") > 0 : false
+    }),
+  )
+
+  const sessionCost = createMemo(() =>
+    family().reduce((sum, sessionID) => {
+      const session = sessions.get(sessionID)
+      const reported = session?.cost ?? 0
+      if (reported > 0 || !estimate() || !session?.tokens) return sum + reported
+
+      const price = priceOf(session.model, session.tokens.input + session.tokens.cache.read)
+      return sum + (price ? estimateCost(session.tokens, price) : 0)
+    }, 0),
+  )
+
+  const cost = createMemo(() => {
+    if (!replied()) return undefined
+
+    const lookup = estimate()
+      ? (message: TokenMessage) => {
+          const tokens = message.tokens
+          if (!tokens) return undefined
+          return priceOf(message.model, tokens.input + tokens.cache.read)
+        }
+      : undefined
+
+    return messagesCost(turn(), lookup)
+  })
+
+  /** The formatted count, or `undefined` while there is nothing worth showing. */
+  const format = (value: number) => (value > 0 ? formatTokens(value, style()) : undefined)
+
+  const promptCount = () => (enabled() && perPrompt() ? format(prompt()) : undefined)
+  const totalCount = () => (enabled() && sessionTotal() ? format(total()) : undefined)
+  const promptCostLabel = () => {
+    const value = cost()
+    return enabled() && promptCost() && value !== undefined
+      ? formatCost(value, costDigits())
+      : undefined
+  }
+  const totalCostLabel = () =>
+    enabled() && totalCost() ? formatCost(sessionCost(), costDigits()) : undefined
+
+  return { enabled, promptKey, promptCount, totalCount, promptCostLabel, totalCostLabel }
+}
+
+/**
+ * Inline placement has no row of its own: it hands the prompt count to the
+ * injector, which splices it into the host's tok/s line. The composer slot is
+ * claimed anyway because it is the published place that gives the plugin a
+ * reactive session context above the prompt; this component renders nothing.
+ */
+export function TokenInline(props: {
+  readonly context: Context
+  readonly input: SlotMap["session.composer.top"]
+  readonly store: SettingsStore
+  readonly injector: TokenInjector
+}) {
+  const counts = useCounts({
+    context: props.context,
+    store: props.store,
+    sessionID: () => props.input.sessionID,
+  })
+
+  createEffect(() => {
+    if (!counts.enabled()) {
+      props.injector.clear()
+      return
+    }
+
+    props.injector.setTtft(props.store.read(tokensTweak, TTFT).value !== false)
+
+    const count = counts.promptCount()
+    const cost = counts.promptCostLabel()
+    props.injector.setLabels(
+      {
+        before: count ? ` · ${count} tok` : undefined,
+        after: cost ? ` · ${cost}` : undefined,
+      },
+      counts.promptKey(),
+    )
+  })
+
+  return null
+}
+
+/** The bottom status line, next to the working directory and the other details. */
+export function TokenStatus(props: {
+  readonly context: Context
+  readonly input: SlotMap["prompt.footer.status"]
+  readonly store: SettingsStore
+  readonly injector: TokenInjector
+}) {
+  const counts = useCounts({
+    context: props.context,
+    store: props.store,
+    sessionID: () => props.input.sessionID,
+  })
+
+  // The host prints its own shell and subagent indicator before the context
+  // usage, so the figures normally ride on that text. The slot is only a
+  // fallback for a footer with neither of them.
+  const children = createMemo(() => {
+    const sessionID = props.input.sessionID
+    if (!sessionID) return false
+
+    try {
+      const shells = props.context.data.shell
+        .list(props.context.location)
+        .filter(
+          (shell) =>
+            (shell.metadata as { sessionID?: string } | undefined)?.sessionID === sessionID,
+        ).length
+      const sessions = props.context.data.session
+      const subagents = sessions
+        .family(sessionID)
+        .filter((id) => id !== sessionID && sessions.status(id) === "running").length
+      return shells + subagents > 0
+    } catch {
+      // A session the client has not synced yet simply has no indicator.
+      return false
+    }
+  })
+
+  const figures = () => {
+    const parts: string[] = []
+    const tokens = counts.totalCount()
+    if (tokens) parts.push(`${tokens} tok total`)
+    const cost = counts.totalCostLabel()
+    if (cost) parts.push(cost)
+    return parts.length > 0 ? parts.join(" · ") : undefined
+  }
+
+  const [placed, setPlaced] = createSignal(false)
+
+  const repaint = () => props.injector.setFooterFigures(figures(), setPlaced)
+
+  createEffect(() => {
+    // Read the host's detail state so the figures follow the usage line when
+    // the host shows or hides it.
+    props.input.showDetails
+    repaint()
+  })
+
+  // The host adds or removes its shell indicator in a render pass of its own,
+  // which rebuilds the usage text and leaves the figures beside a stray
+  // separator for a moment. Repainting right away, then again over the next
+  // frames, keeps the line from settling visibly.
+  let lastPresence: boolean | undefined
+  createEffect(() => {
+    const present = children()
+    if (present === lastPresence) return
+    lastPresence = present
+    // The token counters must not re-run this effect: it would cancel the
+    // follow-up passes every time a figure changes.
+    untrack(repaint)
+    const passes = [16, 50, 150].map((delay) => setTimeout(() => untrack(repaint), delay))
+    onCleanup(() => {
+      for (const pass of passes) clearTimeout(pass)
+    })
+  })
+
+  const [stale, setStale] = createSignal(false)
+
+  createEffect(() => {
+    // A rejected splice is transient while the host redraws the line, so the
+    // slot only takes over after the figures have stayed out for a while.
+    setStale(false)
+    if (placed()) return
+    const timer = setTimeout(() => setStale(true), 500)
+    onCleanup(() => clearTimeout(timer))
+  })
+
+  // The injector owns the real line: it puts the figures after the shell
+  // indicator and before the context usage. The slot is only a last resort
+  // after the splice has stayed unavailable, so nothing flashes to the wrong
+  // side of a shell while the host is still drawing it.
+  const fallback = () => (placed() || !stale() ? undefined : figures())
+
+  return (
+    <Show when={fallback()}>
+      <text fg={props.context.theme.text.muted} wrapMode="none" flexShrink={0}>
+        {fallback()}
+      </text>
+    </Show>
+  )
+}

package/src/tweaks/tokens-model.ts

@@ -0,0 +1,213 @@
+/** The token counters OpenCode stores on an assistant message. */
+export interface MessageTokens {
+  readonly input: number
+  readonly output: number
+  readonly reasoning: number
+  readonly cache: { readonly read: number; readonly write: number }
+}
+
+/** Only what the sum needs, so any session message list fits. */
+export interface TokenMessage {
+  readonly id?: string
+  readonly type: string
+  readonly tokens?: MessageTokens
+  readonly cost?: number
+  readonly model?: { readonly providerID: string; readonly id: string }
+  /** How the step ended; the host only draws a footer for a finished one. */
+  readonly finish?: string | null
+  readonly error?: unknown
+  readonly retry?: unknown
+}
+
+/**
+ * Which counters a count adds up.
+ *
+ * - `new` is what the model actually processed: prompt, completion, reasoning,
+ *   and cache writes, without cache reads. A turn re-reads the whole context at
+ *   every step, so cache reads would dwarf every other counter.
+ * - `generated` is only what the model wrote.
+ * - `all` matches the counters `/stats` reports, cache reads included.
+ */
+export type TokenCount = "new" | "generated" | "all"
+
+/** The tokens in one assistant message's counters under the chosen definition. */
+export function usageTokens(tokens: MessageTokens, mode: TokenCount): number {
+  const { input, output, reasoning, cache } = tokens
+
+  switch (mode) {
+    case "generated":
+      return output + reasoning
+
+    case "new":
+      return input + output + reasoning + cache.write
+
+    case "all":
+      return input + output + reasoning + cache.read + cache.write
+  }
+}
+
+/** The tokens one assistant message spent under the chosen definition. */
+export function messageTokens(message: TokenMessage, mode: TokenCount): number {
+  if (message.type !== "assistant" || !message.tokens) return 0
+  return usageTokens(message.tokens, mode)
+}
+
+/** Every token a session spent under the chosen definition. */
+export function sessionTokens(messages: readonly TokenMessage[], mode: TokenCount): number {
+  return messages.reduce((total, message) => total + messageTokens(message, mode), 0)
+}
+
+/** The index just after the last user prompt before `end`. */
+function turnStart(messages: readonly TokenMessage[], end: number): number {
+  for (let index = end - 1; index >= 0; index--) {
+    if (messages[index]?.type === "user") return index + 1
+  }
+  return 0
+}
+
+/** Where the turn that starts at `start` ends: at the next prompt, or the end. */
+function turnEnd(messages: readonly TokenMessage[], start: number): number {
+  for (let index = start; index < messages.length; index++) {
+    if (messages[index]?.type === "user") return index
+  }
+  return messages.length
+}
+
+/**
+ * The newest message the host draws a footer under. A footer belongs to the
+ * last step of a turn: one that stopped for any reason other than another tool
+ * call, or one that failed or is being retried.
+ */
+export function footerMessage(messages: readonly TokenMessage[]): TokenMessage | undefined {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index]
+    if (message?.type !== "assistant") continue
+    if (message.error || message.retry) return message
+    if (message.finish && message.finish !== "tool-calls" && message.finish !== "unknown") {
+      return message
+    }
+  }
+  return undefined
+}
+
+/**
+ * The messages of the turn whose footer is on screen. A prompt with no finished
+ * reply yet leaves the previous turn's line there, so that line keeps showing
+ * the previous turn's numbers instead of the running one's.
+ */
+export function replyTurnMessages(messages: readonly TokenMessage[]): readonly TokenMessage[] {
+  const footer = footerMessage(messages)
+  if (!footer) return []
+
+  const last = messages.lastIndexOf(footer)
+  const start = turnStart(messages, last + 1)
+  return messages.slice(start, turnEnd(messages, start))
+}
+
+/** The tokens that turn spent under the chosen definition. */
+export function replyTurnTokens(messages: readonly TokenMessage[], mode: TokenCount): number {
+  return sessionTokens(replyTurnMessages(messages), mode)
+}
+
+/** A model's list price, in dollars per million tokens. */
+export interface ModelPrice {
+  readonly input: number
+  readonly output: number
+  readonly cache: { readonly read: number; readonly write: number }
+  readonly tier?: { readonly size: number }
+}
+
+/**
+ * The price that applies at a context size: the base price, raised by a tier
+ * once the request is large enough. Long-context pricing works this way.
+ */
+export function priceFor(prices: readonly ModelPrice[], context: number): ModelPrice | undefined {
+  let base: ModelPrice | undefined
+  let tiered: ModelPrice | undefined
+
+  for (const price of prices) {
+    const tier = price.tier
+    if (!tier) {
+      base ??= price
+      continue
+    }
+    if (context < tier.size) continue
+    if (!tiered?.tier || tier.size > tiered.tier.size) tiered = price
+  }
+
+  return tiered ?? base ?? prices[0]
+}
+
+/**
+ * The list-price cost of one message's counters. Reasoning is billed at the
+ * output price, as providers do.
+ */
+export function estimateCost(tokens: MessageTokens, price: ModelPrice): number {
+  const { input, output, reasoning, cache } = tokens
+  const total =
+    input * price.input +
+    (output + reasoning) * price.output +
+    cache.read * price.cache.read +
+    cache.write * price.cache.write
+
+  return total / 1_000_000
+}
+
+/** Resolves the list price of one message, if the model is known. */
+export type PriceLookup = (message: TokenMessage) => ModelPrice | undefined
+
+/**
+ * The cost of a list of messages: what the provider reported, or the list-price
+ * estimate when it reported nothing and a price is available.
+ */
+export function messagesCost(messages: readonly TokenMessage[], price?: PriceLookup): number {
+  return messages.reduce((total, message) => {
+    const reported = message.cost ?? 0
+    if (reported > 0) return total + reported
+    if (!price || !message.tokens) return total + reported
+
+    const value = price(message)
+    return total + (value ? estimateCost(message.tokens, value) : reported)
+  }, 0)
+}
+
+const compact = new Intl.NumberFormat("en-US", { notation: "compact", maximumFractionDigits: 1 })
+const exact = new Intl.NumberFormat("en-US")
+
+/**
+ * `12.4K` in compact style, matching the numbers in `/stats`, or `12,431` for
+ * every digit. Both stay short enough for the prompt footer.
+ */
+export function formatTokens(value: number, style: "compact" | "exact"): string {
+  const total = Math.max(0, Math.round(value))
+  return style === "exact" ? exact.format(total) : compact.format(total)
+}
+
+/**
+ * Dollars with two decimals, or more under a cent so the first significant
+ * digit shows. `auto` picks the decimals; a number fixes them.
+ */
+export function formatCost(value: number, digits: CostDigits = "auto"): string {
+  const cost = Math.max(0, value)
+  const places = digits === "auto" ? autoDigits(cost) : digits
+
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: places,
+    maximumFractionDigits: places,
+  }).format(cost)
+}
+
+export type CostDigits = "auto" | 2 | 3 | 4 | 5 | 6
+
+/** Whether a stored or configured value is a cost digit choice. */
+export function isCostDigits(value: unknown): value is CostDigits {
+  return value === "auto" || value === 2 || value === 3 || value === 4 || value === 5 || value === 6
+}
+
+/** Normal amounts keep two decimals; smaller ones grow until a digit shows. */
+function autoDigits(cost: number): number {
+  if (cost === 0 || cost >= 0.01) return 2
+  return Math.min(6, Math.ceil(-Math.log10(cost)))
+}

package/src/tweaks/tokens.ts

@@ -0,0 +1,113 @@
+import { defineTweak } from "./types"
+
+/**
+ * Token usage is a session statistic, so it joins existing status lines instead
+ * of taking a panel of its own. Each number has its own toggle: a turn's usage
+ * follows the prompt on screen, the session's follows the whole tree.
+ */
+export const tokensTweak = defineTweak({
+  id: "tokens",
+  title: "Tokens",
+  description: "Show token and cost usage for a turn and for the whole session.",
+  category: "Session",
+  settings: [
+    {
+      id: "enabled",
+      title: "Enabled",
+      description: "Turn the token and cost counts on.",
+      category: "General",
+      kind: "boolean",
+      default: true,
+    },
+    {
+      id: "prompt",
+      title: "Turn tokens",
+      description:
+        "Show the latest finished turn's tokens inline with its tok/s line. Best effort: that line belongs to OpenCode.",
+      category: "Display",
+      kind: "boolean",
+      default: true,
+    },
+    {
+      id: "promptCost",
+      title: "Turn cost",
+      description: "Show that turn's cost after the tok/s figure.",
+      category: "Display",
+      kind: "boolean",
+      default: true,
+    },
+    {
+      id: "total",
+      title: "Session tokens",
+      description: "Show the session's total token usage on the bottom status line.",
+      category: "Display",
+      kind: "boolean",
+      default: true,
+    },
+    {
+      id: "totalCost",
+      title: "Session cost",
+      description: "Show the session's total cost on the bottom status line.",
+      category: "Display",
+      kind: "boolean",
+      default: true,
+    },
+    {
+      id: "format",
+      title: "Token format",
+      description: "Compact counts such as 12.4K, or every digit.",
+      category: "Display",
+      kind: "select",
+      default: "compact",
+      values: ["compact", "exact"],
+    },
+    {
+      id: "costDigits",
+      title: "Cost decimals",
+      description:
+        "Decimals shown for costs, or auto to keep going until the first significant digit.",
+      category: "Display",
+      kind: "select",
+      default: "auto",
+      values: ["auto", 2, 3, 4, 5, 6],
+      labels: ["Auto", "2 digits", "3 digits", "4 digits", "5 digits", "6 digits"],
+    },
+    {
+      id: "ttft",
+      title: "First token time",
+      description:
+        "Show the host's ttft figure, the wait before the first token, at the end of the throughput line. Turn it off to keep tok/s alone.",
+      category: "Display",
+      kind: "boolean",
+      default: false,
+    },
+    {
+      id: "count",
+      title: "Token count",
+      description:
+        "New tokens leave out cache reads, generated tokens are only what the model wrote, everything matches /stats.",
+      category: "Scope",
+      kind: "select",
+      default: "generated",
+      values: ["new", "generated", "all"],
+      labels: ["New tokens", "Generated only", "Everything"],
+    },
+    {
+      id: "subagents",
+      title: "Include subagents",
+      description: "Add the tokens used by subagents to the session totals.",
+      category: "Scope",
+      kind: "boolean",
+      default: true,
+    },
+    {
+      id: "estimateCost",
+      title: "Estimate cost",
+      description:
+        "Guess the cost from the model's list price when the provider reports none. A session that changed model is estimated with the model it ended on.",
+      category: "Scope",
+      kind: "boolean",
+      default: true,
+    },
+  ],
+})