dsh-plugin-billing-card 0.2.0 → 0.3.0

package/README.md

@@ -4,10 +4,14 @@
 默认内置 DeepSeek 官方价格（含**峰谷分时计价**），并保留完整的扩展能力：价格表、峰谷规则、
 其他模型/提供商都可以在插件配置里追加，不需要改代码。0.2.0 起同时统计 **DeepSeek 官方网页搜索 /
 抓取 API** 的调用次数与按次费用（Search 服务端调用免费至 2026-11-01 00:00，之后按每 1000 次
-5 元估算）。
+5 元估算）；0.3.0 起卡片按当前**实际生效的 provider** 标注——服务端搜索（`deepseek-official`）、
+直连 Search / Fetch API（`deepseek-search-api` / `deepseek-fetch-api`）、本地 HTTP 抓取（`http`）
+各按自己的计费口径显示，不会再把本地免费抓取或直连 API 标成「免费期内」。
 
-> npm：[`dsh-plugin-billing-card@0.2.0`](https://www.npmjs.com/package/dsh-plugin-billing-card)
-> · `tofu-box@1.2.1` 起包含本版本（伞包 1.2.0 含 0.1.0）。
+> npm：[`dsh-plugin-billing-card@0.3.0`](https://www.npmjs.com/package/dsh-plugin-billing-card)
+> · `tofu-box@1.2.2` 起包含本版本。
+>
+> 兼容性：`engines.dsh` 声明为 `>=0.2.0-rc.2 <0.3.0-0`，已实测运行于 dsh **0.2.1-rc.3**。
 
 - **Host 半**：注册一个客户端可见的 Session 投影单元 `billingUsage`，在提交事件时折叠
   `assistant/message` / `assistant/attempt` 中模型上报的 `usage`（按 `request/header` 归属模型路由），
@@ -31,13 +35,14 @@
 - 按模型分项：模型名、token 数、估算费用；没有配置价格的模型显示「未配置价格」，
   token 仍计入合计，但不计入费用。
 - 联网搜索小节（本会话有搜索/抓取调用时出现）：搜索调用次数、provider 请求数、预计计费请求数、
-  搜索费用；直连 Fetch API 的抓取次数与费用。搜索仍处免费期时显示「免费期内（11/1 起 …）」。
+  搜索费用、抓取次数；标注随当前 provider 变化——服务端搜索免费期内显示「免费期内（11/1 起 …）」，
+  直连 API 直接显示按次费用，本地 HTTP 抓取显示「免费」。
 
 会话还没有任何已结算的 token 用量时，卡片不显示（不会占位、不会报错）。
 
 ## 安装
 
-已发布 npm：`dsh-plugin-billing-card@0.2.0`，同时也是 `tofu-box` 伞包（1.2.1 起）的成员。
+已发布 npm：`dsh-plugin-billing-card@0.3.0`，同时也是 `tofu-box` 伞包（1.2.2 起）的成员。
 插件行 id 为 `billing-card`，Client 半是手写浏览器模块，无需构建步骤。
 
 ```bash
@@ -103,22 +108,31 @@ plugin_manager install_bundle target = D:\program\dsh-plugins\dsh-plugin-billing
 > 价格来源：DeepSeek 官方「模型 & 价格」页（中文 / 英文），核对时间 2026-10-17。
 > 官方保留调价权利，请以官网与你的实际结算为准；调价后覆盖本插件配置即可。
 
-## 联网搜索 / 抓取计费（0.2.0）
+## 联网搜索 / 抓取计费（0.3.0）
 
 官方口径（Search / Fetch API，2026-10-17 上线）：
 
 - 按**成功请求次数**计费：每 1,000 次成功请求 **5 元 / $0.75**；失败、空结果、超时不计费，
   `count` 只控制返回条数、不影响单价。
 - 在 DeepSeek Harness / Claude Code / Codex 中由**服务端工具调用**触发的 Search / Fetch 目前免费，
-  **北京时间 2026-11-01 00:00 起**按次收费。DSH 的 `web_search` 走服务端 `web_search` 工具；
-  而 `web_fetch` 是直连 `POST https://api.deepseek.com/v1/tools/fetch` 的普通 API 请求，
-  不属于服务端工具调用，按官方规则自上线起计费。
+  **北京时间 2026-11-01 00:00 起**按次收费；而直连 API（`web.searchProvider: deepseek-search-api` /
+  `web.fetchProvider: deepseek-fetch-api`）自上线起就按次计费，没有免费期。
 - 本插件从会话日志统计（不额外发请求）：
   - `web_search`：每次工具调用按**去重后的 query 数**计为 provider 请求数（工具本身就是每个
     query 发一个请求）；一次调用成功且结果源非空时，这些 query 计为「预计计费请求」。
-  - `web_fetch`：按 HTTP 200 的成功抓取计为 Fetch API 计费请求。
+  - `web_fetch`：按 HTTP 200 的成功抓取计为一次抓取请求。
 - 费用 = 预计计费请求数 × `search.perRequest`（默认 0.005 元/次，美元 0.00075/次）。
-- 搜索仍在免费期时，卡片显示「免费期内（11/1 起 ¥…）」；抓取费用始终按已计费估算显示。
+- 卡片读取当前 `web` 行的 `searchProvider` / `fetchProvider`（「设置 → 插件 → Web 搜索」里的
+  「启用新版 Web 搜索 API」开关写的就是这两个字段），据此标注：
+
+  | 生效 provider | 搜索费用标签 | 抓取费用标签 |
+  |---|---|---|
+  | 服务端 Messages 搜索 `deepseek-official` | 免费期内显示「免费期内（11/1 起 ¥…）」 | —（默认抓取是 `http`） |
+  | 直连 Search / Fetch API | 直接显示按次费用，并注明没有服务端免费期 | 显示 `次数 · 费用` |
+  | 本地 HTTP 抓取 `http` | — | 显示 `次数 · 免费`，并注明不计费 |
+  | 其他 provider（Exa / Perplexity 等） | 只显示按次估算，不声称免费期 | 同上 |
+
+  读不到设置时按出厂默认（`deepseek-official` + `http`）标注，不会因此隐藏卡片。
 
 已知限制（估算口径）：
 
@@ -127,9 +141,9 @@ plugin_manager install_bundle target = D:\program\dsh-plugins\dsh-plugin-billing
 - 多 query 批量搜索失败时，已成功的那部分可能已被官方计费，但这里整单失败、不计费；
   空结果的成功调用不计费（与官方一致）。
 - 服务端搜索附带的辅助模型 token 费用不写入会话日志，本卡片不统计。
-- 统计假设 `web_search` / `web_fetch` 由 DeepSeek 官方 provider 提供（出厂 profile 即如此）。
-  若你改配了 Exa / Perplexity 搜索或本地 HTTP 抓取，请把 `search.enabled` 设为 `false`，
-  否则按次费用会误计。
+- 计数只按工具名（`web_search` / `web_fetch`），不区分 provider；换用 Exa / Perplexity 等
+  第三方 provider 时次数仍会累计，卡片只会显示按 `search.perRequest` 的估算而不声称官方口径。
+  这类部署若不想看到按次费用，把 `search.enabled` 设为 `false`。
 
 ## 配置
 

package/billing-core.js

@@ -1081,10 +1081,11 @@ function counterValue(value) {
 
 /**
  * Build the wire view of the search / fetch cost section. Counts are always
- * present; costs are estimates from the resolved per-request price. The search
- * cost is the post-free-window estimate (the client decides how to label it
- * while `searchFreeUntil` is still in the future), while the fetch cost is the
- * direct Fetch API spend, which is billable from launch.
+ * present; costs are estimates from the resolved per-request price. Both costs
+ * assume the DeepSeek APIs charge per request, so the search cost is the
+ * post-free-window estimate and the fetch cost the direct-API estimate; the
+ * client decides how to label each one from the `web` row's provider selection,
+ * which this replayable fold deliberately does not read.
  * @param {{ search?: Record<string, any> }} state - fold state.
  * @param {ReturnType<typeof resolveBillingConfig>} resolvedConfig - resolved config.
  * @returns {Record<string, any>} the `search` wire section.

package/client.js

@@ -51,9 +51,12 @@ window.__ModuleLoader__.load({
       'search.cost': '搜索费用',
       'search.freeValue': '免费期内（11/1 起 {cost}）',
       'search.freeNote': '服务端搜索调用免费至 2026-11-01 00:00，之后按官方每 1000 次价格估算。',
+      'search.directNote': '当前使用直连 DeepSeek Search API，按次计费，没有服务端免费期。',
       'search.fetch': '网页抓取',
       'search.fetchValue': '{count} 次 · {cost}',
+      'search.fetchLocalValue': '{count} 次 · 免费',
       'search.fetchNote': '网页抓取为直连 DeepSeek Fetch API，按次计费。',
+      'search.fetchLocalNote': '网页抓取走本地 HTTP，不产生按次费用。',
       'footer.estimate': '费用为按配置价格表估算的预估值，非实际账单。',
       'footer.config': '价格与峰谷时段可在插件配置中调整。',
       'pill.aria': '预估费用 {cost}',
@@ -81,9 +84,12 @@ window.__ModuleLoader__.load({
       'search.cost': 'Search cost',
       'search.freeValue': 'Free until Nov 1 (then {cost})',
       'search.freeNote': 'Server-side search calls are free until 2026-11-01 00:00 Beijing; afterward priced at the official per-1,000-request rate.',
+      'search.directNote': 'The direct DeepSeek Search API is billed per request with no server-side free window.',
       'search.fetch': 'Web fetch',
       'search.fetchValue': '{count} requests · {cost}',
+      'search.fetchLocalValue': '{count} requests · free',
       'search.fetchNote': 'Web fetch calls the DeepSeek Fetch API directly and is billed per request.',
+      'search.fetchLocalNote': 'Web fetch uses local HTTP and incurs no per-request charge.',
       'footer.estimate': 'Costs are estimates from the configured price table, not an actual bill.',
       'footer.config': 'Pricing and peak windows are configurable in the plugin config.',
       'pill.aria': 'Estimated cost {cost}',
@@ -196,6 +202,94 @@ window.__ModuleLoader__.load({
       return Math.round(cacheRead / denominator * 100)
     }
 
+    /**
+     * Provider ids the `web` row selects. Both its fields are volatile, so the
+     * card follows the live selection instead of the composition's startup value.
+     */
+    const DIRECT_SEARCH_PROVIDER = 'deepseek-search-api'
+    const DIRECT_FETCH_PROVIDER = 'deepseek-fetch-api'
+    /** The shipped `web` selection; also the fallback when settings are unreadable. */
+    const MESSAGES_SEARCH_PROVIDER = 'deepseek-official'
+    const HTTP_FETCH_PROVIDER = 'http'
+
+    /**
+     * Classify the selected web providers into the per-request billing each one
+     * carries. Only these two DeepSeek deployments are known: server-side search
+     * has the free window, the direct Search and Fetch APIs bill from launch, and
+     * the local HTTP fetch bills nothing. Any other provider id stays `other`, so
+     * the card reports the resolved cost without claiming a DeepSeek rate.
+     * @param webValue - the `web` settings namespace value, or `null` when unread.
+     * @returns `{ search, fetch }` modes: `side`/`direct`/`other`, `local`/`api`/`other`.
+     */
+    function searchBilling(webValue) {
+      const value = webValue !== null && typeof webValue === 'object' ? webValue : null
+      const providerOf = (field, fallback) => {
+        const id = value === null ? undefined : value[field]
+        return typeof id === 'string' && id !== '' ? id : fallback
+      }
+      const searchProvider = providerOf('searchProvider', MESSAGES_SEARCH_PROVIDER)
+      const fetchProvider = providerOf('fetchProvider', HTTP_FETCH_PROVIDER)
+      return {
+        search: searchProvider === DIRECT_SEARCH_PROVIDER
+          ? 'direct'
+          : searchProvider === MESSAGES_SEARCH_PROVIDER ? 'side' : 'other',
+        fetch: fetchProvider === DIRECT_FETCH_PROVIDER
+          ? 'api'
+          : fetchProvider === HTTP_FETCH_PROVIDER ? 'local' : 'other',
+      }
+    }
+
+    /** Modes of the shipped selection, used until (or unless) settings resolve. */
+    const SHIPPED_SEARCH_BILLING = Object.freeze(searchBilling(null))
+
+    /**
+     * Bare observable over the `web` row's provider selection for the
+     * registration's `hooks` compartment.
+     *
+     * The settings form is resolved lazily because the settings service may
+     * activate after this plugin, and an absent service must not remove the
+     * card: the shipped selection is the answer until one resolves. The
+     * snapshot keeps one identity until the form itself changes, because the
+     * renderer compares snapshots by reference.
+     * @param ctx - the plugin's client context.
+     * @returns `{ getSnapshot, subscribe }`.
+     */
+    function webSearchBillingSource(ctx) {
+      let form
+      /** The `web` form, or `undefined` while the settings service is absent. */
+      const formOf = () => {
+        if (form !== undefined) return form
+        const forms = typeof ctx.get === 'function' ? ctx.get('configForms') : undefined
+        if (forms === undefined || forms === null || typeof forms.get !== 'function') return undefined
+        try {
+          form = forms.get('web')
+        } catch {
+          return undefined
+        }
+        return form
+      }
+      let cachedSnapshot
+      let cachedModes = SHIPPED_SEARCH_BILLING
+      return {
+        getSnapshot() {
+          const current = formOf()
+          if (current === undefined || typeof current.getSnapshot !== 'function') return SHIPPED_SEARCH_BILLING
+          const snapshot = current.getSnapshot()
+          if (snapshot !== cachedSnapshot) {
+            cachedSnapshot = snapshot
+            cachedModes = Object.freeze(searchBilling(snapshot !== null && typeof snapshot === 'object' ? snapshot.value : null))
+          }
+          return cachedModes
+        },
+        subscribe(listener) {
+          const current = formOf()
+          return current === undefined || typeof current.subscribe !== 'function'
+            ? () => {}
+            : current.subscribe(listener)
+        },
+      }
+    }
+
     /**
      * Validate and normalize the Host wire view. Any value that does not match
      * the version-1 shape with a positive token total yields null, so a
@@ -251,11 +345,18 @@ window.__ModuleLoader__.load({
     /**
      * The dock entry. Renders the collapsed pill always (when usage exists)
      * and portals the expanded card above it while open.
-     * @param props - framework standard props plus the plugin's `locale` service.
+     * @param props - framework standard props, the plugin's `locale` service,
+     *   and the provider-mode hook bound from the registration's inject face.
      */
-    function BillingCard({ useProjection, locale }) {
+    function BillingCard({ useProjection, useWebSearchBilling, locale }) {
       const t = useTranslate(locale)
       const data = renderableView(useProjection(PROJECTION_KEY))
+      // A registration always supplies the hook; the shipped selection keeps a
+      // hand-mounted component rendering instead of throwing. The renderer's
+      // selector hook requires a selector, so pass identity.
+      const billing = typeof useWebSearchBilling === 'function'
+        ? useWebSearchBilling(value => value)
+        : SHIPPED_SEARCH_BILLING
       const visible = data !== null
       const [open, setOpen] = React.useState(false)
       const [position, setPosition] = React.useState(null)
@@ -393,8 +494,11 @@ window.__ModuleLoader__.load({
       const searchRows = []
       const searchNotes = []
       if (showSearch) {
+        // The free window is a DeepSeek server-side fact: it holds only while the
+        // deployment still searches through Messages. The direct Search API has
+        // none, and an unknown provider is not claimed to have one.
         const freeUntil = typeof search.searchFreeUntil === 'number' ? search.searchFreeUntil : null
-        const freePeriod = freeUntil !== null && Date.now() < freeUntil
+        const freePeriod = billing.search === 'side' && freeUntil !== null && Date.now() < freeUntil
         const pushSearchRow = (key, label, value) => {
           searchRows.push(h('dt', { key: `search-${key}-label`, className: 'bc-row-label' }, label))
           searchRows.push(h('dd', { key: `search-${key}-value`, className: 'bc-row-value' }, value))
@@ -411,13 +515,19 @@ window.__ModuleLoader__.load({
           ? t('search.freeValue', { cost: searchCostText })
           : searchCostText)
         if (fetchCalls > 0) {
-          pushSearchRow('fetch', t('search.fetch'), t('search.fetchValue', {
-            count: formatCount(finite(search.fetchBillable)),
-            cost: formatCost(finite(search.fetchCost), currency),
-          }))
+          const fetchCount = formatCount(finite(search.fetchBillable))
+          // The projection counts every answered fetch; only the direct Fetch API
+          // charges for one, so the local HTTP provider reports no cost.
+          pushSearchRow('fetch', t('search.fetch'), billing.fetch === 'local'
+            ? t('search.fetchLocalValue', { count: fetchCount })
+            : t('search.fetchValue', { count: fetchCount, cost: formatCost(finite(search.fetchCost), currency) }))
         }
         if (freePeriod) searchNotes.push(t('search.freeNote'))
-        if (fetchCalls > 0) searchNotes.push(t('search.fetchNote'))
+        if (billing.search === 'direct') searchNotes.push(t('search.directNote'))
+        if (fetchCalls > 0) {
+          if (billing.fetch === 'api') searchNotes.push(t('search.fetchNote'))
+          else if (billing.fetch === 'local') searchNotes.push(t('search.fetchLocalNote'))
+        }
       }
 
       const panel = open ? ReactDOM.createPortal(        h('div', {
@@ -519,8 +629,18 @@ window.__ModuleLoader__.load({
 
         ctx.effect(() => registerDictionaries(ctx.locale))
 
+        // The `web` row's provider selection decides which Search / Fetch
+        // deployment this card is labelling; it is read from the settings
+        // domain rather than the projection so the fold stays replayable.
+        const webSearchBilling = webSearchBillingSource(ctx)
+
         ctx.slots.inject('conversation.composer.dock', () => ctx.slots.register(
-          { name: 'conversation.composer.dock', id: 'billing-card', order: 2 },
+          {
+            name: 'conversation.composer.dock',
+            id: 'billing-card',
+            order: 2,
+            inject: () => ({ hooks: { webSearchBilling } }),
+          },
           props => h(BillingCard, { ...props, locale: ctx.locale })))
       },
     }

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "dsh-plugin-billing-card",
-  "version": "0.2.0",
+  "version": "0.3.0",
+  "engines": { "dsh": ">=0.2.0-rc.2 <0.3.0-0" },
   "license": "MIT",
   "keywords": ["dsh-plugin", "deepseek-harness", "dsh", "billing", "token", "usage", "cost", "deepseek"],
   "publishConfig": { "registry": "https://registry.npmjs.org" },