opencode-deepseek-peak 0.1.0

package/src/index.ts

@@ -0,0 +1,131 @@
+import { Plugin } from "@opencode/plugin"
+import { DEFAULT_SIGNAL_HEADERS, readApiPricePeriod } from "./api-signal.js"
+import { DeepSeekPeakRpc } from "./rpc.js"
+import { scheduleInfo } from "./schedule.js"
+import type { PeakStatus } from "./types.js"
+
+function stringList(value: unknown, fallback: readonly string[]): string[] {
+  return Array.isArray(value) && value.every((item) => typeof item === "string")
+    ? value
+    : [...fallback]
+}
+
+export default Plugin.define({
+  id: "opencode-deepseek-peak",
+  async setup(context) {
+    const providerIDs = new Set(stringList(context.options.providerIDs, ["deepseek"]))
+    const signalHeaders = stringList(context.options.apiSignalHeaders, DEFAULT_SIGNAL_HEADERS)
+    const configuredTtl = Number(context.options.apiSignalTtlMs)
+    const apiSignalTtlMs = Number.isFinite(configuredTtl) && configuredTtl >= 0
+      ? configuredTtl
+      : 5 * 60 * 1000
+    const statuses = new Map<string, PeakStatus>()
+    const apiSignals = new Map<string, { period: PeakStatus["period"]; evidence: string; observedAt: number }>()
+
+    const rpc = await context.rpc.register(DeepSeekPeakRpc, {
+      status: async (input) => {
+        const { sessionID } = input as { sessionID: string }
+        const status = statuses.get(sessionID)
+        return status ? { found: true, status } : { found: false }
+      },
+      // Lets the TUI show the current period as soon as a session opens with a
+      // DeepSeek model selected, without waiting for the first request.
+      preview: async (input) => {
+        const { sessionID } = input as { sessionID: string }
+        const observed = statuses.get(sessionID)
+        if (observed) return { found: true, status: observed }
+        try {
+          const session = await context.session.get({ sessionID })
+          const model = session.model
+          if (!model || !isDeepSeek(model.providerID)) return { found: false }
+          const schedule = scheduleInfo(new Date())
+          const evidence = schedule.holiday
+            ? `Chinese public holiday: ${schedule.holiday} (no request observed yet)`
+            : "Current schedule (no request observed yet)"
+          return {
+            found: true,
+            status: {
+              sessionID,
+              providerID: model.providerID,
+              modelID: model.id,
+              period: schedule.period,
+              scheduledPeriod: schedule.period,
+              source: "official-schedule",
+              phase: "request",
+              mismatch: false,
+              observedAt: Date.now(),
+              evidence,
+              holiday: schedule.holiday,
+            },
+          }
+        } catch {
+          return { found: false }
+        }
+      },
+    })
+
+    const publish = async (status: PeakStatus) => {
+      statuses.set(status.sessionID, status)
+      await rpc.events.emit("updated", status as unknown as Readonly<Record<string, unknown>>)
+    }
+
+    const isDeepSeek = (providerID: string) => providerIDs.has(providerID)
+    const modelKey = (providerID: string, modelID: string) => `${providerID}/${modelID}`
+
+    const stopRequest = await context.session.hook("model.request", async (event) => {
+      if (event.kind !== "primary" || !isDeepSeek(event.model.providerID)) return
+      const now = Date.now()
+      const schedule = scheduleInfo(new Date(now))
+      const cached = apiSignals.get(modelKey(event.model.providerID, event.model.id))
+      const api = cached && now - cached.observedAt <= apiSignalTtlMs ? cached : undefined
+      await publish({
+        sessionID: event.sessionID,
+        providerID: event.model.providerID,
+        modelID: event.model.id,
+        period: api?.period ?? schedule.period,
+        scheduledPeriod: schedule.period,
+        source: api ? "api-header" : "official-schedule",
+        phase: "request",
+        mismatch: api ? api.period !== schedule.period : false,
+        observedAt: now,
+        evidence: api
+          ? `${api.evidence} (cached)`
+          : schedule.holiday
+            ? `Chinese public holiday: ${schedule.holiday}`
+            : "DeepSeek official UTC pricing schedule",
+        holiday: schedule.holiday,
+      })
+    })
+
+    const stopResponse = await context.session.hook("http.response", async (event) => {
+      if (event.kind !== "primary" || !isDeepSeek(event.model.providerID)) return
+      const api = readApiPricePeriod(event.response.headers, signalHeaders)
+      if (!api) return
+      const now = Date.now()
+      const schedule = scheduleInfo(new Date(now))
+      apiSignals.set(modelKey(event.model.providerID, event.model.id), {
+        ...api,
+        observedAt: now,
+      })
+      await publish({
+        sessionID: event.sessionID,
+        providerID: event.model.providerID,
+        modelID: event.model.id,
+        period: api.period,
+        scheduledPeriod: schedule.period,
+        source: "api-header",
+        phase: "response",
+        mismatch: api.period !== schedule.period,
+        observedAt: now,
+        evidence: api.evidence,
+        holiday: schedule.holiday,
+      })
+    })
+
+    return async () => {
+      await stopRequest.dispose()
+      await stopResponse.dispose()
+      await rpc.dispose()
+    }
+  },
+})

