@schlenkr/ragents 0.1.6 → 0.1.8

package/packages/agent/src/core/compaction/compaction.ts

@@ -1,20 +1,10 @@
-/**
- * Context compaction for long sessions.
- *
- * Pure functions for compaction logic. The session manager handles I/O,
- * and after compaction the session is reloaded.
- */
+/** Context compaction over the context log of one agent; pure functions, the caller persists the result. */
 
 import type { AgentMessage, StreamFn, ThinkingLevel } from "../../loop/index.ts";
 import type { AssistantMessage, Context, Model, SimpleStreamOptions, Usage } from "@ragents/ai";
 import { completeSimple } from "@ragents/ai";
+import { type ContextCompaction, type ContextLogEntry, contextEntryMessages, contextMessages } from "../context-log.ts";
 import { convertToLlm } from "../messages.ts";
-import {
-	buildSessionContext,
-	type CompactionEntry,
-	type SessionEntry,
-	sessionEntryToContextMessages,
-} from "../session-manager.ts";
 import {
 	computeFileLists,
 	createFileOps,
@@ -26,72 +16,29 @@ import {
 	collectUserAttachments,
 } from "./utils.ts";
 
-// ============================================================================
-// File Operation Tracking
-// ============================================================================
-
-/** Details stored in CompactionEntry.details for file tracking */
-export interface CompactionDetails {
-	readFiles: string[];
-	modifiedFiles: string[];
-}
-
-/**
- * Extract file operations from messages and previous compaction entries.
- */
-function extractFileOperations(
-	messages: AgentMessage[],
-	entries: SessionEntry[],
-	prevCompactionIndex: number,
-): FileOperations {
+/** Earlier compaction lists plus the file operations of the summarized messages. */
+function extractFileOperations(messages: AgentMessage[], previous: ContextCompaction | undefined): FileOperations {
 	const fileOps = createFileOps();
-
-	// Collect from previous compaction's details (if agent-generated)
-	if (prevCompactionIndex >= 0) {
-		const prevCompaction = entries[prevCompactionIndex] as CompactionEntry;
-		if (!prevCompaction.fromHook && prevCompaction.details) {
-			// fromHook field kept for session file compatibility
-			const details = prevCompaction.details as CompactionDetails;
-			if (Array.isArray(details.readFiles)) {
-				for (const f of details.readFiles) fileOps.read.add(f);
-			}
-			if (Array.isArray(details.modifiedFiles)) {
-				for (const f of details.modifiedFiles) fileOps.edited.add(f);
-			}
-		}
-	}
-
-	// Extract from tool calls in messages
+	for (const file of previous?.readFiles ?? []) fileOps.read.add(file);
+	for (const file of previous?.modifiedFiles ?? []) fileOps.edited.add(file);
 	for (const msg of messages) {
 		extractFileOpsFromMessage(msg, fileOps);
 	}
-
 	return fileOps;
 }
 
-// ============================================================================
-// Message Extraction
-// ============================================================================
-
-/**
- * Extract AgentMessage from an entry if it produces one.
- * Returns undefined for entries that don't contribute to LLM context.
- */
-function getMessageFromEntryForCompaction(entry: SessionEntry): AgentMessage | undefined {
-	if (entry.type === "compaction") {
-		return undefined;
-	}
-	return sessionEntryToContextMessages(entry)[0];
+function messageOf(entry: ContextLogEntry): AgentMessage | undefined {
+	return entry.kind === "message" ? entry.message : undefined;
 }
 
-/** Result from compact() - SessionManager adds uuid/parentUuid when saving */
-export interface CompactionResult<T = unknown> {
+/** Result of compact(); the caller records it as a compaction entry. */
+export interface CompactionResult {
 	summary: string;
-	firstKeptEntryId: string;
+	firstKeptId: string;
 	tokensBefore: number;
 	estimatedTokensAfter?: number;
-	/** Extension-specific data (e.g., ArtifactIndex, version markers for structured compaction) */
-	details?: T;
+	readFiles: string[];
+	modifiedFiles: string[];
 }
 
 // ============================================================================
@@ -283,38 +230,24 @@ function isTurnStartMessage(message: AgentMessage): boolean {
 	return false;
 }
 
-function isTurnStartEntry(entry: SessionEntry): boolean {
-	if (entry.type === "compaction") {
-		return false;
-	}
-	return sessionEntryToContextMessages(entry).some(isTurnStartMessage);
+function isTurnStartEntry(entry: ContextLogEntry): boolean {
+	return entry.kind === "message" && isTurnStartMessage(entry.message);
 }
 
-/**
- * Find valid cut points: indices of context-visible user-like or assistant messages.
- * Never cut at tool results (they must follow their tool call).
- * When we cut at an assistant message with tool calls, its tool results follow it
- * and will be kept.
- */
-function findValidCutPoints(entries: SessionEntry[], startIndex: number, endIndex: number): number[] {
+/** User-like or assistant messages, never a tool result, since it must follow its call. */
+function findValidCutPoints(entries: ContextLogEntry[], startIndex: number, endIndex: number): number[] {
 	const cutPoints: number[] = [];
 	for (let i = startIndex; i < endIndex; i++) {
 		const entry = entries[i];
-		if (entry.type === "compaction") {
-			continue;
-		}
-		if (sessionEntryToContextMessages(entry).some(isCutPointMessage)) {
+		if (entry.kind === "message" && isCutPointMessage(entry.message)) {
 			cutPoints.push(i);
 		}
 	}
 	return cutPoints;
 }
 
-/**
- * Find the context-visible user-role message that starts the turn containing the given entry index.
- * Returns -1 if no turn start found before the index.
- */
-export function findTurnStartIndex(entries: SessionEntry[], entryIndex: number, startIndex: number): number {
+/** The user-like message that starts the turn containing the given index, or -1. */
+export function findTurnStartIndex(entries: ContextLogEntry[], entryIndex: number, startIndex: number): number {
 	for (let i = entryIndex; i >= startIndex; i--) {
 		if (isTurnStartEntry(entries[i])) {
 			return i;
@@ -332,24 +265,9 @@ export interface CutPointResult {
 	isSplitTurn: boolean;
 }
 
-/**
- * Find the cut point in session entries that keeps approximately `keepRecentTokens`.
- *
- * Algorithm: Walk backwards from newest, accumulating estimated message sizes.
- * Stop when we've accumulated >= keepRecentTokens. Cut at that point.
- *
- * Can cut at user OR assistant messages (never tool results). When cutting at an
- * assistant message with tool calls, its tool results come after and will be kept.
- *
- * Returns CutPointResult with:
- * - firstKeptEntryIndex: the entry index to start keeping from
- * - turnStartIndex: if cutting mid-turn, the user message that started that turn
- * - isSplitTurn: whether we're cutting in the middle of a turn
- *
- * Only considers entries between `startIndex` and `endIndex` (exclusive).
- */
+/** The valid cut point that keeps about `keepRecentTokens` of the entries between `startIndex` and `endIndex`, counted from the newest. */
 export function findCutPoint(
-	entries: SessionEntry[],
+	entries: ContextLogEntry[],
 	startIndex: number,
 	endIndex: number,
 	keepRecentTokens: number,
@@ -360,22 +278,15 @@ export function findCutPoint(
 		return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };
 	}
 
-	// Walk backwards from newest, accumulating estimated message sizes
 	let accumulatedTokens = 0;
-	let cutIndex = cutPoints[0]; // Default: keep from first message (not header)
+	let cutIndex = cutPoints[0];
 
 	for (let i = endIndex - 1; i >= startIndex; i--) {
-		const entry = entries[i];
-		const messageTokens = sessionEntryToContextMessages(entry).reduce(
-			(sum, message) => sum + estimateTokens(message),
-			0,
-		);
+		const messageTokens = contextEntryMessages(entries[i]).reduce((sum, message) => sum + estimateTokens(message), 0);
 		if (messageTokens === 0) continue;
 		accumulatedTokens += messageTokens;
 
-		// Check if we've exceeded the budget
 		if (accumulatedTokens >= keepRecentTokens) {
-			// Find the closest valid cut point at or after this entry
 			for (let c = 0; c < cutPoints.length; c++) {
 				if (cutPoints[c] >= i) {
 					cutIndex = cutPoints[c];
@@ -386,17 +297,6 @@ export function findCutPoint(
 		}
 	}
 
-	// Scan backwards from cutIndex to include adjacent metadata entries that do not affect context.
-	while (cutIndex > startIndex) {
-		const prevEntry = entries[cutIndex - 1];
-		// Stop at compaction boundaries or context-visible entries.
-		if (prevEntry.type === "compaction" || sessionEntryToContextMessages(prevEntry).length > 0) {
-			break;
-		}
-		cutIndex--;
-	}
-
-	// Determine if this is a split turn
 	const cutEntry = entries[cutIndex];
 	const startsTurn = isTurnStartEntry(cutEntry);
 	const turnStartIndex = startsTurn ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
@@ -583,12 +483,12 @@ export async function generateSummary(
 }
 
 // ============================================================================
-// Compaction Preparation (for extensions)
+// Compaction Preparation
 // ============================================================================
 
 export interface CompactionPreparation {
-	/** UUID of first entry to keep */
-	firstKeptEntryId: string;
+	/** Id of the first entry to keep */
+	firstKeptId: string;
 	/** Messages that will be summarized and discarded */
 	messagesToSummarize: AgentMessage[];
 	/** Messages that will be turned into turn prefix summary (if splitting) */
@@ -600,61 +500,54 @@ export interface CompactionPreparation {
 	previousSummary?: string;
 	/** File operations extracted from messagesToSummarize */
 	fileOps: FileOperations;
-	/** Compaction settions from settings.jsonl	*/
 	settings: CompactionSettings;
 }
 
+/** Prepares a compaction of the whole context log; undefined when there is nothing to summarize. */
 export function prepareCompaction(
-	pathEntries: SessionEntry[],
+	entries: ContextLogEntry[],
 	settings: CompactionSettings,
 ): CompactionPreparation | undefined {
-	if (pathEntries.length > 0 && pathEntries[pathEntries.length - 1].type === "compaction") {
+	if (entries.length > 0 && entries[entries.length - 1].kind === "compaction") {
 		return undefined;
 	}
 
 	let prevCompactionIndex = -1;
-	for (let i = pathEntries.length - 1; i >= 0; i--) {
-		if (pathEntries[i].type === "compaction") {
+	for (let i = entries.length - 1; i >= 0; i--) {
+		if (entries[i].kind === "compaction") {
 			prevCompactionIndex = i;
 			break;
 		}
 	}
 
-	let previousSummary: string | undefined;
+	const previous = prevCompactionIndex >= 0 ? (entries[prevCompactionIndex] as ContextCompaction) : undefined;
 	let boundaryStart = 0;
-	if (prevCompactionIndex >= 0) {
-		const prevCompaction = pathEntries[prevCompactionIndex] as CompactionEntry;
-		previousSummary = prevCompaction.summary;
-		const firstKeptEntryIndex = pathEntries.findIndex((entry) => entry.id === prevCompaction.firstKeptEntryId);
+	if (previous) {
+		const firstKeptEntryIndex = entries.findIndex((entry) => entry.id === previous.firstKeptId);
 		boundaryStart = firstKeptEntryIndex >= 0 ? firstKeptEntryIndex : prevCompactionIndex + 1;
 	}
-	const boundaryEnd = pathEntries.length;
+	const boundaryEnd = entries.length;
 
-	const tokensBefore = estimateContextTokens(buildSessionContext(pathEntries).messages).tokens;
+	const tokensBefore = estimateContextTokens(contextMessages(entries)).tokens;
 
-	const cutPoint = findCutPoint(pathEntries, boundaryStart, boundaryEnd, settings.keepRecentTokens);
-
-	// Get UUID of first kept entry
-	const firstKeptEntry = pathEntries[cutPoint.firstKeptEntryIndex];
-	if (!firstKeptEntry?.id) {
-		return undefined; // Session needs migration
+	const cutPoint = findCutPoint(entries, boundaryStart, boundaryEnd, settings.keepRecentTokens);
+	const firstKeptEntry = entries[cutPoint.firstKeptEntryIndex];
+	if (!firstKeptEntry) {
+		return undefined;
 	}
-	const firstKeptEntryId = firstKeptEntry.id;
 
 	const historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptEntryIndex;
 
-	// Messages to summarize (will be discarded after summary)
 	const messagesToSummarize: AgentMessage[] = [];
 	for (let i = boundaryStart; i < historyEnd; i++) {
-		const msg = getMessageFromEntryForCompaction(pathEntries[i]);
+		const msg = messageOf(entries[i]);
 		if (msg) messagesToSummarize.push(msg);
 	}
 
-	// Messages for turn prefix summary (if splitting a turn)
 	const turnPrefixMessages: AgentMessage[] = [];
 	if (cutPoint.isSplitTurn) {
 		for (let i = cutPoint.turnStartIndex; i < cutPoint.firstKeptEntryIndex; i++) {
-			const msg = getMessageFromEntryForCompaction(pathEntries[i]);
+			const msg = messageOf(entries[i]);
 			if (msg) turnPrefixMessages.push(msg);
 		}
 	}
@@ -663,10 +556,7 @@ export function prepareCompaction(
 		return undefined;
 	}
 
-	// Extract file operations from messages and previous compaction
-	const fileOps = extractFileOperations(messagesToSummarize, pathEntries, prevCompactionIndex);
-
-	// Also extract file ops from turn prefix if splitting
+	const fileOps = extractFileOperations(messagesToSummarize, previous);
 	if (cutPoint.isSplitTurn) {
 		for (const msg of turnPrefixMessages) {
 			extractFileOpsFromMessage(msg, fileOps);
@@ -674,12 +564,12 @@ export function prepareCompaction(
 	}
 
 	return {
-		firstKeptEntryId,
+		firstKeptId: firstKeptEntry.id,
 		messagesToSummarize,
 		turnPrefixMessages,
 		isSplitTurn: cutPoint.isSplitTurn,
 		tokensBefore,
-		previousSummary,
+		previousSummary: previous?.summary,
 		fileOps,
 		settings,
 	};
@@ -704,13 +594,7 @@ Summarize the prefix to provide context for the retained suffix:
 
 Be concise. Focus on what's needed to understand the kept suffix.`;
 
-/**
- * Generate summaries for compaction using prepared data.
- * Returns CompactionResult - SessionManager adds uuid/parentUuid when saving.
- *
- * @param preparation - Pre-calculated preparation from prepareCompaction()
- * @param customInstructions - Optional custom focus for the summary
- */
+/** Summarizes a prepared compaction; the caller records the result. */
 export async function compact(
 	preparation: CompactionPreparation,
 	model: Model<any>,
@@ -723,7 +607,7 @@ export async function compact(
 	env?: Record<string, string>,
 ): Promise<CompactionResult> {
 	const {
-		firstKeptEntryId,
+		firstKeptId,
 		messagesToSummarize,
 		turnPrefixMessages,
 		isSplitTurn,
@@ -783,20 +667,10 @@ export async function compact(
 		);
 	}
 
-	// Compute file lists and append to summary
 	const { readFiles, modifiedFiles } = computeFileLists(fileOps);
 	summary += formatFileOperations(readFiles, modifiedFiles);
 
-	if (!firstKeptEntryId) {
-		throw new Error("First kept entry has no UUID - session may need migration");
-	}
-
-	return {
-		summary,
-		firstKeptEntryId,
-		tokensBefore,
-		details: { readFiles, modifiedFiles } as CompactionDetails,
-	};
+	return { summary, firstKeptId, tokensBefore, readFiles, modifiedFiles };
 }
 
 /**

package/packages/agent/src/core/context-log.ts

@@ -0,0 +1,49 @@
+import type { AgentMessage } from "../loop/index.ts";
+import { createCompactionSummaryMessage } from "./messages.ts";
+
+/** A compaction replaces every entry before its first kept entry with its summary. */
+export interface ContextCompaction {
+	kind: "compaction";
+	id: string;
+	summary: string;
+	firstKeptId: string;
+	tokensBefore: number;
+	timestamp: number;
+	readFiles: string[];
+	modifiedFiles: string[];
+}
+
+/** One entry of an agent's model context in the order the conversation produced it. */
+export type ContextLogEntry = { kind: "message"; id: string; message: AgentMessage } | ContextCompaction;
+
+export function latestCompaction(entries: readonly ContextLogEntry[]): ContextCompaction | undefined {
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (entry.kind === "compaction") return entry;
+	}
+	return undefined;
+}
+
+/** The entries the model sees: the latest compaction, the entries it keeps, and everything after it. */
+export function activeContextEntries(entries: readonly ContextLogEntry[]): ContextLogEntry[] {
+	const compaction = latestCompaction(entries);
+	if (!compaction) return [...entries];
+	const compactionIndex = entries.indexOf(compaction);
+	const firstKeptIndex = entries.findIndex((entry, index) => index < compactionIndex && entry.id === compaction.firstKeptId);
+	return [
+		compaction,
+		...(firstKeptIndex < 0 ? [] : entries.slice(firstKeptIndex, compactionIndex)),
+		...entries.slice(compactionIndex + 1),
+	];
+}
+
+export function contextEntryMessages(entry: ContextLogEntry): AgentMessage[] {
+	return entry.kind === "message"
+		? [entry.message]
+		: [createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp)];
+}
+
+/** The messages of the model context, compaction-aware; the order is the order of the log. */
+export function contextMessages(entries: readonly ContextLogEntry[]): AgentMessage[] {
+	return activeContextEntries(entries).flatMap(contextEntryMessages);
+}

package/packages/agent/src/core/messages.ts

@@ -11,7 +11,7 @@ export const COMPACTION_SUMMARY_PREFIX = `The conversation history before this p
 export const COMPACTION_SUMMARY_SUFFIX = `
 </summary>`;
 
-/** Message that an extension injects into the context of a model call. */
+/** A hidden note that a hook adds to one model call; it is not part of the context. */
 export interface CustomMessage<T = unknown> {
 	role: "custom";
 	customType: string;
@@ -39,24 +39,17 @@ declare module "../loop/types.ts" {
 export function createCompactionSummaryMessage(
 	summary: string,
 	tokensBefore: number,
-	timestamp: string,
+	timestamp: number,
 ): CompactionSummaryMessage {
 	return {
 		role: "compactionSummary",
 		summary: summary,
 		tokensBefore,
-		timestamp: new Date(timestamp).getTime(),
+		timestamp,
 	};
 }
 
-/**
- * Transform AgentMessages (including custom types) to LLM-compatible Messages.
- *
- * This is used by:
- * - Agent's transormToLlm option (for prompt calls and queued messages)
- * - Compaction's generateSummary (for summarization)
- * - Custom extensions and tools
- */
+/** Transform AgentMessages, including hook notes and compaction summaries, to LLM messages. */
 export function convertToLlm(messages: AgentMessage[]): Message[] {
 	return messages
 		.map((m): Message | undefined => {
@@ -67,6 +60,7 @@ export function convertToLlm(messages: AgentMessage[]): Message[] {
 						role: "user",
 						content,
 						timestamp: m.timestamp,
+						transient: true,
 					};
 				}
 				case "compactionSummary":

package/packages/agent/src/core/tool-definition.ts

@@ -0,0 +1,29 @@
+/** The form of the read, write, edit and bash tools; the host runs them in its workspace executor. */
+
+import type { AgentToolResult, AgentToolUpdateCallback, ToolExecutionMode } from "../loop/index.ts";
+import type { Static, TSchema } from "typebox";
+
+export type { AgentToolResult, AgentToolUpdateCallback, ToolExecutionMode };
+
+export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = unknown> {
+	name: string;
+	label: string;
+	description: string;
+	parameters: TParams;
+	/** Optional compatibility shim to prepare raw tool call arguments before schema validation. */
+	prepareArguments?: (args: unknown) => Static<TParams>;
+	executionMode?: ToolExecutionMode;
+	execute(
+		toolCallId: string,
+		params: Static<TParams>,
+		signal: AbortSignal | undefined,
+		onUpdate: AgentToolUpdateCallback<TDetails> | undefined,
+	): Promise<AgentToolResult<TDetails>>;
+}
+
+/** Preserve parameter inference for standalone tool definitions. */
+export function defineTool<TParams extends TSchema, TDetails = unknown>(
+	tool: ToolDefinition<TParams, TDetails>,
+): ToolDefinition<TParams, TDetails> {
+	return tool;
+}

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

@@ -5,7 +5,7 @@ import { Type } from "typebox";
 import { waitForChildProcess } from "../../utils/child-process.ts";
 import { resolvePath } from "../../utils/paths.ts";
 import { getShellConfig, killProcessTree } from "../../utils/shell.ts";
-import type { ToolDefinition } from "../extensions/types.ts";
+import type { ToolDefinition } from "../tool-definition.ts";
 import { OutputAccumulator } from "./output-accumulator.ts";
 import { DEFAULT_MAX_LINES, formatSize, type TruncationResult } from "./truncate.ts";
 
@@ -64,12 +64,7 @@ export interface BashOperations {
 	) => Promise<{ exitCode: number | null }>;
 }
 
-/**
- * Create bash operations using the built-in local shell execution backend.
- *
- * This is useful for extensions that intercept user_bash and still want the
- * standard local shell behavior while wrapping or rewriting commands.
- */
+/** Bash operations on the built-in local shell. */
 export function createLocalBashOperations(options?: { shellPath?: string }): BashOperations {
 	return {
 		exec: async (command, cwd, { onData, signal, timeout, env }) => {
@@ -168,14 +163,12 @@ export function createBashToolDefinition(
 		name: "bash",
 		label: "bash",
 		description: `Execute a bash command in the working directory, or in the folder given as cwd. Returns stdout and stderr; a nonzero exit code is reported at the end of the result (for example grep without a match), not as a tool error. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${BASH_MAX_BYTES / 1024}KB (whichever is hit first), and lines longer than ${BASH_MAX_LINE_CHARS} characters are shortened. If anything was cut, the full output is saved to a temp file. Optionally provide a timeout in seconds.`,
-		promptSnippet: "Execute bash commands (ls, grep, find, etc.)",
 		parameters: bashSchema,
 		async execute(
 			_toolCallId,
 			{ command, timeout, cwd: folder }: { command: string; timeout?: number; cwd?: string },
 			signal?: AbortSignal,
 			onUpdate?,
-			_ctx?,
 		) {
 			const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
 			const spawnContext = resolveSpawnContext(resolvedCommand, folder === undefined ? cwd : resolvePath(folder, cwd), spawnHook);

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

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 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";
@@ -130,18 +130,9 @@ export function createEditToolDefinition(
 		label: "edit",
 		description:
 			"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.",
-		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.",
-		],
 		parameters: editSchema,
 		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);
 

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

@@ -1,11 +1,11 @@
 import { createHash } from "node:crypto";
-import type { Api, ImageContent, Model, TextContent } from "@ragents/ai";
+import type { ImageContent, TextContent } from "@ragents/ai";
 import { constants } from "fs";
 import { access as fsAccess, readFile as fsReadFile } from "fs/promises";
 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 { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate.ts";
@@ -48,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,
@@ -65,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) => {
@@ -100,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 },

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

@@ -1,7 +1,7 @@
 import { mkdir as fsMkdir, writeFile as fsWriteFile } from "fs/promises";
 import { dirname } from "path";
 import { Type } from "typebox";
-import type { ToolDefinition } from "../extensions/types.ts";
+import type { ToolDefinition } from "../tool-definition.ts";
 import { withFileMutationQueue } from "./file-mutation-queue.ts";
 import { resolveToCwd } from "./path-utils.ts";
 
@@ -42,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);