@basein/runner 0.3.24 → 0.3.26

package/dist/replay/bundle.d.ts

@@ -13,6 +13,20 @@
  * fresh execution (§8.1). It is surfaced in the header *and* per entry, because
  * a bundle that quietly passed off a stale result as a live one would be the
  * worst outcome available here.
+ *
+ * The agent pays to take the bundle in, so it carries nothing the model already
+ * has (docs/calculatedReplay.md, "How a bundle reads"): a result is its text,
+ * not MCP's JSON envelope, and consecutive calls to one tool share a section
+ * that says once what they share.
+ *
+ * And it carries detail only where detail is needed. A run that went entirely
+ * well is laid out briefly ({@link AssembleOptions.brief}): the agent's job is
+ * to see that the steps were right and say what was done, which takes every
+ * record and field a long result has — the IDs, dates, senders and names it
+ * checks the steps against — but not every word of its long text. Anything
+ * else — a step that broke, a run that stopped short, a recorded stand-in, a
+ * sub-task the agent carries on with — gets every result whole, because that
+ * is what the agent works from.
  */
 /** `permissionDecisionReason` is fed to the model as text; keep denials bounded. */
 export declare const MAX_REPLAY_REASON = 60000;
@@ -63,11 +77,77 @@ export interface AssembleOptions {
      * leave the agent its tools.
      */
     reportTool?: string;
+    /**
+     * Lay the run out briefly if it went entirely well, with `summary` — the
+     * plan's response model — in a few words above the footer. Asked for by a
+     * caller whose agent answers from the bundle and nothing else (`bir-
+     * scenario`'s run of a whole plan); `summary` may be absent or `{}`.
+     *
+     * Entirely well means every entry ran live and none reported an error, and
+     * the agent is to answer now: with `handover` or `subTask` set, a recorded
+     * entry, or a result marked as an error, the bundle is laid out in full as
+     * if this were not set. The summary is then the caller's to deliver.
+     */
+    brief?: {
+        summary?: Record<string, unknown>;
+    };
 }
 /**
  * Compose the bundle. `maxChars` is a hard ceiling on the returned string.
  */
 export declare function assembleBundle(entries: readonly BundleEntry[], maxChars: number, opts?: AssembleOptions): string;
+/**
+ * Whether a run went entirely well and the agent answers now — the one case a
+ * bundle may be brief ({@link AssembleOptions.brief}). A run that went wrong
+ * anywhere, stood on a recording, or is one the agent carries on from is what
+ * the agent works from next: it gets every result.
+ */
+export declare function wentWell(entries: readonly BundleEntry[], opts: Pick<AssembleOptions, "handover" | "subTask">): boolean;
+/**
+ * JSON text with every string of prose longer than 40 characters cut to its
+ * first 40 and "…". Keys, numbers, short strings and strings with no space in
+ * them ({@link BRIEF_ID_CHARS}: a link, a path, an id) stay as they are. A
+ * character is never split: an escape counts as one, `\n` and a Unicode
+ * escape (a backslash, a `u` and four hex digits) alike, and so does a pair of
+ * surrogates, written out (an emoji) or as two such escapes.
+ * Works on JSON a parser would refuse — a tool's `NaN`, a result cut short —
+ * because it walks the text's string literals from the start, so it always
+ * knows which quote opens one: the text between two strings, a list of numbers
+ * say, is never taken for one. An unterminated string is left as it is.
+ */
+export declare function cutLongText(json: string): string;
+/**
+ * `key = value` for each field, each value in a few words ({@link briefValue}),
+ * ended at a field's end with "…" rather than run past `max` characters.
+ */
+export declare function briefFields(fields: Record<string, unknown>, max: number): string;
+/**
+ * A value of the plan's summary in a few words. Numbers, booleans and short
+ * strings whole; long text cut, as a result's is ({@link cutLongText}: a link
+ * or an id is whole); a list or object whose JSON is short — a few IDs, names
+ * or addresses — whole; a longer list counted; a longer object by its first
+ * fields, one level down, below which it is counted too. A summary's long
+ * lists are mostly the records the steps above already show.
+ */
+export declare function briefValue(value: unknown, depth?: number): string;
+/**
+ * A tool result as the model should read it.
+ *
+ * Executors hand the bundle the JSON of MCP's `CallToolResult`. Laid out as it
+ * came, every result pays for the envelope —
+ * `{"content":[{"type":"text","text":"…"}],"isError":false}`, some fifty
+ * characters — and for a second layer of escaping: every quote in the text
+ * written `\"`, every backslash `\\`. Neither tells the model anything, and on
+ * a long plan they are a large share of what it reads (and of what the agent
+ * pays to put in its context). A result whose content is text and nothing else
+ * is shown as that text, marked when `isError` is true. Anything else — an
+ * image, a resource, structured content, an answer that is not a
+ * `CallToolResult` at all — is shown exactly as it came.
+ */
+export declare function resultText(response: string): {
+    text: string;
+    error: boolean;
+};
 /** Truncate to `max` chars, appending a marker naming how much was dropped. */
 export declare function truncate(s: string, max: number): string;
 //# sourceMappingURL=bundle.d.ts.map

