opencode-tweaks 0.7.2 → 0.9.0

package/README.md

@@ -197,17 +197,26 @@ The cost settings used to live in the Tokens entry. A choice saved there before
 
 ### Model
 
-Model shows the model the session is using and its list price in the sidebar, under the quota. The name, provider,
-and reasoning variant come from the session, so the card follows `/models`. Click the `Model` header to collapse or
-expand the card.
+Model shows the current model's list price in the sidebar, under the quota. The model name, provider, and variant
+already sit on the bottom bar, so the card only carries the rates and the peak state. The rates follow the prompt's
+selected model, so picking another one in `/models` updates them at once, before the next turn. Click the `Model`
+header to collapse or expand it.
 
 `Input price`, `Output price`, and `Cache read price` choose the rates, all in dollars per million tokens. The card
-uses the catalog price that applies to the session's context, so a long-context tier shows the higher rate with its
-threshold (`>512K`).
+draws them as a price list with the labels on the left and the values in the theme accent. `Price alignment` picks
+whether the prices start on one shared column (`left`) or sit against the right edge (`right`). It uses the catalog
+price that applies to the session's context, so a long-context tier shows the higher rate with its threshold
+(`>512K`).
 
-`Peak state` adds the provider's live peak marker for schedules the plugin knows, such as DeepSeek and OpenCode Go:
-`peak ×2 now` during the higher window and `off-peak` otherwise. The badge on the turn cost still records the window
-each round started in.
+A model that bills nothing, such as a free promo, follows `Free models`. `List price` shows the rates of the paid
+catalog entry it borrows. `Free label` shows a single `Free` line instead. `Hide card` removes the card until a paid
+model is selected.
+
+`Peak state` puts the price multiplier on the right of the card header for schedules the plugin knows, such as
+DeepSeek and OpenCode Go: `×2` in the warning colour during the higher window and `×1` in the normal text colour off
+it. A model without a schedule shows nothing. The marker stays visible when the card is collapsed. `Peak only` hides
+`×1`, so the header stays empty at the base price. The badge on the turn cost still records the window each round
+started in.
 
 ## Development
 
@@ -234,6 +243,7 @@ src/
     messages.ts     message shape and turn selection
     tokens.ts       token sums and formatting
     cost.ts         list prices, estimates, and cost formatting
+    catalog.ts      catalog entries and paid sibling lookup
     price-window.ts provider peak hours and holidays
   tui.tsx           terminal entry: commands and slots
   tweaks/

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-tweaks",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "Opt-in settings and small interface improvements for OpenCode.",
   "type": "module",
   "license": "MIT",

package/src/tweaks/model-panel.tsx

@@ -1,6 +1,7 @@
 import type { Context, SlotMap } from "@opencode/plugin/tui/context"
 import { TextAttributes } from "@opentui/core"
 import { createEffect, createMemo, createSignal, For, onCleanup, Show } from "solid-js"
+import { type CatalogModel, paidSibling } from "../usage/catalog"
 import { formatRate, priceFor } from "../usage/cost"
 import { hasPriceSchedule, priceWindowFor } from "../usage/price-window"
 import { formatTokens } from "../usage/tokens"
@@ -18,19 +19,21 @@ const ENABLED = setting("enabled")
 const INPUT = setting("input")
 const OUTPUT = setting("output")
 const CACHE = setting("cache")
-const VARIANT = setting("variant")
 const PEAK = setting("peak")
