@flame0510/project-aether 1.9.1 → 1.11.0

package/lib/model-pricing.ts

@@ -1,8 +1,12 @@
 /**
- * Model pricing data — static, from model-pricing.json in the project root.
+ * Model pricing data — static, from model-pricing.json in the project root, in $ per
+ * 1M tokens. `npm run refresh:pricing` regenerates the OpenRouter entries; the direct
+ * vendors' entries are kept by hand from each vendor's own pricing page.
  *
- * OpenRouter models are NOT included here; their pricing is fetched live
- * via the OpenRouter API and merged client-side.
+ * Besides the display, these prices are what every agent's OpenClaw computes its costs
+ * with: `buildRev4aProviderConfig()` writes `priceAt()` into each model of the synced
+ * `rev4a` block, and a vendor with time-of-day pricing (PRICE_SCHEDULES) is re-synced
+ * at each change of rate (lib/price-schedule-sync.ts).
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -10,8 +14,48 @@ import * as path from 'path';
 export interface ModelPricing {
   input: number;
   output: number;
+  /** Cached input read. Absent when the vendor's cache rate is not known. */
+  cacheRead?: number;
+  /** Cached input written. Absent when not known or not billed apart from input. */
+  cacheWrite?: number;
 }
 
+/** The four rates OpenClaw's `models.providers.*.models[].cost` takes, $ per 1M tokens. */
+export interface ModelCost {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+/**
+ * A vendor whose rates depend on the time of day: `peak` windows at the listed rates,
+ * every other hour at `offPeakFactor` times them. Hours are UTC, `[from, to)`; days are
+ * UTC weekdays, 0 = Sunday.
+ */
+export interface PriceSchedule {
+  source: string;
+  peak: { days: number[]; hours: [number, number][] };
+  offPeakFactor: number;
+}
+
+/**
+ * Keyed by the first segment of our model id: `deepseek/deepseek-flash` is DeepSeek's
+ * own API. `openrouter/deepseek/…` is OpenRouter's price and has no schedule.
+ *
+ * DeepSeek (checked 2026-09-27): "Off-peak rates are half of the peak rates. Peak hours
+ * are 01:00 - 04:00 and 06:00 - 10:00 UTC, Monday through Friday, excluding Chinese
+ * public holidays." Those holidays are not modelled: a call on one is priced at peak, a
+ * small overestimate on a few days a year.
+ */
+export const PRICE_SCHEDULES: Record<string, PriceSchedule> = {
+  deepseek: {
+    source: 'https://api-docs.deepseek.com/quick_start/pricing',
+    peak: { days: [1, 2, 3, 4, 5], hours: [[1, 4], [6, 10]] },
+    offPeakFactor: 0.5,
+  },
+};
+
 let _cache: Record<string, ModelPricing> | null = null;
 let _cacheMtime = 0;
 
@@ -61,3 +105,79 @@ export function formatPricing(p: ModelPricing | null | undefined): string {
   };
   return `${fmt(p.input)} / ${fmt(p.output)}`;
 }