package/dist/replay/bundle.js

@@ -13,6 +13,20 @@
  * fresh execution (§8.1). It is surfaced in the header *and* per entry, because
  * a bundle that quietly passed off a stale result as a live one would be the
  * worst outcome available here.
+ *
+ * The agent pays to take the bundle in, so it carries nothing the model already
+ * has (docs/calculatedReplay.md, "How a bundle reads"): a result is its text,
+ * not MCP's JSON envelope, and consecutive calls to one tool share a section
+ * that says once what they share.
+ *
+ * And it carries detail only where detail is needed. A run that went entirely
+ * well is laid out briefly ({@link AssembleOptions.brief}): the agent's job is
+ * to see that the steps were right and say what was done, which takes every
+ * record and field a long result has — the IDs, dates, senders and names it
+ * checks the steps against — but not every word of its long text. Anything
+ * else — a step that broke, a run that stopped short, a recorded stand-in, a
+ * sub-task the agent carries on with — gets every result whole, because that
+ * is what the agent works from.
  */
 /** `permissionDecisionReason` is fed to the model as text; keep denials bounded. */
 export const MAX_REPLAY_REASON = 60_000;
@@ -30,6 +44,14 @@ export const BASH_CHANNEL_MAX = 25_000;
 const MAX_INPUT_CHARS = 2_000;
 /** Fixed structural overhead reserved per step (labels, separators). */
 const PER_STEP_OVERHEAD = 80;