package/src/panel/FooterStatus.tsx

@@ -0,0 +1,32 @@
+/** @jsxImportSource @opentui/solid */
+
+import { createMemo, For, Show } from "solid-js"
+import { themeColors } from "../core/display.js"
+import { createT } from "../i18n.js"
+import type { IndicatorProps } from "./PeakPanel.js"
+
+/** Prompt-footer status: peak stands out in the default text color, off-peak stays muted. */
+export function FooterStatus(props: IndicatorProps) {
+  const t = createT(() => props.lang())
+
+  const segments = createMemo(() => {
+    const status = props.status()
+    if (!status) return []
+    const { normal, muted, warning } = themeColors(props.context.theme)
+    const peak = status.period === "peak"
+    const label = peak ? t("period.peak") : t("period.offPeak")
+    const out = [{ text: `DS ${label}`, color: peak ? normal : muted }]
+    if (status.source === "api-header") out.push({ text: " API", color: muted })
+    if (status.mismatch) out.push({ text: " ⚠", color: warning })
+    out.push({ text: " ·", color: muted })
+    return out
+  })
+
+  return (
+    <Show when={props.enabled() && props.status()}>
+      <text>
+        <For each={segments()}>{(segment) => <span style={{ fg: segment.color }}>{segment.text}</span>}</For>
+      </text>
+    </Show>
+  )
+}

package/src/panel/PeakPanel.tsx

@@ -0,0 +1,59 @@
+/** @jsxImportSource @opentui/solid */
+
+import type { Plugin } from "@opencode/plugin/tui"
+import { createEffect, createMemo, For, Show } from "solid-js"
+import { evidenceLabel, themeColors } from "../core/display.js"
+import { createT, type LangCode } from "../i18n.js"
+import type { PeakStatus } from "../types.js"
+
+export interface IndicatorProps {
+  context: Plugin.Context
+  status: () => PeakStatus | undefined
+  enabled: () => boolean
+  lang: () => LangCode
+  sessionID: string
+  refresh: (sessionID: string) => void
+}
+
+export interface PanelProps extends IndicatorProps {
+  evidence: () => boolean
+}
+
+export function PeakPanel(props: PanelProps) {
+  const t = createT(() => props.lang())
+
+  // The server keeps the last observed request per session, so opening a
+  // session must pull that status instead of waiting for the next event.
+  createEffect(() => {
+    const sessionID = props.sessionID
+    if (sessionID) props.refresh(sessionID)
+  })
+
+  // Single compact status line, flush left, plus an optional muted evidence line.
+  const segments = createMemo(() => {
+    const status = props.status()
+    if (!status) return []
+    const { normal, muted, warning } = themeColors(props.context.theme)
+    const peak = status.period === "peak"
+    const out = [
+      { text: "DeepSeek ", color: muted },
+      { text: `● ${t(peak ? "period.peak" : "period.offPeak")}`, color: peak ? normal : muted },
+    ]
+    if (status.source === "api-header") out.push({ text: " · API", color: muted })
+    if (status.mismatch) out.push({ text: ` · ${t("label.mismatch")} ⚠`, color: warning })
+    return out
+  })
+
+  return (
+    <Show when={props.enabled() && props.status()}>
+      <box flexDirection="column" alignItems="flex-start" alignSelf="flex-start">
+        <text>
+          <For each={segments()}>{(segment) => <span style={{ fg: segment.color }}>{segment.text}</span>}</For>
+        </text>
+        <Show when={props.evidence() ? props.status() : undefined}>
+          {(status) => <text fg={themeColors(props.context.theme).muted}>{evidenceLabel(status(), t)}</text>}
+        </Show>
+      </box>
+    </Show>
+  )
+}

