@schlenkr/ragents 0.1.5 → 0.1.7

package/packages/agent/src/core/tools/edit-diff.ts

@@ -3,9 +3,6 @@
  */
 
 import * as Diff from "diff";
-import { constants } from "fs";
-import { access, readFile } from "fs/promises";
-import { resolveToCwd } from "./path-utils.ts";
 
 export function detectLineEnding(content: string): "\r\n" | "\n" {
 	const crlfIdx = content.indexOf("\r\n");
@@ -645,60 +642,3 @@ export function generateDiffString(
 
 	return { diff: output.join("\n"), firstChangedLine };
 }
-
-export interface EditDiffResult {
-	diff: string;
-	firstChangedLine: number | undefined;
-}
-
-export interface EditDiffError {
-	error: string;
-}
-
-/**
- * Compute the diff for one or more edit operations without applying them.
- * Used for preview rendering in the TUI before the tool executes.
- */
-export async function computeEditsDiff(
-	path: string,
-	edits: Edit[],
-	cwd: string,
-): Promise<EditDiffResult | EditDiffError> {
-	const absolutePath = resolveToCwd(path, cwd);
-
-	try {
-		// Check if file exists and is readable
-		try {
-			await access(absolutePath, constants.R_OK);
-		} catch (error: unknown) {
-			const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
-			return { error: `Could not edit file: ${path}. ${errorMessage}.` };
-		}
-
-		// Read the file
-		const rawContent = await readFile(absolutePath, "utf-8");
-
-		// Strip BOM before matching (LLM won't include invisible BOM in oldText)
-		const { text: content } = stripBom(rawContent);
-		const normalizedContent = normalizeToLF(content);
-		const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
-
-		// Generate the diff
-		return generateDiffString(baseContent, newContent);
-	} catch (err) {
-		return { error: err instanceof Error ? err.message : String(err) };
-	}
-}
-
-/**
- * Compute the diff for a single edit operation without applying it.
- * Kept as a convenience wrapper for single-edit callers.
- */
-export async function computeEditDiff(
-	path: string,
-	oldText: string,
-	newText: string,
-	cwd: string,
-): Promise<EditDiffResult | EditDiffError> {
-	return computeEditsDiff(path, [{ oldText, newText }], cwd);
-}

package/packages/agent/src/core/tools/edit.ts

@@ -1,13 +1,11 @@
 import { createHash } from "node:crypto";
-import type { AgentTool } from "@aicontainer/agent-core";
 import { constants } from "fs";
 import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
 import { type Static, Type } from "typebox";
-import type { ToolDefinition } from "../extensions/types.ts";
+import type { ToolDefinition } from "../tool-definition.ts";
 import { applyEditsToNormalizedContent, detectLineEnding, type Edit, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, stripBom } from "./edit-diff.ts";
 import { withFileMutationQueue } from "./file-mutation-queue.ts";
 import { resolveToCwd } from "./path-utils.ts";
-import { wrapToolDefinition } from "./tool-definition-wrapper.ts";
 
 const replaceEditSchema = Type.Object(
 	{
@@ -41,10 +39,6 @@ const replaceEditSchema = Type.Object(
 const editSchema = Type.Object(
 	{
 		path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
-		expectedHash: Type.Optional(Type.String({
-			description: "SHA-256 from the latest read. The edit is rejected if the file changed since that read.",
-			pattern: "^[a-f0-9]{64}$",
-		})),
 		edits: Type.Array(replaceEditSchema, {
 			description:
 				"One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead.",
@@ -135,21 +129,10 @@ export function createEditToolDefinition(
 		name: "edit",
 		label: "edit",
 		description:
-			"Edit a single file using exact text replacement. Pass expectedHash from the latest read so the edit is rejected if the file changed meanwhile. Every edits[].oldText must match a unique, non-overlapping region of the original file, or be anchored with occurrence, nearLine or replaceAll. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
-		promptSnippet:
-			"Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
-		promptGuidelines: [
-			"Use edit for precise changes (edits[].oldText must match exactly)",
-			"When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
-			"Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
-			"Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
-			"If oldText is not unique, the error lists every occurrence with its line number. Pick one with occurrence (1-based) or nearLine instead of padding oldText with more context, and use replaceAll only when every occurrence must change.",
-			"Pass expectedHash from the latest read so an edit cannot overwrite a file that changed since you inspected it.",
-		],
+			"Edit a single file using exact text replacement. Read the file first; the edit is rejected if the file changed since that read. Every edits[].oldText must match a unique, non-overlapping region of the original file, or be anchored with occurrence, nearLine or replaceAll. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
 		parameters: editSchema,
-		renderShell: "self",
 		prepareArguments: prepareEditArguments,
-		async execute(_toolCallId, input: EditToolInput, signal?: AbortSignal, _onUpdate?, _ctx?) {
+		async execute(_toolCallId, input: EditToolInput, signal?: AbortSignal) {
 			const { path, edits } = validateEditInput(input);
 			const absolutePath = resolveToCwd(path, cwd);
 
@@ -177,10 +160,6 @@ export function createEditToolDefinition(
 
 				// Read the file.
 				const buffer = await ops.readFile(absolutePath);
-				const currentHash = createHash("sha256").update(buffer).digest("hex");
-				if (input.expectedHash && input.expectedHash !== currentHash) {
-					throw new Error(`Could not edit ${path}: stale read. Expected SHA-256 ${input.expectedHash}, current SHA-256 ${currentHash}. Read the file again before editing.`);
-				}
 				const rawContent = buffer.toString("utf-8");
 				throwIfAborted();
 
@@ -206,7 +185,7 @@ export function createEditToolDefinition(
 					content: [
 						{
 							type: "text",
-							text: `Successfully replaced ${replacementCount} block(s) in ${path}. New content SHA-256: ${contentHash}.`,
+							text: `Successfully replaced ${replacementCount} block(s) in ${path}.`,
 						},
 					],
 					details: { diff: diffResult.diff, patch, firstChangedLine: diffResult.firstChangedLine, contentHash },
@@ -216,7 +195,3 @@ export function createEditToolDefinition(
 
 	};
 }
-
-export function createEditTool(cwd: string, options?: EditToolOptions): AgentTool<typeof editSchema> {
-	return wrapToolDefinition(createEditToolDefinition(cwd, options));
-}

package/packages/agent/src/core/tools/index.ts

@@ -1,130 +1,4 @@
-export {
-	type BashOperations,
-	type BashSpawnContext,
-	type BashSpawnHook,
-	type BashToolDetails,
-	type BashToolInput,
-	type BashToolOptions,
-	createBashTool,
-	createBashToolDefinition,
-	createLocalBashOperations,
-} from "./bash.ts";
-export {
-	createEditTool,
-	createEditToolDefinition,
-	type EditOperations,
-	type EditToolDetails,
-	type EditToolInput,
-	type EditToolOptions,
-} from "./edit.ts";
-export { withFileMutationQueue } from "./file-mutation-queue.ts";
-export {
-	createReadTool,
-	createReadToolDefinition,
-	type ReadOperations,
-	type ReadToolDetails,
-	type ReadToolInput,
-	type ReadToolOptions,
-} from "./read.ts";
-export {
-	DEFAULT_MAX_BYTES,
-	DEFAULT_MAX_LINES,
-	formatSize,
-	type TruncationOptions,
-	type TruncationResult,
-	truncateHead,
-	truncateLine,
-	truncateTail,
-} from "./truncate.ts";
-export {
-	createWriteTool,
-	createWriteToolDefinition,
-	type WriteOperations,
-	type WriteToolInput,
-	type WriteToolOptions,
-} from "./write.ts";
-
-import type { AgentTool } from "@aicontainer/agent-core";
-import type { ToolDefinition } from "../extensions/types.ts";
-import { type BashToolOptions, createBashTool, createBashToolDefinition } from "./bash.ts";
-import { createEditTool, createEditToolDefinition, type EditToolOptions } from "./edit.ts";
-import { createReadTool, createReadToolDefinition, type ReadToolOptions } from "./read.ts";
-import { createWriteTool, createWriteToolDefinition, type WriteToolOptions } from "./write.ts";
-
-export type Tool = AgentTool<any>;
-export type ToolDef = ToolDefinition<any, any>;
-export type ToolName = "read" | "bash" | "edit" | "write";
-export const allToolNames: Set<ToolName> = new Set(["read", "bash", "edit", "write"]);
-
-export interface ToolsOptions {
-	read?: ReadToolOptions;
-	bash?: BashToolOptions;
-	write?: WriteToolOptions;
-	edit?: EditToolOptions;
-}
-
-export function createToolDefinition(toolName: ToolName, cwd: string, options?: ToolsOptions): ToolDef {
-	switch (toolName) {
-		case "read":
-			return createReadToolDefinition(cwd, options?.read);
-		case "bash":
-			return createBashToolDefinition(cwd, options?.bash);
-		case "edit":
-			return createEditToolDefinition(cwd, options?.edit);
-		case "write":
-			return createWriteToolDefinition(cwd, options?.write);
-		default:
-			throw new Error(`Unknown tool name: ${toolName}`);
-	}
-}
-
-export function createTool(toolName: ToolName, cwd: string, options?: ToolsOptions): Tool {
-	switch (toolName) {
-		case "read":
-			return createReadTool(cwd, options?.read);
-		case "bash":
-			return createBashTool(cwd, options?.bash);
-		case "edit":
-			return createEditTool(cwd, options?.edit);
-		case "write":
-			return createWriteTool(cwd, options?.write);
-		default:
-			throw new Error(`Unknown tool name: ${toolName}`);
-	}
-}
-
-export function createCodingToolDefinitions(cwd: string, options?: ToolsOptions): ToolDef[] {
-	return [
-		createReadToolDefinition(cwd, options?.read),
-		createBashToolDefinition(cwd, options?.bash),
-		createEditToolDefinition(cwd, options?.edit),
-		createWriteToolDefinition(cwd, options?.write),
-	];
-}
-
-export function createAllToolDefinitions(cwd: string, options?: ToolsOptions): Record<ToolName, ToolDef> {
-	return {
-		read: createReadToolDefinition(cwd, options?.read),
-		bash: createBashToolDefinition(cwd, options?.bash),
-		edit: createEditToolDefinition(cwd, options?.edit),
-		write: createWriteToolDefinition(cwd, options?.write),
-	};
-}
-
-export function createCodingTools(cwd: string, options?: ToolsOptions): Tool[] {
-	return [
-		createReadTool(cwd, options?.read),
-		createBashTool(cwd, options?.bash),
-		createEditTool(cwd, options?.edit),
-		createWriteTool(cwd, options?.write),
-	];
-}
-
-export function createAllTools(cwd: string, options?: ToolsOptions): Record<ToolName, Tool> {
-	return {
-		read: createReadTool(cwd, options?.read),
-		bash: createBashTool(cwd, options?.bash),
-		edit: createEditTool(cwd, options?.edit),
-		write: createWriteTool(cwd, options?.write),
-	};
-}
+export { type BashOperations, createBashToolDefinition } from "./bash.ts";
+export { createEditToolDefinition } from "./edit.ts";
+export { createReadToolDefinition } from "./read.ts";
+export { createWriteToolDefinition } from "./write.ts";

package/packages/agent/src/core/tools/output-accumulator.ts

@@ -7,6 +7,8 @@ import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type TruncationResult, truncateTa
 export interface OutputAccumulatorOptions {
 	maxLines?: number;
 	maxBytes?: number;
+	/** Lines longer than this are shortened in snapshots and marked; the temp file keeps them whole. */
+	maxLineChars?: number;
 	tempFilePrefix?: string;
 }
 
@@ -25,6 +27,16 @@ function byteLength(text: string): number {
 	return Buffer.byteLength(text, "utf-8");
 }
 
+const shortenedLines = (text: string, maxLineChars: number): string =>
+	text
+		.split("\n")
+		.map((line) =>
+			line.length > maxLineChars
+				? `${line.slice(0, maxLineChars)} [line shortened, ${line.length - maxLineChars} more characters]`
+				: line,
+		)
+		.join("\n");
+
 /**
  * Incrementally tracks streaming output with bounded memory.
  *
@@ -35,6 +47,7 @@ function byteLength(text: string): number {
 export class OutputAccumulator {
 	private readonly maxLines: number;
 	private readonly maxBytes: number;
+	private readonly maxLineChars: number | undefined;
 	private readonly maxRollingBytes: number;
 	private readonly tempFilePrefix: string;
 	private readonly decoder = new TextDecoder();
@@ -48,6 +61,8 @@ export class OutputAccumulator {
 	private completedLines = 0;
 	private totalLines = 0;
 	private currentLineBytes = 0;
+	private currentLineChars = 0;
+	private longestLineChars = 0;
 	private hasOpenLine = false;
 	private finished = false;
 
@@ -57,6 +72,7 @@ export class OutputAccumulator {
 	constructor(options: OutputAccumulatorOptions = {}) {
 		this.maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
 		this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+		this.maxLineChars = options.maxLineChars;
 		this.maxRollingBytes = Math.max(this.maxBytes * 2, 1);
 		this.tempFilePrefix = options.tempFilePrefix ?? "agent-output";
 	}
@@ -89,7 +105,8 @@ export class OutputAccumulator {
 	}
 
 	snapshot(options: { persistIfTruncated?: boolean } = {}): OutputSnapshot {
-		const tailTruncation = truncateTail(this.getSnapshotText(), {
+		const text = this.getSnapshotText();
+		const tailTruncation = truncateTail(this.maxLineChars === undefined ? text : shortenedLines(text, this.maxLineChars), {
 			maxLines: this.maxLines,
 			maxBytes: this.maxBytes,
 		});
@@ -145,6 +162,10 @@ export class OutputAccumulator {
 		return this.currentLineBytes;
 	}
 
+	hasShortenedLines(): boolean {
+		return this.maxLineChars !== undefined && Math.max(this.longestLineChars, this.currentLineChars) > this.maxLineChars;
+	}
+
 	private appendDecodedText(text: string): void {
 		if (text.length === 0) {
 			return;
@@ -159,18 +180,22 @@ export class OutputAccumulator {
 		}
 
 		let newlines = 0;
-		let lastNewline = -1;
+		let lineStart = 0;
 		for (let i = text.indexOf("\n"); i !== -1; i = text.indexOf("\n", i + 1)) {
+			this.longestLineChars = Math.max(this.longestLineChars, this.currentLineChars + i - lineStart);
+			this.currentLineChars = 0;
 			newlines++;
-			lastNewline = i;
+			lineStart = i + 1;
 		}
 		if (newlines === 0) {
 			this.currentLineBytes += bytes;
+			this.currentLineChars += text.length;
 			this.hasOpenLine = true;
 		} else {
 			this.completedLines += newlines;
-			const tail = text.slice(lastNewline + 1);
+			const tail = text.slice(lineStart);
 			this.currentLineBytes = byteLength(tail);
+			this.currentLineChars = tail.length;
 			this.hasOpenLine = tail.length > 0;
 		}
 		this.totalLines = this.completedLines + (this.hasOpenLine ? 1 : 0);
@@ -204,7 +229,10 @@ export class OutputAccumulator {
 
 	private shouldUseTempFile(): boolean {
 		return (
-			this.totalRawBytes > this.maxBytes || this.totalDecodedBytes > this.maxBytes || this.totalLines > this.maxLines
+			this.totalRawBytes > this.maxBytes ||
+			this.totalDecodedBytes > this.maxBytes ||
+			this.totalLines > this.maxLines ||
+			this.hasShortenedLines()
 		);
 	}
 

package/packages/agent/src/core/tools/path-utils.ts

@@ -1,6 +1,6 @@
-import { accessSync, constants } from "node:fs";
+import { constants } from "node:fs";
 import { access } from "node:fs/promises";
-import { normalizePath, resolvePath } from "../../utils/paths.ts";
+import { resolvePath } from "../../utils/paths.ts";
 
 const NARROW_NO_BREAK_SPACE = "\u202F";
 
@@ -19,15 +19,6 @@ function tryCurlyQuoteVariant(filePath: string): string {
 	return filePath.replace(/'/g, "\u2019");
 }
 
-function fileExists(filePath: string): boolean {
-	try {
-		accessSync(filePath, constants.F_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
 export async function pathExists(filePath: string): Promise<boolean> {
 	try {
 		await access(filePath, constants.F_OK);
@@ -37,10 +28,6 @@ export async function pathExists(filePath: string): Promise<boolean> {
 	}
 }
 
-export function expandPath(filePath: string): string {
-	return normalizePath(filePath, { normalizeUnicodeSpaces: true, stripAtPrefix: true });
-}
-
 /**
  * Resolve a path relative to the given cwd.
  * Handles ~ expansion and absolute paths.
@@ -49,40 +36,6 @@ export function resolveToCwd(filePath: string, cwd: string): string {
 	return resolvePath(filePath, cwd, { normalizeUnicodeSpaces: true, stripAtPrefix: true });
 }
 
-export function resolveReadPath(filePath: string, cwd: string): string {
-	const resolved = resolveToCwd(filePath, cwd);
-
-	if (fileExists(resolved)) {
-		return resolved;
-	}
-
-	// Try macOS AM/PM variant (narrow no-break space before AM/PM)
-	const amPmVariant = tryMacOSScreenshotPath(resolved);
-	if (amPmVariant !== resolved && fileExists(amPmVariant)) {
-		return amPmVariant;
-	}
-
-	// Try NFD variant (macOS stores filenames in NFD form)
-	const nfdVariant = tryNFDVariant(resolved);
-	if (nfdVariant !== resolved && fileExists(nfdVariant)) {
-		return nfdVariant;
-	}
-
-	// Try curly quote variant (macOS uses U+2019 in screenshot names)
-	const curlyVariant = tryCurlyQuoteVariant(resolved);
-	if (curlyVariant !== resolved && fileExists(curlyVariant)) {
-		return curlyVariant;
-	}
-
-	// Try combined NFD + curly quote (for French macOS screenshots like "Capture d'écran")
-	const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
-	if (nfdCurlyVariant !== resolved && fileExists(nfdCurlyVariant)) {
-		return nfdCurlyVariant;
-	}
-
-	return resolved;
-}
-
 export async function resolveReadPathAsync(filePath: string, cwd: string): Promise<string> {
 	const resolved = resolveToCwd(filePath, cwd);
 

package/packages/agent/src/core/tools/read.ts

@@ -1,15 +1,13 @@
 import { createHash } from "node:crypto";
-import { relative } from "node:path";
-import type { AgentTool } from "@aicontainer/agent-core";
-import type { Api, ImageContent, Model, TextContent } from "@aicontainer/ai";
+import type { ImageContent, TextContent } from "@ragents/ai";
 import { constants } from "fs";
 import { access as fsAccess, readFile as fsReadFile } from "fs/promises";
-import { type Static, Type } from "typebox";
+import { Type } from "typebox";
 import { processImage } from "../../utils/image-process.ts";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.ts";
-import type { ToolDefinition } from "../extensions/types.ts";
+import type { ToolDefinition } from "../tool-definition.ts";
+import { BASH_MAX_LINE_CHARS } from "./bash.ts";
 import { resolveReadPathAsync } from "./path-utils.ts";
-import { wrapToolDefinition } from "./tool-definition-wrapper.ts";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate.ts";
 
 const readSchema = Type.Object({
@@ -18,7 +16,6 @@ const readSchema = Type.Object({
 	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
 });
 
-export type ReadToolInput = Static<typeof readSchema>;
 
 export interface ReadToolDetails {
 	truncation?: TruncationResult;
@@ -51,13 +48,6 @@ export interface ReadToolOptions {
 	operations?: ReadOperations;
 }
 
-function getNonVisionImageNote(model: Model<Api> | undefined): string | undefined {
-	if (!model || model.input.includes("image")) {
-		return undefined;
-	}
-	return "[Current model does not support images. The image will be omitted from this request.]";
-}
-
 export function createReadToolDefinition(
 	cwd: string,
 	options?: ReadToolOptions,
@@ -68,15 +58,11 @@ export function createReadToolDefinition(
 		name: "read",
 		label: "read",
 		description: `Read the contents of a file. Supports text files and images (jpg, png, gif, webp, bmp). Images are sent as attachments. For text files, output is truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Use offset/limit for large files. When you need the full file, continue with offset until complete.`,
-		promptSnippet: "Read file contents",
-		promptGuidelines: ["Use read to examine files instead of cat or sed."],
 		parameters: readSchema,
 		async execute(
 			_toolCallId,
 			{ path, offset, limit }: { path: string; offset?: number; limit?: number },
 			signal?: AbortSignal,
-			_onUpdate?,
-			ctx?,
 		) {
 			return new Promise<{ content: (TextContent | ImageContent)[]; details: ReadToolDetails | undefined }>(
 				(resolve, reject) => {
@@ -103,18 +89,14 @@ export function createReadToolDefinition(
 							const contentHash = createHash("sha256").update(buffer).digest("hex");
 							let content: (TextContent | ImageContent)[];
 							let details: ReadToolDetails | undefined;
-							const nonVisionImageNote = getNonVisionImageNote(ctx?.model);
 							if (mimeType) {
 								// Read image as binary.
 								const processed = await processImage(buffer, mimeType, { autoResizeImages });
 								if (!processed.ok) {
-									let textNote = `Read image file [${mimeType}]\n${processed.message}`;
-									if (nonVisionImageNote) textNote += `\n${nonVisionImageNote}`;
-									content = [{ type: "text", text: textNote }];
+									content = [{ type: "text", text: `Read image file [${mimeType}]\n${processed.message}` }];
 								} else {
 									let textNote = `Read image file [${processed.mimeType}]`;
 									if (processed.hints.length > 0) textNote += `\n${processed.hints.join("\n")}`;
-									if (nonVisionImageNote) textNote += `\n${nonVisionImageNote}`;
 									content = [
 										{ type: "text", text: textNote },
 										{ type: "image", data: processed.data, mimeType: processed.mimeType },
@@ -148,7 +130,7 @@ export function createReadToolDefinition(
 								if (truncation.firstLineExceedsLimit) {
 									// First line alone exceeds the byte limit. Point the model at a bash fallback.
 									const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
-									outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;
+									outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | fold -w ${BASH_MAX_LINE_CHARS} | head -n 20]`;
 									details = { truncation };
 								} else if (truncation.truncated) {
 									// Truncation occurred. Build an actionable continuation notice.
@@ -170,7 +152,6 @@ export function createReadToolDefinition(
 									// No truncation and no remaining user-limited content.
 									outputText = truncation.content;
 								}
-								outputText += `\n\n[Content SHA-256: ${contentHash}]`;
 								content = [{ type: "text", text: outputText }];
 							}
 							details = { ...details, contentHash };
@@ -189,7 +170,3 @@ export function createReadToolDefinition(
 
 	};
 }
-
-export function createReadTool(cwd: string, options?: ReadToolOptions): AgentTool<typeof readSchema> {
-	return wrapToolDefinition(createReadToolDefinition(cwd, options));
-}

package/packages/agent/src/core/tools/truncate.ts

@@ -10,7 +10,6 @@
 
 export const DEFAULT_MAX_LINES = 2000;
 export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
-export const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line
 
 export interface TruncationResult {
 	/** The truncated content */
@@ -260,17 +259,3 @@ function truncateStringToBytesFromEnd(str: string, maxBytes: number): string {
 
 	return buf.slice(start).toString("utf-8");
 }
-
-/**
- * Truncate a single line to max characters, adding [truncated] suffix.
- * Used for grep match lines.
- */
-export function truncateLine(
-	line: string,
-	maxChars: number = GREP_MAX_LINE_LENGTH,
-): { text: string; wasTruncated: boolean } {
-	if (line.length <= maxChars) {
-		return { text: line, wasTruncated: false };
-	}
-	return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
-}

package/packages/agent/src/core/tools/write.ts

@@ -1,18 +1,15 @@
-import type { AgentTool } from "@aicontainer/agent-core";
 import { mkdir as fsMkdir, writeFile as fsWriteFile } from "fs/promises";
 import { dirname } from "path";
-import { type Static, Type } from "typebox";
-import type { ToolDefinition } from "../extensions/types.ts";
+import { Type } from "typebox";
+import type { ToolDefinition } from "../tool-definition.ts";
 import { withFileMutationQueue } from "./file-mutation-queue.ts";
 import { resolveToCwd } from "./path-utils.ts";
-import { wrapToolDefinition } from "./tool-definition-wrapper.ts";
 
 const writeSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
 	content: Type.String({ description: "Content to write to the file" }),
 });
 
-export type WriteToolInput = Static<typeof writeSchema>;
 
 /**
  * Pluggable operations for the write tool.
@@ -45,15 +42,11 @@ export function createWriteToolDefinition(
 		label: "write",
 		description:
 			"Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
-		promptSnippet: "Create or overwrite files",
-		promptGuidelines: ["Use write only for new files or complete rewrites."],
 		parameters: writeSchema,
 		async execute(
 			_toolCallId,
 			{ path, content }: { path: string; content: string },
 			signal?: AbortSignal,
-			_onUpdate?,
-			_ctx?,
 		) {
 			const absolutePath = resolveToCwd(path, cwd);
 			const dir = dirname(absolutePath);
@@ -84,7 +77,3 @@ export function createWriteToolDefinition(
 
 	};
 }
-
-export function createWriteTool(cwd: string, options?: WriteToolOptions): AgentTool<typeof writeSchema> {
-	return wrapToolDefinition(createWriteToolDefinition(cwd, options));
-}