@nijaru/pi-peak-hours 0.0.4 → 0.0.5

package/README.md

@@ -4,9 +4,9 @@ Correct pi's recorded cost for providers that bill by time of day, and show the
 
 DeepSeek is the current example. Its peak windows are `01:00–04:00` and `06:00–10:00` UTC, Monday to Friday, and off-peak is half the peak rate. pi has no notion of time-of-day pricing: `usage.cost` is computed once from the model's flat rates when usage is finalized, so a session is over- or understated by up to 2x depending on which side of the schedule the recorded rate sits.
 
-Both built-in entries follow what DeepSeek advertises: ×2 inside those windows and ×1 outside, because the published rate is the off-peak one and peak is a surcharge on it. Since the extension scales whatever rate pi recorded, an entry is right only where that rate really is the off-peak one — true of the OpenRouter route, which pi rates at `0.15/0.60`, and of the direct provider wherever `models.json` pins it to off-peak. Stock pi.dev rates direct as `deepseek-flash` at `0.30/1.20`, its peak number, so the configuration below inverts that one entry; the pair exists because each entry is scoped, covering the DeepSeek models on both routes without claiming unrelated OpenRouter models. Naming your own providers replaces both.
+The default covers DeepSeek direct only: pi records it at the published **peak** rate, so correction is ×1 inside the windows and ×0.5 outside. Reseller routes bill flat — OpenRouter prices each model per key and publishes no time-of-day overrides — so a default multiplier would corrupt their cost instead of correcting it. Give a route an explicit schedule only when its provider really bills by time of day. Custom `models.json` rates also need matching multipliers.
 
-This extension rewrites `usage.cost` on the finalized assistant message, so the footer total, the per-model breakdown, and the HTML export all reflect the billed rate. The status line quotes the rate in force for the selected model — `· ▲ peak $0.30/$1.20/M` during a peak window, `· $0.15/$0.60/M` off it — with `▲ peak` or `▼ off-peak` added when the hour costs more or less than the rate pi recorded. `/peak-hours status` names the schedule behind it.
+This extension rewrites `usage.cost` on the finalized assistant message, so the footer total, the per-model breakdown, and the HTML export all reflect the billed rate. The status line quotes the rate in force for the selected model — `· ▲ peak $0.30/$1.20/M` during a peak window, `· $0.15/$0.60/M` off it — with `▲ peak` or `▼ off-peak` added when the hour costs more or less than the rate pi recorded. With stock peak-base prices, the peak indicator is absent and off-peak is marked as a discount. `/peak-hours status` names the schedule behind it.
 
 The quoted rate is pi's recorded rate scaled by the schedule, so it always agrees with the cost written to the session. It describes the hour in force rather than a particular request, though: a request that started before a boundary is billed by its start time while the footer has already moved to the new hour. Where pi's rate table is stale or wrong for your route, the quoted rate is stale in the same way — the extension corrects the shape of the bill, not the base rate.
 
@@ -29,13 +29,13 @@ The footer status is a separate line under the stats bar. It shows the model's c
 
 ## Configuration
 
-Optional. `~/.pi/agent/extensions/pi-peak-hours.json` overlays the DeepSeek schedule; anything you leave out keeps its default. The OpenRouter route for the same models is covered out of the box, and setting `providers` yourself replaces both built-in schedules with the one you describe.
+Optional. `~/.pi/agent/extensions/pi-peak-hours.json` overlays the DeepSeek schedule; anything you leave out keeps its default. A `schedules` list replaces the default outright instead of overlaying it.
 
 ```json
 {
   "active": true,
-  "multiplier": 2,
-  "outside": 1,
+  "multiplier": 1,
+  "outside": 0.5,
   "windows": [["01:00", "04:00"], ["06:00", "10:00"]],
   "days": ["mon", "tue", "wed", "thu", "fri"],
   "providers": ["deepseek"],
@@ -51,7 +51,7 @@ Times are **UTC**. `days` accepts names or `0`–`6` (`0` is Sunday). `providers
 "windows": [{ "start": "22:00", "end": "08:00", "multiplier": 0.4 }]
 ```
 
-**Pick the side that matches your own rate card.** The extension applies the difference from the rate pi recorded; it does not guess which side that is. The built-in pair encodes today's pi.dev catalog — DeepSeek direct at its **peak** rate, the same model through OpenRouter at its **off-peak** rate — and if your catalog changes, or you override rates in `models.json` as below, say so in the config instead of relying on the default. `/peak-hours status` reports what it would charge right now, and the numbers are in the provider's docs.
+**Pick the side that matches your own rate card.** The extension applies the difference from the rate pi recorded; it does not guess which side that is. The built-in schedule encodes today's pi.dev catalog — DeepSeek direct at its **peak** rate — and if your catalog changes, or you override rates in `models.json` as below, say so in the config instead of relying on the default. `/peak-hours status` reports what it would charge right now, and the numbers are in the provider's docs.
 
 ```json
 // Your models.json pins DeepSeek direct to the off-peak rate: scale up at peak.
