pi-zip 0.0.0-stage → 0.2.0

package/src/learn.ts

@@ -0,0 +1,141 @@
+// What the prompt cache costs and how long it lives, learned from the provider's own usage reports. Counts only, never content.
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { type Any, clamp } from "./util.ts";
+
+/** explicit: the provider reports cacheWrite (a write premium, Anthropic style); automatic: it never does (prefix cache, writes cost input). */
+export type CacheClass = "explicit" | "automatic";
+
+/** Prices of one prefix token in units of the input price: r = cache read, w = rewrite, out = output. */
+export interface Prices { r: number; w: number; input: number; out: number; cls: CacheClass; src: "class" }
+
+/** Price ratios to input per cache class. explicit = Anthropic list multipliers (read 0.1, 5-min write 1.25, 1-h write 2: kappa = w/r - 1
+ *  = 11.5 / 19); automatic: r = 0.2 (kappa = 4: GLM's own ratio 0.186 -> 4.38 is the only automatic provider measured; the class spans
+ *  kappa 1..9 and its geometric centre 3 was worse on quality). Output = 4 x the class's 5-min write: 5 (= 50 r) / 4 (= 20 r). */
+export const CLASS_RATIOS: Record<CacheClass, { r: number; w: number }> = { explicit: { r: 0.1, w: 1.25 }, automatic: { r: 0.2, w: 1 } };
+
+/** The class ratios, never Pi's price table (model.cost): the law is homogeneous in prices, so ratios are all it needs, and true prices
+ *  instead of the class ratios moved the bill by 0.0-1.0%. w: explicit 1.25, or 2 on the 1-h tier; automatic 1. The class comes from the
+ *  usage reports (learned, persisted); unknown before the first response = null (the legacy rule). */
+export function lawPrices(cls: CacheClass | undefined, longTier: boolean): Prices | null {
+	if (!cls) return null;
+	const d = CLASS_RATIOS[cls];
+	const w = cls === "explicit" && longTier ? 2 : d.w;
+	return { r: d.r, w, input: 1, out: 4 * d.w, cls, src: "class" };
+}
+
+// ---- cache survival ------------------------------------------------------------------------------------------------
+/** Gap bins (s): [GAP_EDGES[i], GAP_EDGES[i+1]). Edges sit on the known TTL tiers (300 s, 3600 s): a deterministic TTL never splits a bin. */
+export const GAP_EDGES = [30, 60, 120, 180, 240, 300, 330, 360, 420, 480, 600, 900, 1200, 1800, 2700, 3600, 5400];
+export const HALF_LIFE = 16; // observations per bin: old evidence counts half after 16 newer ones in the same bin (a provider may change its TTL)
+// The declared TTL as pseudo-observations. Asymmetric because the signal is: a read of the re-sent prefix cannot happen on a dead cache,
+// but warm misses do (GLM 4-9%, glm-flash ~22%, research round 5). Beyond the TTL one clean read overrides it (weight 1/4: one hit -> 0.8);
+// inside it a lone miss does not (weight 2: one miss -> 0.67, two -> 0.5, three -> 0.4). Otherwise one random miss flips a warm bin to
+// dead, the next returns there fold, and a miss right after a fold is censored: nothing would ever correct it (live smoke, glm-5.3-flash).
+const PRIOR_WEIGHT = { alive: 2, dead: 0.25 };
+// Prefix tokens a sample needs: far above the shared prefix other sessions keep warm (system prompt + tools, ~2-4K; live GLM reads on dead
+// caches: 0 / 704 / 1792 / 3200). Also the head every edit leaves untouched on an automatic cache (plan.ts), so returns stay observable.
+export const MIN_EXPECT = 8192;
+
+export interface Entry { cls?: CacheClass; bins: Record<string, [number, number]>; n: number } // bin index -> [alive, dead] (decayed counts)
+interface File { v: 1; models: Record<string, Entry> }
+
+export const statsPath = (): string =>
+	process.env.PI_ZIP_CACHE_STATS || join(process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent"), "pi-zip", "cache-survival.json");
+
+export const binOf = (gapS: number): number => GAP_EDGES.findLastIndex((e) => gapS >= e); // -1 = below 30 s: not recorded
+const fin = (x: Any) => typeof x === "number" && Number.isFinite(x) && x >= 0;
+
+/** The persisted stats; a missing, unreadable or malformed file is ignored (empty). */
+export function loadStats(path = statsPath()): File {
+	try {
+		const j = JSON.parse(readFileSync(path, "utf8"));
+		const out: File = { v: 1, models: {} };
+		if (j?.v !== 1 || typeof j.models !== "object" || !j.models) return out;
+		for (const [k, e] of Object.entries<Any>(j.models)) {
+			const bins: Entry["bins"] = {};
+			for (const [b, c] of Object.entries<Any>(e?.bins ?? {})) if (GAP_EDGES[Number(b)] !== undefined && Array.isArray(c) && fin(c[0]) && fin(c[1])) bins[b] = [c[0], c[1]];
+			out.models[k] = { bins, n: fin(e?.n) ? e.n : 0, ...(e?.cls === "explicit" || e?.cls === "automatic" ? { cls: e.cls } : {}) };
+		}
+		return out;
+	} catch {
+		return { v: 1, models: {} };
+	}
+}
+
+/** Was the cache alive after the gap? `expect` = prefix tokens this request re-sent unchanged (the previous prompt, or the untouched prefix
+ *  before our first edit), `total` = this prompt, `cls` = the model's cache class. One bar, half of max(expect, MIN_EXPECT):
+ *  alive = the read AND our own unchanged prefix both clear it (a read the shared prefix cannot explain; a smaller untouched prefix still
+ *  counts when the read covers it: live GLM 6.3K expected, 7.8-9.8K read), dead = a read below half of an expect of at least MIN_EXPECT.
+ *  null = censored: too small to tell, the prompt shrank under someone else's edit, or a miss after our own edit on a breakpoint cache
+ *  (explicit: the provider looks back only ~20 blocks from the last breakpoint; an automatic prefix cache reads any untouched head). */
+export function sample(expect: number, cacheRead: number, total = Infinity, edited = false, cls?: CacheClass): boolean | null {
+	const e = Math.min(expect, total), bar = 0.5 * Math.max(e, MIN_EXPECT);
+	if (cacheRead >= bar && e >= bar) return true;
+	if (!(e >= MIN_EXPECT)) return null;
+	return total >= expect && (!edited || cls === "automatic") ? false : null;
+}
+
+/** Fold one response into the stats (re-read, update, atomic write: concurrent sessions share the file). Returns the model's entry. */
+export function record(key: string, u: { explicit: boolean; total: number; gapS?: number; alive?: boolean | null }, path = statsPath()): Entry {
+	const f = loadStats(path);
+	const e = (f.models[key] ??= { bins: {}, n: 0 });
+	let dirty = false;
+	if (u.explicit && e.cls !== "explicit") (e.cls = "explicit"), (dirty = true); // sticky: a write premium once reported stays
+	else if (!e.cls && u.total >= 2048) (e.cls = "automatic"), (dirty = true);
+	const b = u.gapS !== undefined && typeof u.alive === "boolean" ? binOf(u.gapS) : -1;
+	if (b >= 0) {
+		const decay = 2 ** (-1 / HALF_LIFE);
+		const [a, d] = e.bins[b] ?? [0, 0];
+		e.bins[b] = [+(a * decay + (u.alive ? 1 : 0)).toFixed(3), +(d * decay + (u.alive ? 0 : 1)).toFixed(3)];
+		e.n++;
+		dirty = true;
+	}
+	if (dirty) {
+		try {
+			mkdirSync(dirname(path), { recursive: true });
+			const tmp = `${path}.${process.pid}.tmp`;
+			writeFileSync(tmp, JSON.stringify(f));
+			renameSync(tmp, path);
+		} catch {}
+	}
+	return e;
+}
+
+/** Monotone (non-increasing in the gap) survival per observed bin: (alive + m x prior) / (n + m), pooled adjacent violators. */
+export function curve(e: Entry | undefined, priorS: number): { bin: number; p: number; n: number }[] {
+	const pts = Object.entries(e?.bins ?? {}).map(([b, [a, d]]) => {
+		const i = Number(b), mid = Math.sqrt(GAP_EDGES[i] * (GAP_EDGES[i + 1] ?? 2 * GAP_EDGES[i])), pi = mid <= priorS ? 1 : 0;
+		const m = pi ? PRIOR_WEIGHT.alive : PRIOR_WEIGHT.dead;
+		return { bins: [i], p: (a + m * pi) / (a + d + m), w: a + d + m };
+	}).sort((x, y) => x.bins[0] - y.bins[0]);
+	const st: typeof pts = [];
+	for (const q of pts) {
+		st.push(q);
+		while (st.length > 1 && st[st.length - 2].p < st[st.length - 1].p) {
+			const y = st.pop()!, x = st.pop()!;
+			st.push({ bins: [...x.bins, ...y.bins], p: (x.p * x.w + y.p * y.w) / (x.w + y.w), w: x.w + y.w });
+		}
+	}
+	return st.flatMap((q) => q.bins.map((bin) => ({ bin, p: q.p, n: (e!.bins[bin][0] + e!.bins[bin][1]) })));
+}
+
+/** P(the cache survived a gap of gapS). Observed bin: its monotone estimate. Otherwise the declared TTL (cold start = today's rule), clamped
+ *  between the nearest observed bins below and above (an alive read at 365 s makes every shorter gap warm; a miss makes longer ones dead). */
+export function pWarm(e: Entry | undefined, gapS: number, priorS: number): { p: number; src: "prior" | "learned" } {
+	const prior = gapS <= priorS ? 1 : 0;
+	const c = curve(e, priorS), b = binOf(gapS);
+	const at = c.find((x) => x.bin === b);
+	if (at) return { p: at.p, src: "learned" };
+	const hi = c.filter((x) => x.bin < b).at(-1)?.p ?? 1, lo = c.find((x) => x.bin > b)?.p ?? 0;
+	const p = clamp(prior, lo, hi);
+	return { p, src: p === prior ? "prior" : "learned" };
+}
+
+/** /zip status text: class and the learned curve ("360-420s 0.80 n1"). */
+export function describe(e: Entry | undefined, priorS: number): string {
+	const c = curve(e, priorS);
+	const bins = c.map((x) => `${GAP_EDGES[x.bin]}-${GAP_EDGES[x.bin + 1] ?? "∞"}s ${x.p.toFixed(2)} n${Math.round(x.n * 10) / 10}`).join(", ");
+	return `survival ${bins || `none learned yet (declared TTL ${Math.round(priorS)} s)`} · ${e?.n ?? 0} sample${e?.n === 1 ? "" : "s"}`;
+}

package/src/notice.ts

@@ -0,0 +1,108 @@
+// User-facing text (F15, F16): one notice line per turn, honest stats, the /zip command. Notices never enter model context.
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type Any, PRODUCT } from "./util.ts";
+
+export interface NoticeAction {
+	kind: "fold" | "summary";
+	count: number;
+	tokensBefore: number;
+	tokensAfter: number;
+	ms: number;
+	prepared?: boolean; // summary computed while the user was away
+	pressure?: boolean; // done by the warm valve (the law fired while the cache is still warm), not because the cache was cold
+}
+
+export const fmtK = (tokens: number): string => `${tokens >= 99_500 ? Math.round(tokens / 1000) : Math.round(tokens / 100) / 10}K`;
+
+export function noticeText(actions: NoticeAction[]): string {
+	const segs = actions.map((a) => {
+		const sizes = `${fmtK(a.tokensBefore)} → ${fmtK(a.tokensAfter)} tokens`;
+		if (a.kind === "fold") {
+			const ms = a.ms < 10 ? (Math.round(a.ms * 10) / 10).toFixed(1) : String(Math.round(a.ms));
+			return `folded ${a.count} old output${a.count === 1 ? "" : "s"} · ${sizes} · ${ms} ms · originals recallable${a.pressure ? " · context over the warm-cache limit" : ""}`;
+		}
+		const s = (Math.round(a.ms / 100) / 10).toFixed(1);
+		return `summarized ${a.count} request${a.count === 1 ? "" : "s"} · ${sizes} · ${a.prepared ? `${s} s (done while you were away)` : `waited ${s} s`}`;
+	});
+	return `${PRODUCT} · ${segs.join(" · ")}`;
+}
+
+/** Prices are $ per million tokens, as declared by the model. */
+export interface Prices {
+	cacheWrite: number;
+	cacheRead: number;
+}
+
+export class Stats {
+	folds = 0; // outputs folded
+	foldedTokens = 0; // tokens removed by folds (estimate: chars/4)
+	summaries = 0;
+	summarizedTokens = 0; // tokens removed by summaries
+	summaryMs = 0;
+	summaryUsd = 0; // what the narrative model calls cost
+	recalls = 0;
+	recallChars = 0;
+	pressureEdits = 0; // warm-valve edits
+	pressureRewriteTokens = 0; // upper bound: a valve edit on a warm cache may rewrite the whole context
+	writeSavedTokens = 0; // tokens NOT rewritten at a cold return
+	readSavedTokens = 0; // tokens NOT read, summed over every request sent after an edit
+	activeSaved = 0; // tokens currently removed from the context by our edits
+	notices = 0;
+
+	/** Estimated $ saved versus doing nothing: avoided cache writes and reads, minus summary calls, recalled content re-entering the context, and warm-valve rewrites. */
+	savedUsd(p: Prices | null): number | null {
+		if (!p) return null;
+		const gross = (this.writeSavedTokens * p.cacheWrite + this.readSavedTokens * p.cacheRead) / 1e6;
+		const recall = (this.recallChars / 4) * p.cacheWrite / 1e6;
+		const pressure = this.pressureRewriteTokens * Math.max(p.cacheWrite - p.cacheRead, 0) / 1e6;
+		return gross - this.summaryUsd - recall - pressure;
+	}
+}
+
+export const pricesOf = (model: Any): Prices | null => {
+	const c = model?.cost;
+	const cw = c?.cacheWrite > 0 ? c.cacheWrite : c?.input > 0 ? c.input : 0;
+	const cr = c?.cacheRead > 0 ? c.cacheRead : cw * 0.1;
+	return cw > 0 ? { cacheWrite: cw, cacheRead: cr } : null;
+};
+
+export function statsText(s: Stats, model: Any): string {
+	const usd = s.savedUsd(pricesOf(model));
+	const money = usd === null ? "n/a (model declares no prices)" : `${usd < 0 ? "-" : ""}$${Math.abs(usd).toFixed(usd !== 0 && Math.abs(usd) < 0.1 ? 4 : 2)}`;
+	return (
+		`${PRODUCT} stats (since pi started): folded ${s.folds} output${s.folds === 1 ? "" : "s"} (${fmtK(s.foldedTokens)} tokens), ` +
+		`${s.summaries} summar${s.summaries === 1 ? "y" : "ies"} (${fmtK(s.summarizedTokens)} tokens, ${(s.summaryMs / 1000).toFixed(1)} s waited, $${s.summaryUsd.toFixed(4)}), ` +
+		`${s.recalls} recall${s.recalls === 1 ? "" : "s"} (~${fmtK(s.recallChars / 4)} tokens re-read). ` +
+		`Estimated saved vs doing nothing: ${money}, counting avoided cache writes and reads minus summary calls, recalled content and warm-valve rewrites; token counts are chars/4 estimates.`
+	);
+}
+
+export interface ZipControl {
+	status(): string;
+	statsLine(): string;
+	setOff(off: boolean): string;
+	toggleQuiet(): string;
+}
+
+export function registerZipCommand(pi: ExtensionAPI, zip: ZipControl) {
+	pi.registerCommand("zip", {
+		description: `${PRODUCT}: status | stats | off | on | quiet`,
+		handler: async (args: string, cctx: Any) => {
+			const sub = (args ?? "").trim().toLowerCase() || "status";
+			const text =
+				sub === "status" ? zip.status()
+				: sub === "stats" ? zip.statsLine()
+				: sub === "off" ? zip.setOff(true)
+				: sub === "on" ? zip.setOff(false)
+				: sub === "quiet" ? zip.toggleQuiet()
+				: `${PRODUCT}: unknown subcommand "${sub}" (use status | stats | off | on | quiet)`;
+			if (cctx?.ui?.notify && (cctx.mode === "tui" || cctx.mode === "rpc")) {
+				try {
+					cctx.ui.notify(text);
+					return;
+				} catch {}
+			}
+			process.stderr.write(text + "\n"); // stdout carries the program's own output (JSON mode): never mix command text into it
+		},
+	});
+}