package/src/rpc.ts

@@ -0,0 +1,74 @@
+import { Rpc } from "@opencode/plugin/rpc"
+
+const statusSchema = {
+  type: "object",
+  properties: {
+    sessionID: { type: "string" },
+    providerID: { type: "string" },
+    modelID: { type: "string" },
+    period: { type: "string", enum: ["peak", "off-peak"] },
+    scheduledPeriod: { type: "string", enum: ["peak", "off-peak"] },
+    source: { type: "string", enum: ["official-schedule", "api-header"] },
+    phase: { type: "string", enum: ["request", "response"] },
+    mismatch: { type: "boolean" },
+    observedAt: { type: "number" },
+    evidence: { type: "string" },
+    holiday: { type: "string" },
+  },
+  required: [
+    "sessionID",
+    "providerID",
+    "modelID",
+    "period",
+    "scheduledPeriod",
+    "source",
+    "phase",
+    "mismatch",
+    "observedAt",
+    "evidence",
+  ],
+  additionalProperties: false,
+} as const
+
+export const DeepSeekPeakRpc = Rpc.define({
+  id: "deepseek-peak",
+  methods: {
+    status: {
+      input: {
+        type: "object",
+        properties: { sessionID: { type: "string" } },
+        required: ["sessionID"],
+        additionalProperties: false,
+      },
+      output: {
+        type: "object",
+        properties: {
+          found: { type: "boolean" },
+          status: statusSchema,
+        },
+        required: ["found"],
+        additionalProperties: false,
+      },
+    },
+    preview: {
+      input: {
+        type: "object",
+        properties: { sessionID: { type: "string" } },
+        required: ["sessionID"],
+        additionalProperties: false,
+      },
+      output: {
+        type: "object",
+        properties: {
+          found: { type: "boolean" },
+          status: statusSchema,
+        },
+        required: ["found"],
+        additionalProperties: false,
+      },
+    },
+  },
+  events: {
+    updated: { schema: statusSchema },
+  },
+})

package/src/schedule.ts

@@ -0,0 +1,66 @@
+import Holidays from "date-holidays"
+import type { PricePeriod } from "./types.js"
+
+const chinaHolidays = new Holidays("CN", { languages: ["en"] })
+
+function datePartsInChina(date: Date) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(date)
+  const value = (type: Intl.DateTimeFormatPartTypes) =>
+    parts.find((part) => part.type === type)?.value ?? ""
+  return `${value("year")}-${value("month")}-${value("day")}`
+}
+
+/** Name of the Chinese public holiday covering this instant, when any. */
+export function chinesePublicHoliday(date: Date): string | undefined {
+  // Peak windows are 09:00–18:00 in China, so their UTC and China calendar
+  // dates align. Noon avoids boundary ambiguity in holiday libraries.
+  const chinaDate = datePartsInChina(date)
+  const holiday = chinaHolidays.isHoliday(new Date(`${chinaDate}T12:00:00+08:00`))
+  if (!Array.isArray(holiday)) return undefined
+  return holiday.find((entry) => entry.type === "public")?.name
+}
+
+export function isChinesePublicHoliday(date: Date): boolean {
+  return chinesePublicHoliday(date) !== undefined
+}
+
+function peakWindow(date: Date): PricePeriod {
+  const hour = date.getUTCHours() + date.getUTCMinutes() / 60
+  return (hour >= 1 && hour < 4) || (hour >= 6 && hour < 10) ? "peak" : "off-peak"
+}
+
+export interface ScheduleInfo {
+  period: PricePeriod
+  /** Set when a Chinese public holiday makes the whole day off-peak. */
+  holiday?: string
+}
+
+/**
+ * DeepSeek's official pricing schedule as published in September 2026:
+ * 01:00–04:00 and 06:00–10:00 UTC, Monday–Friday, excluding Chinese
+ * public holidays. Interval ends are exclusive.
+ */
+export function scheduleInfo(
+  date: Date,
+  holidayName: (value: Date) => string | undefined = chinesePublicHoliday,
+): ScheduleInfo {
+  const day = date.getUTCDay()
+  if (day === 0 || day === 6) return { period: "off-peak" }
+  const holiday = holidayName(date)
+  if (holiday) return { period: "off-peak", holiday }
+  return { period: peakWindow(date) }
+}
+
+export function officialPricePeriod(
+  date: Date,
+  holidayCheck: (value: Date) => boolean = isChinesePublicHoliday,
+): PricePeriod {
+  const day = date.getUTCDay()
+  if (day === 0 || day === 6 || holidayCheck(date)) return "off-peak"
+  return peakWindow(date)
+}

