dsh-session-fee 0.0.0-stage → 0.4.4

package/lib/projection.js

@@ -0,0 +1,295 @@
+// Minimal validators with the `.parse()` DSH's projection registry calls; no
+// runtime dependency. Restored checkpoints that fail them are re-folded.
+const count = (value) => Number.isSafeInteger(value) && value >= 0;
+const amount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+const text = (value) => typeof value === "string";
+const nullable = (check) => (value) => value === null || check(value);
+const list = (check) => (value) => Array.isArray(value) && value.every(check);
+const shape = (fields) => (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+  && Object.entries(fields).every(([key, check]) => check(value[key]));
+
+function schema(name, check) {
+  return {
+    parse(value) {
+      if (!check(value)) throw new TypeError(`Invalid session-fee ${name}`);
+      return value;
+    }
+  };
+}
+
+const route = shape({ provider: text, model: text });
+const usage = shape({
+  uncachedInputTokens: count,
+  outputTokens: count,
+  cacheReadTokens: count,
+  cacheWriteTokens: count,
+  reasoningTokens: count
+});
+const attemptShape = shape({
+  turn: count,
+  step: count,
+  firstSeq: count,
+  lastSeq: count,
+  startTime: amount,
+  route: nullable(route),
+  usage
+});
+
+const stateSchema = schema("state", shape({
+  inherited: count,
+  attempts: list(attemptShape),
+  route: nullable(route),
+  open: nullable(shape({ turn: count, step: count, startTime: amount })),
+  current: nullable(shape({ index: count, turn: count, step: count })),
+  compaction: nullable(shape({ turn: count, startTime: amount }))
+}));
+
+const viewSchema = schema("view", shape({
+  totalCalls: count,
+  pricedCalls: count,
+  segments: list(shape({
+    provider: text,
+    model: text,
+    calls: count,
+    unknownCalls: count,
+    firstTime: amount,
+    lastTime: amount,
+    usage,
+    amounts: list(shape({ currency: text, amount })),
+    rules: list(text)
+  }))
+}));
+
+const zeroUsage = () => ({
+  uncachedInputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0,
+  cacheWriteTokens: 0,
+  reasoningTokens: 0
+});
+
+function sameRoute(left, right) {
+  return left === right || left !== null && right !== null && left.provider === right.provider && left.model === right.model;
+}
+
+function headerRoute(event) {
+  const config = event.data.header?.config;
+  if (typeof config?.provider !== "string" || typeof config?.model !== "string" || config.provider === "" || config.model === "") return null;
+  return { provider: config.provider, model: config.model };
+}
+
+function messageRoute(event) {
+  if (event.type !== "assistant/message") return null;
+  const source = event.data.message?.source;
+  if (typeof source?.provider !== "string" || typeof source?.model !== "string" || source.provider === "" || source.model === "") return null;
+  return { provider: source.provider, model: source.model };
+}
+
+/** Compaction summaries report their own route; older logs only carry the session route. */
+function summaryRoute(event) {
+  const { provider, model } = event.data;
+  if (typeof provider !== "string" || typeof model !== "string" || provider === "" || model === "") return null;
+  return { provider, model };
+}
+
+function lastUsageChunk(stream) {
+  if (!Array.isArray(stream)) return null;
+  for (let index = stream.length - 1; index >= 0; index -= 1) {
+    const record = stream[index];
+    if (record?.type === "chunk" && record.chunk?.type === "usage") return record.chunk.usage;
+  }
+  return null;
+}
+
+function usageOf(event) {
+  if (event.type === "assistant/message" && event.data.usage !== void 0) return event.data.usage;
+  if (event.type !== "assistant/message" && event.type !== "assistant/attempt") return null;
+  return lastUsageChunk(event.data.stream);
+}
+
+function bucketsOf(sample) {
+  if (typeof sample !== "object" || sample === null || !count(sample.inputTokens) || !count(sample.outputTokens)) return null;
+  if (sample.cacheReadTokens !== void 0 && !count(sample.cacheReadTokens)) return null;
+  if (sample.cacheWriteTokens !== void 0 && !count(sample.cacheWriteTokens)) return null;
+  if (sample.reasoningTokens !== void 0 && !count(sample.reasoningTokens)) return null;
+  // DSH usage buckets are disjoint: inputTokens already excludes cache reads/writes.
+  return {
+    uncachedInputTokens: sample.inputTokens,
+    outputTokens: sample.outputTokens,
+    cacheReadTokens: sample.cacheReadTokens ?? 0,
+    cacheWriteTokens: sample.cacheWriteTokens ?? 0,
+    reasoningTokens: sample.reasoningTokens ?? 0
+  };
+}
+
+/** Build a projection definition closed over one pricer (price book + catalog). */
+export function createSessionCostProjection(pricer) {
+  function attempt(event, route, usage, startTime) {
+    return {
+      turn: event.data.turn,
+      step: event.data.step,
+      firstSeq: event.seq,
+      lastSeq: event.seq,
+      startTime,
+      route,
+      usage
+    };
+  }
+
+  function applyUsage(state, event) {
+    const usage = bucketsOf(usageOf(event));
+    if (usage === null || !count(event.data.turn) || !count(event.data.step)) return state;
+    const current = state.current;
+    const route = messageRoute(event) ?? state.route;
+    if (current !== null && current.turn === event.data.turn && current.step === event.data.step) {
+      const previous = state.attempts[current.index];
+      if (previous === void 0) return state;
+      const nextRoute = route ?? previous.route;
+      const replacement = {
+        ...previous,
+        lastSeq: event.seq,
+        route: nextRoute,
+        usage
+      };
+      const attempts = state.attempts.slice();
+      attempts[current.index] = replacement;
+      return { ...state, attempts };
+    }
+    const open = state.open;
+    const startTime = open !== null && open.turn === event.data.turn && open.step === event.data.step ? open.startTime : event.time;
+    const next = attempt(event, route, usage, startTime);
+    return {
+      ...state,
+      attempts: [...state.attempts, next],
+      current: { index: state.attempts.length, turn: next.turn, step: next.step }
+    };
+  }
+
+  /**
+   * Compaction summarisation is a real model call with its own provider-reported
+   * usage, billed at the time the summary request started. It is appended as its
+   * own attempt (step 0, never `current`) so a later assistant/message for the
+   * surrounding step still replaces that step instead of this one.
+   */
+  function applyCompaction(state, event) {
+    const usage = bucketsOf(event.data.usage);
+    if (usage === null) return state;
+    const started = state.compaction;
+    const next = {
+      turn: started?.turn ?? 0,
+      step: 0,
+      firstSeq: event.seq,
+      lastSeq: event.seq,
+      startTime: started?.startTime ?? event.time,
+      route: summaryRoute(event) ?? state.route,
+      usage
+    };
+    return { ...state, attempts: [...state.attempts, next] };
+  }
+
+  function view(state) {
+    const segments = [];
+    let pricedCalls = 0;
+    for (const item of state.attempts) {
+      const provider = item.route?.provider ?? "";
+      const model = item.route?.model ?? "";
+      let segment = segments.at(-1);
+      if (segment === void 0 || segment.provider !== provider || segment.model !== model) {
+        segment = {
+          provider,
+          model,
+          calls: 0,
+          unknownCalls: 0,
+          firstTime: item.startTime,
+          lastTime: item.startTime,
+          usage: zeroUsage(),
+          amounts: [],
+          rules: []
+        };
+        segments.push(segment);
+      }
+      segment.calls += 1;
+      segment.lastTime = item.startTime;
+      for (const key of Object.keys(segment.usage)) segment.usage[key] += item.usage[key];
+      // Cost is deliberately derived at the wire boundary. Projection checkpoints
+      // contain only log facts, so a new price book reprices the whole history.
+      const cost = item.route === null ? null : pricer.price(item.route, item.usage, item.startTime);
+      if (cost === null) {
+        segment.unknownCalls += 1;
+        continue;
+      }
+      pricedCalls += 1;
+      let amount = segment.amounts.find((entry) => entry.currency === cost.currency);
+      if (amount === void 0) {
+        amount = { currency: cost.currency, amount: 0 };
+        segment.amounts.push(amount);
+      }
+      amount.amount += cost.amount;
+      if (!segment.rules.includes(cost.rule)) segment.rules.push(cost.rule);
+    }
+    return { totalCalls: state.attempts.length, pricedCalls, segments };
+  }
+
+  return {
+    key: "sessionCost",
+    stateVersion: 6,
+    stateSchema,
+    // Forks (branches, fork subagents) start with a copy of the parent's log.
+    // Those inherited calls were paid in the parent, so they are skipped here;
+    // otherwise a parent total that includes its subagents would count them twice.
+    init: (_header, inheritedEventCount) => ({
+      inherited: Number.isSafeInteger(inheritedEventCount) && inheritedEventCount > 0 ? inheritedEventCount : 0,
+      attempts: [],
+      route: null,
+      open: null,
+      current: null,
+      compaction: null
+    }),
+    apply: (state, event) => {
+      if (event.seq < state.inherited) return state;
+      switch (event.type) {
+        case "request/header": {
+          const route = headerRoute(event);
+          const open = state.open !== null && state.current === null ? { ...state.open, startTime: event.time } : state.open;
+          return sameRoute(state.route, route) && open === state.open ? state : { ...state, route, open };
+        }
+        case "request/context":
+          if (state.open === null || state.current !== null) return state;
+          return { ...state, open: { ...state.open, startTime: event.time } };
+        case "step/start":
+          return {
+            ...state,
+            open: { turn: event.data.turn, step: event.data.step, startTime: event.time },
+            current: null
+          };
+        case "llm/retry-started": {
+          const matches = state.current?.turn === event.data.turn && state.current?.step === event.data.step || state.open?.turn === event.data.turn && state.open?.step === event.data.step;
+          if (!matches) return state;
+          return {
+            ...state,
+            open: state.open === null ? null : { ...state.open, startTime: event.time },
+            current: null
+          };
+        }
+        case "step/end":
+          if (state.open === null && state.current === null) return state;
+          return { ...state, open: null, current: null };
+        case "assistant/attempt":
+        case "assistant/message":
+          return applyUsage(state, event);
+        case "compaction/start":
+          return {
+            ...state,
+            compaction: { turn: count(event.data.turn) ? event.data.turn : 0, startTime: event.time }
+          };
+        case "compaction/summary":
+          return applyCompaction(state, event);
+        case "compaction/end":
+          return state.compaction === null ? state : { ...state, compaction: null };
+        default:
+          return state;
+      }
+    },
+    wire: { viewSchema, view }
+  };
+}

package/lib/reload.js

@@ -0,0 +1,68 @@
+import { utimesSync, watch } from "node:fs";
+import { basename, dirname } from "node:path";
+
+/**
+ * Keep one valid pricing registration live. Saving the price book (atomically
+ * or in place) re-registers the Host projection, then touches the Client
+ * artifact so DSH's Client HMR re-reads the current projection snapshot.
+ *
+ * `load(path)` builds the whole pricing context; `fingerprint(context)` decides
+ * whether anything changed. `onLoad` / `onError` report each outcome.
+ */
+export function watchPriceBook({
+  priceBookPath,
+  clientArtifact,
+  load,
+  register,
+  onError,
+  fingerprint = (value) => JSON.stringify(value),
+  onLoad = () => {}
+}) {
+  let current = load(priceBookPath);
+  let dispose = register(current);
+  let stopped = false;
+  let timer = null;
+  onLoad(current);
+
+  const report = (error) => {
+    if (!stopped) onError(error);
+  };
+
+  const reload = () => {
+    timer = null;
+    if (stopped) return;
+    try {
+      const next = load(priceBookPath);
+      if (fingerprint(next) === fingerprint(current)) return;
+      dispose();
+      dispose = register(next);
+      current = next;
+      onLoad(next);
+      // dsh-client-hmr polls artifact mtime/ctime/size. Content and Git stay
+      // unchanged, while the Client re-reads the newly registered projection.
+      utimesSync(clientArtifact, new Date(), new Date());
+    } catch (error) {
+      // A half-written or invalid file never displaces the last good book.
+      report(error);
+    }
+  };
+
+  const directory = dirname(priceBookPath);
+  const filename = basename(priceBookPath);
+  const watcher = watch(directory, { persistent: false }, (_event, changed) => {
+    if (stopped || changed !== null && changed !== filename) return;
+    if (timer !== null) clearTimeout(timer);
+    timer = setTimeout(reload, 180);
+  });
+  watcher.on("error", report);
+
+  return {
+    close() {
+      if (stopped) return;
+      stopped = true;
+      if (timer !== null) clearTimeout(timer);
+      watcher.close();
+      dispose();
+    }
+  };
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Session Cost",
+    "description": "Shows what the current session (including subagents) would cost at market token prices, below the composer; per-model runs, per-currency, with a details panel."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Session 费用",
+    "description": "在输入框下显示当前会话（含子代理）按市面 token 价折算的费用；换模型分段相加，各币种分开，点开看明细。"
+  }
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "dsh-session-fee",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.4",
+  "description": "在 DSH 输入框下显示当前会话（含子代理）按市面 token 价折算的费用：自维护价格表（别名、峰闲时、节假日、限时、长上下文阶梯）＋ pi-ai 模型目录兜底。",
+  "author": "youxia",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fujingzhai/youxia-dsh-plugins.git",
+    "directory": "dsh-session-fee"
+  },
+  "homepage": "https://github.com/fujingzhai/youxia-dsh-plugins/tree/main/dsh-session-fee#readme",
+  "bugs": {
+    "url": "https://github.com/fujingzhai/youxia-dsh-plugins/issues"
+  },
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "lib/*.js",
+    "cordis.patch.yml",
+    "prices.json",
+    "prices.example.json",
+    "PRICES.md",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-api-session-controller",
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  },
+  "scripts": {
+    "check": "node --check index.js && node --check client.js && node --check lib/pricing.js && node --check lib/catalog.js && node --check lib/config.js && node --check lib/projection.js && node --check lib/reload.js",
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=24.9",
+    "dsh": ">=0.2.1-rc.5"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "token",
+    "cost",
+    "pricing"
+  ],
+  "license": "MIT"
+}

