Apply the shared truncation primitive where grep results are returned

ripgrepPlugin answers grep and search_files without calling next, so the
result-truncation middleware later in the plugin array never observed
those results and an oversized grep reached the model uncapped. Apply
the shared primitive at ripgrepPlugin's own return paths, and restore
the match-count notice, which reports an omission no size-based pass can
infer.

Author: TheGreatAxios

src/plugins/result-truncation-plugin.ts

@@ -4,16 +4,14 @@ const TRUNCATABLE_TOOLS = new Set(["read_file", "grep", "run_shell", "search_fil
 
 // Characters, not tokens — conversion ratio is roughly 4 chars/token.
 // 80 000 chars ≈ 20 000 tokens. Keeps a single result from dominating context.
-const MAX_RESULT_CHARS = 80_000;
+export const MAX_RESULT_CHARS = 80_000;
 
-// Shared with the MCP tool runner (src/mcp/plugin.ts), which is not part of
-// the posix runner this middleware wraps and so applies the same truncation
-// directly. This is the single primitive that produces a truncation notice —
-// callers may pass their own threshold but never invent their own wording, so
-// a result can never carry two differently-worded "truncated" notices. The
-// grep-specific caps in rg-output.ts and ripgrep-plugin.ts deliberately don't
-// call this: they trim silently and leave notice duty to this middleware,
-// which runs after them in the plugin chain and sees the final content.
+// The single primitive for size truncation: callers may pass their own
+// threshold but never invent their own wording, so a result can never carry
+// two differently-worded "truncated" notices. Called directly by runners this
+// middleware does not wrap — the MCP tool runner (src/mcp/plugin.ts), and
+// ripgrep-plugin.ts, which answers grep without calling next and so never
+// reaches this middleware despite sitting earlier in the same plugin array.
 export function truncateToolResultContent(
   content: string,
   maxChars: number = MAX_RESULT_CHARS,

src/plugins/ripgrep-plugin.ts

@@ -1,13 +1,15 @@
 import { statSync } from "node:fs";
 import { dirname, basename } from "node:path";
 import type { ToolPlugin } from "@intx/tools-posix";
+import type { ToolResult } from "@intx/types/runtime";
 
 import {
   runBoundedGrep,
   runBoundedSearchFiles,
   type BoundedGrepArgs,
 } from "./bounded-grep-fallback.js";
 import { createRgCollector } from "./rg-output.js";
+import { truncateToolResultContent } from "./result-truncation-plugin.js";
 import { MAX_OUTPUT_BYTES, runRg, type RgLimits, type SpawnRg } from "./rg-run.js";
 
 // A grep over a large tree with the pure-TypeScript walker enumerates the whole
@@ -21,19 +23,28 @@ import { MAX_OUTPUT_BYTES, runRg, type RgLimits, type SpawnRg } from "./rg-run.j
 const DEFAULT_GREP_MAX = 500;
 const DEFAULT_SEARCH_MAX = 1000;
 
-// Caps the number of matches shown; carries no notice of its own. The final
-// tool result still passes through result-truncation-plugin.ts, which is the
-// single place a "truncated" notice gets attached — a count-based notice
-// here would double up with that pass whenever both conditions are true.
+// Dropping matches is a different fact from dropping characters, and the size
+// pass below cannot infer it: a run can be well under the char cap and still
+// have discarded thousands of matches. That omission is announced here; the
+// size cap announces its own.
 function capLines(text: string, max: number): string {
   const lines = text.split("\n").filter((line) => line.length > 0);
-  return lines.slice(0, max).join("\n");
+  if (lines.length <= max) return lines.join("\n");
+  return `${lines.slice(0, max).join("\n")}\n... (showing first ${max} of ${lines.length}+ matches; narrow path/glob)`;
+}
+
+// ripgrepPlugin answers grep and search_files without calling next, so the
+// result-truncation middleware sitting later in the chain never sees these
+// results. The shared primitive is applied here instead, keeping one wording
+// for size truncation on a path that would otherwise return uncapped.
+function bounded(callId: string, content: string): ToolResult {
+  return { callId, content: truncateToolResultContent(content) };
 }
 
 // Mirrors read_file's truncate-and-offer behavior: a cap or timeout still
 // surfaces whatever matches were collected before it fired, instead of
 // discarding them behind a bare error. `notice` is only set for conditions
-// result-truncation-plugin.ts can't see, like a run timing out.
+// neither cap describes, like a run timing out.
 function partialContent(stdout: string, maxResults: number, notice?: string): string {
   const capped = capLines(stdout, maxResults);
   if (capped.length === 0) {
@@ -103,7 +114,7 @@ export function ripgrepPlugin(cwd: string, limits: RgLimits = {}, spawnChild?: S
             };
             if (glob !== undefined) boundedArgs.glob = glob;
             const content = await runBoundedGrep(boundedArgs, signal, rgCwd);
-            return { callId: call.id, content: boundedContent(content, maxResults, maxBytes) };
+            return bounded(call.id, boundedContent(content, maxResults, maxBytes));
           } catch (err) {
             return {
               callId: call.id,
@@ -119,9 +130,9 @@ export function ripgrepPlugin(cwd: string, limits: RgLimits = {}, spawnChild?: S
           return { callId: call.id, content: result.message, isError: true };
         }
         if (result.kind === "partial") {
-          return { callId: call.id, content: partialContent(result.stdout, maxResults, result.notice) };
+          return bounded(call.id, partialContent(result.stdout, maxResults, result.notice));
         }
-        return { callId: call.id, content: capLines(result.stdout, maxResults) };
+        return bounded(call.id, capLines(result.stdout, maxResults));
       }
 
       if (call.name === "search_files") {
@@ -139,7 +150,7 @@ export function ripgrepPlugin(cwd: string, limits: RgLimits = {}, spawnChild?: S
               signal,
               rgCwd,
             );
-            return { callId: call.id, content: boundedContent(content, maxResults, maxBytes) };
+            return bounded(call.id, boundedContent(content, maxResults, maxBytes));
           } catch (err) {
             return {
               callId: call.id,
@@ -155,9 +166,9 @@ export function ripgrepPlugin(cwd: string, limits: RgLimits = {}, spawnChild?: S
           return { callId: call.id, content: result.message, isError: true };
         }
         if (result.kind === "partial") {
-          return { callId: call.id, content: partialContent(result.stdout, maxResults, result.notice) };
+          return bounded(call.id, partialContent(result.stdout, maxResults, result.notice));
         }
-        return { callId: call.id, content: capLines(result.stdout, maxResults) };
+        return bounded(call.id, capLines(result.stdout, maxResults));
       }
 
       return next(call, signal);

tests/unit/ripgrep-plugin.test.ts

@@ -4,8 +4,12 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import type { ToolCall, ToolResult } from "@intx/types/runtime";
 
+import { createPosixTools } from "@intx/tools-posix";
+
 import { ripgrepPlugin } from "../../src/plugins/ripgrep-plugin.js";
-import { resultTruncationPlugin } from "../../src/plugins/result-truncation-plugin.js";
+import { MAX_RESULT_CHARS } from "../../src/plugins/result-truncation-plugin.js";
+import { buildCorePosixToolPlugins } from "../../src/agent/posix-tool-plugins.js";
+import { createPermissionGate } from "../../src/permission/gate.js";
 import type { RgChild, SpawnRg } from "../../src/plugins/rg-run.js";
 
 // Repo root derived from this file, not process.cwd(): these cases search real
@@ -151,12 +155,11 @@ test("the output byte cap holds when ripgrep is unavailable", async () => {
 });
 
 // A grep run that both breaches the byte cap (rg-output.ts) and matches more
-// lines than max_results (ripgrep-plugin.ts's own count cap) used to carry
-// two notices: capLines added its own "(showing first N of M+ lines...)"
-// text on top of whatever the byte-cap breach had already reported, because
-// partialContent concatenated both unconditionally. It must report the
-// truncation exactly once.
-test("a grep result that hits both the byte cap and the match-count cap carries exactly one truncation notice", async () => {
+// lines than max_results (ripgrep-plugin.ts's own count cap) used to stack the
+// byte cap's wording on top of the count cap's. The byte cap is silent now, so
+// what is left describes the omission the reader cannot otherwise detect: how
+// many matches were dropped.
+test("a grep result that hits both the byte cap and the match-count cap announces the dropped matches once", async () => {
   // 400 matched lines emitted directly, bypassing a real `rg` process so
   // nothing upstream of ripgrep-plugin.ts pre-limits the line count.
   const result = await run(
@@ -167,37 +170,65 @@ test("a grep result that hits both the byte cap and the match-count cap carries
 
   expect(result.isError).toBeUndefined();
   const content = String(result.content);
-  // Both grep-specific caps fired (byte cap at 200 bytes, line cap at 3
-  // matches) but neither attaches its own notice — ripgrep-plugin.ts leaves
-  // that to result-truncation-plugin.ts, which runs later in the real chain
-  // and sees the final content. A regression that reintroduces either cap's
-  // own notice text would fail this.
-  expect(content.split("\n").length).toBeLessThanOrEqual(3);
-  expect(content).not.toMatch(/showing first|exceeded \d+ bytes|timed out/);
+  expect(content.split("\n").filter((l) => l.includes("match line here")).length).toBe(3);
+  expect((content.match(/showing first/g) ?? []).length).toBe(1);
+  expect(content).not.toMatch(/exceeded \d+ bytes|timed out|\[output truncated/);
 });
 
-// The same result, run through the full chain (ripgrepPlugin then
-// result-truncation-plugin, matching buildCorePosixToolPlugins in
-// src/agent/posix-tool-plugins.ts), still carries at most one notice — the
-// grep-specific caps stay silent and result-truncation-plugin.ts's char cap
-// is the backstop for content that's still oversized after them.
-test("a large grep result carries at most one truncation notice through the plugin chain", async () => {
+// Composed through buildCorePosixToolPlugins, not a hand-assembled pair:
+// ripgrepPlugin sits at an earlier array index than resultTruncationPlugin and
+// answers grep without calling next, so resultTruncationPlugin never sees a
+// grep result. Assembling the two by hand in the other order hides that and
+// lets an oversized result reach the model uncapped and unannounced.
+async function grepThroughRealChain(dir: string): Promise<string> {
+  const gate = createPermissionGate({
+    approvals: [],
+    interactive: false,
+    skipPermissions: true,
+    cwd: dir,
+  });
+  const runner = createPosixTools({
+    cwd: dir,
+    plugins: buildCorePosixToolPlugins({ cwd: dir, permissionGate: gate }),
+  });
+  const result = await runner.run(
+    { id: "c", name: "grep", arguments: { pattern: "line", path: dir } },
+    new AbortController().signal,
+  );
+  expect(result.isError).not.toBe(true);
+  return String(result.content);
+}
+
+async function writeOversizedHaystack(dir: string): Promise<void> {
+  const lines = Array.from({ length: 5000 }, (_, i) => `line ${i} ${"x".repeat(300)}`);
+  await writeFile(join(dir, "big.txt"), lines.join("\n") + "\n");
+}
+
+function truncationNoticeCount(content: string): number {
+  return (content.match(/\[output truncated/g) ?? []).length;
+}
+
+test("an oversized grep result is capped and announced once through the real plugin chain", async () => {
   await withTempDir(async (dir) => {
-    const lines = Array.from({ length: 1000 }, (_, i) => `line ${i} ${"x".repeat(300)}`);
-    await writeFile(join(dir, "big.txt"), lines.join("\n") + "\n");
-
-    const grepHandler = ripgrepPlugin(dir).middleware!(fallback);
-    const handler = resultTruncationPlugin().middleware!(grepHandler);
-    const result = await handler(
-      { id: "c", name: "grep", arguments: { pattern: "line", path: dir } },
-      new AbortController().signal,
-    );
+    await writeOversizedHaystack(dir);
+    const content = await grepThroughRealChain(dir);
 
-    expect(result.isError).toBeUndefined();
-    const content = String(result.content);
-    expect(content).toContain("output truncated");
+    expect(content.length).toBeLessThanOrEqual(MAX_RESULT_CHARS + 200);
+    expect(truncationNoticeCount(content)).toBe(1);
     expect(content).not.toContain("showing first");
-    expect((content.match(/\[output truncated/g) ?? []).length).toBe(1);
+  });
+});
+
+test("an oversized grep result is capped and announced once when ripgrep is unavailable", async () => {
+  await withTempDir(async (dir) => {
+    await writeOversizedHaystack(dir);
+    await withoutRipgrep(async () => {
+      const content = await grepThroughRealChain(dir);
+
+      expect(content.length).toBeLessThanOrEqual(MAX_RESULT_CHARS + 200);
+      expect(truncationNoticeCount(content)).toBe(1);
+      expect(content).not.toContain("showing first");
+    });
   });
 });