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]>
144 lines
9.2 KiB
JavaScript
144 lines
9.2 KiB
JavaScript
// Row 125 (#1619, REQ-LIMIT-3, REQ-LIMIT-4): the token-limit check on its own. It is pure, so
|
|
// these tests pass it limits and records and read its answers; no loader, store or file.
|
|
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import * as check from "../limit-check/token-limit/index.mjs";
|
|
|
|
const SINCE = "2026-10-18T00:00:00.000Z";
|
|
const NOW = "2026-10-18T12:00:00.000Z";
|
|
const subject = (over = {}) => ({ instance: "coder", provider: "anthropic", model: "opus", account: null, ...over });
|
|
let seq = 0;
|
|
const known = (over = {}, counts = [10, 20, 30, 40]) => {
|
|
const [input, output, cacheWrite, cacheRead] = counts;
|
|
return { at: "2026-10-18T06:00:00.000Z", run: "r1", turn: `t${++seq}`, source: "pi-session", instance: "coder",
|
|
provider: "anthropic", model: "opus", account: null, status: "known", input, output, cacheWrite, cacheRead, ...over };
|
|
};
|
|
const unknown = (over = {}) => ({ ...known(over), status: "unknown", input: null, output: null, cacheWrite: null, cacheRead: null });
|
|
const limits = tokens => ({ tokens });
|
|
const args = (tokens, records, over = {}) => ({ business: "demo", limits: limits(tokens), subject: subject(), records, now: NOW, ...over });
|
|
|
|
test("REQ-LIMIT-3 token-limit exports interface version 2 with mayLaunch, mustStop and report", () => {
|
|
assert.equal(check.interfaceVersion, 2);
|
|
for (const name of ["mayLaunch", "mustStop", "report"]) assert.equal(typeof check[name], "function");
|
|
});
|
|
|
|
test("REQ-LIMIT-3 each subject kind refuses at its limit and allows under it", () => {
|
|
const records = [known(), known()]; // 100 tokens each, 200 in all
|
|
const cases = [
|
|
{ tokens: { instances: { coder: { limit: 200, since: SINCE } } }, path: ["tokens", "instances", "coder"], subject: {} },
|
|
{ tokens: { providers: { anthropic: { limit: 200, since: SINCE } } }, path: ["tokens", "providers", "anthropic"], subject: {} },
|
|
{ tokens: { models: { anthropic: { opus: { limit: 200, since: SINCE } } } }, path: ["tokens", "models", "anthropic", "opus"], subject: {} },
|
|
{ tokens: { keys: { k1: { limit: 200, since: SINCE } } }, path: ["tokens", "keys", "k1"], subject: { account: "k1" },
|
|
records: records.map(r => ({ ...r, account: "k1" })) },
|
|
];
|
|
for (const c of cases) {
|
|
const recs = c.records ?? records;
|
|
const at = args(c.tokens, recs, { subject: subject(c.subject) });
|
|
const hit = { path: c.path, limit: 200, count: 200, unknownTurns: 0 };
|
|
assert.deepEqual(check.mayLaunch(at), { allow: false, hit }, c.path.join("."));
|
|
assert.deepEqual(check.mustStop(at), { stop: true, hit }, c.path.join("."));
|
|
const over = JSON.parse(JSON.stringify(c.tokens).replace('"limit":200', '"limit":201'));
|
|
assert.deepEqual(check.mayLaunch(args(over, recs, { subject: subject(c.subject) })), { allow: true }, c.path.join("."));
|
|
assert.deepEqual(check.mustStop(args(over, recs, { subject: subject(c.subject) })), { stop: false }, c.path.join("."));
|
|
}
|
|
});
|
|
|
|
test("REQ-LIMIT-3 a limit covers only its own subject's records and launches", () => {
|
|
const tokens = { instances: { coder: { limit: 150, since: SINCE } }, models: { anthropic: { opus: { limit: 150, since: SINCE } } } };
|
|
const records = [known({ instance: "tester", model: "sonnet" }), known({ instance: "tester", model: "sonnet" })];
|
|
// Another instance's and another model's records count toward neither limit.
|
|
assert.deepEqual(check.mayLaunch(args(tokens, records)), { allow: true });
|
|
// A launch of another subject isn't covered by a limit that is over.
|
|
const full = [known(), known()];
|
|
assert.deepEqual(check.mayLaunch(args(tokens, full, { subject: subject({ instance: "tester", model: "sonnet" }) })), { allow: true });
|
|
// A model limit is per provider: the same model name under another provider doesn't match it.
|
|
assert.deepEqual(check.mayLaunch(args({ models: { anthropic: { opus: { limit: 150, since: SINCE } } } },
|
|
full.map(r => ({ ...r, provider: "other" })), { subject: subject({ provider: "other" }) })), { allow: true });
|
|
// A provider limit counts only that provider's records and covers only its launches.
|
|
const byProvider = { providers: { anthropic: { limit: 150, since: SINCE } } };
|
|
const other = full.map(r => ({ ...r, provider: "other" }));
|
|
assert.deepEqual(check.mayLaunch(args(byProvider, other)), { allow: true });
|
|
assert.equal(check.report(args(byProvider, other))[0].count, 0);
|
|
assert.deepEqual(check.mayLaunch(args(byProvider, full, { subject: subject({ provider: "other" }) })), { allow: true });
|
|
assert.equal(check.mayLaunch(args(byProvider, full)).allow, false);
|
|
});
|
|
|
|
test("REQ-LIMIT-4 only known records count; an unknown turn adds nothing and is counted apart", () => {
|
|
const tokens = { instances: { coder: { limit: 100, since: SINCE } } };
|
|
const u = unknown({ run: "r2", turn: "u1" });
|
|
const records = [known({}, [1, 2, 3, 4]), u, { ...u, source: "other-source" }, unknown({ run: "r2", turn: "u2" })];
|
|
assert.deepEqual(check.mayLaunch(args(tokens, records)), { allow: true });
|
|
const [entry] = check.report(args(tokens, records));
|
|
assert.deepEqual(entry, { path: ["tokens", "instances", "coder"], limit: 100, since: SINCE, count: 10,
|
|
kinds: { input: 1, output: 2, cacheWrite: 3, cacheRead: 4 }, unknownTurns: 2 });
|
|
// With no usage source, every turn is the '@none' unknown record: the count is 0.
|
|
const none = [unknown({ source: "@none" }), unknown({ source: "@none" })];
|
|
const [empty] = check.report(args(tokens, none));
|
|
assert.equal(empty.count, 0);
|
|
assert.equal(empty.unknownTurns, 2);
|
|
assert.deepEqual(check.mayLaunch(args(tokens, none)), { allow: true });
|
|
});
|
|
|
|
test("REQ-LIMIT-3 a reset moves since: records before it no longer count", () => {
|
|
const tokens = { instances: { coder: { limit: 100, since: "2026-10-18T07:00:00.000Z" } } };
|
|
const records = [known({ at: "2026-10-18T06:59:59.999Z" }), known({ at: "2026-10-18T07:00:00.000Z" }, [1, 1, 1, 1])];
|
|
assert.deepEqual(check.mayLaunch(args(tokens, records)), { allow: true });
|
|
assert.equal(check.report(args(tokens, records))[0].count, 4);
|
|
const before = { instances: { coder: { limit: 100, since: SINCE } } };
|
|
assert.equal(check.mayLaunch(args(before, records)).allow, false);
|
|
});
|
|
|
|
test("REQ-LIMIT-3 limit 0 refuses with no records; the first limit hit in file order is named", () => {
|
|
assert.deepEqual(check.mayLaunch(args({ instances: { coder: { limit: 0, since: SINCE } } }, [])),
|
|
{ allow: false, hit: { path: ["tokens", "instances", "coder"], limit: 0, count: 0, unknownTurns: 0 } });
|
|
const tokens = { instances: { coder: { limit: 50, since: SINCE } }, providers: { anthropic: { limit: 50, since: SINCE } } };
|
|
assert.deepEqual(check.mustStop(args(tokens, [known()])).hit.path, ["tokens", "instances", "coder"]);
|
|
});
|
|
|
|
test("REQ-LIMIT-3 a key limit is not enforced while every record's account is null (decision 150 Q1)", () => {
|
|
const tokens = { keys: { k1: { limit: 1, since: SINCE } }, instances: { coder: { limit: 1000, since: SINCE } } };
|
|
const report = check.report(args(tokens, [known()]));
|
|
assert.deepEqual(report, [
|
|
{ path: ["tokens", "instances", "coder"], limit: 1000, since: SINCE, count: 100,
|
|
kinds: { input: 10, output: 20, cacheWrite: 30, cacheRead: 40 }, unknownTurns: 0 },
|
|
{ path: ["tokens", "keys", "k1"], limit: 1, since: SINCE, notEnforced: "no records name a key" },
|
|
]);
|
|
// A launch whose subject has no account isn't covered by a key limit.
|
|
assert.deepEqual(check.mayLaunch(args(tokens, [known()])), { allow: true });
|
|
// Once a record names an account, the key limit is counted.
|
|
const named = check.report(args(tokens, [known({ account: "k1" })]));
|
|
assert.equal(named[1].count, 100);
|
|
});
|
|
|
|
test("REQ-LIMIT-3 counts past the safe integer range come back as digit strings", () => {
|
|
const big = Number.MAX_SAFE_INTEGER;
|
|
const tokens = { instances: { coder: { limit: 1, since: SINCE } } };
|
|
const [entry] = check.report(args(tokens, [known({}, [big, big, 0, 0])]));
|
|
assert.equal(entry.count, (2n * BigInt(big)).toString());
|
|
assert.equal(entry.kinds.input, big);
|
|
assert.equal(check.mustStop(args(tokens, [known({}, [big, big, 0, 0])])).hit.count, (2n * BigInt(big)).toString());
|
|
});
|
|
|
|
test("REQ-LIMIT-4 bad records or times throw a code, and the check reads nothing but its arguments", () => {
|
|
const tokens = { instances: { coder: { limit: 1, since: SINCE } } };
|
|
for (const fn of ["mayLaunch", "mustStop", "report"]) {
|
|
assert.throws(() => check[fn](args(tokens, null)), { code: "bad-records" }, fn);
|
|
assert.throws(() => check[fn](args(tokens, [known({ at: "yesterday" })])), { code: "bad-time" }, fn);
|
|
assert.throws(() => check[fn](args(tokens, [known({}, [-1, 0, 0, 0])])), { code: "bad-record" }, fn);
|
|
assert.throws(() => check[fn](args({ instances: { coder: { limit: 1, since: "never" } } }, [known()])), { code: "bad-time" }, fn);
|
|
}
|
|
const input = args(tokens, [known()]);
|
|
const copy = structuredClone(input);
|
|
check.mayLaunch(input); check.mustStop(input); check.report(input);
|
|
assert.deepEqual(input, copy);
|
|
});
|
|
|
|
test("REQ-LIMIT-3 no token limits: every launch is allowed and the report is empty", () => {
|
|
for (const l of [{}, { tokens: {} }, { agents: 3 }]) {
|
|
const a = { business: "demo", limits: l, subject: subject(), records: [known()], now: NOW };
|
|
assert.deepEqual(check.mayLaunch(a), { allow: true });
|
|
assert.deepEqual(check.mustStop(a), { stop: false });
|
|
assert.deepEqual(check.report(a), []);
|
|
}
|
|
});
|