package/prices.example.json

@@ -0,0 +1,71 @@
+{
+  "version": 2,
+  "note": "写法示例，金额均为虚构，不是实际报价。",
+  "timeZone": "Asia/Shanghai",
+  "dateSets": {
+    "holidays": ["2026-10-01..2026-10-07", "2026-12-25"]
+  },
+  "models": [
+    {
+      "name": "示例国产模型（多个路由共用一份价格）",
+      "match": [
+        "your-provider/internal-key",
+        "another-relay/example-chat",
+        "*/example-chat"
+      ],
+      "rules": [
+        {
+          "name": "工作日高峰（虚构）",
+          "currency": "CNY",
+          "input": 4,
+          "cacheRead": 0.4,
+          "cacheWrite": 0,
+          "output": 8,
+          "when": {
+            "weekdays": [1, 2, 3, 4, 5],
+            "excludeDates": ["@holidays"],
+            "intervals": [{ "start": "09:00", "end": "12:00" }, { "start": "14:00", "end": "18:00" }]
+          }
+        },
+        {
+          "name": "每日深夜（虚构，跨午夜）",
+          "currency": "CNY",
+          "input": 1,
+          "cacheRead": 0.1,
+          "cacheWrite": 0,
+          "output": 2,
+          "when": { "intervals": [{ "start": "22:00", "end": "08:00" }] }
+        },
+        { "name": "常规（虚构）", "currency": "CNY", "input": 2, "cacheRead": 0.2, "cacheWrite": 0, "output": 4 }
+      ]
+    },
+    {
+      "name": "示例美国模型（限时价＋长上下文阶梯）",
+      "match": ["*/example-pro*"],
+      "rules": [
+        {
+          "name": "首发限时（虚构）",
+          "currency": "USD",
+          "input": 1,
+          "cacheRead": 0.1,
+          "output": 5,
+          "when": { "to": "2026-12-01T00:00:00+08:00" },
+          "tiers": [{ "above": 200000, "input": 2, "cacheRead": 0.2, "output": 7.5 }]
+        },
+        {
+          "name": "标准（虚构）",
+          "currency": "USD",
+          "input": 2,
+          "cacheRead": 0.2,
+          "output": 10,
+          "tiers": [{ "above": 200000, "input": 4, "cacheRead": 0.4, "output": 15 }]
+        }
+      ]
+    },
+    {
+      "name": "怪名字的路由借用 pi-ai 目录里的价格",
+      "match": ["antigravity/gemini-3.1-pro-high"],
+      "catalog": "google/gemini-3.1-pro-preview"
+    }
+  ]
+}