Files
stack/packages/business/src/launch.mjs
T
jason.woltjeandClaude Opus 5.5 aa625565f6 bus, cli, webui: token limits per instance, model, provider and key (row 125, #1619)
Adds token limits under launch.limits.tokens (instances, providers, keys,
models.P.M). Core (packages/bus/src/limits.mjs) reads the organization
file and the per-turn usage records row 124 writes, then asks every
switched-on limit-check plug-in; the first refusal wins. A limit no
switched-on check reports reads "not enforced". The limit-check kind is
interface 2 (mayLaunch, mustStop, report); a v1 check is refused at load.
The shipped token-limit check is pure and counts known end records only;
unknown turns add nothing and are shown as their own count.

The launcher refuses limit-reached through the host's mayLaunch op, or
limit-check-failed naming the check. The broker asks mustStop after a
usage end and stops the run at its next receive or state. Settings stamps
since on a new or changed limit and runs reset; launch.mjs and
business.mjs validate the shape. Readers: mosaic limits and mosaic limits
reset, the bus limits view, the Console /api/bus/limits route and the
Settings token table with Reset. Key limits stay "not enforced" until
row 126 names accounts on records.

Owner Dewey, design under lead decision 150.
Reviewer Filbert: r1 changes (comment 28965), r2 approve (28981), r3
approve (28996) on candidate manifest 8b71c405...fe56 after the rebase
onto row 164 (37 of 38 paths with identical +/- lines, TOOLS.md:621
bracket). Decision 123 go on the bus.js hunk from Mos (mos-0814). Sage
gate on b6827d19e: 25 steps, all rc 0 (15 packages, 10 script suites), 2295 node tests and 422 script selftests, 0 failed, 20:03:25Z to 20:08:08Z, network sage-r125_default removed.

Live stays as pinned. Not part of the 8e7ea89a1 window.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-18 15:21:49 -05:00

122 lines
5.4 KiB
JavaScript

// REQ-LIMIT-1: editable concurrency policy, never a compiled-in capacity ceiling.
import { requireObject, requireId, requireString, rejectUnknownKeys } from "./util.mjs";
import { refuse } from "./errors.mjs";
const name = (value, at) => requireString(value, at, { max: 200 });
const count = (value, at) => {
if (!Number.isSafeInteger(value) || value < 0) refuse(`${at} must be a whole number of 0 or more`);
return value;
};
const own = (object, key) => Object.hasOwn(object ?? {}, key) ? object[key] : undefined;
export function checkModels(value, where = "launch.models") {
requireObject(value, where);
if (!Object.keys(value).length) refuse(`${where} must name at least one model`);
return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
requireId(key, where);
requireObject(entry, `${where}.${key}`);
rejectUnknownKeys(entry, ["provider", "model"], `${where}.${key}`);
return [key, {
provider: name(entry.provider, `${where}.${key}.provider`),
model: name(entry.model, `${where}.${key}.model`),
}];
}));
}
// Row 125 (#1619, REQ-LIMIT-3): one token limit, a count of 0 or more and the
// canonical time it was set or last reset. The settings writer stamps `since`.
const SINCE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
const tokenLimit = (value, at) => {
requireObject(value, at);
rejectUnknownKeys(value, ["limit", "since"], at);
const since = value.since;
if (typeof since !== "string" || !SINCE.test(since) || Number.isNaN(Date.parse(since)) ||
new Date(since).toISOString() !== since) refuse(`${at}.since must be a canonical timestamp`);
return { limit: count(value.limit, `${at}.limit`), since };
};
const tokenMap = (value, at, key, each) => {
requireObject(value, at);
return Object.fromEntries(Object.entries(value).map(([k, v]) => [key(k, at), each(v, `${at}.${k}`)]));
};
// launch.limits.tokens: instances, providers, models (per provider) and keys, each optional.
export function checkTokenLimits(value, where = "launch.limits.tokens") {
requireObject(value, where);
rejectUnknownKeys(value, ["instances", "providers", "models", "keys"], where);
const out = {};
if (Object.hasOwn(value, "instances")) out.instances = tokenMap(value.instances, `${where}.instances`, requireId, tokenLimit);
if (Object.hasOwn(value, "providers")) out.providers = tokenMap(value.providers, `${where}.providers`, name, tokenLimit);
if (Object.hasOwn(value, "models")) {
out.models = tokenMap(value.models, `${where}.models`, name, (models, at) => tokenMap(models, at, name, tokenLimit));
}
// A key is a name until row 126 names the accounts.
if (Object.hasOwn(value, "keys")) out.keys = tokenMap(value.keys, `${where}.keys`, requireId, tokenLimit);
return out;
}
export function checkLimits(value = {}, where = "launch.limits") {
requireObject(value, where);
rejectUnknownKeys(value, ["total", "providers", "models", "tokens"], where);
const out = {};
if (Object.hasOwn(value, "total")) out.total = count(value.total, `${where}.total`);
if (Object.hasOwn(value, "providers")) {
requireObject(value.providers, `${where}.providers`);
out.providers = Object.fromEntries(Object.entries(value.providers).map(([provider, limit]) => {
return [name(provider, where), count(limit, `${where}.providers.${provider}`)];
}));
}
if (Object.hasOwn(value, "models")) {
requireObject(value.models, `${where}.models`);
out.models = Object.fromEntries(Object.entries(value.models).map(([provider, models]) => {
name(provider, where);
requireObject(models, where);
return [provider, Object.fromEntries(Object.entries(models).map(([model, limit]) => {
return [name(model, where), count(limit, `${where}.models.${provider}.${model}`)];
}))];
}));
}
if (Object.hasOwn(value, "tokens")) out.tokens = checkTokenLimits(value.tokens, `${where}.tokens`);
return out;
}
export function usageCounts(sessions, business) {
const running = sessions.filter(session => session.business === business);
const providerCounts = new Map();
const modelCounts = new Map();
for (const session of running) {
const { provider, model } = session;
if (typeof provider !== "string" || typeof model !== "string") {
refuse("running session has no exact provider/model; reconcile before launching");
}
providerCounts.set(provider, (providerCounts.get(provider) ?? 0) + 1);
if (!modelCounts.has(provider)) modelCounts.set(provider, new Map());
const models = modelCounts.get(provider);
models.set(model, (models.get(model) ?? 0) + 1);
}
const providers = Object.fromEntries(providerCounts);
const models = Object.fromEntries([...modelCounts].map(([provider, counts]) => {
return [provider, Object.fromEntries(counts)];
}));
return { total: running.length, providers, models };
}
export function limitHit(sessions, business, limits, selected) {
const usage = usageCounts(sessions, business);
const { provider, model } = selected;
const checks = [
["total", limits.total, usage.total],
["provider", own(limits.providers, provider), own(usage.providers, provider) ?? 0],
["model", own(own(limits.models, provider), model), own(own(usage.models, provider), model) ?? 0],
];
for (const [scope, limit, running] of checks) {
if (limit !== undefined && running >= limit) {
return {
scope, limit, running,
...(scope !== "total" ? { provider } : {}),
...(scope === "model" ? { model } : {}),
};
}
}
return null;
}