openmausbot 0.1.85 → 0.1.87

package/dist-server/server/spend.js

@@ -1,33 +1,76 @@
+// Spend limits over the usage ledger: what this workspace has spent this
+// month against its cap, the refusal a turn gets once the cap is reached,
+// and the one-per-month notices when the month crosses the warning
+// threshold and the cap. The figure is every cost in the ledger: what
+// engines reported (on a workspace of personal subscriptions, their
+// equivalents too) plus the estimates booked for engines that report tokens
+// but no price (server/model-prices.ts). A turn on an unpriced model counts
+// nothing. Enforced only with the `budgets` entitlement; without it the
+// setting is inert.
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { entitled } from "./enterprise.js";
-import { readUsage } from "./usage-ledger.js";
+import { readUsage, usageRowKey } from "./usage-ledger.js";
 const DEFAULT_WARN_AT_PERCENT = 80;
 const CACHE_MS = 15_000;
 // Every turn start asks; reading the month file each time would be silly.
+// A read keeps the keys of the rows it summed, so a booked row can be told
+// apart from the same row read back later.
 const cache = new Map();
+// Booked turns whose ledger row may not be on disk yet: dataDir → row key →
+// cost. The append is asynchronous, and a turn that ran longer than CACHE_MS
+// would otherwise be re-read out of the month before its own row landed.
+const unwritten = new Map();
 function monthOf(now) {
     return now.toISOString().slice(0, 7);
 }
