perf(dashboard-agent): cap read_file at 48KB / 1500 lines

A single read could put ~65k tokens in the transcript, paid for on every later
turn. The truncation notice points at the line range, and the range is now applied
before the cap so a read past the ceiling returns the lines asked for.

Author: kathiekiwi

internal-packages/dashboard-agent/src/dashboard-agent.test.ts

@@ -2490,9 +2490,9 @@ describe("the view-model tools don't echo the view back to the model", () => {
   ) {
     const modelMessages = await convertToModelMessages([message], { tools });
     const part = modelMessages
-      .flatMap((m) => (Array.isArray(m.content) ? m.content : []))
-      .find((p) => (p as { type: string }).type === "tool-result");
-    return (part as { output: { type: string; value: unknown } }).output;
+      .flatMap((m) => (Array.isArray(m.content) ? (m.content as Array<{ type: string }>) : []))
+      .find((p) => p.type === "tool-result");
+    return (part as unknown as { output: { type: string; value: unknown } }).output;
   }
 
   it("render_view hands the blocks to the client and an acknowledgement to the model", async () => {

internal-packages/dashboard-agent/src/repo-tools.test.ts

@@ -2,7 +2,14 @@ import { execFileSync } from "node:child_process";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { buildRepoTools, disposeRepoWorkspaces, workdirFor, type RepoSnapshot } from "./repo-tools";
+import {
+  buildRepoTools,
+  disposeRepoWorkspaces,
+  MAX_READ_BYTES,
+  MAX_READ_LINES,
+  workdirFor,
+  type RepoSnapshot,
+} from "./repo-tools";
 
 // The code tools normally download + extract a tarball. Here we pre-seed the
 // deterministic workspace path with a `.ready` marker, so `ensureWorkspace`
@@ -49,6 +56,17 @@ beforeAll(async () => {
     'import { task } from "@trigger.dev/sdk";\nconst LIMIT = 10000;\nexport const order = task({ id: "order" });\n'
   );
   await writeFile(join(dir, "README.md"), "# demo\n");
+  // Both ceilings blown: 4000 lines and ~200KB. Line 3000 is findable so a range
+  // read can be checked past the line cap.
+  await writeFile(
+    join(dir, "src/trigger/huge.ts"),
+    Array.from({ length: 4000 }, (_, i) => `// line ${i + 1} ${"x".repeat(40)}`).join("\n")
+  );
+  // 4000 short lines: under the byte ceiling, so the line ceiling is what bites.
+  await writeFile(
+    join(dir, "src/trigger/narrow.ts"),
+    Array.from({ length: 4000 }, () => "//").join("\n")
+  );
   await writeFile(join(dir, ".ready"), snapshot.sha);
 
   // The pinned commit's workspace, with a different LIMIT.
@@ -93,6 +111,40 @@ describe("repo-tools", () => {
     expect(res.endLine).toBe(2);
   });
 
+  it("read_file caps a big file and tells the model how to get the rest", async () => {
+    const res: any = await call(tools.read_file, { path: "src/trigger/huge.ts" });
+    expect(res.truncated).toBe(true);
+    expect(res.notice).toMatch(/startLine and endLine/);
+    // Long lines, so the byte ceiling bites before the line ceiling.
+    expect(res.content.split("\n").length).toBeLessThanOrEqual(MAX_READ_LINES);
+    expect(Buffer.byteLength(res.content, "utf8")).toBeLessThanOrEqual(MAX_READ_BYTES);
+    expect(res.content).not.toContain("// line 1501 ");
+  });
+
+  it("read_file caps a long file of short lines at the line ceiling", async () => {
+    const res: any = await call(tools.read_file, { path: "src/trigger/narrow.ts" });
+    expect(res.truncated).toBe(true);
+    expect(res.content.split("\n")).toHaveLength(MAX_READ_LINES);
+    expect(Buffer.byteLength(res.content, "utf8")).toBeLessThan(MAX_READ_BYTES);
+  });
+
+  it("read_file serves a range past the line cap, since the cap is applied after it", async () => {
+    const res: any = await call(tools.read_file, {
+      path: "src/trigger/huge.ts",
+      startLine: 3000,
+      endLine: 3002,
+    });
+    expect(res.truncated).toBeUndefined();
+    expect(res.content.split("\n")[0]).toContain("// line 3000 ");
+    expect(res.startLine).toBe(3000);
+  });
+
+  it("read_file leaves a small file untruncated", async () => {
+    const res: any = await call(tools.read_file, { path: "src/trigger/order.ts" });
+    expect(res.truncated).toBe(false);
+    expect(res.notice).toBeUndefined();
+  });
+
   it("read_file refuses to escape the repository root", async () => {
     for (const path of ["../../../etc/passwd", "src/../../escape", "../outside.txt"]) {
       const res: any = await call(tools.read_file, { path });

internal-packages/dashboard-agent/src/repo-tools.ts

@@ -38,11 +38,30 @@ export type RepoSnapshot = {
 };
 
 const MAX_ARCHIVE_BYTES = 100 * 1024 * 1024; // 100MB ceiling on the download
-const MAX_READ_BYTES = 256 * 1024; // per read_file
+// A tool result the model has to pay for on every later turn of the conversation:
+// 48KB is ~12k tokens, where the old 256KB ceiling was ~65k.
+export const MAX_READ_BYTES = 48 * 1024;
+export const MAX_READ_LINES = 1500;
 const MAX_LIST_FILES = 500;
 const MAX_MATCHES = 80;
 const FETCH_TIMEOUT_MS = 30_000;
 
+// Points at the mechanism the prompt already teaches — the stack-trace line is
+// where a truncated read gets resumed.
+export const READ_TRUNCATION_NOTICE =
+  `Truncated to the first ${MAX_READ_LINES} lines / ${MAX_READ_BYTES / 1024}KB. ` +
+  "Read the part you need with startLine and endLine — the line from the stack trace or the search match is where to start.";
+
+/** Caps a read at both ceilings, whichever bites first. */
+function capRead(content: string): { content: string; truncated: boolean } {
+  const lines = content.split("\n");
+  let capped = lines.length > MAX_READ_LINES ? lines.slice(0, MAX_READ_LINES).join("\n") : content;
+  if (Buffer.byteLength(capped, "utf8") > MAX_READ_BYTES) {
+    capped = Buffer.from(capped, "utf8").subarray(0, MAX_READ_BYTES).toString("utf8");
+  }
+  return { content: capped, truncated: capped.length !== content.length };
+}
+
 // In-flight + completed extractions, keyed by workdir, so concurrent tool calls
 // in a turn extract once. Module scope: shared across turns of a warm run.
 const workspaces = new Map<string, Promise<string>>();
@@ -236,23 +255,29 @@ export function buildRepoTools(
         if (realTarget && !isInside(workdir, realTarget)) {
           return { error: "Path escapes the repository root." };
         }
-        let content: string;
-        let truncated = false;
+        let whole: string;
         try {
-          const buf = await readFile(realTarget ?? target);
-          content = buf.subarray(0, MAX_READ_BYTES).toString("utf8");
-          truncated = buf.length > MAX_READ_BYTES;
+          whole = (await readFile(realTarget ?? target)).toString("utf8");
         } catch {
           return { error: `Couldn't read ${path} (not found or not a file).` };
         }
+        // The range is applied before the cap: capping first made a range past the
+        // ceiling come back empty rather than as the lines that were asked for.
         if (startLine != null || endLine != null) {
-          const lines = content.split("\n");
+          const lines = whole.split("\n");
           const from = Math.max(1, startLine ?? 1);
           const to = Math.min(lines.length, endLine ?? lines.length);
-          content = lines.slice(from - 1, to).join("\n");
-          return { path, content, startLine: from, endLine: to };
+          const range = capRead(lines.slice(from - 1, to).join("\n"));
+          return {
+            path,
+            content: range.content,
+            startLine: from,
+            endLine: to,
+            ...(range.truncated ? { truncated: true, notice: READ_TRUNCATION_NOTICE } : {}),
+          };
         }
-        return { path, content, truncated };
+        const { content, truncated } = capRead(whole);
+        return { path, content, truncated, ...(truncated ? { notice: READ_TRUNCATION_NOTICE } : {}) };
       },
     }),