+/**
+ * The least each result is shown of. When the inputs leave the results less
+ * than this each, the results keep it and the inputs give up the difference:
+ * the results are what the agent answers from, and fourteen inputs at their cap
+ * once left them nothing at all, every "Result:" empty under a header that
+ * calls it the call's actual output.
+ */
+const MIN_RESULT_CHARS = 200;
 /** The test's words, one line and short, for a bundle or a note. */
 export function testWords(text) {
     const line = (text ?? "").trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
@@ -111,6 +133,37 @@ const SUBTASK_HEADER = "[BaseInstRunner calculated replay] The tool calls below
     "steps are done: do not repeat these calls. Continue your task from where they end, " +
     "calling tools as needed.";
 const SUBTASK_FOOTER = "\n\nThe calls above are done. Continue your task, calling tools as needed.";
+/**
+ * Every step ran live and succeeded ({@link AssembleOptions.brief}). The same
+ * assurances as {@link LIVE_HEADER} — it happened, now, for real — plus what
+ * the agent needs to read the steps below: why some text ends in "…".
+ */
+const BRIEF_HEADER = "[BaseInstRunner calculated replay] The tool calls below have JUST been executed " +
+    "for real, moments ago, against the live system, on the user's behalf. Every one " +
+    "of them succeeded, and every side effect is already in place. Do NOT repeat, redo " +
+    "or re-verify this work, and do NOT call any tools. In a long result, every record " +
+    "and field is shown, and text longer than 40 characters is cut short with \"…\"; " +
+    "a link, a path or an id (no spaces, up to 300 characters) is shown whole.";
+/** The reply is output, the dearest tokens an agent spends: asked for briefly. */
+const BRIEF_FOOTER = "\n\nThe work above is done. Answer the user's request from it in a few sentences: " +
+    "what was done, and the key results. Do not call any tools.";
+/** A result up to this long is shown whole even in a brief bundle: it is its own best evidence. */
+const BRIEF_RESULT_CHARS = 300;
+/** At most this much of a brief bundle is the plan's summary. */
+const BRIEF_SUMMARY_CHARS = 1_000;
+/** A longer string — in a long result, or in the summary — is cut to this many characters. */
+const BRIEF_STRING_CHARS = 40;
+/**
+ * But a string with no space in it — a link, a path, an id, a hash, an e-mail
+ * address — is what the agent passes on to the user, and cut it opens nothing
+ * and names nothing: it is kept whole up to this many characters. Past them it
+ * is a blob (an encoded image, a minified line), and is cut like text.
+ */
+const BRIEF_ID_CHARS = 300;
+/** A list or object in the summary whose JSON is up to this long is shown whole; a longer one is counted. */
+const BRIEF_INLINE_CHARS = 160;
+/** A longer object in the summary shows its first fields, this many. */
+const BRIEF_OBJECT_FIELDS = 6;
 /**
  * Compose the bundle. `maxChars` is a hard ceiling on the returned string.
  */
@@ -119,6 +172,7 @@ export function assembleBundle(entries, maxChars, opts = {}) {
     // that answered split it.
     const n = entries.filter((e) => !e.notNeeded).length;
     const anyRecorded = entries.some((e) => e.recorded);
+    const brief = opts.brief !== undefined && wentWell(entries, opts);
     // A hand-over outranks a sub-task: it says "continue" too, and it also has to
     // say that the plan stopped short. A sub-task outranks the live and mixed
     // headers, whose wording forbids further tool calls.
@@ -126,36 +180,413 @@ export function assembleBundle(entries, maxChars, opts = {}) {
         ? HANDOVER_HEADER
         : opts.subTask
             ? SUBTASK_HEADER
-            : withReportException(anyRecorded ? MIXED_HEADER : LIVE_HEADER, opts.reportTool);
+            : withReportException(brief ? BRIEF_HEADER : anyRecorded ? MIXED_HEADER : LIVE_HEADER, opts.reportTool);
     const footer = opts.handover
         ? HANDOVER_FOOTER
         : opts.subTask
             ? SUBTASK_FOOTER
-            : withReportException(anyRecorded ? MIXED_FOOTER : LIVE_FOOTER, opts.reportTool);
-    const fixedCost = header.length +
-        footer.length +
-        entries.reduce((sum, e) => sum +
-            PER_STEP_OVERHEAD +
-            e.toolName.length +
-            e.input.length +
-            // A left-out step's line, which has no response to take from.
-            (e.notNeeded ? PER_STEP_OVERHEAD + (testWords(e.notNeeded.text)?.length ?? 0) : 0), 0);
-    const responseBudget = Math.max(0, maxChars - fixedCost);
-    const perResponse = n > 0 ? Math.floor(responseBudget / n) : responseBudget;
-    const sections = entries.map((e, i) => {
-        if (e.notNeeded) {
-            // Never "skipped" or "failed": the step was left out on purpose, because
-            // this request does not need it, and nothing is missing for its absence.
-            const why = testWords(e.notNeeded.text);
-            return (`\n\n--- Step ${i + 1}: ${e.toolName} (not needed) ---\n` +
-                `Not run: this request does not need it${why ? ` — it is only for when ${why}` : ""}.`);
+            : withReportException(brief ? BRIEF_FOOTER : anyRecorded ? MIXED_FOOTER : LIVE_FOOTER, opts.reportTool);
+    const summary = brief ? briefSummary(opts.brief?.summary) : "";
+    const labels = entries.reduce((sum, e) => sum +
+        PER_STEP_OVERHEAD +
+        e.toolName.length +
+        // A left-out step's line, which has no response to take from.
+        (e.notNeeded ? PER_STEP_OVERHEAD + (testWords(e.notNeeded.text)?.length ?? 0) : 0), 0);
+    const inputs = entries.reduce((sum, e) => sum + e.input.length, 0);
+    // What the frame and the labels leave is shared by the inputs and the
+    // results. The inputs go in whole and the results split what they leave —
+    // unless that is less than a floor each (or nothing at all, when the inputs
+    // alone pass the limit): then each result keeps the floor, and the inputs,
+    // cut to a share of the rest, say how much of themselves is left out.
+    const free = Math.max(0, maxChars - (header.length + footer.length + summary.length + labels));
+    let perResponse = n > 0 ? Math.floor(Math.max(0, free - inputs) / n) : Math.max(0, free - inputs);
+    let inputCap = Number.POSITIVE_INFINITY;
+    const floor = Math.min(MIN_RESULT_CHARS, Math.floor(free / (2 * Math.max(1, n))));
+    if (n > 0 && perResponse < floor) {
+        perResponse = floor;
+        inputCap = Math.floor((free - n * floor) / entries.length);
+    }
+    const shownEntries = Number.isFinite(inputCap)
+        ? entries.map((e) => ({ ...e, input: truncate(e.input, inputCap) }))
+        : entries;
+    const show = (e) => {
+        const result = resultText(e.response);
+        // A built-in's result is shown as its own text, whole within its share.
+        const own = brief ? builtinText(e.toolName, e.response) : undefined;
+        const text = own ?? result.text;
+        return {
+            text: brief && own === undefined ? briefResult(text, perResponse) : truncate(text, perResponse),
+            marks: resultMarks(e.recorded, result.error),
+        };
+    };
+    const sections = [];
+    for (const run of consecutiveRuns(shownEntries)) {
+        if (run.length === 1) {
+            const { entry: e, index: i } = run[0];
+            if (e.notNeeded) {
+                // Never "skipped" or "failed": the step was left out on purpose, because
+                // this request does not need it, and nothing is missing for its absence.
+                const why = testWords(e.notNeeded.text);
+                sections.push(`\n\n--- Step ${i + 1}: ${e.toolName} (not needed) ---\n` +
+                    `Not run: this request does not need it${why ? ` — it is only for when ${why}` : ""}.`);
+                continue;
+            }
+            const shown = show(e);
+            sections.push(`\n\n--- Step ${i + 1}: ${e.toolName} ---\n` +
+                `Call: ${e.input}\n` +
+                `Result${shown.marks}: ${shown.text}`);
+            continue;
+        }
+        sections.push(runSection(run, show));
+    }
+    // The labels are an estimate, and a bundle that still passes the limit loses
+    // its middle, never its footer: the last thing the agent is told. Where even
+    // that does not fit the limit, the end goes, as it always did.
+    const whole = header + sections.join("") + summary + footer;
+    if (whole.length <= maxChars)
+        return whole;
+    const keepFooter = truncate(header + sections.join("") + summary, Math.max(0, maxChars - footer.length)) + footer;
+    return keepFooter.length <= maxChars ? keepFooter : truncate(whole, maxChars);
+}
+/**
+ * Whether a run went entirely well and the agent answers now — the one case a
+ * bundle may be brief ({@link AssembleOptions.brief}). A run that went wrong
+ * anywhere, stood on a recording, or is one the agent carries on from is what
+ * the agent works from next: it gets every result.
+ */
+export function wentWell(entries, opts) {
+    return (!opts.handover &&
+        !opts.subTask &&
+        entries.every((e) => e.notNeeded || (!e.recorded && !resultText(e.response).error)));
+}
+/**
+ * A result in a brief bundle. Whole when it is short. A long one that is JSON
+ * — a search's records, nearly always — keeps every record and field, and
+ * only its long text is cut ({@link cutLongText}): the agent checks the steps
+ * against the IDs, dates, senders and names, and those are short. A long
+ * result in words is shown whole: it may be the very answer.
+ *
+ * Measured on B2's length tests: showing only the values the plan took from a
+ * result instead left the agent unable to check the plan's choices — "I
+ * couldn't confirm these were the newest", "or who sent them" — in one reply
+ * in six, and once it reported a correct run as wrong.
+ */
+function briefResult(text, budget) {
+    if (text.length > BRIEF_RESULT_CHARS && /^\s*[[{]/.test(text))
+        return truncate(cutLongText(text), budget);
+    return truncate(text, budget);
+}
+/** The runner's built-ins whose results {@link builtinText} lays out as text. */
+const BUILTIN_RESULT_TOOLS = new Set(["Bash", "Read", "Glob", "Grep"]);
+/**
+ * A built-in tool's result as the text it is, or undefined when it is not one
+ * the brief layout can show so: what a command printed, a file's lines, a
+ * search's lines or file names.
+ *
+ * The runner's own tools answer in the hook's shape — `{stdout, stderr, …}`,
+ * `{type, file: {content, …}}`, `{mode, content | filenames, …}`, `{filenames,
+ * …}` — and not in MCP's `CallToolResult`, so {@link resultText} leaves them as
+ * JSON, and the brief layout took all of it for one long string: a command's
+ * output of 470 characters ending "TOTAL DIFFERENCE 100.00" was cut to its
+ * first 40, a Glob's file names every one, under a header that says to call no
+ * tools. The same words from an MCP tool were shown whole.
+ */
+function builtinText(toolName, response) {
+    if (!BUILTIN_RESULT_TOOLS.has(toolName))
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(response);
+    }
+    catch {
+        return undefined;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return undefined;
+    const r = parsed;
+    const lines = (v) => Array.isArray(v) && v.every((x) => typeof x === "string") ? v.join("\n") : undefined;
+    let body;
+    if (toolName === "Bash") {
+        if (typeof r.stdout !== "string" || r.interrupted === true || r.isImage === true)
+            return undefined;
+        const stderr = typeof r.stderr === "string" && r.stderr !== "" ? `stderr: ${r.stderr}` : "";
+        body = stderr && r.stdout !== "" && !r.stdout.endsWith("\n") ? `${r.stdout}\n${stderr}` : r.stdout + stderr;
+    }
+    else if (toolName === "Read") {
+        const file = r.file;
+        body = r.type === "text" && typeof file?.content === "string" ? file.content : undefined;
+    }
+    else {
+        body = typeof r.content === "string" && toolName === "Grep" ? r.content : lines(r.filenames);
+    }
+    if (body === undefined)
+        return undefined;
+    if (body === "")
+        return toolName === "Bash" ? "(no output)" : toolName === "Read" ? "(empty file)" : "(nothing found)";
+    // A list the tool cut where it made it: its text alone would read as the whole answer.
+    return r.truncated === true ? `${body}\n(cut short by the tool: there may be more than is shown)` : body;
+}
+/**
+ * JSON text with every string of prose longer than 40 characters cut to its
+ * first 40 and "…". Keys, numbers, short strings and strings with no space in
+ * them ({@link BRIEF_ID_CHARS}: a link, a path, an id) stay as they are. A
+ * character is never split: an escape counts as one, `\n` and a Unicode
+ * escape (a backslash, a `u` and four hex digits) alike, and so does a pair of
+ * surrogates, written out (an emoji) or as two such escapes.
+ * Works on JSON a parser would refuse — a tool's `NaN`, a result cut short —
+ * because it walks the text's string literals from the start, so it always
+ * knows which quote opens one: the text between two strings, a list of numbers
+ * say, is never taken for one. An unterminated string is left as it is.
+ */
+export function cutLongText(json) {
+    let out = "";
+    let at = 0;
+    while (at < json.length) {
+        const open = json.indexOf('"', at);
+        if (open < 0)
+            return out + json.slice(at);
+        out += json.slice(at, open + 1);
+        // Walk the string a character at a time to its closing quote, noting where
+        // the 40th ends and whether the text has a space in it.
+        let end = open + 1;
+        let units = 0;
+        let cutAt = -1;
+        let spaced = false;
+        while (end < json.length && json[end] !== '"') {
+            const code = json.charCodeAt(end);
+            if (code === 92 || (code >= 0xd800 && code <= 0xdbff)) {
+                // An escape, or the first half of a surrogate pair: it may take more
+                // than one character of the text.
+                const unit = characterAt(json, end);
+                end += unit.length;
+                spaced ||= unit.space;
+            }
+            else {
+                // Nearly every character, and a result may be megabytes of them: one
+                // of the text, a space only when it says so.
+                spaced ||= code === 32 || ((code < 32 || code > 126) && /\s/.test(json[end]));
+                end += 1;
+            }
+            units += 1;
+            if (units === BRIEF_STRING_CHARS)
+                cutAt = end;
+        }
+        if (end >= json.length)
+            return out + json.slice(open + 1);
+        const cut = units > (spaced ? BRIEF_STRING_CHARS : BRIEF_ID_CHARS);
+        out += cut ? `${json.slice(open + 1, cutAt)}…"` : json.slice(open + 1, end + 1);
+        at = end + 1;
+    }
+    return out;
+}
+/**
+ * The character of a JSON string's text that starts at `i`: how many
+ * characters of the text it takes, and whether it is a space (a `\t`, or a
+ * Unicode escape of a space, is one as much as the character itself).
+ */
+function characterAt(text, i) {
+    const c = text[i];
+    if (c === "\\") {
+        const unit = unicodeEscape(text, i);
+        if (unit === undefined)
+            return { length: 2, space: /^[nrtf]$/.test(text[i + 1] ?? "") };
+        // Two escapes that are the halves of one character are one character.
+        const low = unit >= 0xd800 && unit <= 0xdbff ? unicodeEscape(text, i + 6) : undefined;
+        if (low !== undefined && low >= 0xdc00 && low <= 0xdfff)
+            return { length: 12, space: false };
+        return { length: 6, space: /\s/.test(String.fromCharCode(unit)) };
+    }
+    const code = c.charCodeAt(0);
+    const next = text.charCodeAt(i + 1);
+    if (code >= 0xd800 && code <= 0xdbff && next >= 0xdc00 && next <= 0xdfff)
+        return { length: 2, space: false };
+    return { length: 1, space: /\s/.test(c) };
+}
+/** The code unit of a `\uXXXX` escape at `i`, or undefined when there is none there. */
+function unicodeEscape(text, i) {
+    return text[i] === "\\" && text[i + 1] === "u" && /^[0-9a-fA-F]{4}$/.test(text.slice(i + 2, i + 6))
+        ? parseInt(text.slice(i + 2, i + 6), 16)
+        : undefined;
+}
+/**
+ * The plan's summary (its response model) in a few words, or "" when it has
+ * nothing to add: none at all, or only the note that it was left out — which
+ * sends the model to the steps, and they are right above it.
+ */
+function briefSummary(model) {
+    if (!model)
+        return "";
+    const keys = Object.keys(model);
+    if (keys.length === 0 || keys.every((k) => k === "summaryLeftOut"))
+        return "";
+    return `\n\nThe plan's summary: ${briefFields(model, BRIEF_SUMMARY_CHARS)}`;
+}
+/**
+ * `key = value` for each field, each value in a few words ({@link briefValue}),
+ * ended at a field's end with "…" rather than run past `max` characters.
+ */
+export function briefFields(fields, max) {
+    let out = "";
+    for (const [key, value] of Object.entries(fields)) {
+        const part = `${key} = ${briefValue(value)}`;
+        const next = out ? `${out}; ${part}` : part;
+        if (next.length > max)
+            return out ? `${out}; …` : truncate(part, max);
+        out = next;
+    }
+    return out;
+}
+/**
+ * A value of the plan's summary in a few words. Numbers, booleans and short
+ * strings whole; long text cut, as a result's is ({@link cutLongText}: a link
+ * or an id is whole); a list or object whose JSON is short — a few IDs, names
+ * or addresses — whole; a longer list counted; a longer object by its first
+ * fields, one level down, below which it is counted too. A summary's long
+ * lists are mostly the records the steps above already show.
+ */
+export function briefValue(value, depth = 0) {
+    if (typeof value === "string")
+        return cutLongText(JSON.stringify(value));
+    if (value === null || typeof value !== "object")
+        return String(value);
+    let whole;
+    try {
+        whole = JSON.stringify(value) ?? "";
+    }
+    catch {
+        return "[unserializable]";
+    }
+    if (whole.length <= BRIEF_INLINE_CHARS)
+        return whole;
+    if (Array.isArray(value))
+        return `${value.length} ${value.length === 1 ? "item" : "items"}`;
+    const fields = Object.entries(value);
+    if (depth >= 1)
+        return `{${fields.length} ${fields.length === 1 ? "field" : "fields"}}`;
+    const shown = fields.slice(0, BRIEF_OBJECT_FIELDS).map(([k, v]) => `${k}: ${briefValue(v, depth + 1)}`);
+    return `{${shown.join(", ")}${fields.length > BRIEF_OBJECT_FIELDS ? ", …" : ""}}`;
+}
+/**
+ * A tool result as the model should read it.
+ *
+ * Executors hand the bundle the JSON of MCP's `CallToolResult`. Laid out as it
+ * came, every result pays for the envelope —
+ * `{"content":[{"type":"text","text":"…"}],"isError":false}`, some fifty
+ * characters — and for a second layer of escaping: every quote in the text
+ * written `\"`, every backslash `\\`. Neither tells the model anything, and on
+ * a long plan they are a large share of what it reads (and of what the agent
+ * pays to put in its context). A result whose content is text and nothing else
+ * is shown as that text, marked when `isError` is true. Anything else — an
+ * image, a resource, structured content, an answer that is not a
+ * `CallToolResult` at all — is shown exactly as it came.
+ */
+export function resultText(response) {
+    const asIs = { text: response, error: false };
+    let parsed;
+    try {
+        parsed = JSON.parse(response);
+    }
+    catch {
+        return asIs;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return asIs;
+    const result = parsed;
+    if (!Object.keys(result).every((k) => k === "content" || k === "isError"))
+        return asIs;
+    if (result.isError !== undefined && typeof result.isError !== "boolean")
+        return asIs;
+    if (!Array.isArray(result.content) || result.content.length === 0)
+        return asIs;
+    const texts = [];
+    for (const item of result.content) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return asIs;
+        const part = item;
+        if (part.type !== "text" || typeof part.text !== "string")
+            return asIs;
+        if (!Object.keys(part).every((k) => k === "type" || k === "text"))
+            return asIs;
+        texts.push(part.text);
+    }
+    return { text: texts.join("\n"), error: result.isError === true };
+}
+/** `(recorded)`, `(error)` or `(recorded, error)` after a result's label; "" for a plain live result. */
+function resultMarks(recorded, error) {
+    const marks = [recorded ? "recorded" : "", error ? "error" : ""].filter(Boolean);
+    return marks.length > 0 ? ` (${marks.join(", ")})` : "";
+}
+/**
+ * The entries cut into runs of consecutive calls to one tool. A long plan is
+ * mostly such runs — eleven look-ups, then thirty-two forwards — and laying
+ * each step out on its own repeats the tool's name and the section frame every
+ * time. A step left out stands alone, so its "not needed" line reads as before.
+ */
+function consecutiveRuns(entries) {
+    const runs = [];
+    entries.forEach((entry, index) => {
+        const last = runs.at(-1);
+        const prev = last?.at(-1)?.entry;
+        if (last && prev && !prev.notNeeded && !entry.notNeeded && prev.toolName === entry.toolName) {
+            last.push({ entry, index });
+        }
+        else {
+            runs.push([{ entry, index }]);
         }
-        const response = truncate(e.response, perResponse);
-        return (`\n\n--- Step ${i + 1}: ${e.toolName} ---\n` +
-            `Call: ${e.input}\n` +
-            `Result${e.recorded ? " (recorded)" : ""}: ${response}`);
     });
-    return truncate(header + sections.join("") + footer, maxChars);
+    return runs;
+}
+/**
+ * Two or more consecutive calls to one tool, as one section: one line per call,
+ * numbered as its step, with its result after the arrow. What every call shares
+ * is said once above the calls — input fields with the same value in each, and
+ * the answer, when every call got the same one. Each result is shown as `show`
+ * shows a step on its own, budget included.
+ */
+function runSection(run, show) {
+    const first = run[0];
+    const head = `\n\n--- Steps ${first.index + 1}-${run[run.length - 1].index + 1}: ${first.entry.toolName} (${run.length} calls) ---`;
+    const inputs = sharedInput(run.map(({ entry }) => entry.input));
+    const shown = run.map(({ entry, index }, i) => ({ step: index + 1, input: inputs.own[i], ...show(entry) }));
+    const lines = inputs.shared === null ? "" : `\nIn every call: ${inputs.shared}`;
+    const same = shown.every((s) => s.text === shown[0].text && s.marks === shown[0].marks);
+    if (same) {
+        return (`${head}${lines}\nEvery call's result${shown[0].marks}: ${shown[0].text}` +
+            shown.map((s) => `\n${s.step}: ${s.input}`).join(""));
+    }
+    return head + lines + shown.map((s) => `\n${s.step}${s.marks}: ${s.input} -> ${s.text}`).join("");
+}
+/**
+ * The input fields a run of calls all share, said once, and what is left of
+ * each call's input. A forward sends thirty-two emails to one recipient; the
+ * recipient need not be read thirty-two times. Only plain JSON objects are
+ * split, and only on fields present in every call with the same value; an
+ * input that was capped, or is not an object, leaves the run as it came.
+ */
+function sharedInput(inputs) {
+    const asCame = { shared: null, own: [...inputs] };
+    const objects = [];
+    for (const input of inputs) {
+        let parsed;
+        try {
+            parsed = JSON.parse(input);
+        }
+        catch {
+            return asCame;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return asCame;
+        objects.push(parsed);
+    }
+    const value = (o, key) => JSON.stringify(o[key]);
+    const common = Object.keys(objects[0]).filter((key) => objects.every((o) => Object.hasOwn(o, key) && value(o, key) === value(objects[0], key)));
+    if (common.length === 0)
+        return asCame;
+    const pick = (o, keep) => JSON.stringify(Object.fromEntries(Object.entries(o).filter(([key]) => keep(key))));
+    return {
+        shared: pick(objects[0], (key) => common.includes(key)),
+        own: objects.map((o) => pick(o, (key) => !common.includes(key))),
+    };
 }
 /** Truncate to `max` chars, appending a marker naming how much was dropped. */
 export function truncate(s, max) {