-/** Reported cost this month so far, from the ledger, cached briefly. */
+const costOf = (value) => (typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0);
+/** Reported and estimated cost this month so far: the ledger file (read at
+ * most every CACHE_MS) plus turns booked since whose rows have not landed. */
 export function monthToDateSpend(dataDir, now = new Date()) {
     const month = monthOf(now);
-    const hit = cache.get(dataDir);
-    if (hit && hit.month === month && now.getTime() - hit.at < CACHE_MS)
-        return hit.spentUsd;
-    const from = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
-    const spentUsd = readUsage(dataDir, { from, to: now }).reduce((sum, row) => sum + (typeof row.costUsd === "number" && Number.isFinite(row.costUsd) ? row.costUsd : 0), 0);
-    cache.set(dataDir, { at: now.getTime(), month, spentUsd });
-    return spentUsd;
-}
-/** Called right after a turn is booked, so the next check sees it without
- * waiting for the ledger's append to land or the cache to expire. */
-export function noteSpend(dataDir, costUsd, now = new Date()) {
-    const hit = cache.get(dataDir);
-    if (hit && hit.month === monthOf(now) && typeof costUsd === "number" && Number.isFinite(costUsd) && costUsd > 0) {
-        hit.spentUsd += costUsd;
+    let read = cache.get(dataDir);
+    if (!read || read.month !== month || now.getTime() - read.at >= CACHE_MS) {
+        const from = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+        const rows = readUsage(dataDir, { from, to: now });
+        read = { at: now.getTime(), month, fileUsd: rows.reduce((sum, row) => sum + costOf(row.costUsd), 0), keys: new Set(rows.map(usageRowKey)) };
+        cache.set(dataDir, read);
     }
+    let pending = 0;
+    for (const [key, entry] of unwritten.get(dataDir) ?? []) {
+        if (entry.month === month && !read.keys.has(key))
+            pending += entry.costUsd;
+    }
+    return read.fileUsd + pending;
+}
+/** Called as a turn is booked, with the ledger's write for its row
+ * (appendUsage's promise). The cost counts from memory at once; when the
+ * row lands it moves into the cached read, and a re-read that already sees
+ * the row never counts it twice. A write that failed stops counting, as
+ * the ledger has no row for it. */
+export function noteSpend(dataDir, row, written) {
+    const costUsd = costOf(row.costUsd);
+    if (!costUsd)
+        return;
+    const key = usageRowKey(row);
+    const month = row.at.slice(0, 7);
+    const entries = unwritten.get(dataDir) ?? new Map();
+    unwritten.set(dataDir, entries);
+    entries.set(key, { month, costUsd });
+    void written.then((landed) => {
+        entries.delete(key);
+        if (entries.size === 0 && unwritten.get(dataDir) === entries)
+            unwritten.delete(dataDir);
+        const read = cache.get(dataDir);
+        if (landed && read && read.month === month && !read.keys.has(key)) {
+            read.fileUsd += costUsd;
+            read.keys.add(key);
+        }
+    });
 }
 export function resetSpendCacheForTests() {
     cache.clear();
+    unwritten.clear();
 }
 /** The cap and where the month stands against it; null when there is no
  * enforceable cap (no entitlement, or none set). */
@@ -59,3 +102,55 @@ export function assertWithinBudget(cfg, dataDir, now = new Date(), isEntitled =
         return;
     throw Object.assign(new Error(`this workspace has reached its monthly spend limit of $${usd(state.monthlyUsd)} — an admin can raise it under Settings → Usage`), { status: 409, code: "spend_cap" });
 }
+const ALERTS_FILE = "alerts.json";
+function readMarks(dataDir) {
+    try {
+        const value = JSON.parse(readFileSync(join(dataDir, "usage", ALERTS_FILE), "utf8"));
+        if (typeof value !== "object" || value === null)
+            return null;
+        const marks = value;
+        return typeof marks.month === "string" && typeof marks.monthlyUsd === "number" ? marks : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The notice this booking should raise, if any: the cap the first time the
+ * month reaches it, the warning the first time it crosses the threshold, and
+ * nothing again for either that month. A new month, or a different cap, is a
+ * new budget and starts over. Marks live beside the ledger so a restart does
+ * not repeat them; if they cannot be written the notice is still sent once
+ * for this run. */
+export function takeSpendAlert(dataDir, state) {
+    if (!state || (!state.warn && !state.exceeded))
+        return null;
+    const saved = readMarks(dataDir) ?? memoryMarks.get(dataDir) ?? null;
+    const marks = saved && saved.month === state.month && saved.monthlyUsd === state.monthlyUsd
+        ? saved
+        : { month: state.month, monthlyUsd: state.monthlyUsd };
+    const alert = state.exceeded && !marks.cap ? "cap" : state.warn && !marks.warn && !marks.cap ? "warn" : null;
+    if (!alert)
+        return null;
+    // Reaching the cap also answers the warning: one notice, the stronger one.
+    const next = { ...marks, warn: true, ...(alert === "cap" ? { cap: true } : {}) };
+    memoryMarks.set(dataDir, next);
+    try {
+        mkdirSync(join(dataDir, "usage"), { recursive: true, mode: 0o700 });
+        writeFileSync(join(dataDir, "usage", ALERTS_FILE), JSON.stringify(next), { mode: 0o600 });
+    }
+    catch {
+        /* bookkeeping must never take down the turn */
+    }
+    return alert;
+}
+const memoryMarks = new Map();
+export function resetSpendAlertsForTests() {
+    memoryMarks.clear();
+}
+/** The notice's words. English like the server's other notification titles. */
+export function spendAlertText(alert, state) {
+    const spent = `$${state.spentUsd.toFixed(2)} of $${usd(state.monthlyUsd)} spent this month (${state.month})`;
+    return alert === "cap"
+        ? { title: "Monthly spend limit reached", body: `${spent}. New turns are refused until an admin raises the limit under Settings → Usage.` }
+        : { title: `Spend is at ${state.percent}% of the monthly limit`, body: `${spent}. New turns stop when the limit is reached.` };
+}

package/dist-server/server/steer-queue.js

@@ -72,6 +72,8 @@ export function queueSteeredMessage(botId, threadId, text, options = {}) {
         reason: options.reason,
         unattended: options.unattended,
         peerAsk: options.peerAsk,
+        sender: options.sender,
+        trigger: options.trigger,
     };
     saveChatFollowup({ id, kind: "bot", ownerId: botId, threadId, payload: item });
     entry.items.push(item);
@@ -79,14 +81,15 @@ export function queueSteeredMessage(botId, threadId, text, options = {}) {
     changed();
     return { id };
 }
-/** Where a thread stands among this bot's threads waiting for a free slot:
+/** Where a thread stands among this bot's threads waiting for the bot to
+ * become available (a full slot list or an active room turn):
  * 1 for the next to start. The drain visits queues in insertion order, so
  * insertion order is the line. Null when nothing of this bot's is waiting
  * on that thread. */
 export function queuedThreadPosition(botId, threadId) {
     let position = 0;
     for (const [candidate, entry] of queues) {
-        if (entry.botId !== botId || !entry.items.some((item) => item.reason === "capacity"))
+        if (entry.botId !== botId || !entry.items.some((item) => item.reason === "capacity" || item.reason === "group-turn"))
             continue;
         position += 1;
         if (candidate === threadId)
@@ -140,6 +143,7 @@ export function drainSteeredMessages(store, run, isBlocked) {
                 sendId: item.sendId,
                 queueId: item.messageId,
                 peerAsk: item.peerAsk,
+                sender: item.sender,
             }));
         }
         const last = appended.at(-1);
@@ -153,7 +157,9 @@ export function drainSteeredMessages(store, run, isBlocked) {
         const running = run(entry.botId, threadId, prompt, last, appended.map((message) => message.id), 
         // one unattended line makes the whole drained turn unattended: a
         // person's words in the same queue cannot re-attend a bot's own
-        entry.items.some((item) => item.unattended === true));
+        entry.items.some((item) => item.unattended === true), 
+        // the first waiting line is the one that starts this turn
+        { trigger: entry.items[0].trigger, sender: entry.items[0].sender, peerAsk: entry.items[0].peerAsk });
         void Promise.resolve(running).then(() => settleChatFollowups(ids, null), () => settleChatFollowups(ids, "interrupted")).catch((error) => console.warn("steer-queue: could not settle durable follow-up", error));
     }
 }