+
+/** The time-of-day schedule a model is billed on, or null for a flat price. */
+export function priceScheduleFor(modelId: string): PriceSchedule | null {
+  return PRICE_SCHEDULES[modelId.split('/')[0]] ?? null;
+}
+
+function isPeak(schedule: PriceSchedule, at: Date): boolean {
+  if (!schedule.peak.days.includes(at.getUTCDay())) return false;
+  const h = at.getUTCHours();
+  return schedule.peak.hours.some(([from, to]) => h >= from && h < to);
+}
+
+/** 'peak' or 'off-peak' for a model on a schedule, null for a flat price. */
+export function priceBandAt(modelId: string, at: Date = new Date()): 'peak' | 'off-peak' | null {
+  const schedule = priceScheduleFor(modelId);
+  if (!schedule) return null;
+  return isPeak(schedule, at) ? 'peak' : 'off-peak';
+}
+
+const round6 = (n: number) => Math.round(n * 1e6) / 1e6;
+
+/**
+ * What a free model is written with. OpenClaw treats an all-zero cost as "no price" and
+ * counts every call as unpriced, which would flag free models as missing a price. One
+ * millionth of a dollar per 1M tokens makes them priced and, in practice, free: a billion
+ * tokens come to $0.001.
+ */
+const FREE_RATE = 0.000001;
+/**
+ * A cache write with no published rate, as a multiple of the input rate. Vendors that
+ * bill cache writes apart charge more than input (Anthropic: 1.25× for its default
+ * five-minute cache); the ones that do not report cache writes at all never use it.
+ */
+const CACHE_WRITE_FALLBACK = 1.25;
+
+/**
+ * The rates in force for a model at a moment, in the shape OpenClaw's config takes.
+ *
+ * Null when there is nothing to write: no entry, or a dynamic router price (-1), whose
+ * calls OpenClaw then counts as unpriced. A free model (all zero) gets FREE_RATE. A cache
+ * rate the file does not carry falls back to a rate that does not undercount: the input
+ * rate for a cache read (as if the cache gave no discount), CACHE_WRITE_FALLBACK × input
+ * for a cache write.
+ */
+export function priceAt(modelId: string, at: Date = new Date()): ModelCost | null {
+  const p = getPricing(modelId);
+  if (!p || p.input < 0 || p.output < 0) return null;
+  if (p.input === 0 && p.output === 0 && !p.cacheRead && !p.cacheWrite) {
+    return { input: FREE_RATE, output: FREE_RATE, cacheRead: FREE_RATE, cacheWrite: FREE_RATE };
+  }
+  const schedule = priceScheduleFor(modelId);
+  const factor = schedule && !isPeak(schedule, at) ? schedule.offPeakFactor : 1;
+  return {
+    input: round6(p.input * factor),
+    output: round6(p.output * factor),
+    cacheRead: round6((p.cacheRead ?? p.input) * factor),
+    cacheWrite: round6((p.cacheWrite ?? p.input * CACHE_WRITE_FALLBACK) * factor),
+  };
+}
+
+/**
+ * The next moment any of these models changes rate, or null when none is on a schedule.
+ * Every schedule changes on the hour, so the search walks hour marks (up to 8 days).
+ */
+export function nextPriceChange(modelIds: string[], from: Date = new Date()): Date | null {
+  const schedules = [...new Set(modelIds.map(priceScheduleFor).filter((s): s is PriceSchedule => s !== null))];
+  if (!schedules.length) return null;
+  const now = schedules.map((s) => isPeak(s, from));
+  const t = new Date(from);
+  t.setUTCMinutes(0, 0, 0);
+  for (let i = 0; i < 8 * 24; i++) {
+    t.setUTCHours(t.getUTCHours() + 1);
+    if (schedules.some((s, j) => isPeak(s, t) !== now[j])) return new Date(t);
+  }
+  return null;
+}

package/lib/price-schedule-sync.ts

