@qthinker/opencode-deepseek-search 0.2.1 → 0.3.2

package/src/status-view.ts

@@ -1,16 +1,20 @@
 // Pure view model for the sidebar card. No renderer, no runtime dependency:
 // the card and the tests both derive their text from here.
-import type { SearchStatus, UsageCounts } from "./rpc.ts"
+import { format, pack, t } from "./i18n/index.ts"
+import type { BalanceStatus, SearchStatus, UsageCounts, Language } from "./rpc.ts"
 
 export interface SidebarInput {
   readonly status: SearchStatus | undefined
-  readonly error: string | undefined
+  /** The last read failure, if any; undefined while the first read is in flight. */
+  readonly error?: string | undefined
   /**
    * Columns one row may occupy. Defaults to the narrow sidebar budget; a host
    * that has measured its width may pass it, and the desktop panel passes
    * `Infinity` because it has room for the verbose copy.
    */
   readonly maxColumns?: number
+  /** Resolved by the server and carried in `status`; both sidebars read it there. */
+  readonly language: Language
 }
 
 export interface SidebarRows {
@@ -37,7 +41,12 @@ export interface SidebarRows {
   readonly hint: string | undefined
   /** Whether a click on `action` really performs it (some states have no action). */
   readonly clickable: boolean
-  /** Body rows: the three usage rows, or the short error reason. */
+  /**
+   * Body rows: the three usage rows (or the single collapsed usage row when
+   * not even the shortest fits), or the short error reason, then the optional
+   * balance row last. A row starting with `!` is an unavailable balance; the
+   * marker is a color directive for the renderer and never part of the copy.
+   */
   readonly lines: readonly string[]
   /** Drives the state color in card.ts. */
   readonly tone: "on" | "off" | "warn" | "error" | "idle"
@@ -58,7 +67,11 @@ export const DEFAULT_COLUMNS = 24
 
 const PERIODS = ["today", "month", "total"] as const
 type Period = (typeof PERIODS)[number]
-const LABELS: Readonly<Record<Period, string>> = { today: "今日", month: "本月", total: "累计" }
+const LABEL_KEY = {
+  today: "usage.label.today",
+  month: "usage.label.month",
+  total: "usage.label.total",
+} as const
 
 type Counts = NonNullable<SearchStatus["counts"]>
 
@@ -106,9 +119,9 @@ function clip(text: string, maxColumns: number): string {
 }
 
 /** One short body line: collapse whitespace, then clip to the available columns. */
-function shortMessage(message: string, maxColumns: number): string {
+function shortMessage(message: string, maxColumns: number, language: Language): string {
   const text = message.replace(/\s+/g, " ").trim()
-  return clip(text || "读取失败", maxColumns)
+  return clip(text || t(language, "state.failed"), maxColumns)
 }
 
 /** Micro-currency as `¥0.015`: three decimals, trailing zeros trimmed to cents. */
@@ -142,72 +155,141 @@ function usageLayout(counts: Counts): UsageLayout {
 
 /**
  * One usage row, e.g. `今日  Search 0  Fetch 3  ¥0.015` when the surface is
- * wide, otherwise shorter forms down to `今日`. The words are the product's
- * copy, so they survive as long as any shape can hold them: the amount goes
- * first, then the tighter grouping, and only then `0S` / `3F`. Counts are
- * right-aligned in their shared width and every row picks the same form, so
- * the three rows read as a table.
+ * wide, otherwise shorter forms down to the amount or the search count alone.
+ * The ladder is per language: each locale owns the shapes that read well at its
+ * widths, so no language is squeezed into another one's budget. Counts are
+ * right-aligned in their shared width and every row picks the same form, so the
+ * three rows read as a table. `undefined` means not even the shortest rung fits;
+ * the caller then collapses the three rows instead of emitting blanks.
  */
 function compactUsageRow(
   period: Period,
   counts: UsageCounts,
   layout: UsageLayout,
   maxColumns: number,
-): string {
-  const label = LABELS[period]
+  language: Language,
+): string | undefined {
+  const label = t(language, LABEL_KEY[period])
   const search = String(counts.search).padStart(layout.search, " ")
   const fetch = String(counts.fetch).padStart(layout.fetch, " ")
   const cost = money(counts.costMicro).padStart(layout.cost, " ")
+  const params = { label, search, fetch, cost }
+  const forms = pack(language).usageForms
   // Each candidate is a complete row, so nothing is ever left dangling and no
   // number is ever cut from its unit.
-  const candidates = [
-    `${label}  Search ${search}  Fetch ${fetch}  ${cost}`,
-    `${label} Search ${search} Fetch ${fetch} ${cost}`,
-    `${label}  Search ${search}  Fetch ${fetch}`,
-    `${label} Search ${search} Fetch ${fetch}`,
-    `${label}  ${search}S  ${fetch}F  ${cost}`,
-    `${label}  ${search}S  ${fetch}F`,
-    `${label}  ${search}S`,
-  ]
-  for (const row of candidates) {
+  for (const form of forms.slice(0, -1)) {
+    const row = format(form, params)
     if (textColumns(row) <= maxColumns) return row
   }
-  return textColumns(label) <= maxColumns ? label : clip(label, maxColumns)
+  // The amount alone outranks the ladder's last rung, a lone search count: money
+  // is what this card is for, and a single counter is not. The row is composed
+  // here because it carries no count, so it is not a locale ladder entry — the
+  // label still comes from the locale table.
+  const amountRow = `${label} ${cost}`
+  if (textColumns(amountRow) <= maxColumns) return amountRow
+  const narrowest = forms[forms.length - 1]
+  if (narrowest !== undefined) {
+    const row = format(narrowest, params)
+    if (textColumns(row) <= maxColumns) return row
+  }
+  return undefined
 }
 
 /**
- * An older server only sends pre-formatted strings. Keep the full string when
- * it fits, otherwise drop its trailing segments whole: the amount and the
- * diagnostic counters go first, then the fetch count.
+ * Below the shortest rung no usage row can carry a number, so the three rows
+ * become one that still does: the total cost first (the number this card is
+ * opened for), then the total search count, then the bare amount, which fits
+ * the card floor on its own. A label with no number behind it is a row of noise
+ * and is never emitted.
  */
-function legacyUsageRow(period: Period, text: string, maxColumns: number): string {
-  const label = LABELS[period]
-  const full = `${label} ${text}`
-  if (textColumns(full) <= maxColumns) return full
-  const stats = text.split(" · ").filter((part) => !part.startsWith("¥") && !part.startsWith("空/失"))
+function collapseUsageRow(counts: UsageCounts, layout: UsageLayout, maxColumns: number, language: Language): string {
+  const label = t(language, LABEL_KEY.total)
+  const cost = money(counts.costMicro)
   const candidates = [
-    `${label} ${stats.join("  ")}`.trimEnd(),
-    `${label} ${stats[0] ?? ""}`.trimEnd(),
-    label,
+    `${label} ${cost.padStart(layout.cost, " ")}`,
+    `${label} ${String(counts.search).padStart(layout.search, " ")}S`,
+    cost,
   ]
   for (const row of candidates) {
     if (textColumns(row) <= maxColumns) return row
   }
-  return clip(label, maxColumns)
+  // Nothing unclipped fits: only a clipped amount is left, and it still shows a
+  // digit as far as the columns allow.
+  return clip(cost, maxColumns)
 }
 
-function usageLines(status: SearchStatus, maxColumns: number): readonly string[] {
+function usageLines(status: SearchStatus, maxColumns: number, language: Language): readonly string[] {
   // The desktop panel lays the original verbose copy out as ` · ` chunks of its
   // own table; only the terminal needs the compact form.
   if (maxColumns === Number.POSITIVE_INFINITY) {
-    return [`今日 ${status.today}`, `本月 ${status.month}`, `累计 ${status.total}`]
+    return [
+      `${t(language, "usage.label.today")} ${status.today}`,
+      `${t(language, "usage.label.month")} ${status.month}`,
+      `${t(language, "usage.label.total")} ${status.total}`,
+    ]
   }
   const counts = status.counts
   if (counts) {
     const layout = usageLayout(counts)
-    return PERIODS.map((period) => compactUsageRow(period, counts[period], layout, maxColumns))
+    const rows: string[] = []
+    for (const period of PERIODS) {
+      const row = compactUsageRow(period, counts[period], layout, maxColumns, language)
+      // All three rows share their padded widths, so they either all fit or none
+      // does; the first miss is enough to collapse rather than half a table.
+      if (row === undefined) return [collapseUsageRow(counts.total, layout, maxColumns, language)]
+      rows.push(row)
+    }
+    return rows
+  }
+  return PERIODS.map((period) => legacyUsageRow(period, status[period], maxColumns, language))
+}
+
+// The server normalizes `currency` to one of these codes, so the symbol is a
+// lookup rather than a formatting library. An unknown code contributes nothing
+// instead of a wrong symbol. The desktop panel reuses it for its account block.
+export const CURRENCY_SYMBOL: Readonly<Record<string, string>> = { CNY: "¥", USD: "$" }
+
+/**
+ * The account-balance row, or `undefined` when it does not fit. The amount is
+ * the server's string verbatim (`110.00`), never re-rounded: DeepSeek's account
+ * balance is authoritative and this row only mirrors it.
+ *
+ * `!` marks an unavailable balance and costs one column; it is the only marker,
+ * so the renderer can turn it into a color and every other consumer keeps a
+ * plain string. The row is never compressed into another one: below its width it
+ * is dropped, because half an amount is worse than no amount.
+ */
+function balanceRow(balance: BalanceStatus, maxColumns: number, language: Language): string | undefined {
+  const marker = balance.isAvailable ? "" : "!"
+  const amount = `${CURRENCY_SYMBOL[balance.currency] ?? ""}${balance.totalBalance}`
+  for (const form of pack(language).balanceForms) {
+    const row = `${marker}${format(form, { amount })}`
+    if (textColumns(row) <= maxColumns) return row
   }
-  return PERIODS.map((period) => legacyUsageRow(period, status[period], maxColumns))
+  return undefined
+}
+
+/**
+ * An older server only sends pre-formatted strings, and those are always the
+ * Chinese ones this plugin used to send: the filter below is deliberately
+ * Chinese-only and stays correct while the UI language changes. Keep the full
+ * string when it fits, otherwise drop its trailing segments whole: the amount
+ * and the diagnostic counters go first, then the fetch count.
+ */
+function legacyUsageRow(period: Period, text: string, maxColumns: number, language: Language): string {
+  const label = t(language, LABEL_KEY[period])
+  const full = `${label} ${text}`
+  if (textColumns(full) <= maxColumns) return full
+  const stats = text.split(" · ").filter((part) => !part.startsWith("¥") && !part.startsWith("空/失"))
+  const candidates = [
+    `${label} ${stats.join("  ")}`.trimEnd(),
+    `${label} ${stats[0] ?? ""}`.trimEnd(),
+    label,
+  ]
+  for (const row of candidates) {
+    if (textColumns(row) <= maxColumns) return row
+  }
+  return clip(label, maxColumns)
 }
 
 /**
@@ -236,12 +318,17 @@ interface TitleFit {
  * and the title keeps the full width, and only then do the product name and the
  * wordy state shrink. Within one wording the glyph is the first thing to go,
  * because it costs two columns and the state word is right beside it.
+ *
+ * `allowActionBelow` is false on a card whose body is already full: giving the
+ * action its own row would push the card past its height budget, so the title
+ * shrinks instead — the action row always wins, because it is the only control.
  */
 function fitTitle(
   state: string,
   shortState: string,
   maxColumns: number,
   actionColumns: number | undefined,
+  allowActionBelow = true,
 ): TitleFit {
   const budget = (glyph: boolean, actionBelow: boolean): number => {
     if (maxColumns === Number.POSITIVE_INFINITY) return Number.POSITIVE_INFINITY
@@ -258,7 +345,7 @@ function fitTitle(
   ]
   // Inline first, then the action below it; a wording is never traded for a
   // shorter one that happens to fit inline, because the wording is the point.
-  const placements = actionColumns === undefined ? [false] : [false, true]
+  const placements = actionColumns === undefined || !allowActionBelow ? [false] : [false, true]
   for (const candidate of candidates) {
     for (const actionBelow of placements) {
       for (const glyph of [true, false]) {
@@ -269,24 +356,20 @@ function fitTitle(
     }
   }
   // Nothing fits whole at a pathological width: clip the state and give the
-  // action its own row so the hit area never disappears.
-  const actionBelow = actionColumns !== undefined
+  // action its own row so the hit area never disappears — unless the body has
+  // already spent that row, in which case the clipped title shares the width.
+  const actionBelow = allowActionBelow && actionColumns !== undefined
   return { title: clip(shortState, budget(false, actionBelow)), glyph: false, actionBelow }
 }
 
 /** The fix hint for a missing key; it gets its own row because no click can fix it. */
-function fitHint(maxColumns: number): string {
-  const candidates = [
-    "设置 DEEPSEEK_API_KEY 后重启",
-    "设置 API KEY 后重启",
-    "设置 API KEY",
-    "设置 KEY",
-  ]
-  if (maxColumns === Number.POSITIVE_INFINITY) return candidates[0]
-  for (const candidate of candidates) {
-    if (textColumns(candidate) <= maxColumns) return candidate
+function fitHint(maxColumns: number, language: Language): string {
+  const forms = pack(language).hintForms
+  if (maxColumns === Number.POSITIVE_INFINITY) return forms[0] ?? ""
+  for (const form of forms) {
+    if (textColumns(form) <= maxColumns) return form
   }
-  return clip(candidates[candidates.length - 1], maxColumns)
+  return clip(forms[forms.length - 1] ?? "", maxColumns)
 }
 
 interface ActionRows extends TitleFit {
@@ -294,39 +377,67 @@ interface ActionRows extends TitleFit {
 }
 
 /** Fit the action first: the title can only use the columns it leaves over. */
-function actionRows(state: string, shortState: string, verb: string, maxColumns: number): ActionRows {
+function actionRows(
+  state: string,
+  shortState: string,
+  verb: string,
+  maxColumns: number,
+  allowActionBelow = true,
+): ActionRows {
   const action = fitAction(verb, maxColumns)
-  return { ...fitTitle(state, shortState, maxColumns, textColumns(action)), action }
+  return { ...fitTitle(state, shortState, maxColumns, textColumns(action), allowActionBelow), action }
 }
 
 export function sidebarRows(input: SidebarInput): SidebarRows {
-  const { status, error } = input
+  const { status, error, language } = input
   const maxColumns = input.maxColumns ?? DEFAULT_COLUMNS
-  const lines = status === undefined ? [] : usageLines(status, maxColumns)
+  const usage = status === undefined ? [] : usageLines(status, maxColumns, language)
+  // Only the two states that really point at the account show it: an enabled
+  // takeover or an explicit native mode. A state where nothing is taken over, a
+  // missing key, or a failed read leaves the body to usage and the error reason.
+  const balance =
+    status !== undefined &&
+    ((status.patched && status.hasKey) || status.mode === "native") &&
+    status.balance !== undefined
+      ? balanceRow(status.balance, maxColumns, language)
+      : undefined
+  // The balance row closes the body: the three usage rows read as the receipt
+  // (what this machine spent) and the account truth lands under them (what is
+  // left to spend). It still costs one body row, so the header must keep the
+  // action inline to stay within five rows.
+  const lines = balance === undefined ? usage : [...usage, balance]
+  const allowActionBelow = balance === undefined
 
   // No status yet: the body has no numbers to show, only the reason (or that
   // the first read is still in flight).
   if (status === undefined) {
+    const retry = t(language, "action.retry")
     return error === undefined || error.trim() === ""
       ? {
-          ...actionRows("正在读取…", "正在读取…", "重试", maxColumns),
+          ...actionRows(t(language, "state.loading"), t(language, "state.loadingShort"), retry, maxColumns),
           hint: undefined,
           clickable: true,
           lines,
           tone: "idle",
         }
       : {
-          ...actionRows("读取失败", "读取失败", "重试", maxColumns),
+          ...actionRows(t(language, "state.failed"), t(language, "state.failedShort"), retry, maxColumns),
           hint: undefined,
           clickable: true,
-          lines: [shortMessage(error, maxColumns)],
+          lines: [shortMessage(error, maxColumns, language)],
           tone: "error",
         }
   }
 
   if (status.patched && status.hasKey) {
     return {
-      ...actionRows("已启用", "已启用", "停用", maxColumns),
+      ...actionRows(
+        t(language, "state.enabled"),
+        t(language, "state.enabledShort"),
+        t(language, "action.disable"),
+        maxColumns,
+        allowActionBelow,
+      ),
       hint: undefined,
       clickable: true,
       lines,
@@ -337,7 +448,13 @@ export function sidebarRows(input: SidebarInput): SidebarRows {
     // DeepSeek was requested but the built-in tool was not found: nothing is
     // actually taken over, so the only honest action is to release the mode.
     return {
-      ...actionRows("未接管内置 websearch", "未接管", "交还", maxColumns),
+      ...actionRows(
+        t(language, "state.unpatched"),
+        t(language, "state.unpatchedShort"),
+        t(language, "action.release"),
+        maxColumns,
+        allowActionBelow,
+      ),
       hint: undefined,
       clickable: true,
       lines,
@@ -346,7 +463,13 @@ export function sidebarRows(input: SidebarInput): SidebarRows {
   }
   if (status.mode === "native") {
     return {
-      ...actionRows("已停用", "已停用", "启用", maxColumns),
+      ...actionRows(
+        t(language, "state.disabled"),
+        t(language, "state.disabledShort"),
+        t(language, "action.enable"),
+        maxColumns,
+        allowActionBelow,
+      ),
       hint: undefined,
       clickable: true,
       lines,
@@ -356,9 +479,9 @@ export function sidebarRows(input: SidebarInput): SidebarRows {
   // A missing key is not something a click can fix, so the title row stands
   // alone and the hint gets its own row directly under it. The env var name
   // only survives on surfaces wide enough for it.
-  const hint = fitHint(maxColumns)
+  const hint = fitHint(maxColumns, language)
   return {
-    ...fitTitle("未配置 API Key", "缺 API Key", maxColumns, undefined),
+    ...fitTitle(t(language, "state.missingKey"), t(language, "state.missingKeyShort"), maxColumns, undefined),
     action: hint,
     hint,
     clickable: false,

package/src/tui/card.ts

@@ -3,12 +3,16 @@
 import type { JSX } from "@opentui/solid"
 import type { ResolvedTheme } from "@opencode/theme/tui"
 import { createElement, insert, setProp } from "@opentui/solid"
-import type { SearchStatus } from "../rpc.ts"
+import type { Language, SearchStatus } from "../rpc.ts"
 import { DEFAULT_COLUMNS, sidebarRows } from "../status-view.ts"
 import type { SidebarRows } from "../status-view.ts"
 
 /** A measured width under this cannot show even the usage label; treat it as unmeasured. */
 const MIN_CARD_COLUMNS = 8
+/** Body rows are inset this far from the title, so the card reads as one block. */
+const INDENT = "  "
+/** Under this many columns the indent costs more than it explains. */
+const INDENT_MIN_COLUMNS = 16
 
 /**
  * Columns the card may use. Before the first layout pass the host reports 0 (or
@@ -69,9 +73,45 @@ function element(tag: string, props: Props | undefined, children: readonly Child
   return node
 }
 
+/** The amount at the end of a row, e.g. `¥0.015` / `$6.17`; it gets its own color. */
+const MONEY_TAIL = /([¥$][\d.,]+)$/u
+
+/**
+ * One body row split into the three tiers the card colors. The view model emits
+ * plain strings — one row per line, deliberately not structured — so the row is
+ * split here: the leading label reads faint, the counters in the middle muted,
+ * and the amount at the end is the number the user came for, so it gets full
+ * contrast.
+ */
+interface BodyParts {
+  readonly label: string
+  readonly middle: string
+  readonly amount: string
+  /** The row starts with `!`: the balance could not be read. */
+  readonly unavailable: boolean
+}
+
+function bodyParts(line: string): BodyParts {
+  // `!` is the only unavailable marker in the row text and is consumed here as a
+  // color directive: it is never drawn. The label and the amount still are.
+  const unavailable = line.startsWith("!")
+  const text = unavailable ? line.slice(1) : line
+  const amount = MONEY_TAIL.exec(text)?.[1] ?? ""
+  const head = amount === "" ? text : text.slice(0, text.length - amount.length)
+  const gap = head.indexOf(" ")
+  return {
+    label: gap < 0 ? head : head.slice(0, gap),
+    middle: gap < 0 ? "" : head.slice(gap),
+    amount,
+    unavailable,
+  }
+}
+
 export function sidebarCard(input: {
   readonly status: SearchStatus | undefined
   readonly error: string | undefined
+  /** UI language resolved by the server; the card never picks one itself. */
+  readonly language: Language
   readonly theme: ResolvedTheme
   readonly onToggle: () => void
   /**
@@ -83,10 +123,15 @@ export function sidebarCard(input: {
 }): JSX.Element {
   // The terminal sidebar is the surface this ladder is tuned for: the measured
   // width, not a guessed constant, decides whether the words fit.
+  const columns = cardColumns(input.maxColumns)
+  // The indent is part of the drawn row, so it is subtracted from the budget the
+  // model composes against: every row still ends inside the measured width.
+  const indent = columns >= INDENT_MIN_COLUMNS ? INDENT : ""
   const rows = sidebarRows({
     status: input.status,
     error: input.error,
-    maxColumns: cardColumns(input.maxColumns),
+    maxColumns: columns - indent.length,
+    language: input.language,
   })
   const theme = input.theme
   const state = toneColor(theme, rows.tone)
@@ -105,14 +150,18 @@ export function sidebarCard(input: {
   //
   // The state word carries the tone color, so a narrow sidebar that has to drop
   // the glyph still shows the state at a glance (the desktop panel does the same).
+  // When the glyph is gone the word also goes bold — the emphasis has to live
+  // somewhere. Bold rides in `style`, because the reconciler ignores an
+  // `attributes` prop on text nodes and only maps `style` (fg/bg/attributes).
+  const stateStyle = rows.glyph ? { fg: state } : { fg: state, bold: true }
   const separator = rows.title.indexOf(" · ")
   const titleSpans: Child[] =
     separator < 0
-      ? [element("span", { style: { fg: state } }, [rows.title])]
+      ? [element("span", { style: stateStyle }, [rows.title])]
       : [
           element("span", { style: { fg: theme.text.base } }, [rows.title.slice(0, separator)]),
           element("span", { style: { fg: theme.text.faint } }, [" · "]),
-          element("span", { style: { fg: state } }, [rows.title.slice(separator + 3)]),
+          element("span", { style: stateStyle }, [rows.title.slice(separator + 3)]),
         ]
   if (rows.glyph) {
     titleSpans.unshift(element("span", { style: { fg: state } }, [`${GLYPH[rows.tone]} `]))
@@ -154,11 +203,28 @@ export function sidebarCard(input: {
           [action],
         )
 
-  // The model already composed every row to fit the sidebar, so each body row
-  // is one text node: the host must never get the chance to wrap it.
-  const body = rows.lines.map((line) =>
-    element("text", { content: line, fg: theme.text.muted, wrapMode: "none", width: "100%" }),
-  )
+  // The model already composed every row to fit the sidebar, so each body row is
+  // one text node: the host must never get the chance to wrap it. The row's own
+  // text is split into colored spans, so the label, the counters and the amount
+  // each read at their own weight without a second row or a box per line.
+  const body = rows.lines.map((line) => {
+    const parts = bodyParts(line)
+    const spans: Child[] = []
+    if (indent !== "") spans.push(element("span", { style: { fg: theme.text.faint } }, [indent]))
+    if (parts.label !== "") {
+      spans.push(element("span", { style: { fg: theme.text.faint } }, [parts.label]))
+    }
+    if (parts.middle !== "") {
+      spans.push(element("span", { style: { fg: theme.text.muted } }, [parts.middle]))
+    }
+    if (parts.amount !== "") {
+      // An unavailable balance is the one thing on the card that must not look
+      // like an ordinary amount: it is the reason the next call will fail.
+      const fg = parts.unavailable ? theme.text.feedback.warning.base : theme.text.base
+      spans.push(element("span", { style: { fg } }, [parts.amount]))
+    }
+    return element("text", { selectable: false, wrapMode: "none", width: "100%" }, spans)
+  })
   // A missing key has no action, so the fix hint gets the row right under the
   // title. It is plain text: there is nothing to click.
   const hint =

package/src/tui/main.ts

@@ -9,7 +9,8 @@ import { Plugin } from "@opencode/plugin/tui"
 import { createElement, insert, setProp, type JSX } from "@opentui/solid"
 import type { Renderable } from "@opentui/core"
 import { createSignal } from "solid-js"
-import { DeepSeekRpc, readModeResult, readStatus, type SearchStatus } from "../rpc.ts"
+import { DeepSeekRpc, readModeResult, readStatus, type Language, type SearchStatus } from "../rpc.ts"
+import { t } from "../i18n/index.ts"
 import { sidebarCard } from "./card.ts"
 
 const REFRESH_MS = 10_000
@@ -25,17 +26,28 @@ export default Plugin.define({
 
     const describeError = (e: unknown) => (e instanceof Error ? e.message : String(e)).slice(0, ERROR_MAX)
 
+    // One language for every string this half renders. Before the first status
+    // arrives there is nothing to read it from, so the first frame is English;
+    // the reactive card and the host-re-run keymap factory pick up the real one
+    // as soon as the server reports it.
+    const language = (): Language => status()?.language ?? "en"
+
     // `status` takes a required first argument: plain JSON Schema degrades the
     // input type to `unknown`, and the host validates the payload against the
     // method's object schema, so an omitted input is rejected as invalid.
-    async function refresh() {
+    //
+    // `force` asks the server to re-probe the account balance instead of serving
+    // the cache; only a user action may spend that request. The timer and the
+    // `changed` event therefore send `{}` exactly — an older server rejects
+    // unknown input properties, so a stray `force: false` would break it.
+    async function refresh(force = false) {
       try {
-        const next = readStatus(await rpc.status({}))
+        const next = readStatus(await rpc.status(force ? { force: true } : {}))
         if (next) {
           setStatus(next)
           setError(undefined)
         } else {
-          setError("状态数据格式不符")
+          setError(t(language(), "toast.statusMalformed"))
         }
       } catch (e) {
         setError(describeError(e))
@@ -46,7 +58,7 @@ export default Plugin.define({
     async function applyMode(mode: "deepseek" | "native") {
       try {
         const result = readModeResult(await rpc.setMode({ mode }))
-        if (!result) ctx.ui.toast.show({ message: "模式切换结果格式不符", variant: "error" })
+        if (!result) ctx.ui.toast.show({ message: t(language(), "toast.modeMalformed"), variant: "error" })
         else if (!result.ok) ctx.ui.toast.show({ message: result.message, variant: "error" })
       } catch (e) {
         ctx.ui.toast.show({ message: describeError(e), variant: "error" })
@@ -58,11 +70,12 @@ export default Plugin.define({
     }
 
     // The card labels the action it can really perform: switching the takeover
-    // when a status is known, retrying the read when it is not.
+    // when a status is known, retrying the read when it is not. A retry is a user
+    // action, so it refreshes the cached balance snapshot as well.
     function toggle() {
       const current = status()
       if (!current || error()) {
-        void refresh()
+        void refresh(true)
         return
       }
       void applyMode(current.mode === "deepseek" ? "native" : "deepseek")
@@ -72,16 +85,18 @@ export default Plugin.define({
     // entry point that always works (keymap command + `/deepseek` slash).
     async function openMenu() {
       const choice = await ctx.ui.dialog.select<"deepseek" | "native" | "refresh">({
-        title: "DeepSeek 搜索",
+        title: t(language(), "dialog.title"),
         options: [
-          { title: "启用", value: "deepseek", description: "接管内置 websearch" },
-          { title: "停用", value: "native", description: "把内置 websearch 交还宿主" },
-          { title: "刷新", value: "refresh", description: "重新读取状态与统计" },
+          { title: t(language(), "dialog.enable"), value: "deepseek", description: t(language(), "dialog.enableDesc") },
+          { title: t(language(), "dialog.disable"), value: "native", description: t(language(), "dialog.disableDesc") },
+          { title: t(language(), "dialog.refresh"), value: "refresh", description: t(language(), "dialog.refreshDesc") },
         ],
         current: status()?.mode,
       })
       if (choice === undefined) return
-      if (choice === "refresh") await refresh()
+      // The dialog's refresh is an explicit "show me now", so it bypasses the
+      // server's balance cache; enabling/disabling refreshes through applyMode.
+      if (choice === "refresh") await refresh(true)
       else await applyMode(choice)
     }
 
@@ -106,6 +121,7 @@ export default Plugin.define({
           sidebarCard({
             status: status(),
             error: error(),
+            language: language(),
             theme: ctx.theme,
             onToggle: toggle,
             maxColumns: width(),
@@ -121,7 +137,7 @@ export default Plugin.define({
       commands: [
         {
           id: "deepseek-search.toggle",
-          title: "DeepSeek: 启用/停用搜索接管",
+          title: t(language(), "command.toggle"),
           slash: { name: "deepseek" },
           run: () => void openMenu(),
         },