opencode-tweaks 0.5.0 → 0.6.1

package/README.md

@@ -179,6 +179,13 @@ Costs come from what the provider reports, so a free plan shows `$0.00`. `Cost d
 `Auto` keeps two decimals and grows until the first significant digit shows (`$0.004`), while a fixed choice always
 keeps that many (`$0.0042`).
 
+`Price windows` marks rounds billed above the catalog price. DeepSeek doubles its listed prices from 01:00 to
+04:00 and from 06:00 to 10:00 UTC, Monday to Friday, and bills Chinese public holidays at the off-peak rate; OpenCode
+Go publishes the same DeepSeek rates. The badge reads `peak ×2` beside the turn cost when that round started in a peak
+window, so it stays on screen after the window closes. The catalog already holds the off-peak price, so the figures
+themselves stay the listed rate. The 2026 and 2027 holidays are built in; update `src/usage/price-window.ts` when the
+next calendar is published.
+
 `Estimate cost` fills in a price the provider did not report, using the model's list price from the same catalog
 OpenCode already synced: prompt, completion, reasoning billed as output, and cache traffic, each at its own rate. A
 provider that reports a price always wins, and a session that changed model is estimated with the model it ended on, so
@@ -212,6 +219,7 @@ src/
     messages.ts     message shape and turn selection
     tokens.ts       token sums and formatting
     cost.ts         list prices, estimates, and cost formatting
+    price-window.ts provider peak hours and holidays
   tui.tsx           terminal entry: commands and slots
   tweaks/
     types.ts        settings schema and validation

package/package.json

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

package/src/tweaks/cost.ts

@@ -57,6 +57,14 @@ export const costTweak = defineTweak({
       values: ["auto", 2, 3, 4, 5, 6],
       labels: ["Auto", "2 digits", "3 digits", "4 digits", "5 digits", "6 digits"],
     },
+    {
+      id: "windows",
+      title: "Price windows",
+      description: "Mark rounds billed above the catalog price, such as DeepSeek peak hours.",
+      category: "Display",
+      kind: "boolean",
+      default: true,
+    },
     {
       id: "estimate",
       title: "Estimate cost",

package/src/tweaks/usage-slots.tsx

@@ -10,6 +10,7 @@ import {
   priceFor,
 } from "../usage/cost"
 import { footerMessage, replyTurnMessages, type UsageMessage } from "../usage/messages"
+import { formatPriceWindow, type PriceModel, turnPriceWindow } from "../usage/price-window"
 import { formatTokens, sessionTokens, type TokenCount, usageTokens } from "../usage/tokens"
 import { costTweak } from "./cost"
 import type { SettingsStore } from "./settings"
@@ -23,6 +24,15 @@ function setting(tweak: Tweak, id: string): TweakSetting {
   return found
 }
 
+/** The model of the newest message that carries one. */
+function lastModel(messages: readonly UsageMessage[]): PriceModel | undefined {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const model = messages[index]?.model
+    if (model) return model
+  }
+  return undefined
+}
+
 const TOKENS_ON = setting(tokensTweak, "enabled")
 const PROMPT = setting(tokensTweak, "prompt")
 const TOTAL = setting(tokensTweak, "total")
@@ -35,6 +45,7 @@ const COST_ON = setting(costTweak, "enabled")
 const PROMPT_COST = setting(costTweak, "prompt")
 const TOTAL_COST = setting(costTweak, "total")
 const COST_DIGITS = setting(costTweak, "digits")
+const WINDOWS = setting(costTweak, "windows")
 const ESTIMATE = setting(costTweak, "estimate")
 
 /**
@@ -55,6 +66,7 @@ function useUsage(props: {
   const subagents = () => props.store.read(tokensTweak, SUBAGENTS).value === true
   const promptCost = () => props.store.read(costTweak, PROMPT_COST).value === true
   const totalCost = () => props.store.read(costTweak, TOTAL_COST).value === true
+  const windowsOn = () => props.store.read(costTweak, WINDOWS).value === true
   const estimate = () => props.store.read(costTweak, ESTIMATE).value === true
   const ttft = () => props.store.read(tokensTweak, TTFT).value !== false
   const costDigits = (): CostDigits => {
@@ -173,12 +185,22 @@ function useUsage(props: {
 
   const promptCount = () => (tokensOn() && perPrompt() ? format(prompt()) : undefined)
   const totalCount = () => (tokensOn() && sessionTotal() ? format(total()) : undefined)
+
+  const sessionModel = () => {
+    const sessionID = props.sessionID()
+    if (!sessionID) return undefined
+    return sessions.get(sessionID)?.model ?? lastModel(messages(sessionID))
+  }
+
   const promptCostLabel = () => {
     const value = cost()
-    return costOn() && promptCost() && value !== undefined
-      ? formatCost(value, costDigits())
-      : undefined
+    if (!costOn() || !promptCost() || value === undefined) return undefined
+
+    const label = formatCost(value, costDigits())
+    const window = windowsOn() ? turnPriceWindow(turn(), sessionModel()) : undefined
+    return window ? `${label} · ${formatPriceWindow(window)}` : label
   }
+
   const totalCostLabel = () =>
     costOn() && totalCost() ? formatCost(sessionCost(), costDigits()) : undefined
 

package/src/usage/messages.ts

@@ -13,6 +13,8 @@ export interface UsageMessage {
   readonly tokens?: MessageTokens
   readonly cost?: number
   readonly model?: { readonly providerID: string; readonly id: string }
+  /** When the step was created, which is when the provider started billing it. */
+  readonly time?: { readonly created?: number }
   /** How the step ended; the host only draws a footer for a finished one. */
   readonly finish?: string | null
   readonly error?: unknown

package/src/usage/price-window.ts

@@ -0,0 +1,157 @@
+import type { UsageMessage } from "./messages"
+
+/** The provider and model a message belongs to. */
+export interface PriceModel {
+  readonly providerID: string
+  readonly id: string
+}
+
+/** A period that bills above the catalog price. */
+export interface PriceWindow {
+  /** Short label shown beside the cost, such as `peak`. */
+  readonly label: string
+  /** What the period does to the catalog price, such as 2 for double. */
+  readonly multiplier: number
+}
+
+interface PeakRange {
+  /** Minutes after midnight UTC, inclusive. */
+  readonly from: number
+  /** Minutes after midnight UTC, exclusive. */
+  readonly to: number
+}
+
+interface PriceSchedule {
+  /** Providers whose catalog price follows this schedule. */
+  readonly providers: readonly string[]
+  /** Model id prefix the schedule covers, when the provider serves other models. */
+  readonly modelPrefix: string
+  /** Weekdays billed at the higher price, where 1 is Monday and 7 is Sunday. */
+  readonly peakDays: readonly number[]
+  /** Peak windows in UTC; none of them crosses midnight. */
+  readonly peak: readonly PeakRange[]
+  /** Days billed at the catalog price even when they fall on a peak weekday. */
+  readonly holidays?: ReadonlySet<string>
+  readonly label: string
+  readonly multiplier: number
+}
+
+/** Every UTC date from `from` to `to`, both included. */
+function dateRange(from: string, to: string): string[] {
+  const dates: string[] = []
+  const end = Date.parse(`${to}T00:00:00Z`)
+
+  for (let at = Date.parse(`${from}T00:00:00Z`); at <= end; at += 86_400_000) {
+    dates.push(new Date(at).toISOString().slice(0, 10))
+  }
+
+  return dates
+}
+
+/**
+ * Mainland China public holidays from the State Council notices of 2025-11-04
+ * (2026) and 2026-11-05 (2027). DeepSeek bills these days at the off-peak rate
+ * even when they fall on a weekday. Add the next notice's dates here.
+ */
+const CHINA_HOLIDAYS: ReadonlySet<string> = new Set([
+  ...dateRange("2026-01-01", "2026-01-03"),
+  ...dateRange("2026-02-15", "2026-02-23"),
+  ...dateRange("2026-04-04", "2026-04-06"),
+  ...dateRange("2026-05-01", "2026-05-05"),
+  ...dateRange("2026-06-19", "2026-06-21"),
+  ...dateRange("2026-09-25", "2026-09-27"),
+  ...dateRange("2026-10-01", "2026-10-07"),
+  ...dateRange("2027-01-01", "2027-01-03"),
+  ...dateRange("2027-02-05", "2027-02-13"),
+  ...dateRange("2027-04-03", "2027-04-05"),
+  ...dateRange("2027-05-01", "2027-05-05"),
+  ...dateRange("2027-06-09", "2027-06-09"),
+  ...dateRange("2027-09-15", "2027-09-15"),
+  ...dateRange("2027-10-01", "2027-10-07"),
+])
+
+/**
+ * DeepSeek doubles its catalog price from 01:00 to 04:00 and from 06:00 to
+ * 10:00 UTC, Monday to Friday, excluding Chinese public holidays. Its catalog
+ * prices are the off-peak rates, so the higher price is twice the listed one.
+ * OpenCode Go publishes the same DeepSeek rates.
+ *
+ * Source: https://api-docs.deepseek.com/quick_start/pricing/ (2026-11)
+ */
+const DEEPSEEK: PriceSchedule = {
+  providers: ["deepseek", "opencode-go"],
+  modelPrefix: "deepseek-",
+  peakDays: [1, 2, 3, 4, 5],
+  peak: [
+    { from: 1 * 60, to: 4 * 60 },
+    { from: 6 * 60, to: 10 * 60 },
+  ],
+  holidays: CHINA_HOLIDAYS,
+  label: "peak",
+  multiplier: 2,
+}
+
+const schedules: readonly PriceSchedule[] = [DEEPSEEK]
+
+/** Monday-first weekday, since the schedules are written that way. */
+function weekday(date: Date): number {
+  const day = date.getUTCDay()
+  return day === 0 ? 7 : day
+}
+
+function utcDate(date: Date): string {
+  return date.toISOString().slice(0, 10)
+}
+
+function utcMinutes(date: Date): number {
+  return date.getUTCHours() * 60 + date.getUTCMinutes()
+}
+
+/**
+ * The higher price that applies to a model at `at`, or `undefined` when the
+ * catalog price is the one being charged. The check is deliberately narrow:
+ * only published schedules show a badge, and an unknown provider stays silent.
+ */
+export function priceWindowFor(model: PriceModel | undefined, at: Date): PriceWindow | undefined {
+  if (!model) return undefined
+
+  const schedule = schedules.find(
+    (candidate) =>
+      candidate.providers.includes(model.providerID) && model.id.startsWith(candidate.modelPrefix),
+  )
+  if (!schedule) return undefined
+
+  if (!schedule.peakDays.includes(weekday(at))) return undefined
+  if (schedule.holidays?.has(utcDate(at))) return undefined
+
+  const minutes = utcMinutes(at)
+  if (!schedule.peak.some((range) => minutes >= range.from && minutes < range.to)) {
+    return undefined
+  }
+
+  return { label: schedule.label, multiplier: schedule.multiplier }
+}
+
+/** The short text shown beside a cost, such as `peak ×2`. */
+export function formatPriceWindow(window: PriceWindow): string {
+  return `${window.label} ×${window.multiplier}`
+}
+
+/**
+ * The window that applied to a round, from the step that started it. Each
+ * request is billed when it starts, so a round that ran during peak keeps its
+ * marker after the window closes. Only assistant steps carry a start time.
+ */
+export function turnPriceWindow(
+  messages: readonly UsageMessage[],
+  fallback?: PriceModel,
+): PriceWindow | undefined {
+  const step = messages.find(
+    (message) => message.type === "assistant" && message.time?.created !== undefined,
+  )
+  const created = step?.time?.created
+  const model = step?.model ?? fallback
+  if (!model || created === undefined) return undefined
+
+  return priceWindowFor(model, new Date(created))
+}