@@ -0,0 +1,133 @@
+/**
+ * Re-sync the agents' prices when a vendor's rate changes with the time of day.
+ *
+ * OpenClaw's `cost` has no notion of time: it prices each call with the rates in its
+ * config at that moment and keeps that cost. DeepSeek bills half price off-peak, so at
+ * every change of band the `rev4a` block is written again with the rates now in force
+ * (`priceAt()` in `buildRev4aProviderConfig()`). A config patch of `models` applies
+ * without a gateway restart.
+ *
+ * A check, not one long timer: at most every minute it compares the bands in force with
+ * the ones last written, and syncs only when they differ. A single timeout to the next
+ * change would fire late after the machine sleeps (a laptop), leaving every agent on
+ * the other band's rates; the check costs a little arithmetic and no I/O. When the next
+ * change is less than a minute away the check is set for that moment, so a change is
+ * applied within a couple of seconds.
+ *
+ * The check runs whether or not a scheduled model is on offer, and skips the sync when
+ * none is: enabling a DeepSeek model later needs no restart to be priced right. A sync
+ * that did not reach every agent is retried every few minutes, not every check — a full
+ * sync holds the server for a few seconds — and at most a few times: an agent busy with
+ * an update, recreate, restore or edit writes the prices itself when it finishes, and one
+ * that stays broken must not keep the server syncing every agent around the clock. A new
+ * change of band is applied at once, whatever retry was pending.
+ */
+import { syncAllAgents } from '@/app/api/gateway/sync';
+import { loadModelsConfig, loadOfferedModels } from '@/lib/model-catalogue';
+import { PRICE_SCHEDULES, nextPriceChange, priceBandAt, priceScheduleFor } from '@/lib/model-pricing';
+
+const CHECK_MS = 60_000;
+/** Past the hour mark, so the band has changed when the sync reads the clock. */
+const AFTER_CHANGE_MS = 2_000;
+const RETRY_MS = 5 * 60_000;
+/** Syncs tried for one band before waiting for the next change (or the next save or restart). */
+const MAX_TRIES = 3;
+
+interface State {
+  timer?: ReturnType<typeof setTimeout>;
+  /**
+   * The bands last written to the agents, e.g. `deepseek:off-peak`. Set by every sync,
+   * complete or not: a sync that misses one agent still writes every other one.
+   */
+  applied?: string;
+  /** Syncs tried for `applied` that missed an agent. */
+  tries?: number;
+  /** When to retry for the agents the last sync missed; unset when nothing is owed. */
+  retryAfter?: number;
+}
+// One timer per process, across dev-mode module reloads.
+const g = globalThis as unknown as { __rev4aPriceSchedule?: State };
+const state: State = (g.__rev4aPriceSchedule ??= {});
+
+/** The band of every scheduled vendor right now, as one comparable string. */
+function bandsNow(at: Date): string {
+  return Object.keys(PRICE_SCHEDULES)
+    .map((vendor) => `${vendor}:${priceBandAt(`${vendor}/`, at)}`)
+    .join(',');
+}
+
+function schedule(): void {
+  if (state.timer) clearTimeout(state.timer);
+  const next = nextPriceChange(loadModelsConfig().map((m) => m.id));
+  const untilChange = next ? next.getTime() - Date.now() + AFTER_CHANGE_MS : Infinity;
+  state.timer = setTimeout(check, Math.max(1_000, Math.min(CHECK_MS, untilChange)));
+  state.timer.unref?.();
+}
+
+/** Write `bands` into every agent; on a miss, owe a retry until MAX_TRIES. */
+function sync(bands: string): void {
+  let ok = false;
+  let summary = '';
+  try {
+    const outcome = syncAllAgents();
+    ok = outcome.ok;
+    summary = outcome.summary;
+  } catch (e) {
+    summary = (e as Error).message;
+  }
+  state.applied = bands;
+  if (ok) {
+    state.tries = 0;
+    state.retryAfter = undefined;
+    console.log(`[rev4a] Price band now ${bands}: ${summary}`);
+    return;
+  }
+  state.tries = (state.tries ?? 0) + 1;
+  if (state.tries < MAX_TRIES) {
+    state.retryAfter = Date.now() + RETRY_MS;
+    console.warn(`[rev4a] Price band now ${bands}, sync incomplete: ${summary} Retrying in ${RETRY_MS / 60_000} min.`);
+  } else {
+    state.retryAfter = undefined;
+    console.warn(`[rev4a] Price band now ${bands}, sync incomplete after ${state.tries} tries: ${summary} Not retried until the next change; Sync All Agents applies it sooner.`);
+  }
+}
+
+function check(): void {
+  try {
+    const bands = bandsNow(new Date());
+    const offered = loadOfferedModels().some((m) => priceScheduleFor(m.id));
+    if (bands !== state.applied) {
+      // A change of band: write it now, whatever retry was owed for the previous one.
+      state.tries = 0;
+      state.retryAfter = undefined;
+      if (offered) sync(bands);
+      else state.applied = bands; // nothing on offer is priced by time of day
+    } else if (state.retryAfter && Date.now() >= state.retryAfter) {
+      if (offered) sync(bands);
+      else state.retryAfter = undefined;
+    }
+  } catch (e) {
+    console.warn(`[rev4a] Price band check failed: ${(e as Error).message}`);
+  } finally {
+    try {
+      schedule();
+    } catch (e) {
+      // Never let the chain die: check again in a minute.
+      console.warn(`[rev4a] Price band check could not be scheduled: ${(e as Error).message}`);
+      state.timer = setTimeout(check, CHECK_MS);
+      state.timer.unref?.();
+    }
+  }
+}
+
+/**
+ * Start the checks; called once at server start, after the startup sync. When that sync
+ * reached every agent, the bands it wrote count as applied; otherwise the first check
+ * (a minute later) writes them.
+ */
+export function startPriceScheduleSync(startupSynced: boolean): void {
+  state.applied = startupSynced ? bandsNow(new Date()) : undefined;
+  state.tries = 0;
+  state.retryAfter = undefined;
+  schedule();
+}