@@ -63,7 +63,7 @@ Times are **UTC**. `days` accepts names or `0`–`6` (`0` is Sunday). `providers
 
 ### Other providers
 
-A `schedules` list replaces the built-in schedules with one entry per service. Each entry starts from a clean slate rather than inheriting DeepSeek's windows.
+A `schedules` list replaces the built-in schedule with one entry per service. Each entry starts from a clean slate rather than inheriting DeepSeek's windows.
 
 **Z.ai coding plan** — the standard credit rate during the weekday peak window, half of it everywhere else (docs.z.ai/devpack). This is inverted relative to DeepSeek: `06:00–10:00` UTC Monday–Friday is the *expensive* side, so the windows match and the multiplier lands below 1.
 
@@ -92,6 +92,8 @@ Note that a coding plan is billed in credits against a subscription, so pi's cos
 }
 ```
 
+**Xiaomi MiMo Token Plan** — subscription credits rather than the pay-as-you-go API (which is flat-rate): the night rate consumes 0.8× credits from 00:00–08:00 Beijing (16:00–24:00 UTC) daily ([docs](https://mimo.mi.com/static/docs/price/token-plan.md)), as a `schedules` entry: `{ "providers": ["xiaomi-token-plan-*"], "windows": [["16:00", "00:00"]], "multiplier": 0.8, "outside": 1 }`.
+
 OpenRouter publishes the same windows machine-readably for models it hosts (`pricing.overrides` with `utc_days` / `utc_start` / `utc_end` on `https://openrouter.ai/api/v1/models`), but this extension reads its schedule from config rather than the network: the correction is a rate difference, not a price lookup, and a fetch would add a failure mode to a handler that must never throw.
 
 A malformed field falls back to its default rather than disabling the extension; a malformed file warns and resolves to defaults.
@@ -100,10 +102,10 @@ A malformed field falls back to its default rather than disabling the extension;
 
 - **Only the selected model drives the indicator.** Schedules are provider- and model-scoped, so the footer never shows a rate for a service that does not bill by time of day. A rate above the recorded one reads `peak`, below it `off-peak`, and a discount is never labelled a peak. The quoted rate and the written cost come from the same multiplication, so they cannot disagree.
 - **The footer follows the window it quotes.** pi has no render tick and fires no event while a session is idle, and a rate that changes at 04:00 would otherwise stay on screen until the next turn. The extension arms a single timer for the next instant the quoted rate changes and re-arms it after each fire, from the same clock reading as the status it is keeping fresh. It arms nothing when there is no status on screen, and the timer is unreferenced and cleared on session shutdown, so it neither holds pi open nor outlives its session.
-- **Rate by request start.** DeepSeek bills by arrival time, so the multiplier is chosen from the logical request start captured in `before_provider_request`, not `message_end`. `message_start` only fires once the response begins, so it would misprice a request that spans a window boundary.
+- **Rate by provider invocation.** Pi providers timestamp each assistant message before preparing and sending its HTTP request. That timestamp selects the multiplier, not response completion or the shared payload hook (which also fires for background cache warming). Server arrival can differ across a boundary, so this remains an estimate.
 - **Scaled once.** Retries and overflow recovery can re-deliver the same message object, so adjustments are guarded by identity; the replacement returned to pi is registered too, so a replayed replacement cannot be scaled twice.
 - **Only cost moves.** The four cost fields are scaled and `total` is recomputed from them, matching pi's own invariant. Token counts are untouched, so rate-from-cost derivations stay self-consistent — including pi's cache-miss accounting, which derives its paid and read rates from the same message and scales with it.
-- **Coverage.** Assistant messages carry the bulk of a session's spend. Compaction and branch-summary usage, prompt-cache-warming refreshes, and token usage reported by tools also consume budget but cannot be adjusted after the fact, so totals stay an estimate rather than an invoice.
+- **Coverage.** The default weekday schedule does not encode Chinese public holidays, which DeepSeek treats as off-peak. Holiday costs can therefore be overstated; totals are not an invoice. Assistant messages carry the bulk of a session's spend. Compaction and branch-summary usage, prompt-cache-warming refreshes, and token usage reported by tools also consume budget but cannot be adjusted after the fact, so totals stay an estimate rather than an invoice.
 
 ## Stack
 

package/extensions/index.ts

@@ -15,22 +15,22 @@
  * HTML export without further plumbing.
  *
  * The footer indicator is scoped to the selected model and quotes the rate that
- * applies to it right now, in dollars per million tokens: `· ▲ peak
- * $0.30/$1.20/M` at peak, `· $0.15/$0.60/M` off it. The rate is the one pi
- * recorded scaled by the schedule, so it always agrees with the cost this
- * extension writes. A session on a provider or model no schedule covers never
- * shows a rate, and switching models re-evaluates it.
+ * applies to it right now, in dollars per million tokens: with the default
+ * schedule, `· $0.30/$1.20/M` at peak and `· ▼ off-peak $0.15/$0.60/M` off it.
+ * The rate is the one pi recorded scaled by the schedule, so it always agrees
+ * with the cost this extension writes. A session on a provider or model no
+ * schedule covers never shows a rate, and switching models re-evaluates it.
  *
  * The indicator is a snapshot of the current hour, and pi fires no event while a
  * session sits idle — so a timer armed at the next window boundary keeps it from
  * quoting a rate that has already expired. See `arm`.
  *
- * Schedules are provider-scoped and there can be several, because the shape of
- * the correction differs: DeepSeek's list price is its off-peak rate, so peak is
- * a surcharge (×2), while Z.ai's coding plan and Alibaba's night discount are
- * priced the other way round and land below the recorded rate. A multiplier
- * above 1 reads as `peak`, below 1 as `off-peak`, and the footer names the
- * direction so a discount is never reported as a peak.
+ * Schedules are provider-scoped and there can be several, because the recorded
+ * rate sits on a different side of each: pi records DeepSeek direct at its peak
+ * rate, so off-peak is a discount (×0.5), while a catalog pinned at the off-peak
+ * number would make peak a surcharge (×2). A multiplier above 1 reads as `peak`,
+ * below 1 as `off-peak`, and the footer names the direction so a discount is
+ * never reported as a peak.
  *
  * Design constraints:
  *
@@ -40,10 +40,11 @@
  *   the start; `message_end` gives the end.
  * - A schedule declares the multiplier INSIDE its windows and `outside` for
  *   every other hour. Which side pi's recorded rate sits on is not assumed:
- *   encode it in the config, and only the difference is applied. pi's own
- *   catalog disagrees with itself here — it lists DeepSeek direct at peak rates
- *   and the same model through OpenRouter at off-peak rates — so a schedule that
- *   guesses would double-charge one of them.
+ *   encode it in the config, and only the difference is applied. Only DeepSeek
+ *   direct has a built-in schedule: reseller routes are priced per key at flat
+ *   rates with no time-of-day billing (OpenRouter's DeepSeek routes publish no
+ *   `pricing.overrides`), so a default multiplier would corrupt their cost
+ *   instead of correcting it.
  * - A message is never scaled twice. Retries and overflow recovery can deliver
  *   the same message object again, so adjustments are guarded by identity.
  * - Only the four cost fields are touched, and `total` is recomputed from
@@ -119,10 +120,10 @@ export interface ConfigFile extends ScheduleConfig {
 
 export const DAY_NAMES = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"] as const;
 
-/** DeepSeek's published schedule: peak mornings on UTC weekdays, everything else off-peak. */
+/** Stock Pi rates DeepSeek direct at peak; halve those rates outside its weekday windows. */
 export const DEFAULT_SCHEDULE: Schedule = {
-	multiplier: 2,
-	outside: 1,
+	multiplier: 1,
+	outside: 0.5,
 	windows: [
 		{ start: 60, end: 240 },
 		{ start: 360, end: 600 },
@@ -132,26 +133,6 @@ export const DEFAULT_SCHEDULE: Schedule = {
 	models: ["*"],
 };
 
-/**
- * The same model resold by OpenRouter, which pi's catalog rates at the off-peak
- * price while its own `deepseek` provider is rated at peak. Without this the
- * route silently keeps pi's flat rate.
- */
-export const OPENROUTER_SCHEDULE: Schedule = {
-	multiplier: 2,
-	outside: 1,
-	windows: [
-		{ start: 60, end: 240 },
-		{ start: 360, end: 600 },
-	],
-	days: [1, 2, 3, 4, 5],
-	providers: ["openrouter"],
-	models: ["deepseek/*"],
-};
-
-/** What a config that says nothing about schedules resolves to. */
-export const DEFAULT_SCHEDULES: Schedule[] = [DEFAULT_SCHEDULE, OPENROUTER_SCHEDULE];
-
 /**
  * Base for schedules listed explicitly in `schedules`: no windows, no
  * correction, every provider and model. An entry supplies its own shape rather
@@ -261,16 +242,14 @@ function parseDays(value: unknown): number[] | undefined {
 
 /**
  * Every schedule the config describes. An explicit `schedules` list replaces the
- * built-in schedules; a flat config overlays the DeepSeek one and drops the
- * built-in OpenRouter route once it names its own providers.
+ * default outright; a flat config overlays the DeepSeek one.
  */
 export function resolveSchedules(config: ConfigFile): Schedule[] {
 	if (Array.isArray(config.schedules)) {
 		const entries = config.schedules.filter(isRecord).map((entry) => resolveSchedule(entry, NEUTRAL_SCHEDULE));
 		if (entries.length > 0) return entries;
 	}
-	const schedule = resolveSchedule(config);
-	return config.providers === undefined ? [schedule, OPENROUTER_SCHEDULE] : [schedule];
+	return [resolveSchedule(config)];
 }
 
 /** Whether a window covers the given instant, including windows that wrap midnight. */
@@ -470,7 +449,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-/** Read the config file; undefined means missing or unreadable, which stays inert. */
+/** Missing or malformed config uses defaults; parsing failures are reported. */
 export function readConfig(path: string): ConfigFile | undefined {
 	if (!existsSync(path)) return {};
 	try {
@@ -490,7 +469,7 @@ export function readConfig(path: string): ConfigFile | undefined {
 /** Persist `active` while preserving keys this version does not model. */
 export function writeActive(path: string, active: boolean): void {
 	try {
-		const existing = existsSync(path) ? (JSON.parse(readFileSync(path, "utf8")) as unknown) : {};
+		const existing = readConfig(path) ?? {};
 		const merged = isRecord(existing) ? { ...existing, active } : { active };
 		mkdirSync(dirname(path), { recursive: true });
 		writeFileSync(path, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
@@ -551,8 +530,6 @@ export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions =
 	let schedules = resolveSchedules(config);
 	let active = parseActive(config.active);
 	const adjusted = adjustedMessages();
-	let pendingStart: number | undefined;
-	let requestStartMs: number | undefined;
 	let timer: ReturnType<typeof setTimeout> | undefined;
 
 	function refresh(): void {
@@ -635,8 +612,6 @@ export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions =
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
-		pendingStart = undefined;
-		requestStartMs = undefined;
 		disarm();
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 	});
@@ -651,29 +626,16 @@ export default function peakHours(pi: ExtensionAPI, options: PeakHoursOptions =
 		updateStatus(ctx);
 	});
 
-	// The provider bills when the request arrives, and `message_start` is emitted
-	// only once the response begins, so capture the logical request start here and
-	// fall back to the message clock when no request was observed.
-	pi.on("before_provider_request", async () => {
-		if (active) requestStartMs = Date.now();
-	});
-
-	pi.on("message_start", async (event) => {
-		if (event.message.role !== "assistant") return;
-		pendingStart = requestStartMs ?? Date.now();
-		requestStartMs = undefined;
-	});
-
 	pi.on("message_end", async (event, ctx) => {
 		const message = event.message;
 		if (message.role !== "assistant") return;
 		if (adjusted.has(message)) return;
 		if (!message.usage?.cost) return;
 
-		// The request's start decides its rate; fall back to the message clock when
-		// no start was observed (resumed sessions, extension reloads mid-turn).
-		const startedAt = pendingStart ?? message.timestamp ?? Date.now();
-		pendingStart = undefined;
+		// Pi providers stamp their output at invocation, before HTTP dispatch.
+		// This clock belongs to the foreground response even when the global
+		// payload hook is replayed by background cache warming.
+		const startedAt = message.timestamp;
 
 		if (!active) {
 			updateStatus(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nijaru/pi-peak-hours",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "type": "module",
   "description": "Correct pi's recorded cost for providers that bill by time of day, with a peak multiplier in the footer status.",
   "keywords": [
@@ -34,8 +34,8 @@
     "check": "bun test && oxlint extensions/ tests/ && tsc --noEmit"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.87.0",
-    "@earendil-works/pi-coding-agent": "0.87.0",
+    "@earendil-works/pi-ai": "1.2.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
     "@types/bun": "latest",
     "oxlint": "latest",
     "typescript": "^6.0.3"