package/src/tui.tsx

@@ -0,0 +1,112 @@
+/** @jsxImportSource @opentui/solid */
+
+import type { Plugin } from "@opencode/plugin/tui"
+import { createSignal } from "solid-js"
+import { INITIAL_SETTINGS, statusLabel } from "./core/display.js"
+import { createT, detectLang, type LangCode } from "./i18n.js"
+import { FooterStatus } from "./panel/FooterStatus.js"
+import { PeakPanel } from "./panel/PeakPanel.js"
+import { DeepSeekPeakRpc } from "./rpc.js"
+import type { PeakStatus, TuiSettings } from "./types.js"
+import { CommandRoot } from "./v2/commands.js"
+
+const mod: Plugin.Definition = {
+  id: "opencode-deepseek-peak-tui",
+  setup(context) {
+    const client = context.client.rpc(DeepSeekPeakRpc)
+    const [settings, update] = context.storage.store<TuiSettings>(
+      "opencode-deepseek-peak.settings",
+      { initial: { ...INITIAL_SETTINGS, lang: detectLang() } },
+    )
+    // Stored settings may predate the `lang` field.
+    const lang = () => (settings.lang ?? detectLang()) as LangCode
+    const t = createT(lang)
+    const [statuses, setStatuses] = createSignal<Record<string, PeakStatus>>({})
+    const lastToast = new Map<string, string>()
+
+    const unsubscribe = client.events.on("updated", (event) => {
+      const status = event.data as unknown as PeakStatus
+      setStatuses((current) => ({ ...current, [status.sessionID]: status }))
+      if (!settings.toast) return
+      const fingerprint = `${status.period}:${status.mismatch}`
+      if (!settings.toastEveryRequest && lastToast.get(status.sessionID) === fingerprint) return
+      lastToast.set(status.sessionID, fingerprint)
+      context.ui.toast.show({
+        title: t("toast.title"),
+        message: statusLabel(status, t),
+        variant: status.period === "peak" ? "warning" : "success",
+        duration: 4500,
+      })
+    })
+
+    const readStatus = async (sessionID: string) => {
+      const result = await client.status({ sessionID }) as { found: boolean; status?: PeakStatus }
+      if (result.found && result.status) return result.status
+      try {
+        const preview = await client.preview({ sessionID }) as { found: boolean; status?: PeakStatus }
+        return preview.found ? preview.status : undefined
+      } catch {
+        return undefined
+      }
+    }
+
+    // Pull the server's last observed status so the indicators render as soon
+    // as a session opens, not only after the next DeepSeek request.
+    const refresh = (sessionID: string) => {
+      void readStatus(sessionID)
+        .then((status) => {
+          if (status) setStatuses((current) => ({ ...current, [status.sessionID]: status }))
+        })
+        .catch(() => {})
+    }
+
+    const unregisterCommands = context.ui.slot({
+      append: "app",
+      render: () => (
+        <CommandRoot context={context} settings={settings} update={update} readStatus={readStatus} lang={lang} />
+      ),
+    })
+    const unregisterSidebar = context.ui.slot({
+      append: "sidebar.content",
+      render: (props) => {
+        const sessionID = String(props.sessionID ?? "")
+        return (
+          <PeakPanel
+            context={context}
+            status={() => statuses()[sessionID]}
+            enabled={() => settings.sidebarIndicator !== false}
+            evidence={() => settings.sidebarEvidence !== false}
+            lang={lang}
+            sessionID={sessionID}
+            refresh={refresh}
+          />
+        )
+      },
+    })
+    const unregisterFooter = context.ui.slot({
+      append: "prompt.footer.status",
+      render: (props) => {
+        const sessionID = String(props.sessionID ?? "")
+        return (
+          <FooterStatus
+            context={context}
+            status={() => statuses()[sessionID]}
+            enabled={() => settings.indicator}
+            lang={lang}
+            sessionID={sessionID}
+            refresh={refresh}
+          />
+        )
+      },
+    })
+
+    return () => {
+      unsubscribe()
+      unregisterCommands()
+      unregisterSidebar()
+      unregisterFooter()
+    }
+  },
+}
+
+export default mod