package/lib/utils/format.ts

@@ -4,6 +4,44 @@ export function formatUsd(value: number | null | undefined): string {
   return `$${Number(value ?? 0).toFixed(2)}`;
 }
 
+/** Megabytes as MB, GB or TB with the precision a reader wants: '692 MB', '1.6 GB'. */
+export function formatMb(mb: number | null | undefined): string {
+  if (mb === null || mb === undefined || !Number.isFinite(mb)) return '—';
+  if (mb >= 1024 * 1024) return `${(mb / 1024 / 1024).toFixed(2)} TB`;
+  if (mb >= 1024) return `${(mb / 1024).toFixed(1)} GB`;
+  return `${Math.round(mb)} MB`;
+}
+
+/** A CPU share in percent, with the decimals a small figure needs (an idle agent is 0.02 % of Docker's cores). */
+export function formatSharePercent(percent: number | null | undefined): string {
+  if (percent === null || percent === undefined || !Number.isFinite(percent)) return '—';
+  if (percent === 0) return '0%';
+  if (percent < 0.01) return '<0.01%';
+  if (percent < 1) return `${percent.toFixed(2)}%`;
+  if (percent < 10) return `${percent.toFixed(1)}%`;
+  return `${Math.round(percent)}%`;
+}
+
+/** Bytes per second as B/s, KB/s or MB/s. */
+export function formatRate(bytesPerSecond: number | null | undefined): string {
+  if (bytesPerSecond === null || bytesPerSecond === undefined || !Number.isFinite(bytesPerSecond)) return '—';
+  if (bytesPerSecond >= 1024 * 1024) return `${(bytesPerSecond / 1024 / 1024).toFixed(1)} MB/s`;
+  if (bytesPerSecond >= 1024) return `${(bytesPerSecond / 1024).toFixed(1)} KB/s`;
+  return `${Math.round(bytesPerSecond)} B/s`;
+}
+
+/**
+ * Dollars with the precision a small figure needs: an agent's day can be a fraction of a
+ * cent, which formatUsd would show as $0.00. Used wherever agent costs are shown.
+ */
+export function formatCost(value: number | null | undefined): string {
+  const v = Number(value ?? 0);
+  if (!v) return '$0.00';
+  if (v < 0.01) return `$${v.toFixed(4)}`;
+  if (v < 1) return `$${v.toFixed(3)}`;
+  return `$${v.toFixed(2)}`;
+}
+
 export function formatUsdOrDash(value: number | null | undefined): string {
   if (value === null || value === undefined || !Number.isFinite(Number(value))) return '-';
   return formatUsd(value);