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 onb6827d19e: 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 the8e7ea89a1window. Co-Authored-By: Claude Opus 5.5 <[email protected]>
122 lines
5.4 KiB
JavaScript
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;
|
|
}
|