Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
routing: a request's row is worked out once for each route the trace sends, not again on every update (#1481)
yetoneda058fc9956d
diff --git a/internal/gui/assets/plugins/routing/client.js b/internal/gui/assets/plugins/routing/client.jsindex 75691030b..bd9b03119 100644--- a/internal/gui/assets/plugins/routing/client.js+++ b/internal/gui/assets/plugins/routing/client.js@@ -2652,19 +2652,37 @@ function routingPage(part) {if (rowsMoved) metaFit();renderActs(rs);}- // rowOf: a request's row, kept while what it says is the same- function rowOf(r) {- const lang = document.documentElement.lang;+ // rowSays: what a request's row says, worked out once for each route the+ // trace sends. A trace update replaces only the routes that changed+ // (poll's routes.set), yet every update worked out again every row in+ // sight: its outcome, metrics, token breakdown, title and a JSON+ // signature, ~150 MB of garbage a minute at a request a second, which+ // WebKit let pile up to a gigabyte while the window sat on Routing+ // (#1481). Kept by the route object, it is worked out again only for a+ // new route, or when the language, the metrics shown, the agent's name+ // or icon, or the cost's wording changes.+ const rowSaid = new WeakMap(); // route → { lang, shows, name, icon, cost, said, how, tr, ag, meta, metrics, title, sig }+ function rowSays(r) {+ const lang = document.documentElement.lang, shows = visibleMetrics.join();+ const ag = agentOf(r.agent), name = agentName(r.agent), icon = ag?.icon, cost = routeCost(r);+ let s = rowSaid.get(r);+ if (s && s.lang === lang && s.shows === shows && s.name === name && s.icon === icon && s.cost === cost) { s.ag = ag; return s; }const [said, how, tr] = outcome(r);- const sel = String(pinned ? pinned.id === r.id : cur?.id === r.id);- const ag = agentOf(r.agent);const meta = [];if (r.tries.length > 1) meta.push(t("{n} tries", { n: r.tries.length }));const metrics = requestMetrics(r, how);// all the row says, and its titlesconst title = reqTitle(r, how, tr);- const sig = JSON.stringify([lang, said, how, title, r.time, r.agent, agentName(r.agent), ag?.icon, r.model, r.provider, tagKind(r), r.effort,- tr?.effort, tr?.picked, tr?.fixed, tr?.fast, tr?.swapped && tr.done && tryOk(tr) ? [tr.model, tr.served] : 0, tr?.routed && tr.done && tryOk(tr) ? tr.served : 0, tr?.done && tryOk(tr) ? tr.upstream : 0, meta, metrics, routeCost(r)]);+ const sig = JSON.stringify([lang, said, how, title, r.time, r.agent, name, ag?.icon, r.model, r.provider, tagKind(r), r.effort,+ tr?.effort, tr?.picked, tr?.fixed, tr?.fast, tr?.swapped && tr.done && tryOk(tr) ? [tr.model, tr.served] : 0, tr?.routed && tr.done && tryOk(tr) ? tr.served : 0, tr?.done && tryOk(tr) ? tr.upstream : 0, meta, metrics, cost]);+ s = { lang, shows, name, icon, cost, said, how, tr, ag, meta, metrics, title, sig };+ rowSaid.set(r, s);+ return s;+ }+ // rowOf: a request's row, kept while what it says is the same+ function rowOf(r) {+ const sel = String(pinned ? pinned.id === r.id : cur?.id === r.id);+ const { said, how, tr, ag, meta, metrics, title, sig } = rowSays(r);let x = reqRows.get(r.id);if (!x || x.sig !== sig) {const row = x = { sig, b: reqRow(r, said, how, tr, ag, meta, metrics, title) };diff --git a/internal/gui/tests/routing-row-reuse.test.cjs b/internal/gui/tests/routing-row-reuse.test.cjsnew file mode 100644index 000000000..18fa6bddb--- /dev/null+++ b/internal/gui/tests/routing-row-reuse.test.cjs@@ -0,0 +1,127 @@+// Run with Node's test runner and Playwright on the module path; see README.md.+// What a request's row in Routing says is worked out once for each route+// the gateway's trace sends, not again on every update (#1481). A trace+// update replaces only the routes that changed, yet each one redrew every+// row in sight from scratch: its outcome, its metrics with their token+// breakdown, its title and a JSON signature of all of it, ~150 MB of+// garbage a minute at one request a second. WebKit's WebContent let that+// pile up to a gigabyte while the window sat on Routing.+//+// The test counts the token breakdowns the page works out (each row's+// Tokens metric carries one in its title) while new requests come in one+// at a time over forty listed: worked out again for every row, that is+// forty and more an update; kept, it is one for the new row. A request+// that changed (answered after it was under way) and a new language are+// still drawn anew. MAGPIE_ROUTING_ASSETS points the page at an older+// asset tree, to watch this go red there.+const assert = require("node:assert/strict");+const fs = require("node:fs/promises");+const path = require("node:path");+const { test } = require("node:test");+const { chromium, webkit } = require("playwright");+const engines = process.env.BROWSER ? [process.env.BROWSER] : ["chromium", "webkit"];++const assets = path.resolve(process.env.MAGPIE_ROUTING_ASSETS || path.join(__dirname, "../assets"));+const iso = (ms) => new Date(ms).toISOString();+const acct = (n) => ({ id: `acct-${n}`, provider: `prov${n}`, name: `Provider ${n}`, who: `user${n}@example.com`, kind: "account", model: `model-${n}`, known: true, used: 10 * n, plan: "Pro" });+const agentsOf = ["codex", "claude", "opencode", "kimi"];++function req(id) {+ const t0 = Date.now() - 60e3 + id * 100;+ const order = [acct(id % 5), acct((id + 1) % 5)];+ const tries = order.slice(0, 1).map((w) => ({ id: w.id, model: w.model, start: iso(t0), done: true, ms: 300, ttft: 120, status: 200 }));+ return { id, seq: id, time: iso(t0), agent: agentsOf[id % agentsOf.length], model: order[0].model, provider: order[0].provider, order, tries, done: true, status: 200, ms: 400, ttft: 150, tokens: 900, usage: [{ in: 600, out: 300, cache_read: 0, cache_write: 0 }] };+}+function live(id) {+ const r = req(id);+ r.done = false;+ r.status = 0;+ delete r.usage;+ r.tries.forEach((tr) => { tr.done = false; tr.status = 0; });+ return r;+}++// next: what the long poll answers next, one request at a time+function serve(lang, feed, next) {+ const state = { agents: agentsOf.map((id) => ({ id, name: id[0].toUpperCase() + id.slice(1), path: `/test/${id}`, fields: [] })), profiles: [], settings: { lang, theme: "light" } };+ return async (route) => {+ const url = new URL(route.request().url());+ const json = (data) => route.fulfill({ json: data }).catch(() => {});+ if (url.pathname === "/boot.js") return route.fulfill({ contentType: "text/javascript", body: `window.bootPrefs = {lang:"${lang}",theme:"light",web:true};` });+ if (url.pathname === "/wails/runtime.js") return route.fulfill({ contentType: "text/javascript", body: "export const Window = {};" });+ if (url.pathname === "/api/state") return json(state);+ if (url.pathname === "/api/plugins") return json({ plugins: [] });+ if (url.pathname === "/api/gateway/trace") {+ const wait = url.searchParams.get("wait");+ if (wait && !next.length) await new Promise((r) => setTimeout(r, 50));+ const routes = wait ? next.splice(0, 1) : feed;+ const seq = routes.length ? Math.max(...routes.map((r) => r.seq)) : +(url.searchParams.get("after") || 0);+ return json({ mine: true, now: new Date().toISOString(), seq, totals: { requests: 0, rerouted: 0, errors: 0 }, routes });+ }+ if (url.pathname === "/api/gateway/history") return json({ cut: false, days: [], routes: [] });+ if (url.pathname === "/api/groups") return json({ models: [], groups: [], pools: [] });+ if (url.pathname === "/api/providers") return json({ providers: [], excluded: [], gateway: { running: true, window: true, url: "http://127.0.0.1:3999" } });+ if (url.pathname.startsWith("/api/")) return json({});+ const file = path.join(assets, url.pathname === "/" ? "index.html" : url.pathname);+ const contentType = { ".html": "text/html", ".js": "text/javascript", ".css": "text/css", ".svg": "image/svg+xml", ".png": "image/png" }[path.extname(file)];+ await route.fulfill({ body: await fs.readFile(file), contentType });+ };+}++// the token breakdowns worked out: t("Token breakdown") is asked once for+// each, wherever the page asks it. t is i18n.js's global, which the+// Routing plugin calls by name, so wrapping it counts every call.+const countBreakdowns = () => {+ window.__breakdowns = 0;+ const t0 = window.t;+ window.t = function (s, vars) { if (s === "Token breakdown") window.__breakdowns++; return t0(s, vars); };+};++for (const engine of engines) for (const lang of ["en", "zh"]) {+ test(`${engine} ${lang}: a trace update works out only the rows of the requests it brings`, async (t) => {+ const browser = await (engine === "webkit" ? webkit.launch() : chromium.launch({ channel: "chromium" }));+ t.after(() => browser.close());+ const context = await browser.newContext({ viewport: { width: 1100, height: 900 } });+ const page = await context.newPage();+ page.setDefaultTimeout(8000);+ const errors = [];+ page.on("pageerror", (e) => errors.push(e.message));+ const feed = Array.from({ length: 40 }, (_, i) => req(i + 1)), next = [];+ await page.route("**/*", serve(lang, feed, next));+ await page.goto("http://magpie.test/?view=routing");+ await page.waitForFunction(() => document.querySelectorAll(".rt-req").length >= 40);+ // what the first draw settles into: the days, the agents' names+ await page.waitForTimeout(800);+ await page.evaluate(countBreakdowns);++ // three requests, one update each+ for (const id of [41, 42, 43]) {+ next.push(req(id));+ await page.waitForFunction((n) => document.querySelectorAll(".rt-req").length >= n, id);+ }+ await page.waitForTimeout(300);+ const worked = await page.evaluate(() => window.__breakdowns);+ assert(worked <= 6, `three updates of one request each worked out ${worked} token breakdowns over 43 listed rows: every row in sight was worked out again`);++ // a request under way, then answered: its row says so, the same+ // route id sent again+ next.push(live(44));+ await page.waitForFunction(() => document.querySelectorAll(".rt-req").length >= 44);+ const said = () => page.evaluate(() => document.querySelector(".rt-req .said")?.textContent || "");+ assert.match(await said(), /user4@example\.com · model-4/);+ const before = await said();+ const done = req(44);+ done.seq = 45;+ next.push(done);+ await page.waitForFunction((was) => (document.querySelector(".rt-req .said")?.textContent || "") !== was, before);+ assert.equal(await page.evaluate(() => document.querySelector(".rt-req").className.includes("wait")), false, "the answered request's row still reads as under way");++ // a new language: every row is worked out again, in it+ const title = () => page.evaluate(() => document.querySelector(".rt-req .rt-metric.tokens")?.title || "");+ const was = await title();+ assert(was, "the answered request's row has no Tokens metric to read its breakdown from");+ await page.evaluate((l) => setLocale(l === "en" ? "zh" : "en"), lang);+ await page.waitForFunction((w) => (document.querySelector(".rt-req .rt-metric.tokens")?.title || "") !== w, was);+ assert.equal(errors.length, 0, errors.join("\n"));+ });+}