@qthinker/opencode-deepseek-search 0.1.1 → 0.2.0

package/src/index.ts

@@ -14,6 +14,7 @@
 
 import { Plugin } from "@opencode/plugin"
 import type { Result as ToolResult, ToolContext } from "@opencode/plugin/promise/tool"
+import type { RpcRegistration } from "@opencode/plugin/promise/rpc"
 import {
   deepseekFetch,
   deepseekSearch,
@@ -23,6 +24,7 @@ import {
   validateUrl,
   type SearchResult,
 } from "./deepseek.ts"
+import { DeepSeekRpc, type ModeSwitchResult, type SearchStatus } from "./rpc.ts"
 import {
   USAGE_KEY,
   applyTally,
@@ -32,6 +34,8 @@ import {
   formatUsage,
   formatYuan,
   parseLedger,
+  sumDays,
+  usageSummaryLines,
   type Tally,
   type UsageLedger,
 } from "./usage.ts"
@@ -118,10 +122,19 @@ export default Plugin.define({
       chain = run.catch(() => {})
       return run
     }
+    // Filled in after the tool transforms are registered; `tally` can run before
+    // that, so this stays optional. `changed` tells the sidebars to re-read `status`.
+    let rpcRegistration: RpcRegistration<typeof DeepSeekRpc> | undefined
+    // Nested `changed` events are cheap, but they are also not worth failing a
+    // search or a mode switch over, so every caller ignores the outcome.
+    const notifyChanged = (): void => {
+      void rpcRegistration?.events.emit("changed", {}).catch(() => {})
+    }
     const tally = (kind: Tally): void => {
       void withLedger(async (ledger) => {
         applyTally(ledger, kind, pricePerThousand)
         await ctx.storage.set(USAGE_KEY, ledger)
+        notifyChanged()
         const today = ledger.days[dayKey()] ?? emptyDay()
         console.error(
           `[deepseek-search] usage: today search=${today.search} fetch=${today.fetch} ${formatYuan(today.costMicro)}`,
@@ -212,6 +225,32 @@ export default Plugin.define({
           : " · 未找到内置 websearch 工具，实际未能接管"
         : " · 内置 websearch 保持原生")
 
+    // Shared by the `deepseek_mode` tool and the RPC `setMode` method. The
+    // returned strings are the tool's documented output, word for word.
+    const switchMode = async (action: Exclude<ModeAction, "status">): Promise<string> => {
+      if (!pristine) {
+        return (
+          `未找到内置 ${SEARCH_TOOL} 工具，无法在运行时切换。` +
+          `请改用配置文件把 options.mode 设为 "${action === "config" ? configMode : action}"。`
+        )
+      }
+      if (action === "config") {
+        await ctx.storage.remove(MODE_KEY)
+        overrideMode = undefined
+        await applySearchMode(configMode)
+        notifyChanged()
+        return `${describeMode()}\n\n已清除持久化开关，回到配置文件设置（${configMode}）。`
+      }
+      await ctx.storage.set(MODE_KEY, action)
+      overrideMode = action
+      await applySearchMode(action)
+      notifyChanged()
+      return (
+        `${describeMode()}\n\n已持久化：重启 OpenCode 后仍为 ${action}。` +
+        '要恢复配置文件设置，调用 deepseek_mode 并传 mode: "config"。'
+      )
+    }
+
     // ---------- tools ----------
     await ctx.tool.transform((editor) => {
       const builtin = editor.get(SEARCH_TOOL)
@@ -314,31 +353,50 @@ export default Plugin.define({
         execute: async (input) => {
           const action = readModeAction(input)
           if (action === "status") return { content: describeMode() }
-          if (!pristine) {
-            return {
-              content:
-                `未找到内置 ${SEARCH_TOOL} 工具，无法在运行时切换。` +
-                `请改用配置文件把 options.mode 设为 "${action === "config" ? configMode : action}"。`,
-            }
-          }
-          if (action === "config") {
-            await ctx.storage.remove(MODE_KEY)
-            overrideMode = undefined
-            await applySearchMode(configMode)
-            return { content: `${describeMode()}\n\n已清除持久化开关，回到配置文件设置（${configMode}）。` }
-          }
-          await ctx.storage.set(MODE_KEY, action)
-          overrideMode = action
-          await applySearchMode(action)
-          return {
-            content:
-              `${describeMode()}\n\n已持久化：重启 OpenCode 后仍为 ${action}。` +
-              '要恢复配置文件设置，调用 deepseek_mode 并传 mode: "config"。',
-          }
+          return { content: await switchMode(action) }
         },
       })
     })
 
+    // ---------- RPC contract (TUI / desktop sidebars) ----------
+    // Both sidebars read `status` and call `setMode`; nothing else crosses the
+    // process boundary, so the plugin's state stays the single source of truth.
+    rpcRegistration = await ctx.rpc.register(DeepSeekRpc, {
+      // Reads through `withLedger` so it observes the same serialized chain.
+      status: async (): Promise<SearchStatus> =>
+        withLedger((ledger): SearchStatus => {
+          const todayKey = dayKey()
+          return {
+            mode,
+            source: overrideMode ? "override" : "config",
+            patched: searchToolPatched,
+            hasKey: Boolean(apiKey),
+            pricePerThousand,
+            ...usageSummaryLines(ledger, todayKey),
+            // Same ledger read as the strings above, exposed as numbers so the
+            // sidebars can lay them out for their own width.
+            counts: {
+              today: sumDays(ledger, (k) => k === todayKey),
+              month: sumDays(ledger, (k) => k.startsWith(todayKey.slice(0, 7))),
+              total: sumDays(ledger, () => true),
+            },
+          }
+        }),
+      // The input is plain JSON Schema, hence `unknown`: report, never throw.
+      setMode: async (input: unknown): Promise<ModeSwitchResult> => {
+        let action: ModeAction
+        try {
+          action = readModeAction(input)
+        } catch (e) {
+          return { ok: false, mode, message: e instanceof Error ? e.message : String(e) }
+        }
+        if (action === "status") return { ok: false, mode, message: "status 只读取当前模式，不做切换。" }
+        const message = await switchMode(action)
+        // `!pristine` means switchMode could not apply the change; its message says why.
+        return { ok: Boolean(pristine), mode, message }
+      },
+    })
+
     // Load marker for diagnostics; never logs the key itself.
     console.error(
       `[deepseek-search] loaded: mode=${mode} source=${overrideMode ? "override" : "config"} ` +

package/src/rpc.ts

@@ -0,0 +1,160 @@
+// RPC contract shared by the server plugin (handler side) and the TUI / desktop
+// sidebars (client side).
+//
+// Type-only imports only: this module must stay loadable from all three
+// runtimes (Node type-stripping for the server and the TUI, a CJS bundle for
+// the desktop app), so it carries no runtime dependency.
+//
+// The schemas are plain JSON Schema, so `Rpc.Input` / `Rpc.Output` degrade to
+// `unknown` on the client. `readStatus` / `readModeResult` narrow that back
+// defensively, in the style of `parseLedger` (src/usage.ts).
+
+import type { Rpc } from "@opencode/plugin/rpc"
+
+export const DEEPSEEK_RPC_ID = "deepseek-search"
+
+// Shared by the today/month/total slots of `status.counts`.
+const USAGE_COUNTS_SCHEMA = {
+  type: "object",
+  properties: {
+    search: { type: "integer" },
+    fetch: { type: "integer" },
+    empty: { type: "integer" },
+    failed: { type: "integer" },
+    costMicro: { type: "integer" },
+  },
+  required: ["search", "fetch", "empty", "failed", "costMicro"],
+  additionalProperties: false,
+} as const
+
+export const DeepSeekRpc = {
+  id: DEEPSEEK_RPC_ID,
+  methods: {
+    status: {
+      input: { type: "object", properties: {}, additionalProperties: false },
+      output: {
+        type: "object",
+        properties: {
+          mode: { type: "string", enum: ["deepseek", "native"] },
+          source: { type: "string", enum: ["override", "config"] },
+          patched: { type: "boolean" },
+          hasKey: { type: "boolean" },
+          pricePerThousand: { type: "number" },
+          today: { type: "string" },
+          month: { type: "string" },
+          total: { type: "string" },
+          counts: {
+            type: "object",
+            properties: {
+              today: USAGE_COUNTS_SCHEMA,
+              month: USAGE_COUNTS_SCHEMA,
+              total: USAGE_COUNTS_SCHEMA,
+            },
+            required: ["today", "month", "total"],
+            additionalProperties: false,
+          },
+        },
+        required: ["mode", "source", "patched", "hasKey", "pricePerThousand", "today", "month", "total"],
+        additionalProperties: false,
+      },
+    },
+    setMode: {
+      input: {
+        type: "object",
+        properties: {
+          mode: { type: "string", enum: ["deepseek", "native", "config"] },
+        },
+        required: ["mode"],
+        additionalProperties: false,
+      },
+      output: {
+        type: "object",
+        properties: {
+          ok: { type: "boolean" },
+          mode: { type: "string" },
+          message: { type: "string" },
+        },
+        required: ["ok", "mode", "message"],
+        additionalProperties: false,
+      },
+    },
+  },
+  events: {
+    // Emitted after the ledger or the mode changes.
+    changed: { schema: { type: "object" as const, properties: {} } },
+  },
+} satisfies Rpc.PortableDefinition
+
+export interface UsageCounts {
+  search: number
+  fetch: number
+  empty: number
+  failed: number
+  costMicro: number
+}
+
+export interface SearchStatus {
+  mode: "deepseek" | "native"
+  source: "override" | "config"
+  patched: boolean
+  hasKey: boolean
+  pricePerThousand: number
+  today: string
+  month: string
+  total: string
+  /** Structured counters, so each surface can format for its own width. Optional for older servers. */
+  counts?: { today: UsageCounts; month: UsageCounts; total: UsageCounts }
+}
+
+export interface ModeSwitchResult {
+  ok: boolean
+  mode: string
+  message: string
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function isMode(value: unknown): value is SearchStatus["mode"] {
+  return value === "deepseek" || value === "native"
+}
+
+/** Strict read of one counter bucket: all five fields, integers ≥ 0, finite cost. */
+function readUsageCounts(value: unknown): UsageCounts | undefined {
+  if (!isRecord(value)) return undefined
+  const { search, fetch, empty, failed, costMicro } = value
+  for (const count of [search, fetch, empty, failed]) {
+    if (typeof count !== "number" || !Number.isInteger(count) || count < 0) return undefined
+  }
+  if (typeof costMicro !== "number" || !Number.isFinite(costMicro) || costMicro < 0) return undefined
+  return { search, fetch, empty, failed, costMicro } as UsageCounts
+}
+
+/** Defensive read of an RPC `status` result. Never throws. */
+export function readStatus(raw: unknown): SearchStatus | undefined {
+  if (!isRecord(raw)) return undefined
+  const { mode, source, patched, hasKey, pricePerThousand, today, month, total, counts } = raw
+  if (!isMode(mode)) return undefined
+  if (source !== "override" && source !== "config") return undefined
+  if (typeof patched !== "boolean" || typeof hasKey !== "boolean") return undefined
+  if (typeof pricePerThousand !== "number" || !Number.isFinite(pricePerThousand)) return undefined
+  if (typeof today !== "string" || typeof month !== "string" || typeof total !== "string") return undefined
+  const status: SearchStatus = { mode, source, patched, hasKey, pricePerThousand, today, month, total }
+  // Old servers omit `counts`; a malformed triple is dropped without failing the rest.
+  if (isRecord(counts)) {
+    const todayCounts = readUsageCounts(counts.today)
+    const monthCounts = readUsageCounts(counts.month)
+    const totalCounts = readUsageCounts(counts.total)
+    if (todayCounts && monthCounts && totalCounts) status.counts = { today: todayCounts, month: monthCounts, total: totalCounts }
+  }
+  return status
+}
+
+/** Defensive read of an RPC `setMode` result. Never throws. */
+export function readModeResult(raw: unknown): ModeSwitchResult | undefined {
+  if (!isRecord(raw)) return undefined
+  const { ok, mode, message } = raw
+  if (typeof ok !== "boolean" || typeof mode !== "string" || typeof message !== "string") return undefined
+  return { ok, mode, message }
+}

package/src/status-view.ts

@@ -0,0 +1,368 @@
+// 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"
+
+export interface SidebarInput {
+  readonly status: SearchStatus | undefined
+  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
+}
+
+export interface SidebarRows {
+  /** State headline, e.g. `已启用`; the full name only survives on wide surfaces. */
+  readonly title: string
+  /**
+   * Whether the title row starts with the tone glyph. False only when even the
+   * state alone cannot share the row with the action.
+   */
+  readonly glyph: boolean
+  /**
+   * Clickable label including its hit-area brackets, e.g. `[停用]`. A state
+   * without an action carries its fix copy here instead, where the desktop
+   * panel reads it; the terminal renders that copy as `hint`.
+   */
+  readonly action: string
+  /**
+   * Whether the action must take a row of its own under the title. True only
+   * when the title row cannot hold it: shortening the title is the worse trade,
+   * because the full wording is what the user asked for.
+   */
+  readonly actionBelow: boolean
+  /** Non-interactive fix row under the title; only states without an action have one. */
+  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. */
+  readonly lines: readonly string[]
+  /** Drives the state color in card.ts. */
+  readonly tone: "on" | "off" | "warn" | "error" | "idle"
+}
+
+// The product name in the headline: the user's wording, case included.
+const NAME = "DeepSeek search/fetch"
+// The narrowest headline that still identifies the card; used when the product
+// name above would cost the row too much space.
+const SHORT_NAME = "DeepSeek"
+// The card renders a glyph and a space before the title.
+const TITLE_GLYPH_COLUMNS = 2
+// Minimum space between the title and the action so they never touch.
+const TITLE_ACTION_GAP = 1
+// One card row of the narrowest surface, host padding already subtracted. Also
+// the fallback budget before the host has reported a measured width.
+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: "累计" }
+
+type Counts = NonNullable<SearchStatus["counts"]>
+
+/** Terminal columns of one code point; only CJK-style wide ranges matter here. */
+function columns(char: string): number {
+  const cp = char.codePointAt(0) ?? 0
+  if (cp === 0) return 0
+  if (
+    (cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+    (cp >= 0x2e80 && cp <= 0xa4cf) || // CJK radicals … Yi
+    (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul syllables
+    (cp >= 0xf900 && cp <= 0xfaff) || // CJK compatibility ideographs
+    (cp >= 0xfe10 && cp <= 0xfe19) ||
+    (cp >= 0xfe30 && cp <= 0xfe6f) ||
+    (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth forms
+    (cp >= 0xffe0 && cp <= 0xffe6) ||
+    (cp >= 0x1f300 && cp <= 0x1faff) ||
+    (cp >= 0x20000 && cp <= 0x3fffd)
+  ) {
+    return 2
+  }
+  return 1
+}
+
+/** Terminal columns of a string: the measure every card row must fit. */
+export function textColumns(text: string): number {
+  let total = 0
+  for (const char of text) total += columns(char)
+  return total
+}
+
+/** Clip to the budget with a single ellipsis; used only as a last resort. */
+function clip(text: string, maxColumns: number): string {
+  if (maxColumns < 1) return ""
+  if (textColumns(text) <= maxColumns) return text
+  let out = ""
+  let used = 0
+  for (const char of text) {
+    const width = columns(char)
+    if (used + width > maxColumns - 1) return `${out}…`
+    out += char
+    used += width
+  }
+  return out
+}
+
+/** One short body line: collapse whitespace, then clip to the available columns. */
+function shortMessage(message: string, maxColumns: number): string {
+  const text = message.replace(/\s+/g, " ").trim()
+  return clip(text || "读取失败", maxColumns)
+}
+
+/** Micro-currency as `¥0.015`: three decimals, trailing zeros trimmed to cents. */
+function money(costMicro: number): string {
+  const value = Number.isFinite(costMicro) && costMicro > 0 ? costMicro / 1_000_000 : 0
+  let text = value.toFixed(3)
+  // `0.040` → `0.04`, `0.015` unchanged; keep two decimals so amounts stay currency-shaped.
+  while (text.endsWith("0") && text.length > 4) text = text.slice(0, -1)
+  return `¥${text}`
+}
+
+interface UsageLayout {
+  readonly search: number
+  readonly fetch: number
+  readonly cost: number
+}
+
+/**
+ * Column widths shared by the three usage rows. Counting digits is enough:
+ * every count is a non-negative integer, so its width is its digit count. The
+ * amount is padded too, so all three rows end on the same column.
+ */
+function usageLayout(counts: Counts): UsageLayout {
+  const rows = PERIODS.map((period) => counts[period])
+  return {
+    search: Math.max(...rows.map((row) => String(row.search).length)),
+    fetch: Math.max(...rows.map((row) => String(row.fetch).length)),
+    cost: Math.max(...rows.map((row) => money(row.costMicro).length)),
+  }
+}
+
+/**
+ * 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.
+ */
+function compactUsageRow(
+  period: Period,
+  counts: UsageCounts,
+  layout: UsageLayout,
+  maxColumns: number,
+): string {
+  const label = LABELS[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, " ")
+  // 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) {
+    if (textColumns(row) <= maxColumns) return row
+  }
+  return textColumns(label) <= maxColumns ? label : clip(label, maxColumns)
+}
+
+/**
+ * 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.
+ */
+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("空/失"))
+  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)
+}
+
+function usageLines(status: SearchStatus, maxColumns: number): 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}`]
+  }
+  const counts = status.counts
+  if (counts) {
+    const layout = usageLayout(counts)
+    return PERIODS.map((period) => compactUsageRow(period, counts[period], layout, maxColumns))
+  }
+  return PERIODS.map((period) => legacyUsageRow(period, status[period], maxColumns))
+}
+
+/**
+ * The clickable label, always bracketed: a bare two-character verb is an easy
+ * target to miss. At pathological widths the verb is clipped but the brackets
+ * stay, so the hit area never turns into plain text.
+ */
+function fitAction(verb: string, maxColumns: number): string {
+  const label = `[${verb}]`
+  if (maxColumns === Number.POSITIVE_INFINITY || textColumns(label) <= maxColumns) return label
+  const inner = maxColumns - 2
+  return inner >= 1 ? `[${clip(verb, inner)}]` : clip(label, maxColumns)
+}
+
+interface TitleFit {
+  readonly title: string
+  readonly glyph: boolean
+  /** The action takes its own row, right-aligned, instead of sharing this one. */
+  readonly actionBelow: boolean
+}
+
+/**
+ * The headline and where the action goes. The wording is the user's, so it is
+ * only shortened once no placement can hold it: first the title and the action
+ * share a row (the preferred layout), then the action moves to a row of its own
+ * 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.
+ */
+function fitTitle(
+  state: string,
+  shortState: string,
+  maxColumns: number,
+  actionColumns: number | undefined,
+): TitleFit {
+  const budget = (glyph: boolean, actionBelow: boolean): number => {
+    if (maxColumns === Number.POSITIVE_INFINITY) return Number.POSITIVE_INFINITY
+    const prefix = glyph ? TITLE_GLYPH_COLUMNS : 0
+    const tail = actionColumns === undefined || actionBelow ? 0 : actionColumns + TITLE_ACTION_GAP
+    return Math.max(0, maxColumns - prefix - tail)
+  }
+  const candidates = [
+    `${NAME} · ${state}`,
+    `${SHORT_NAME} · ${state}`,
+    `${SHORT_NAME} · ${shortState}`,
+    state,
+    shortState,
+  ]
+  // 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]
+  for (const candidate of candidates) {
+    for (const actionBelow of placements) {
+      for (const glyph of [true, false]) {
+        if (textColumns(candidate) <= budget(glyph, actionBelow)) {
+          return { title: candidate, glyph, actionBelow }
+        }
+      }
+    }
+  }
+  // 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
+  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
+  }
+  return clip(candidates[candidates.length - 1], maxColumns)
+}
+
+interface ActionRows extends TitleFit {
+  readonly action: string
+}
+
+/** 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 {
+  const action = fitAction(verb, maxColumns)
+  return { ...fitTitle(state, shortState, maxColumns, textColumns(action)), action }
+}
+
+export function sidebarRows(input: SidebarInput): SidebarRows {
+  const { status, error } = input
+  const maxColumns = input.maxColumns ?? DEFAULT_COLUMNS
+  const lines = status === undefined ? [] : usageLines(status, maxColumns)
+
+  // 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) {
+    return error === undefined || error.trim() === ""
+      ? {
+          ...actionRows("正在读取…", "正在读取…", "重试", maxColumns),
+          hint: undefined,
+          clickable: true,
+          lines,
+          tone: "idle",
+        }
+      : {
+          ...actionRows("读取失败", "读取失败", "重试", maxColumns),
+          hint: undefined,
+          clickable: true,
+          lines: [shortMessage(error, maxColumns)],
+          tone: "error",
+        }
+  }
+
+  if (status.patched && status.hasKey) {
+    return {
+      ...actionRows("已启用", "已启用", "停用", maxColumns),
+      hint: undefined,
+      clickable: true,
+      lines,
+      tone: "on",
+    }
+  }
+  if (!status.patched && status.mode === "deepseek") {
+    // 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),
+      hint: undefined,
+      clickable: true,
+      lines,
+      tone: "warn",
+    }
+  }
+  if (status.mode === "native") {
+    return {
+      ...actionRows("已停用", "已停用", "启用", maxColumns),
+      hint: undefined,
+      clickable: true,
+      lines,
+      tone: "off",
+    }
+  }
+  // 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)
+  return {
+    ...fitTitle("未配置 API Key", "缺 API Key", maxColumns, undefined),
+    action: hint,
+    hint,
+    clickable: false,
+    lines,
+    tone: "error",
+  }
+}