omdsh-usage
English | 中文
What this conversation cost, what this project has cost, and what is left on
the account — three figures in the row of the
DeepSeek Harness web GUI you
are already reading.
Help ⚙ Code mode 💬 0.023 ¥ 📁 1.03 ¥ 👛 964.15 ¥ Files Terminal
In Chat and Work the badge sits in the session header, immediately
right of the Chat Mode / Code mode chip. In Code the whole conversation
column is a terminal and there is no header to sit in, so it moves to the
opposite corner, just left of Files. (Files and Terminal at that end of
the row belong to
omdsh-sidepanel, not to
this plugin; they are drawn here because they are what the corner has to sit
inboard of.)
Under a configurable floor — 10 by default, in whatever currency the account is
denominated in — all three icons turn red, and so they do when the provider
reports the account itself unavailable, whatever the figure beside it says. Red
therefore means two things rather than one. Above the floor nothing is tinted
at all, and a balance that could not be read is not an alarm either: no key
stored, or a network blip, leaves every icon its ordinary colour and puts the
reason in the tooltip.
What it adds
| Surface | Where it comes from |
|---|
| The three-figure badge in the session header | conversation.session.header.actions, ui-conversation's action row |
| The same badge in the frame's corner, whenever nothing is drawing a header | shell.overlay, ui-layout's frame-wide floating layer |
The omdshUsage per-model token fold | sessionProjections.register — a projection unit the harness drives once per committed event and checkpoints |
GET /omdsh-usage/summary | webServer, behind the same browser-trust check the /api gateway applies |
The omdsh-usage settings namespace | settings.register, which is the whole of what the plugin hub needs to render this plugin a configuration page |
The figures
| Readout | What it is |
|---|
| Session | Every model call in the conversation on screen, priced. |
| Project | The same, summed over every conversation whose working directory is this one. |
| Balance | What the provider says is left on the account, in the provider's own currency. |
Hover any of them for the tokens behind it, how many of those DeepSeek billed
at its off-peak rate and what that part cost, the directory a project total is
for, how much of the balance is promotional credit, or — when a figure is
missing — why.
This conversation cost 3.02¥ over 1.2M billed tokens (1.2M in, 900k of it
cached; 42k out). 400k of those tokens were billed off-peak, at 1.01¥.
The off-peak line appears only when there is one to draw: a conversation that
ran entirely inside the peak windows, and one this plugin never folded, both
leave the tooltip a line shorter rather than claiming a zero neither of them
can stand behind.
Prices, and the hour they were paid at
The harness carries no prices, so this plugin does. The shipped table is
DeepSeek's published peak rate per million tokens, read from
its pricing page on
2026-08-16:
| CNY per 1M tokens | cache hit | cache miss | output |
|---|
deepseek-v4-flash | 0.10 | 3.00 | 9.00 |
deepseek-v4-pro | 0.30 | 9.00 | 27.00 |
Off-peak is half of each of those, and off-peak is most of the day: peak
hours are 09:00-12:00 and 14:00-18:00 Beijing time (01:00-04:00 and 06:00-10:00
UTC), seven hours out of twenty-four. A badge that ignored the clock would
overstate a night's work by exactly a factor of two, so the fold records which
tier each message was billed at as it counts it — the event's own timestamp is
the last place that information exists — and the discount multiplies that share
at pricing time.
A published price is still a fact about last week: rates change, gateways
discount, and your invoice is the only authority this code can never read. So
all of it is yours to restate, in Settings → Plugins → Plugin hub →
Usage. The panel renders the namespace as a form, and a deployment that wants
to state its own writes the same shape into its profile's cordis.yml:
omdsh-usage:
currency: CNY
rates:
default: 0.3/9/27 # <cache hit>/<cache miss>/<output>, per MILLION tokens, at PEAK
deepseek-v4-flash: 0.1/3/9
deepseek-v4-pro: 0.3/9/27
offPeakDiscount: 0.5 # an off-peak token costs half of the line above
lowBalance: 10
Every field is live: a repriced table reaches the next poll, a few seconds
later, with nothing to restart.
| Field | Meaning |
|---|
currency | CNY or USD. The two spend figures are stated in it and the rates are read in it. The balance always reports the provider's own currency. |
rates | One line per model, "<cache hit>/<cache miss>/<output>" per million tokens, at the peak rate. The default row prices any model the table does not list — it ships as the dearer of the two published models, because overstating a model nobody has priced is the safer direction. A key may be a bare model id or a full provider/model. |
offPeakDiscount | What an off-peak token costs as a fraction of the line above: 0.5 is half price, 1 charges everything the peak rate. Changing it reprices history immediately, because which tokens were off-peak is already recorded. |
lowBalance | The floor under which all three icons turn red. |
apiKeyEnv | Which stored credential the balance call uses — the credential's name, not the key. Defaults to DEEPSEEK_API_KEY. |
baseURL | Where the balance is read from. Point it at the same gateway your model requests use. |
A rate line that is not three non-negative numbers is refused at the moment it
is written, rather than stored and failed on afterwards.
The peak windows are not a setting, while the discount is. The split has to
be decided while the fold runs — the projection checkpoints its state and never
revisits an event — so a window read from settings would make two checkpoints
of the same conversation disagree depending on when each was written. The
discount only multiplies at pricing time, so it costs nothing to let a person
state it.
How it works
Almost none of the accounting is this plugin's. The session log already records
provider usage on every assembled assistant message, and the harness's
projection seam already folds and checkpoints per-session state. So:
- The fold is a projection unit.
omdshUsage accumulates billed tokens per
provider/model over the complete durable log, and, beside them, the share
of each that was billed off-peak. The harness drives it once per committed
event and checkpoints it, so the figures survive paging, compaction, and
restarts — and a conversation using two models across both price tiers is
priced at four rates rather than one blended average.
- "This project" is the checkpoint table. Every session's checkpoint is
stored with its working directory, so a project total is a read of a few
kilobytes of JSON rather than a walk through a directory of compressed logs.
- The balance is one provider call, behind the credential seam, cached for
a minute and shared across every open tab.
- The money is computed on the host. The browser receives numbers to
format and never a rate to multiply, so there is one implementation of the
arithmetic and a stale page cannot render spend at last week's prices.
Two seats, both slots the harness already publishes:
conversation.session.header.actions for the header, and shell.overlay for
the understudy that holds the row's place when nothing is drawing one. The
understudy decides its corner by measuring the frame — if the conversation
column still holds a session header it takes the leading corner, and if
something else has taken the column it takes the trailing one, inboard of
whatever furniture is already there.
It re-measures on the three things that can move it, and two of them are
invisible to a resize observer: a mode taking the column replaces the
conversation with something else in exactly the same box, and a neighbouring
surface appearing in that corner changes where "inboard" is without changing
any size at all. Both are childList mutations on anchors their renderers
publish — the conversation slot's, and the floating layer's — so that is what
is watched.
What it does without
Every service either half injects — webServer, webRuntime, sessions, and
sessionProjections on the host, slots, sessions, and locale in the page
— is the harness's own, and both seats are taken through slots.inject. So no
other plugin in this collection is a precondition: a profile carrying only this
one boots, and the badge is there. What is missing is reported rather than
waited for.
- No credential store, or no key in it. The two spend figures are
unaffected; the balance is a dash and its tooltip says which of the two it
was.
- No session persistence or projection cache. The project total covers the
conversations this host has open rather than every conversation that ever ran
in the directory.
- No
omdsh-codemode. Code mode
is what replaces the conversation column with a terminal, and the trailing
corner exists for that. Without it the header is always there to hold the
badge, and the understudy only ever stands in for a blank conversation. Which
corner is a measurement of the frame either way — nothing here asks who is
installed.
Install
npx @omdsh-plugins/omdsh-plughub add omdsh-usage
That is the plugin hub's
installer with argv where the button was. It resolves this plugin from the
collection's registry, installs it
from its GitHub repository, and writes the pnpm build-allowlist entry a bare
dsh plugin add github:… would leave to you — the entry carries the commit pnpm
resolved, so it can be copied out of a failure and never written down in
advance.
dsh plugin --profile web add @omdsh-plugins/omdsh-usage is not that command yet:
this package is not on npm, and pnpm answers ERR_PNPM_FETCH_404. The same
install is also a button, on this plugin's card in Settings → Plugins → Plugin
hub, once the hub itself is in the profile.
Or from a checkout, which is what an unpublished build wants:
pnpm install && pnpm run build # a local checkout never runs `prepare` — build it yourself first
dsh plugin --profile web add /path/to/omdsh-usage
dsh web
Nothing else. The balance is read with the DEEPSEEK_API_KEY the harness
already holds for model requests, so there is no second key to store — and if
no key is stored, the two spend figures still work and the balance says why it
is absent.
Remove it the same way:
dsh plugin --profile web remove @omdsh-plugins/omdsh-usage
Both halves go with it, and the header row closes back over the seat. Nothing
in this collection is a precondition in either direction — see what it does
without for what each absence costs.
Commands
pnpm install
pnpm run build
pnpm run typecheck
pnpm run test
The committed manifest pins the published harness. To build against a sibling
checkout instead:
pnpm run harness:local ../../deepseek-harness # that checkout must be built first
pnpm install
pnpm run harness:npm # before committing — a link: is one machine's layout
pnpm run check:harness-pin
Every spec runs from a bare clone on the committed pin: the pure modules import
the harness type-only, and the two that need a snapshot store are handed one
rather than importing the browser bundle a test runner cannot load.
Known limitations
- Conversations older than this plugin have no per-model fold, because
nothing was folding one when they ran. They fall back to the harness's own
tokenUsage projection, which records neither the model nor the clock, so
they are priced at the default row and at the peak rate — an upper bound in
both directions at once. The tooltip says when a figure includes an estimate.
Without this fallback a project total would read as "you have spent almost
nothing here", which is a worse error.
- A conversation folded by an older build of this plugin knows its models
but not its tiers; its stored checkpoint is kept rather than discarded, and
everything in it is charged the peak rate until the conversation is reopened,
at which point the whole log refolds and the tiers come back.
- The tier is read off the assembled message's timestamp, which is when the
response finished rather than when the request was made. A turn straddling
09:00 or 18:00 Beijing time is billed on the wrong side of the boundary; a
turn is minutes, and the windows are hours.
- Cold conversations lag by up to a turn. A checkpoint is written at
turn/end; the conversation on screen is live and is recomputed on every
poll.
- Cache writes are billed as cache misses. DeepSeek prices them that way
and its adapter reports no separate bucket; a provider that charged
separately would be priced conservatively.
