@oh-my-pi/pi-coding-agent 13.10.1 → 13.11.1

package/src/tools/grep.ts

@@ -16,7 +16,13 @@ import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, t
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
-import { combineSearchGlobs, hasGlobPathChars, parseSearchPath, resolveToCwd } from "./path-utils";
+import {
+	combineSearchGlobs,
+	hasGlobPathChars,
+	parseSearchPath,
+	resolveMultiSearchPath,
+	resolveToCwd,
+} from "./path-utils";
 import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -107,7 +113,12 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			const effectiveMultiline = multiline ?? patternHasNewline;
 
 			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
+			const formatScopePath = (targetPath: string): string => {
+				const relative = path.relative(this.session.cwd, targetPath).replace(/\\/g, "/");
+				return relative.length === 0 ? "." : relative;
+			};
 			let searchPath: string;
+			let scopePath: string;
 			let globFilter = glob?.trim() || undefined;
 			const internalRouter = this.session.internalRouter;
 			if (searchDir?.trim()) {
@@ -121,27 +132,33 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						throw new ToolError(`Cannot grep internal URL without a backing file: ${rawPath}`);
 					}
 					searchPath = resource.sourcePath;
+					scopePath = formatScopePath(searchPath);
 				} else {
-					const parsedPath = parseSearchPath(rawPath);
-					searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-					if (parsedPath.glob) {
-						globFilter = combineSearchGlobs(parsedPath.glob, globFilter);
+					const multiSearchPath = await resolveMultiSearchPath(rawPath, this.session.cwd, globFilter);
+					if (multiSearchPath) {
+						searchPath = multiSearchPath.basePath;
+						globFilter = multiSearchPath.glob;
+						scopePath = multiSearchPath.scopePath;
+					} else {
+						const parsedPath = parseSearchPath(rawPath);
+						searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
+						if (parsedPath.glob) {
+							globFilter = combineSearchGlobs(parsedPath.glob, globFilter);
+						}
+						scopePath = formatScopePath(searchPath);
 					}
 				}
 			} else {
 				searchPath = resolveToCwd(".", this.session.cwd);
+				scopePath = ".";
 			}
-			const scopePath = (() => {
-				const relative = path.relative(this.session.cwd, searchPath).replace(/\\/g, "/");
-				return relative.length === 0 ? "." : relative;
-			})();
 
 			let isDirectory: boolean;
 			try {
 				const stat = await Bun.file(searchPath).stat();
 				isDirectory = stat.isDirectory();
 			} catch {
-				throw new ToolError(`Path not found: ${searchPath}`);
+				throw new ToolError(`Path not found: ${scopePath}`);
 			}
 
 			const effectiveOutputMode = "content";

package/src/tools/output-meta.ts

@@ -12,6 +12,7 @@ import type {
 	AgentToolUpdateCallback,
 } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import { formatGroupedDiagnosticMessages } from "../lsp/utils";
 import type { Theme } from "../modes/theme/theme";
 import type { OutputSummary, TruncationResult } from "../session/streaming-output";
 import { formatBytes, wrapBrackets } from "./render-utils";