package/src/types.ts

@@ -0,0 +1,29 @@
+import type { LangCode } from "./i18n.js"
+
+export type PricePeriod = "peak" | "off-peak"
+export type StatusSource = "official-schedule" | "api-header"
+export type StatusPhase = "request" | "response"
+
+export interface PeakStatus {
+  sessionID: string
+  providerID: string
+  modelID: string
+  period: PricePeriod
+  scheduledPeriod: PricePeriod
+  source: StatusSource
+  phase: StatusPhase
+  mismatch: boolean
+  observedAt: number
+  evidence: string
+  /** Chinese public holiday making the whole day off-peak, when applicable. */
+  holiday?: string
+}
+
+export interface TuiSettings {
+  toast: boolean
+  indicator: boolean
+  sidebarIndicator: boolean
+  sidebarEvidence: boolean
+  toastEveryRequest: boolean
+  lang: LangCode
+}

package/src/v2/commands.ts

@@ -0,0 +1,83 @@
+import type { Plugin } from "@opencode/plugin/tui"
+import { statusLabel } from "../core/display.js"
+import { createT, LANG_META, type LangCode } from "../i18n.js"
+import type { PeakStatus, TuiSettings } from "../types.js"
+import { openSettingsMenu } from "./settings-menu.js"
+
+interface CommandProps {
+  context: Plugin.Context
+  settings: TuiSettings
+  update: (mutation: (draft: TuiSettings) => void) => Promise<void>
+  readStatus: (sessionID: string) => Promise<PeakStatus | undefined>
+  lang: () => LangCode
+}
+
+/** Command layer (registered in the app slot: slash commands stay available when the sidebar is hidden). */
+export function CommandRoot(props: CommandProps) {
+  const { context } = props
+  const t = createT(() => props.lang())
+
+  context.keymap.layer(() => ({
+    mode: "global" as const,
+    commands: [
+      {
+        id: "opencode-deepseek-peak.peak.status",
+        title: t("command.status.title"),
+        description: t("command.status.description"),
+        group: "DeepSeek",
+        palette: true,
+        slash: { name: "deepseek-peak" },
+        run: async () => {
+          const route = context.ui.router.current()
+          if (route.type !== "session") {
+            await context.ui.dialog.alert({ title: t("status.title"), message: t("status.noSession") })
+            return
+          }
+          try {
+            const status = await props.readStatus(route.sessionID)
+            await context.ui.dialog.alert({
+              title: t("status.title"),
+              message: status
+                ? `${statusLabel(status, t)}\n${t("status.source")}: ${status.source}\n${t("status.evidence")}: ${status.evidence}`
+                : t("status.noRequest"),
+            })
+          } catch {
+            context.ui.toast.show({ message: t("status.unavailable"), variant: "error" })
+          }
+        },
+      },
+      {
+        id: "opencode-deepseek-peak.peak.sections",
+        title: t("command.sections.title"),
+        description: t("command.sections.description"),
+        group: "DeepSeek",
+        palette: true,
+        slash: { name: "deepseek-peak-sections" },
+        run: () => {
+          openSettingsMenu(context, props.settings, props.update, props.lang)
+        },
+      },
+      {
+        id: "opencode-deepseek-peak.peak.lang",
+        title: t("command.lang.title"),
+        description: t("command.lang.description"),
+        group: "DeepSeek",
+        palette: true,
+        slash: { name: "deepseek-peak-lang" },
+        run: async () => {
+          const picked = await context.ui.dialog.select<LangCode>({
+            title: t("settings.lang"),
+            options: LANG_META.map((meta) => ({ title: meta.label, value: meta.code })),
+            current: props.lang(),
+          })
+          if (picked !== undefined) {
+            await props.update((draft) => {
+              draft.lang = picked
+            })
+          }
+        },
+      },
+    ],
+  }))
+  return null
+}