Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
routing: the last request's story shrinks back after a long one (夜松云 on Discord)
yetone0455b9279248
diff --git a/internal/gui/assets/plugins/routing/client.js b/internal/gui/assets/plugins/routing/client.jsindex 4e6e9d13b..b14f6b376 100644--- a/internal/gui/assets/plugins/routing/client.js+++ b/internal/gui/assets/plugins/routing/client.js@@ -1995,37 +1995,45 @@ function routingPage(part) {bodies.replaceChildren(grid);}// holdStory keeps the story of the live request, its head and its lines,- // as tall as it has been since the reader began following live, at this+ // as tall as the tallest of the last few requests answered, at this// width: a request under way is told in fewer lines than one answered// ("is answering…", then "answered in 4.0 s…" over two lines at a// phone's width), and its head gets View usage and Replay, taller than// the words, once it is done. So each new request moved the context// window under it up and back down (dumplings on Discord: the card- // jittered on every request). A request picked, a replay or a past day+ // jittered on every request). Only the last STORY_HELD answered count: one+ // told in many lines (a request handed on from member to member) no+ // longer holds the box that tall for good, and it shrinks back once+ // that many shorter ones have come after it (夜松云 on Discord: the box+ // grew and never shrank back). A request picked, a replay or a past day// is drawn at its own height. A change of width measures it again at// once, as it is then (the list coming in under it can take a// scrollbar's width off it before the first live request)- let storyHold = { key: "", h: [0, 0] }, storyDrawn = "";+ const STORY_HELD = 3;+ let storyHold = { key: "", done: new Map() }, storyDrawn = "";function holdStory() {const follow = !pinned && !rp && !day;const w = steps.clientWidth;const key = JSON.stringify([follow, w, document.documentElement.lang]);if (key === storyHold.key && storyDrawn === headKey + stepsKey) return;- if (key !== storyHold.key) storyHold = { key, h: [0, 0] };+ if (key !== storyHold.key) storyHold = { key, done: new Map() };storyDrawn = headKey + stepsKey;+ [logHead, steps].forEach((e) => { e.style.minHeight = ""; });+ if (!follow || !w || !logR) return;+ const hs = [logHead, steps].map((e) => e.getBoundingClientRect().height);+ // an answered request's own height, kept by its id: the last few only+ if (logR.done) {+ storyHold.done.set(logR.id, hs);+ const ids = [...storyHold.done.keys()].sort((x, y) => y - x);+ for (const id of ids.slice(STORY_HELD)) storyHold.done.delete(id);+ }[logHead, steps].forEach((e, i) => {- e.style.minHeight = "";- if (!follow || !w) return;- const h = e.getBoundingClientRect().height;- storyHold.h[i] = Math.max(storyHold.h[i], h);- if (storyHold.h[i] > h) e.style.minHeight = storyHold.h[i] + "px";+ const held = Math.max(0, ...[...storyHold.done.values()].map((h) => h[i]));+ if (held > hs[i]) e.style.minHeight = held + "px";});}- new ResizeObserver(() => {- holdStory();- // grown since it was measured (a font come in): that is its height- [logHead, steps].forEach((e, i) => { storyHold.h[i] = Math.max(storyHold.h[i], e.getBoundingClientRect().height); });- }).observe(steps);+ // grown since it was measured (a font come in): measured again as it is+ new ResizeObserver(() => { storyDrawn = ""; holdStory(); }).observe(steps);// renderCtx draws the request's context window under its story, with// its session's prompts request by request; drawn again only when what// it shows changes. Live, the next request is patched into the carddiff --git a/internal/gui/tests/routing-story-shrinks.test.cjs b/internal/gui/tests/routing-story-shrinks.test.cjsnew file mode 100644index 000000000..5863ecdc3--- /dev/null+++ b/internal/gui/tests/routing-story-shrinks.test.cjs@@ -0,0 +1,119 @@+// Run with Node's test runner and Playwright on the module path; see README.md.+// Routing, live: the story of the last request ("How the last request was+// routed") is as tall as the last few requests' stories, not as tall as the+// tallest one seen (夜松云 on Discord: the box grew when a request was+// handed on through many members and never shrank back). A request handed+// on four times is told in many lines; the box keeps that height while the+// next two short requests come in, so nothing jumps from one request to the+// next (routing-ctx-still), and shrinks to the short ones' at the third.+// English and Chinese, Chromium and WebKit.+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 assets = path.resolve(__dirname, "../assets");+const now = Date.now();+const iso = (ms) => new Date(ms).toISOString();+const seat = (n) => ({ id: "codex@me" + n, provider: "codex", name: "ChatGPT " + n, who: "me" + n + "@example.com", kind: "account", model: "gpt-6.1-sol", known: true, plan: "Pro" });+// a request answered by its first member, or handed on through `hops`+// members that refused it before the last answered+function req(id, hops, step = "done") {+ const t0 = now - (200 - id) * 1000, done = step === "done";+ const order = Array.from({ length: hops + 1 }, (_, i) => seat(i));+ const tries = order.map((s, i) => i < hops+ ? { id: s.id, model: s.model, start: iso(t0 + i * 100), done: true, status: 429, ms: 90, err: "rate limited: try again in 30s" }+ : { id: s.id, model: s.model, start: iso(t0 + i * 100), done, ...(done ? { status: 200, ms: 4000 } : {}) });+ return {+ id, seq: id * 10 + (done ? 2 : 0), time: iso(t0), agent: "codex", session: "019a-session", model: "gpt-6.1-sol", provider: "codex",+ order, tries, done, ...(done ? { status: 200, ms: 4000 + hops * 100, tokens: 2000, cost: 0.05, priced: true, usage: [{ in: 3000, cache_read: 87000, out: 400 }] } : {}),+ };+}+const first = [req(101, 0), req(102, 0)];++function serve(lang, feed) {+ const state = { agents: [{ id: "codex", name: "Codex", path: "/test/codex", fields: [] }], profiles: [], settings: { lang, theme: "light" } };+ return async (route) => {+ const url = new URL(route.request().url());+ const json = (data) => route.fulfill({ json: data });+ 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/gateway/trace") {+ const trace = (routes) => json({ mine: true, now: new Date().toISOString(), seq: routes.length ? routes[routes.length - 1].seq : Number(url.searchParams.get("after")), totals: { requests: 0, rerouted: 0, errors: 0 }, routes });+ if (!url.searchParams.get("wait")) return trace(first);+ const r = await new Promise((res) => { feed.next = res; });+ return trace([r]);+ }+ if (url.pathname === "/api/gateway/history") return json({ cut: false, days: [], routes: [] });+ if (url.pathname === "/api/groups") return json({ groups: [], models: [], pools: [] });+ if (url.pathname === "/api/providers") return json({ providers: [], presets: [], 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).catch(() => ""), contentType });+ };+}++for (const engine of (process.env.BROWSER ? [process.env.BROWSER] : ["chromium", "webkit"])) {+ test(`${engine}: the last request's story shrinks back after a long one`, async (t) => {+ const browser = await (engine === "webkit" ? webkit.launch() : chromium.launch({ channel: "chromium" }));+ t.after(() => browser.close());+ for (const [lang, width] of [["en", 1100], ["zh", 420]]) {+ await t.test(`${lang} ${width}px`, async () => {+ const context = await browser.newContext({ viewport: { width, height: 900 }, reducedMotion: "reduce" });+ const page = await context.newPage();+ page.setDefaultTimeout(5000);+ const errors = [];+ page.on("pageerror", (e) => errors.push(e.message));+ const feed = { next: null };+ await page.route("**/*", serve(lang, feed));+ await page.goto("http://magpie.test/?view=routing");+ await page.locator(".rt-req").nth(first.length - 1).waitFor();+ await page.locator(".rt-log .rt-steps li").first().waitFor();+ await page.waitForTimeout(800);+ const send = async (r) => {+ for (let i = 0; i < 60 && !feed.next; i++) await page.waitForTimeout(50);+ const next = feed.next;+ assert(next, "the page asks for the next trace");+ feed.next = null;+ next(r);+ await page.waitForTimeout(400);+ };+ const story = () => page.evaluate(() => {+ const s = document.querySelector(".rt-log .rt-steps");+ const lines = [...s.children].reduce((b, li) => Math.max(b, li.getBoundingClientRect().bottom), s.getBoundingClientRect().top);+ return { h: s.getBoundingClientRect().height, content: lines - s.getBoundingClientRect().top, held: s.style.minHeight };+ });+ const short = await story();++ await send(req(103, 4));+ const tall = await story();+ assert(tall.h > short.h + 40, `the long request is told in more lines: ${tall.h} vs ${short.h}`);++ // under way after it, and the two answered after it: held, so+ // nothing jumps from one request to the next+ await send(req(104, 0, "start"));+ assert((await story()).h >= tall.h - 0.5, "held while under way");+ for (const id of [104, 105]) {+ await send(req(id, 0));+ const h = (await story()).h;+ assert(h >= tall.h - 0.5, `${id} held: ${h} vs ${tall.h}`);+ }++ // the third short one answered: the long one has gone out of the+ // hold, and the box is as tall as its own lines+ await send(req(106, 0));+ const after = await story();+ assert(after.h < tall.h - 40, `the box shrank back after the long request: ${after.h} vs ${tall.h} (min-height ${after.held || "none"})`);+ assert(Math.abs(after.h - short.h) <= 1, `as tall as a short request: ${after.h} vs ${short.h}`);+ assert(after.h - after.content <= 24, `no empty room under its lines: ${after.h} tall, lines to ${after.content}`);++ assert.deepEqual(errors, []);+ feed.next?.(req(999, 0));+ await context.close();+ });+ }+ });+}