package/src/placeholder.ts

@@ -0,0 +1,135 @@
+// Placeholders (F2): tool + args + size + key lines + handle. Handles are deterministic in the session entry id.
+import { createHash } from "node:crypto";
+import type { Block, Calls } from "./plan.ts";
+import { type Any, clip, textOf } from "./util.ts";
+
+export const PH_MARK = "[folded by pi-zip";
+export const RECALL_TOOL = "zip_recall";
+const MIN_FOLD_CHARS = 1000; // shorter outputs are never worth a placeholder
+
+/** Deterministic recall handle for a session entry id: 10-char base36 of sha256("pi-zip:"+id)[0..12). */
+export function handleFor(entryId: string): string {
+	const hex = createHash("sha256").update(`pi-zip:${entryId}`).digest("hex").slice(0, 12);
+	return BigInt("0x" + hex).toString(36).padStart(Math.ceil(48 / Math.log2(36)), "0").slice(-10);
+}
+
+export interface KeyLine {
+	no: number;
+	text: string;
+	why: "error" | "id" | "first" | "last";
+}
+
+const ERROR_LINE_RE = /error|fail|exception|warning/i;
+const ID_LINE_RE = /\b[A-Z]{2,}-[A-Z0-9-]{3,}\b/;
+const KEYVAL_LINE_RE = /\b[A-Za-z_][A-Za-z0-9_.-]*=(?:"[^"]*"|\S+)/;
+const LABEL_NUM_RE = /\b[A-Za-z][A-Za-z0-9_. \/-]{0,30}:\s*-?\d|\b-?\d[\d.,]*\s+(?:ms|s|kb|mb|gb|tokens?|bytes|lines)\b/i;
+const HEXISH_RE = /\b[0-9a-f]{8,}\b/gi;
+
+const hexLike = (line: string): boolean => {
+	for (const m of line.matchAll(HEXISH_RE)) if (/[a-f]/i.test(m[0]) && /\d/.test(m[0])) return true; // letters+digits reads as an id/hash
+	return false;
+};
+
+/** Deterministic key lines: first line, error/warning lines, id-like lines (tickets, hashes, key=value, labelled numbers), last line; sorted by line number. */
+export function pickKeyLines(text: string, keep = 8): KeyLine[] {
+	const lines = text.split("\n");
+	if (keep <= 0 || !lines.length) return [];
+	const picked = new Map<number, KeyLine>();
+	const add = (no: number, why: KeyLine["why"]) => {
+		if (picked.size >= keep || picked.has(no)) return;
+		const t = lines[no - 1] ?? "";
+		if (t.trim()) picked.set(no, { no, text: t, why });
+	};
+	const room = () => picked.size < keep - (picked.has(lines.length) ? 0 : 1); // always leave room for the last line
+	add(1, "first");
+	for (let i = 0; i < lines.length && room(); i++) if (i > 0 && i < lines.length - 1 && ERROR_LINE_RE.test(lines[i])) add(i + 1, "error");
+	for (let i = 0; i < lines.length && room(); i++) {
+		const no = i + 1;
+		if (no === 1 || no === lines.length || picked.has(no)) continue;
+		if (ID_LINE_RE.test(lines[i]) || hexLike(lines[i]) || KEYVAL_LINE_RE.test(lines[i]) || LABEL_NUM_RE.test(lines[i])) add(no, "id");
+	}
+	add(lines.length, "last");
+	return [...picked.values()].sort((a, b) => a.no - b.no);
+}
+
+/** Collapse whitespace and cut to `n` chars keeping head AND tail (the distinguishing part of a path or command is often its end). */
+export function clipMid(s: string, n: number): string {
+	s = s.replace(/\s+/g, " ").trim();
+	if (s.length <= n) return s;
+	const head = Math.ceil((n - 1) * 0.6);
+	return s.slice(0, head) + "…" + s.slice(s.length - (n - 1 - head));
+}
+
+const ARG_CHARS = 90;
+
+export function shortArgs(args: Any): string {
+	if (!args || typeof args !== "object") return "";
+	if (typeof args.command === "string") return clipMid(args.command, ARG_CHARS);
+	const path = typeof args.path === "string" ? args.path : typeof args.file_path === "string" ? args.file_path : null;
+	if (path !== null && typeof args.pattern !== "string") {
+		const win = ["offset", "limit"].filter((k) => typeof args[k] === "number" && Number.isFinite(args[k])).map((k) => ` ${k}=${args[k]}`).join(""); // which slice of the file
+		return clipMid(path, ARG_CHARS) + win;
+	}
+	if (typeof args.pattern === "string") return clipMid(args.pattern + (args.path ? " " + args.path : ""), ARG_CHARS);
+	try {
+		return clipMid(JSON.stringify(args), ARG_CHARS);
+	} catch {
+		return "";
+	}
+}
+
+const COUNT_RE = /\b(\d+)\s+(passed|passing|pass|failed|failing|fail|skipped|errors?)\b/gi;
+const COUNT_ORDER = ["passed", "failed", "skipped", "errors"];
+
+/**
+ * Deterministic one-line outcome of a command, from the output alone: exit status (bash) and test counts when the tail of the
+ * output has "N passed / N failed" style summaries. `isError` (the tool result flag) lets a bash result without an exit-code
+ * line read as "exit 0" or "error"; leave it undefined when unknown. Empty string = nothing distinctive to say.
+ */
+export function outcomeHint(text: string, tool: string, isError?: boolean): string {
+	if (tool !== "bash") return "";
+	const tail = text.slice(-2000);
+	const parts: string[] = [];
+	const ex = [...tail.matchAll(/Command exited with code (\d+)/g)].pop();
+	if (ex) parts.push(`exit ${ex[1]}`);
+	else if (/Command timed out/.test(tail)) parts.push("timed out");
+	else if (/Command aborted/.test(tail)) parts.push("aborted");
+	else if (isError === true) parts.push("error");
+	else if (isError === false) parts.push("exit 0");
+	const last = new Map<string, string>();
+	for (const m of tail.matchAll(COUNT_RE)) {
+		const w = m[2].toLowerCase();
+		last.set(w.startsWith("pass") ? "passed" : w.startsWith("fail") ? "failed" : w === "skipped" ? "skipped" : "errors", m[1]);
+	}
+	if (last.has("passed") || last.has("failed")) parts.push(COUNT_ORDER.filter((k) => last.has(k)).map((k) => `${last.get(k)} ${k}`).join(", "));
+	return parts.join(", ");
+}
+
+export interface PlaceholderMeta {
+	turn?: number; // user turn the output belongs to (1-based, as seen in the projection when it was folded)
+	isError?: boolean;
+}
+
+/** Placeholder text, or null when the output is too short to be worth folding. The text is stored with the fold (context_edit),
+ *  so it is rendered once and old folds keep their bytes whatever this format becomes. */
+export function makePlaceholder(text: string, tool: string, args: string, handle: string, keep = 8, meta: PlaceholderMeta = {}): string | null {
+	if (text.length <= MIN_FOLD_CHARS) return null;
+	const lines = text.split("\n").length;
+	const keys = pickKeyLines(text, keep);
+	const body = keys.map((k) => `${k.no}: ${clip(k.text, 160)}`).join("\n");
+	const outcome = outcomeHint(text, tool, meta.isError);
+	return (
+		`${PH_MARK} · ${tool}${args ? " " + args : ""}${meta.turn ? ` · turn ${meta.turn}` : ""}${outcome ? ` · ${outcome}` : ""} · ${text.length} chars, ${lines} lines · handle ${handle}]\n` +
+		(keys.length ? `key lines kept (original line numbers; up to ${keep}):\n${body}\n` : "") +
+		`Original kept byte for byte, recallable even after summaries or compaction: ${RECALL_TOOL}("${handle}") (optional grep/range) is instant, free, no side effects; prefer it to re-running or re-reading (output may differ). Do not guess its content.`
+	);
+}
+
+/** Placeholder for a toolResult block (null for image results, entries without an id, or short outputs). */
+export function makePlaceholderFor(b: Block, calls: Calls, keep = 8): string | null {
+	const content = b.msg.content;
+	if (Array.isArray(content) && content.some((c: Any) => c?.type !== "text")) return null;
+	if (!b.entryId) return null;
+	const call = calls.get(b.msg.toolCallId);
+	return makePlaceholder(textOf(content), call?.name ?? b.msg.toolName ?? "tool", call ? shortArgs(call.args) : "", handleFor(b.entryId), keep, { turn: b.userTurn, isError: !!b.msg.isError });
+}