+const PEAK_ONLY = setting("peakOnly")
+const ALIGN = setting("align")
+const FREE = setting("free")
 
 /** The ref stored on a session or returned by the composer. */
 interface ModelRef {
   readonly providerID: string
   readonly id: string
-  readonly variant?: string
 }
 
 /**
- * The model card is a companion to the cost figures: it names the model and
- * lists its catalog rates, while the cost tweak counts what the session spent.
+ * The model card sits under the quota and carries what the bottom bar does
+ * not: the current model's list price and its provider's peak state. The
+ * model name and variant already live on that bar, so the card stays compact.
  */
 export function ModelPanel(props: {
   readonly context: Context
@@ -58,40 +61,35 @@ function ModelBody(props: {
   const inputOn = () => props.store.read(modelTweak, INPUT).value === true
   const outputOn = () => props.store.read(modelTweak, OUTPUT).value === true
   const cacheOn = () => props.store.read(modelTweak, CACHE).value === true
-  const variantOn = () => props.store.read(modelTweak, VARIANT).value === true
   const peakOn = () => props.store.read(modelTweak, PEAK).value === true
-
-  /** The session's model, or the composer's while the session has none yet. */
+  const peakOnly = () => props.store.read(modelTweak, PEAK_ONLY).value === true
+  const alignRight = () => props.store.read(modelTweak, ALIGN).value === "right"
+  const freeMode = () => String(props.store.read(modelTweak, FREE).value)
+
+  /**
+   * The model the next prompt would use, read from the prompt selection so a
+   * switch in `/models` shows its rates at once. The session only supplies a
+   * model for a transcript opened without a prompt of its own.
+   */
   const model = createMemo<ModelRef | undefined>(() => {
-    const session = props.context.data.session.get(props.input.sessionID)
-    if (session?.model) return session.model
-
     const current = props.context.ui.model.current()
-    return current
-      ? { providerID: current.providerID, id: current.modelID, variant: current.variant }
-      : undefined
+    if (current) return { providerID: current.providerID, id: current.modelID }
+
+    return props.context.data.session.get(props.input.sessionID)?.model
   })
 
-  /** The catalog entry for that model, with what the panel needs to show it. */
-  const entry = createMemo(() => {
+  const catalog = () => props.context.data.location.model.list() ?? []
+
+  /** The catalog entry for that model, when the catalog knows it. */
+  const entry = createMemo<CatalogModel | undefined>(() => {
     const ref = model()
     if (!ref) return undefined
 
-    const found = (props.context.data.location.model.list() ?? []).find(
+    return catalog().find(
       (candidate) =>
         candidate.providerID === ref.providerID &&
         (candidate.modelID === ref.id || candidate.id === ref.id),
     )
-    const provider = (props.context.data.location.provider.list() ?? []).find(
-      (candidate) => candidate.id === ref.providerID,
-    )
-
-    return {
-      ref,
-      name: found?.name ?? ref.id,
-      provider: provider?.name,
-      costs: found?.cost ?? [],
-    }
   })
 
   /** The context the session has read so far, which picks a long-context tier. */
@@ -101,52 +99,80 @@ function ModelBody(props: {
   })
 
   const price = createMemo(() => {
-    const costs = entry()?.costs
-    return costs?.length ? priceFor(costs, contextSize()) : undefined
+    const list = entry()?.cost
+    return list && list.length > 0 ? priceFor(list, contextSize()) : undefined
   })
 
-  const rates = createMemo(() => {
+  /** A free model bills zero on every rate the card can show. */
+  const freeModel = createMemo(() => {
     const value = price()
+    return value ? value.input === 0 && value.output === 0 && value.cache.read === 0 : false
+  })
+
+  /** The paid list price of a free promo, when the catalog has its sibling. */
+  const reference = createMemo(() => {
+    if (!freeModel() || freeMode() !== "reference") return undefined
+    const selected = entry()
+    if (!selected) return undefined
+
+    const sibling = paidSibling(catalog(), selected)
+    return sibling ? priceFor(sibling.cost, contextSize()) : undefined
+  })
+
+  /** The rates on screen: the selected model's, or the reference it borrows. */
+  const shown = createMemo(() => reference() ?? (freeModel() ? undefined : price()))
+
+  const rates = createMemo(() => {
+    const value = shown()
     if (!value) return []
 
-    const rows: { label: string; value: string }[] = []
-    if (inputOn()) rows.push({ label: "in", value: formatRate(value.input) })
-    if (outputOn()) rows.push({ label: "out", value: formatRate(value.output) })
-    if (cacheOn()) rows.push({ label: "cache", value: formatRate(value.cache.read) })
+    const rows: { label: string; value: string; muted?: boolean }[] = []
+    if (inputOn()) rows.push({ label: "Input", value: formatRate(value.input) })
+    if (outputOn()) rows.push({ label: "Output", value: formatRate(value.output) })
+    if (cacheOn()) rows.push({ label: "Cache", value: formatRate(value.cache.read) })
     if (rows.length > 0 && value.tier) {
-      rows.push({ label: "from", value: `>${formatTokens(value.tier.size, "compact")}` })
+      rows.push({
+        label: "From",
+        value: `>${formatTokens(value.tier.size, "compact")}`,
+        muted: true,
+      })
     }
 
     return rows
   })
 
-  const variant = () => (variantOn() ? entry()?.ref.variant : undefined)
+  /** A free model with no reference price says so instead of drawing zeroes. */
+  const freeLabel = createMemo(() => {
+    if (!freeModel() || reference()) return false
+    return inputOn() || outputOn() || cacheOn()
+  })
 
-  const title = () => {
-    const name = entry()?.name
-    const selected = variant()
-    return selected ? `${name} · ${selected}` : name
-  }
+  /** `Hide card` removes the panel entirely while a free model is selected. */
+  const hidden = () => freeModel() && freeMode() === "hidden"
+
+  /** The widest label, so the prices start on one column. */
+  const labelWidth = createMemo(() =>
+    rates().reduce((width, row) => Math.max(width, row.label.length), 0),
+  )
 
   const scheduled = () => {
-    const ref = entry()?.ref
+    const ref = model()
     return ref ? hasPriceSchedule(ref) : false
   }
 
   const peak = () => {
-    const ref = entry()?.ref
+    const ref = model()
     if (!ref || !peakOn() || !scheduled()) return undefined
     return priceWindowFor(ref, new Date(now()))
   }
 
-  const stateValue = () => {
-    if (!peakOn() || !scheduled()) return undefined
-    const value = peak()
-    return value ? `${value.label} ×${value.multiplier} now` : "off-peak"
-  }
+  /** The price multiplier now, `1` when the catalog price is the one charged. */
+  const multiplier = () => peak()?.multiplier ?? 1
+
+  const showMultiplier = () => peakOn() && scheduled() && (peak() !== undefined || !peakOnly())
 
   // The live peak marker follows the clock, so refresh it while the card can
-  // show one. Models without a schedule and a hidden peak row need no timer.
+  // show one. Models without a schedule and a hidden peak state need no timer.
   createEffect(() => {
     if (!peakOn() || !scheduled()) return
 
@@ -156,48 +182,58 @@ function ModelBody(props: {
   })
 
   return (
-    <box flexDirection="column">
-      <box
-        flexDirection="row"
-        justifyContent="space-between"
-        onMouseUp={() => setCollapsed((value) => !value)}
-      >
-        <text attributes={TextAttributes.BOLD} fg={theme().text.base}>
-          {collapsed() ? "▶" : "▼"} Model
-        </text>
-        <Show when={entry()?.provider}>
-          <text attributes={TextAttributes.BOLD} fg={theme().text.base} wrapMode="none">
-            {entry()?.provider}
-          </text>
-        </Show>
-      </box>
-      <Show when={!collapsed()}>
-        <Show when={entry()} fallback={<text fg={theme().text.muted}>No model selected</text>}>
-          <text fg={theme().text.base} wrapMode="word">
-            {title()}
+    <Show when={!hidden()}>
+      <box flexDirection="column">
+        <box
+          flexDirection="row"
+          justifyContent="space-between"
+          onMouseUp={() => setCollapsed((value) => !value)}
+        >
+          <text attributes={TextAttributes.BOLD} fg={theme().text.base}>
+            {collapsed() ? "▶" : "▼"} Model
           </text>
-          <For each={rates()}>
-            {(row) => (
-              <box flexDirection="row" gap={1}>
-                <text flexShrink={0} fg={theme().text.muted}>
-                  {row.label.padEnd(5)}
+          <Show when={showMultiplier()}>
+            <text
+              fg={peak() ? theme().text.feedback.warning.base : theme().text.base}
+              wrapMode="none"
+            >
+              {`×${multiplier()}`}
+            </text>
+          </Show>
+        </box>
+        <Show when={!collapsed()}>
+          <Show when={model()} fallback={<text fg={theme().text.muted}>No model selected</text>}>
+            <Show
+              when={!freeLabel()}
+              fallback={
+                <text fg={theme().hue.accent[200]} attributes={TextAttributes.BOLD}>
+                  Free
                 </text>
-                <text fg={theme().text.base}>{row.value}</text>
-              </box>
-            )}
-          </For>
-          <Show when={stateValue()}>
-            <box flexDirection="row" gap={1}>
-              <text flexShrink={0} fg={theme().text.muted}>
-                {"state".padEnd(5)}
-              </text>
-              <text fg={peak() ? theme().text.feedback.warning.base : theme().text.muted}>
-                {stateValue()}
-              </text>
-            </box>
+              }
+            >
+              <For each={rates()}>
+                {(row) => (
+                  <box
+                    flexDirection="row"
+                    justifyContent={alignRight() ? "space-between" : "flex-start"}
+                    gap={1}
+                  >
+                    <text flexShrink={0} fg={theme().text.base}>
+                      {alignRight() ? row.label : row.label.padEnd(labelWidth())}
+                    </text>
+                    <text
+                      flexShrink={0}
+                      fg={row.muted ? theme().text.muted : theme().hue.accent[200]}
+                    >
+                      {row.value}
+                    </text>
+                  </box>
+                )}
+              </For>
+            </Show>
           </Show>
         </Show>
-      </Show>
-    </box>
+      </box>
+    </Show>
   )
 }

package/src/tweaks/model.ts

@@ -44,20 +44,40 @@ export const modelTweak = defineTweak({
       default: true,
     },
     {
-      id: "variant",
-      title: "Variant",
-      description: "Show the reasoning variant selected for the model.",
+      id: "peak",
+      title: "Peak state",
+      description: "Show the model's current price multiplier in the card header.",
       category: "Display",
       kind: "boolean",
       default: true,
     },
     {
-      id: "peak",
-      title: "Peak state",
-      description: "Show whether the model is billed above its catalog price right now.",
+      id: "align",
+      title: "Price alignment",
+      description: "Start the prices on one column, or push them against the right edge.",
+      category: "Display",
+      kind: "select",
+      default: "right",
+      values: ["left", "right"],
+    },
+    {
+      id: "free",
+      title: "Free models",
+      description:
+        "Show the paid list price, a Free label, or no card at all when the selected model is free.",
+      category: "Display",
+      kind: "select",
+      default: "reference",
+      values: ["reference", "label", "hidden"],
+      labels: ["List price", "Free label", "Hide card"],
+    },
+    {
+      id: "peakOnly",
+      title: "Peak only",
+      description: "Show the multiplier only during a peak window.",
       category: "Display",
       kind: "boolean",
-      default: true,
+      default: false,
     },
   ],
 })

package/src/usage/catalog.ts

@@ -0,0 +1,41 @@
+import type { ModelPrice } from "./cost"
+
+/** A catalog entry, narrowed to the fields the model card reads. */
+export interface CatalogModel {
+  readonly id: string
+  readonly modelID: string
+  readonly providerID: string
+  readonly name: string
+  readonly cost: readonly ModelPrice[]
+}
+
+/** Whether a price list charges anything at any of its rates. */
+export function charged(prices: readonly ModelPrice[]): boolean {
+  return prices.some((price) => price.input > 0 || price.output > 0 || price.cache.read > 0)
+}
+
+/**
+ * The paid entry behind a free promo. Providers name the promo after the model
+ * it borrows, so dropping a trailing `Free` and matching the same provider
+ * finds the price the model lists at when it is not on the house.
+ */
+export function paidSibling(
+  models: readonly CatalogModel[],
+  selected: CatalogModel,
+): CatalogModel | undefined {
+  const base = selected.name.replace(/\s*\(?free\)?$/i, "").trim()
+  if (base.length === 0 || base === selected.name) return undefined
+
+  const candidates = models.filter(
+    (candidate) =>
+      candidate.providerID === selected.providerID &&
+      candidate.id !== selected.id &&
+      charged(candidate.cost) &&
+      (candidate.name === base || candidate.name.startsWith(`${base} `)),
+  )
+
+  candidates.sort(
+    (a, b) => Number(b.name === base) - Number(a.name === base) || a.name.length - b.name.length,
+  )
+  return candidates[0]
+}