@@ -116,26 +117,28 @@ export class OutputMetaBuilder {
 		if (!result.truncated) return this;
 
 		const { direction, startLine = 1, totalFileLines, artifactId } = options;
+		const outputLines = result.outputLines ?? result.totalLines;
+		const outputBytes = result.outputBytes ?? result.totalBytes;
+		const truncatedBy: "lines" | "bytes" = result.truncatedBy === "lines" ? "lines" : "bytes";
 
 		let shownStart: number;
 		let shownEnd: number;
 
 		if (direction === "tail") {
-			shownStart = result.totalLines - result.outputLines + 1;
+			shownStart = result.totalLines - outputLines + 1;
 			shownEnd = result.totalLines;
 		} else {
 			shownStart = startLine;
-			shownEnd = startLine + result.outputLines - 1;
+			shownEnd = startLine + outputLines - 1;
 		}
 
 		this.#meta.truncation = {
 			direction,
-			truncatedBy: result.truncatedBy!,
+			truncatedBy,
 			totalLines: totalFileLines ?? result.totalLines,
 			totalBytes: result.totalBytes,
-			outputLines: result.outputLines,
-			outputBytes: result.outputBytes,
-			maxBytes: result.maxBytes,
+			outputLines,
+			outputBytes,
 			shownRange: { start: shownStart, end: shownEnd },
 			artifactId,
 			nextOffset: direction === "head" ? shownEnd + 1 : undefined,
@@ -386,7 +389,7 @@ export function formatOutputNotice(meta: OutputMeta | undefined): string {
 	let diagnosticsNotice = "";
 	if (meta.diagnostics && meta.diagnostics.messages.length > 0) {
 		const d = meta.diagnostics;
-		diagnosticsNotice = `\n\nLSP Diagnostics (${d.summary}):\n  ${d.messages.join("\n  ")}`;
+		diagnosticsNotice = `\n\nLSP Diagnostics (${d.summary}):\n${formatGroupedDiagnosticMessages(d.messages)}`;
 	}
 
 	const notice = parts.length ? `\n\n[${parts.join(". ")}]` : "";

package/src/tools/path-utils.ts

@@ -4,6 +4,14 @@ import * as path from "node:path";
 
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
 const NARROW_NO_BREAK_SPACE = "\u202F";
+const TOP_LEVEL_INTERNAL_URL_PREFIXES = [
+	"agent://",
+	"artifact://",
+	"skill://",
+	"rule://",
+	"local://",
+	"mcp://",
+] as const;
 
 function normalizeUnicodeSpaces(str: string): string {
 	return str.replace(UNICODE_SPACES, " ");
@@ -38,6 +46,15 @@ function fileExists(filePath: string): boolean {
 	}
 }
 
+async function pathExists(filePath: string): Promise<boolean> {
+	try {
+		await fs.promises.access(filePath, fs.constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 function normalizeAtPrefix(filePath: string): string {
 	if (!filePath.startsWith("@")) return filePath;
 
@@ -105,6 +122,24 @@ export interface ParsedSearchPath {
 	glob?: string;
 }
 
+export interface ParsedFindPattern {
+	basePath: string;
+	globPattern: string;
+	hasGlob: boolean;
+}
+
+export interface ResolvedMultiSearchPath {
+	basePath: string;
+	glob?: string;
+	scopePath: string;
+}
+
+export interface ResolvedMultiFindPattern {
+	basePath: string;
+	globPattern: string;
+	scopePath: string;
+}
+
 /**
  * Split a user path into a base path + glob pattern for tools that delegate to
  * APIs accepting separate `path` and `glob` arguments.
@@ -128,6 +163,44 @@ export function parseSearchPath(filePath: string): ParsedSearchPath {
 	};
 }
 
+// Parse a find pattern into a base directory path and a glob pattern.
+// Examples:
+//   src/app/**/\*.tsx -> { basePath: "src/app", globPattern: "**/*.tsx", hasGlob: true }
+//   src/app/\*.tsx -> { basePath: "src/app", globPattern: "*.tsx", hasGlob: true }
+//   \*.ts -> { basePath: ".", globPattern: "**/*.ts", hasGlob: true }
+//   **/\*.json -> { basePath: ".", globPattern: "**/*.json", hasGlob: true }
+//   /abs/path/**/\*.ts -> { basePath: "/abs/path", globPattern: "**/*.ts", hasGlob: true }
+//   src/app -> { basePath: "src/app", globPattern: "**/*", hasGlob: false }
+export function parseFindPattern(pattern: string): ParsedFindPattern {
+	const segments = pattern.split("/");
+	let firstGlobIndex = -1;
+	for (let i = 0; i < segments.length; i++) {
+		if (hasGlobPathChars(segments[i])) {
+			firstGlobIndex = i;
+			break;
+		}
+	}
+
+	if (firstGlobIndex === -1) {
+		return { basePath: pattern, globPattern: "**/*", hasGlob: false };
+	}
+
+	if (firstGlobIndex === 0) {
+		const needsRecursive = !pattern.startsWith("**/");
+		return {
+			basePath: ".",
+			globPattern: needsRecursive ? `**/${pattern}` : pattern,
+			hasGlob: true,
+		};
+	}
+
+	return {
+		basePath: segments.slice(0, firstGlobIndex).join("/"),
+		globPattern: segments.slice(firstGlobIndex).join("/"),
+		hasGlob: true,
+	};
+}
+
 export function combineSearchGlobs(prefixGlob?: string, suffixGlob?: string): string | undefined {
 	if (!prefixGlob) return suffixGlob;
 	if (!suffixGlob) return prefixGlob;
@@ -138,6 +211,281 @@ export function combineSearchGlobs(prefixGlob?: string, suffixGlob?: string): st
 	return `${normalizedPrefix}/${normalizedSuffix}`;
 }
 
+type TopLevelSeparator = "comma" | "whitespace";
+
+function splitTopLevel(value: string, separator: TopLevelSeparator): string[] {
+	const parts: string[] = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	let parenDepth = 0;
+	let quote: '"' | "'" | undefined;
+	let escaped = false;
+
+	const pushCurrent = () => {
+		const normalized = current.trim();
+		if (normalized.length > 0) {
+			parts.push(normalized);
+		}
+		current = "";
+	};
+
+	for (const char of value) {
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+
+		if (char === "\\") {
+			current += char;
+			escaped = true;
+			continue;
+		}
+
+		if (quote) {
+			current += char;
+			if (char === quote) {
+				quote = undefined;
+			}
+			continue;
+		}
+
+		if (char === '"' || char === "'") {
+			quote = char;
+			current += char;
+			continue;
+		}
+
+		if (char === "{") braceDepth += 1;
+		else if (char === "}" && braceDepth > 0) braceDepth -= 1;
+		else if (char === "[") bracketDepth += 1;
+		else if (char === "]" && bracketDepth > 0) bracketDepth -= 1;
+		else if (char === "(") parenDepth += 1;
+		else if (char === ")" && parenDepth > 0) parenDepth -= 1;
+
+		const topLevel = braceDepth === 0 && bracketDepth === 0 && parenDepth === 0;
+		const isWhitespace = /\s/.test(char);
+		if (topLevel && separator === "comma" && char === ",") {
+			pushCurrent();
+			continue;
+		}
+		if (topLevel && separator === "whitespace" && isWhitespace) {
+			pushCurrent();
+			continue;
+		}
+
+		current += char;
+	}
+
+	pushCurrent();
+	return parts.length > 1 ? parts : [value.trim()];
+}
+
+function normalizePosixPath(filePath: string): string {
+	return filePath.replace(/\\/g, "/");
+}
+
+function joinRelativeGlob(basePath: string | undefined, globPattern: string): string {
+	if (!basePath || basePath === ".") return normalizePosixPath(globPattern).replace(/^\/+/, "");
+	const normalizedBase = normalizePosixPath(basePath).replace(/\/+$/, "");
+	const normalizedGlob = normalizePosixPath(globPattern).replace(/^\/+/, "");
+	return `${normalizedBase}/${normalizedGlob}`;
+}
+
+function buildBraceUnion(patterns: string[]): string | undefined {
+	const uniquePatterns = [...new Set(patterns.map(pattern => normalizePosixPath(pattern).trim()).filter(Boolean))];
+	if (uniquePatterns.length === 0) return undefined;
+	if (uniquePatterns.length === 1) return uniquePatterns[0];
+	return `{${uniquePatterns.join(",")}}`;
+}
+
+function findCommonBasePath(paths: string[]): string {
+	if (paths.length === 0) return ".";
+	let commonParts = path.resolve(paths[0]).split(path.sep);
+	for (const candidatePath of paths.slice(1)) {
+		const candidateParts = path.resolve(candidatePath).split(path.sep);
+		let sharedCount = 0;
+		const maxShared = Math.min(commonParts.length, candidateParts.length);
+		while (sharedCount < maxShared && commonParts[sharedCount] === candidateParts[sharedCount]) {
+			sharedCount += 1;
+		}
+		commonParts = commonParts.slice(0, sharedCount);
+	}
+	if (commonParts.length === 0) {
+		return path.parse(path.resolve(paths[0])).root;
+	}
+	const joined = commonParts.join(path.sep);
+	return joined || path.parse(path.resolve(paths[0])).root;
+}
+
+function toScopeDisplay(items: string[]): string {
+	return items.map(item => normalizePosixPath(item)).join(", ");
+}
+
+function looksLikeDelimitedPathToken(token: string): boolean {
+	return (
+		TOP_LEVEL_INTERNAL_URL_PREFIXES.some(prefix => token.startsWith(prefix)) ||
+		token.startsWith(".") ||
+		token.startsWith("/") ||
+		token.startsWith("~") ||
+		token.startsWith("@") ||
+		token.includes("/") ||
+		token.includes("\\") ||
+		hasGlobPathChars(token) ||
+		/\.[^./\\]+$/.test(token)
+	);
+}
+
+async function areDelimitedTokensResolvable(
+	tokens: string[],
+	cwd: string,
+	parseBasePath: (value: string) => string,
+	allowBareExistingTokens: boolean,
+): Promise<boolean> {
+	for (const token of tokens) {
+		if (TOP_LEVEL_INTERNAL_URL_PREFIXES.some(prefix => token.startsWith(prefix))) {
+			return false;
+		}
+
+		if (!allowBareExistingTokens && !looksLikeDelimitedPathToken(token)) {
+			// Bare names like "packages" don't look like path tokens syntactically,
+			// but may still be valid directory names. Check existence before rejecting.
+			const resolvedExactPath = resolveToCwd(token, cwd);
+			if (!(await pathExists(resolvedExactPath))) {
+				return false;
+			}
+			continue;
+		}
+
+		const basePath = parseBasePath(token);
+		const resolvedBasePath = resolveToCwd(basePath, cwd);
+		if (await pathExists(resolvedBasePath)) {
+			continue;
+		}
+
+		if (!allowBareExistingTokens) {
+			return false;
+		}
+
+		const resolvedExactPath = resolveToCwd(token, cwd);
+		if (!(await pathExists(resolvedExactPath))) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+async function splitDelimitedSearchInput(
+	rawInput: string,
+	cwd: string,
+	parseBasePath: (value: string) => string,
+): Promise<string[] | undefined> {
+	const trimmed = rawInput.trim();
+	if (!trimmed) return undefined;
+
+	const resolvedExactPath = resolveToCwd(trimmed, cwd);
+	if (await pathExists(resolvedExactPath)) {
+		return undefined;
+	}
+
+	const commaSeparated = splitTopLevel(trimmed, "comma");
+	if (commaSeparated.length > 1 && (await areDelimitedTokensResolvable(commaSeparated, cwd, parseBasePath, true))) {
+		return [...new Set(commaSeparated)];
+	}
+
+	const whitespaceSeparated = splitTopLevel(trimmed, "whitespace");
+	if (
+		whitespaceSeparated.length > 1 &&
+		(await areDelimitedTokensResolvable(whitespaceSeparated, cwd, parseBasePath, false))
+	) {
+		return [...new Set(whitespaceSeparated)];
+	}
+
+	return undefined;
+}
+
+export async function resolveMultiSearchPath(
+	rawPath: string,
+	cwd: string,
+	suffixGlob?: string,
+): Promise<ResolvedMultiSearchPath | undefined> {
+	const pathItems = await splitDelimitedSearchInput(rawPath, cwd, value => parseSearchPath(value).basePath);
+	if (!pathItems || pathItems.length <= 1) {
+		return undefined;
+	}
+
+	const parsedItems = await Promise.all(
+		pathItems.map(async item => {
+			const parsedPath = parseSearchPath(item);
+			const absoluteBasePath = resolveToCwd(parsedPath.basePath, cwd);
+			const stat = await fs.promises.stat(absoluteBasePath);
+			return { raw: item, parsedPath, absoluteBasePath, stat };
+		}),
+	);
+
+	const commonBasePath = findCommonBasePath(parsedItems.map(item => item.absoluteBasePath));
+	const combinedPatterns = parsedItems.map(item => {
+		const relativeBasePath = normalizePosixPath(path.relative(commonBasePath, item.absoluteBasePath)) || ".";
+		if (item.parsedPath.glob) {
+			const pathGlob = joinRelativeGlob(relativeBasePath, item.parsedPath.glob);
+			return combineSearchGlobs(pathGlob, suffixGlob) ?? pathGlob;
+		}
+		if (suffixGlob) {
+			const pathPrefix = relativeBasePath === "." ? undefined : relativeBasePath;
+			return combineSearchGlobs(pathPrefix, suffixGlob) ?? suffixGlob;
+		}
+		if (item.stat.isDirectory()) {
+			return joinRelativeGlob(relativeBasePath, "**/*");
+		}
+		return relativeBasePath === "." ? path.basename(item.absoluteBasePath) : relativeBasePath;
+	});
+
+	return {
+		basePath: commonBasePath,
+		glob: buildBraceUnion(combinedPatterns),
+		scopePath: toScopeDisplay(pathItems),
+	};
+}
+
+export async function resolveMultiFindPattern(
+	rawPattern: string,
+	cwd: string,
+): Promise<ResolvedMultiFindPattern | undefined> {
+	const patternItems = await splitDelimitedSearchInput(rawPattern, cwd, value => parseFindPattern(value).basePath);
+	if (!patternItems || patternItems.length <= 1) {
+		return undefined;
+	}
+
+	const parsedItems = await Promise.all(
+		patternItems.map(async item => {
+			const parsedPattern = parseFindPattern(item);
+			const absoluteBasePath = resolveToCwd(parsedPattern.basePath, cwd);
+			const stat = await fs.promises.stat(absoluteBasePath);
+			return { raw: item, parsedPattern, absoluteBasePath, stat };
+		}),
+	);
+
+	const commonBasePath = findCommonBasePath(parsedItems.map(item => item.absoluteBasePath));
+	const combinedPatterns = parsedItems.map(item => {
+		const relativeBasePath = normalizePosixPath(path.relative(commonBasePath, item.absoluteBasePath)) || ".";
+		if (item.parsedPattern.hasGlob) {
+			return joinRelativeGlob(relativeBasePath, item.parsedPattern.globPattern);
+		}
+		if (item.stat.isDirectory()) {
+			return joinRelativeGlob(relativeBasePath, "**/*");
+		}
+		return relativeBasePath === "." ? path.basename(item.absoluteBasePath) : relativeBasePath;
+	});
+
+	return {
+		basePath: commonBasePath,
+		globPattern: buildBraceUnion(combinedPatterns) ?? "**/*",
+		scopePath: toScopeDisplay(patternItems),
+	};
+}
+
 export function resolveReadPath(filePath: string, cwd: string): string {
 	const resolved = resolveToCwd(filePath, cwd);
 	const shellEscapedVariant = tryShellEscapedPath(resolved);

package/src/tools/read.ts

@@ -16,6 +16,7 @@ import type { ToolSession } from "../sdk";
 import {
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
+	noTruncResult,
 	type TruncationResult,
 	truncateHead,
 	truncateHeadBytes,
@@ -592,15 +593,13 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const truncation: TruncationResult = {
 				content: selectedContent,
 				truncated: wasTruncated,
-				truncatedBy: stoppedByByteLimit ? "bytes" : wasTruncated ? "lines" : null,
+				truncatedBy: stoppedByByteLimit ? "bytes" : wasTruncated ? "lines" : undefined,
 				totalLines: totalSelectedLines,
 				totalBytes: totalSelectedBytes,
 				outputLines: collectedLines.length,
 				outputBytes: collectedBytes,
 				lastLinePartial: false,
 				firstLineExceedsLimit,
-				maxLines: DEFAULT_MAX_LINES,
-				maxBytes: DEFAULT_MAX_BYTES,
 			};
 
 			const shouldAddHashLines = displayMode.hashLines;
@@ -687,8 +686,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	async #handleInternalUrl(url: string, offset?: number, limit?: number): Promise<AgentToolResult<ReadToolDetails>> {
 		const internalRouter = this.session.internalRouter!;
 
-		const displayMode = resolveFileDisplayMode(this.session);
-
 		// Check if URL has query extraction (agent:// only)
 		let parsed: URL;
 		try {
@@ -716,7 +713,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			return toolResult(details).text(resource.content).sourceInternal(url).done();
 		}
 
-		// Apply pagination similar to file reading
+		// Apply pagination similar to file reading.
 		const allLines = resource.content.split("\n");
 		const totalLines = allLines.length;
 
@@ -733,9 +730,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				.done();
 		}
 
+		const ignoreLimits = scheme === "skill";
 		let selectedContent: string;
 		let userLimitedLines: number | undefined;
-		if (limit !== undefined) {
+		if (limit !== undefined && !ignoreLimits) {
 			const endLine = Math.min(startLine + limit, allLines.length);
 			selectedContent = allLines.slice(startLine, endLine).join("\n");
 			userLimitedLines = endLine - startLine;
@@ -743,14 +741,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			selectedContent = allLines.slice(startLine).join("\n");
 		}
 
-		// Apply truncation
-		const truncation = truncateHead(selectedContent);
-
-		const shouldAddHashLines = displayMode.hashLines;
-		const shouldAddLineNumbers = shouldAddHashLines ? false : displayMode.lineNumbers;
-		const formatText = (text: string, startNum: number): string => {
-			return formatTextWithMode(text, startNum, shouldAddHashLines, shouldAddLineNumbers);
-		};
+		const truncation: TruncationResult = ignoreLimits
+			? noTruncResult(selectedContent)
+			: truncateHead(selectedContent);
 
 		let outputText: string;
 		let truncationInfo:
@@ -762,13 +755,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const firstLineBytes = Buffer.byteLength(firstLine, "utf-8");
 			const snippet = truncateHeadBytes(firstLine, DEFAULT_MAX_BYTES);
 
-			if (shouldAddHashLines) {
-				outputText = `[Line ${startLineDisplay} is ${formatBytes(
-					firstLineBytes,
-				)}, exceeds ${formatBytes(DEFAULT_MAX_BYTES)} limit. Hashline output requires full lines; cannot compute hashes for a truncated preview.]`;
-			} else {
-				outputText = formatText(snippet.text, startLineDisplay);
-			}
+			outputText = snippet.text;
 			if (snippet.text.length === 0) {
 				outputText = `[Line ${startLineDisplay} is ${formatBytes(
 					firstLineBytes,
@@ -780,7 +767,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				options: { direction: "head", startLine: startLineDisplay, totalFileLines: totalLines },
 			};
 		} else if (truncation.truncated) {
-			outputText = formatText(truncation.content, startLineDisplay);
+			outputText = truncation.content;
 			details.truncation = truncation;
 			truncationInfo = {
 				result: truncation,
@@ -790,11 +777,11 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const remaining = allLines.length - (startLine + userLimitedLines);
 			const nextOffset = startLine + userLimitedLines + 1;
 
-			outputText = formatText(truncation.content, startLineDisplay);
+			outputText = truncation.content;
 			outputText += `\n\n[${remaining} more lines in resource. Use offset=${nextOffset} to continue]`;
 			details.truncation = truncation;
 		} else {
-			outputText = formatText(truncation.content, startLineDisplay);
+			outputText = truncation.content;
 		}
 
 		const resultBuilder = toolResult(details).text(outputText).sourceInternal(url);
@@ -924,7 +911,7 @@ export const readToolRenderer = {
 		}
 		if (truncation) {
 			if (fallback?.firstLineExceedsLimit) {
-				let warning = `First line exceeds ${formatBytes(fallback.maxBytes ?? DEFAULT_MAX_BYTES)} limit`;
+				let warning = `First line exceeds ${formatBytes(fallback.outputBytes ?? fallback.totalBytes)} limit`;
 				if (truncation.artifactId) {
 					warning += `. ${formatFullOutputReference(truncation.artifactId)}`;
 				}