fix(core): show the start of tool output that exceeds the limit (#63272)

This commit is contained in:
Aiden Cline
2026-11-11 15:38:06 -06:00
committed by GitHub
Unverified
parent afbd99f93f
commit 7392bd4567
2 changed files with 238 additions and 28 deletions
+69 -23
View File
@@ -75,48 +75,56 @@ const layer = Layer.effect(
const truncate = Effect.fnUntraced(function* (result: Result) {
if (result.metadata?.truncated !== undefined) return result
const content = result.content
const text = content.flatMap((item) => (item.type === "text" ? [item.text] : [])).join("\n")
// A line break joins text parts unless the text before already ends in one.
const text = content.reduce(
(joined, item) =>
item.type !== "text"
? joined
: joined === "" || joined.endsWith("\n")
? joined + item.text
: `${joined}\n${item.text}`,
"",
)
const limits = state.get()
const lines = text.split("\n")
if (text.endsWith("\n")) lines.pop()
const totalBytes = Buffer.byteLength(text, "utf-8")
if (lines.length <= limits.maxLines && totalBytes <= limits.maxBytes)
const totalLines = countLines(text)
if (totalLines <= limits.maxLines && Buffer.byteLength(text, "utf-8") <= limits.maxBytes)
return { ...result, metadata: { ...result.metadata, truncated: false } }
const kept: string[] = []
let bytes = 0
for (const line of lines.slice(0, limits.maxLines)) {
const size = Buffer.byteLength(line, "utf-8") + (kept.length > 0 ? 1 : 0)
if (bytes + size > limits.maxBytes) break
kept.push(line)
bytes += size
}
// Cut once, at the line or byte limit, whichever comes first, so a line too long for the space left shows its
// start. The preview never ends on a line break.
const end = Math.min(afterLines(text, limits.maxLines), byteBoundary(text, limits.maxBytes))
const shown = text.slice(0, text.endsWith("\r\n", end) ? end - 2 : text.endsWith("\n", end) ? end - 1 : end)
const file = path.join(directory, fileName())
const failure = yield* fs.ensureDir(directory).pipe(
Effect.andThen(fs.writeFileString(file, text)),
Effect.as(undefined),
Effect.catch((error) =>
Effect.logWarning("failed to save full tool output", { file, cause: error }).pipe(
Effect.as(describe(error)),
),
Effect.logWarning("failed to save full tool output", { file, cause: error }).pipe(Effect.as(describe(error))),
),
)
const shown = kept.length > 0 ? `lines 1-${kept.length}` : "0 lines"
const marker = `[showing ${shown} of ${lines.length}; ${
// Counted before the final line break is stripped, so a blank last line still counts.
const shownLines = countLines(text.slice(0, end))
const lastLineCut =
shownLines > 0 &&
shown.length < text.length &&
!text.startsWith("\n", shown.length) &&
!text.startsWith("\r\n", shown.length)
const range = shownLines === 0 ? "0 lines" : `lines 1-${shownLines}`
const marker = `[showing ${range} of ${totalLines}${lastLineCut ? " (last line cut)" : ""}; ${
failure === undefined ? `full output saved to ${file}` : `full output could not be saved: ${failure}`
}]`
const bounded: Tool.Content[] = []
let remaining = kept.join("\n").length
let seenText = false
let remaining = shown.length
let separator = false
let marked = false
for (const item of content) {
if (item.type === "file") {
bounded.push(item)
continue
}
if (seenText && remaining > 0) remaining--
seenText = true
if (remaining >= item.text.length) {
if (separator && remaining > 0) remaining--
separator = item.text !== "" && !item.text.endsWith("\n")
if (!marked && remaining >= item.text.length) {
bounded.push(item)
remaining -= item.text.length
continue
@@ -172,3 +180,41 @@ export const node = makeLocationNode({
layer,
deps: [FSUtil.node, Global.node, cleanupNode],
})
/** How many lines `text` has, not counting an empty one after a final line break. Counts without splitting. */
function countLines(text: string) {
if (text === "") return 0
let count = 1
for (let index = text.indexOf("\n"); index !== -1 && index < text.length - 1; index = text.indexOf("\n", index + 1))
count++
return count
}
/** Where the line after the first `count` lines starts, or the end of `text`. */
function afterLines(text: string, count: number) {
let index = 0
for (let line = 0; line < count; line++) {
const next = text.indexOf("\n", index)
if (next === -1) return text.length
index = next + 1
}
return index
}
const encoder = new TextEncoder()
const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" })
/** The longest start of `text` that fits in `budget` UTF-8 bytes without splitting a character, emoji included. */
function byteBoundary(text: string, budget: number) {
// encodeInto only encodes what fits in the buffer, and stops at a whole code point.
const index = encoder.encodeInto(text, new Uint8Array(Math.max(0, budget))).read
if (index === text.length || index === 0) return index
const before = text.charCodeAt(index - 1)
const after = text.charCodeAt(index)
// Two ASCII characters always have a boundary between them, except the two halves of \r\n.
if (before < 0x80 && after < 0x80) return before === 13 && after === 10 ? index - 1 : index
// Otherwise back off to the start of the grapheme the cut is in. A line break always ends one, so segmenting from the
// start of the line keeps flag pairs and long emoji sequences exact; one code point past the cut gives the context.
const start = text.lastIndexOf("\n", index - 1) + 1
return start + (graphemes.segment(text.slice(start, index + 2)).containing(index - start)?.index ?? index - start)
}
+169 -5
View File
@@ -59,7 +59,9 @@ describe("ToolOutput", () => {
{ type: "text", text: "one\ntwo" },
{
type: "text",
text: expect.stringMatching(/^\[showing lines 1-2 of 3; full output could not be saved: E[A-Z]+: [^\n]+\]$/),
text: expect.stringMatching(
/^\[showing lines 1-2 of 3; full output could not be saved: E[A-Z]+: [^\n]+\]$/,
),
},
])
}),
@@ -67,16 +69,16 @@ describe("ToolOutput", () => {
),
)
it.live("reports lines shown under the byte limit", () =>
it.live("cuts at the byte limit, inside a line when it falls there", () =>
withStore(
(output) =>
Effect.gen(function* () {
const result = yield* output.truncate({ content: [{ type: "text", text: "one\ntwo" }] })
expect(result.content).toEqual([
{ type: "text", text: "one" },
{ type: "text", text: "one\nt" },
{
type: "text",
text: expect.stringMatching(/^\[showing lines 1-1 of 2; full output saved to .+\]$/),
text: expect.stringMatching(/^\[showing lines 1-2 of 2 \(last line cut\); full output saved to .+\]$/),
},
])
}),
@@ -84,6 +86,165 @@ describe("ToolOutput", () => {
),
)
it.live("shows the start of a single line longer than the byte limit", () =>
withStore(
(output) =>
Effect.gen(function* () {
const text = JSON.stringify({ items: Array.from({ length: 50 }, (_, index) => index) })
const result = yield* output.truncate({ content: [{ type: "text", text }] })
expect(result.content).toEqual([
{ type: "text", text: text.slice(0, 20) },
{
type: "text",
text: expect.stringMatching(
new RegExp("^\\[showing lines 1-1 of 1 \\(last line cut\\); full output saved to .+\\]$"),
),
},
])
}),
{ maxLines: 100, maxBytes: 20 },
),
)
it.live("never splits a character or an emoji at the cut", () =>
withStore(
(output) =>
Effect.gen(function* () {
const family = "👨‍👩‍👧‍👦"
const cases = [
{ text: "ab✓✓✓", shown: "ab✓" },
{ text: `ab${family}cd`, shown: "ab" },
{ text: "ab👍🏽cd", shown: "ab" },
{ text: "ab🇯🇵cd", shown: "ab" },
{ text: "ab𝒳𝒳", shown: "ab𝒳" },
]
for (const item of cases) {
const result = yield* output.truncate({ content: [{ type: "text", text: item.text }] })
const first = result.content[0]
expect(first).toEqual({ type: "text", text: item.shown })
expect(first?.type === "text" && first.text.isWellFormed()).toBe(true)
}
}),
{ maxLines: 100, maxBytes: 7 },
),
)
it.live("keeps flags and long clusters whole however long the text before them", () =>
withStore(
(output) =>
Effect.gen(function* () {
const flags = yield* output.truncate({ content: [{ type: "text", text: "a" + "🇯🇵".repeat(40) }] })
expect(flags.content[0]).toEqual({ type: "text", text: "a" + "🇯🇵".repeat(20) })
const cluster = "👍" + "🏽\u0301".repeat(60)
const long = yield* output.truncate({ content: [{ type: "text", text: `ab${cluster}z` }] })
expect(long.content[0]).toEqual({ type: "text", text: "ab" })
}),
{ maxLines: 100, maxBytes: 165 },
),
)
it.live("cuts inside a later text part and leaves out the parts after it", () =>
withStore(
(output) =>
Effect.gen(function* () {
const inside = yield* output.truncate({
content: [
{ type: "text", text: "" },
{ type: "text", text: "abc" },
{ type: "text", text: "defgh" },
{ type: "text", text: "" },
],
})
expect(inside.content).toEqual([
{ type: "text", text: "" },
{ type: "text", text: "abc" },
{ type: "text", text: "de" },
{
type: "text",
text: expect.stringMatching(/^\[showing lines 1-2 of 2 \(last line cut\);/),
},
])
const between = yield* output.truncate({
content: [
{ type: "text", text: "abcde" },
{ type: "text", text: "fgh" },
],
})
expect(between.content).toEqual([
{ type: "text", text: "abcde" },
{ type: "text", text: expect.stringMatching(/^\[showing lines 1-1 of 2;/) },
])
}),
{ maxLines: 100, maxBytes: 6 },
),
)
it.live("ends a line cut before its line break", () =>
withStore(
(output) =>
Effect.gen(function* () {
const crlf = yield* output.truncate({ content: [{ type: "text", text: "one\r\ntwo\r\nthree" }] })
expect(crlf.content).toEqual([
{ type: "text", text: "one" },
{ type: "text", text: expect.stringMatching(/^\[showing lines 1-1 of 3;/) },
])
const blank = yield* output.truncate({ content: [{ type: "text", text: "\nfoo\nbar" }] })
expect(blank.content).toEqual([{ type: "text", text: expect.stringMatching(/^\[showing lines 1-1 of 3;/) }])
}),
{ maxLines: 1, maxBytes: 1_000 },
),
)
it.live("counts a blank last line of the preview", () =>
withStore(
(output) =>
Effect.gen(function* () {
const result = yield* output.truncate({ content: [{ type: "text", text: "a\n\n\nb" }] })
expect(result.content).toEqual([
{ type: "text", text: "a\n" },
{ type: "text", text: expect.stringMatching(/^\[showing lines 1-2 of 4;/) },
])
}),
{ maxLines: 2, maxBytes: 1_000 },
),
)
it.live("shows nothing under a zero line limit", () =>
withStore(
(output) =>
Effect.gen(function* () {
const result = yield* output.truncate({ content: [{ type: "text", text: "secret" }] })
expect(result.content).toEqual([{ type: "text", text: expect.stringMatching(/^\[showing 0 lines of 1;/) }])
}),
{ maxLines: 0, maxBytes: 1_000 },
),
)
it.live("joins text parts with a line break only where one is missing", () =>
withStore(
(output, fs) =>
Effect.gen(function* () {
const result = yield* output.truncate({
content: [
{ type: "text", text: "one\n" },
{ type: "text", text: "two" },
{ type: "text", text: "three" },
],
})
const outputPath = result.metadata?.outputPath
expect(typeof outputPath).toBe("string")
if (typeof outputPath !== "string") return
expect(yield* fs.readFileString(outputPath)).toBe("one\ntwo\nthree")
expect(result.content).toEqual([
{ type: "text", text: "one\n" },
{ type: "text", text: "two" },
{ type: "text", text: expect.stringMatching(/^\[showing lines 1-2 of 3;/) },
])
}),
{ maxLines: 2, maxBytes: 1_000 },
),
)
it.live("preserves mixed content ordering", () =>
withStore(
(output) =>
@@ -144,7 +305,10 @@ describe("ToolOutput", () => {
const result = yield* output.truncate({ content: [{ type: "text", text: "one\n" }] })
expect(result.content).toEqual([
{ type: "text", text: "one" },
{ type: "text", text: expect.stringMatching(/^\[showing lines 1-1 of 1; full output saved to /) },
{
type: "text",
text: expect.stringMatching(/^\[showing lines 1-1 of 1; full output saved to /),
},
])
}),
{ maxLines: 2, maxBytes: 3 },