Công cụ và system prompt

export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = unknown, TState = any> {	/** Tool name (used in LLM tool calls) */	name: string;	/** Human-readable label for UI */	label: string;	/** Description for LLM */	description: string;	/** Optional one-line snippet for the Available tools section in the default system prompt. Custom tools are omitted from that section when this is not provided. */	promptSnippet?: string;	/** Optional guideline bullets appended to the default system prompt Guidelines section when this tool is active. */	promptGuidelines?: string[];	/** Parameter schema (TypeBox) */	parameters: TParams;	/** Optional provider-side constrained sampling request for this tool. Set false to explicitly disable it, equivalent to leaving it undefined. */	constrainedSampling?: false | ConstrainedSamplingConfig;	/** Controls whether ToolExecutionComponent renders the standard colored shell or the tool renders its own framing. */	renderShell?: "default" | "self";	/** Optional compatibility shim to prepare raw tool call arguments before schema validation. Must return an object conforming to TParams. */	prepareArguments?: (args: unknown) => Static<TParams>;⋯ lược bớt dòng 599–648	/** Execute the tool. */	execute(		toolCallId: string,		params: Static<TParams>,		signal: AbortSignal | undefined,		onUpdate: AgentToolUpdateCallback<TDetails> | undefined,		ctx: ExtensionToolContext,	): Promise<AgentToolResult<TDetails>>;	/** Custom rendering for tool call display */	renderCall?: (args: Static<TParams>, theme: Theme, context: ToolRenderContext<TState, Static<TParams>>) => Component;	/** Custom rendering for tool result display */	renderResult?: (		result: AgentToolResult<TDetails>,		options: ToolRenderResultOptions,		theme: Theme,		context: ToolRenderContext<TState, Static<TParams>>,	) => Component;}

/** Final or partial result produced by a tool. */export interface AgentToolResult<T = JsonValue | undefined> {	/** Text or image content returned to the model. */	content: (TextContent | ImageContent)[];	/** Arbitrary structured details for logs or UI rendering. */	details: T;	/**	 * Machine-readable result matching the tool's `outputSchema`, for programmatic callers. Not sent	 * to the model; `content` remains the model-facing result.	 */	structuredContent?: JsonValue;	/** Usage from the final tool execution itself, if available. Not used for main LLM context accounting. */	usage?: Usage;	/**	 * Report a failure without throwing. The model sees `content` as an error result, like a thrown	 * error, but `details` and `structuredContent` are kept for the UI and programmatic callers.	 */	isError?: boolean;	/**	 * Hint that the agent should stop after the current tool batch.	 * Early termination only happens when every finalized tool result in the batch sets this to true.	 */	terminate?: boolean;}

export type ToolResultMessage<TDetails = JsonValue> = IsJsonCompatible<TDetails> extends true	? {			role: "toolResult";			toolCallId: string;			toolName: string;			content: (TextContent | ImageContent)[]; // Supports text and images			details?: JsonRepresentation<TDetails>;			/** Usage from the tool execution itself, if available. Not part of main LLM context accounting. */			usage?: Usage;			/** Calls this tool made to other tools. Kept for the session record; not sent to the model. */			nestedCalls?: NestedToolCalls;			isError: boolean;			/** Unix timestamp in milliseconds when the result was created. */			timestamp: number;			/** Milliseconds the tool's execution took, measured with a monotonic clock. Absent for legacy results. */			durationMs?: number;		}	: never;

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 createReadOnlyToolDefinitions(cwd: string, options?: ToolsOptions): ToolDef[] {	return [		createReadToolDefinition(cwd, options?.read),		createGrepToolDefinition(cwd, options?.grep),		createFindToolDefinition(cwd, options?.find),		createLsToolDefinition(cwd, options?.ls),	];}

const toolListError = options.tools ? getToolListError(options.tools) : undefined;if (toolListError) throw new Error(`Invalid tools option: ${toolListError}`);const defaultToolNames = options.noTools ? [] : (settingsManager.getDefaultTools() ?? DEFAULT_TOOL_NAMES);// A `tools` list of only `+name`/`-name` entries changes the default selection instead of// replacing it, like the `defaultTools` setting.const toolModifiers = options.tools?.some(isToolModifier) ? options.tools : undefined;const selectedToolNames = toolModifiers ? applyToolModifiers(defaultToolNames, toolModifiers) : options.tools;const allowedToolNames = toolModifiers	? options.noTools === "all"		? selectedToolNames		: undefined	: (options.tools ?? (options.noTools === "all" ? [] : undefined));const excludedToolNames = options.excludeTools;const isExcludedTool = excludedToolNames ? createToolNameMatcher(excludedToolNames) : undefined;const initialActiveToolNames = (selectedToolNames ?? defaultToolNames).filter((name) => !isExcludedTool?.(name));

const autoResizeImages = this.settingsManager.getImageAutoResize();const shellCommandPrefix = this.settingsManager.getShellCommandPrefix();const shellPath = this.settingsManager.getShellPath();const baseToolDefinitions = this._baseToolsOverride	? Object.fromEntries(			Object.entries(this._baseToolsOverride).map(([name, tool]) => [				name,				createToolDefinitionFromAgentTool(tool),			]),		)	: createAllToolDefinitions(this._cwd, {			read: { autoResizeImages },			bash: { commandPrefix: shellCommandPrefix, shellPath },		});⋯ lược bớt dòng 3685–3709const defaultActiveToolNames = this._baseToolsOverride	? Object.keys(this._baseToolsOverride)	: ["read", "bash", "edit", "write"];const baseActiveToolNames = options.activeToolNames ?? defaultActiveToolNames;this._refreshToolRegistry({	activeToolNames: baseActiveToolNames,	includeAllExtensionTools: options.includeAllExtensionTools,});

export function wrapToolDefinition<TDetails = unknown>(	definition: ToolDefinition<any, TDetails>,	ctxFactory?: ToolContextFactory,): AgentTool<any, TDetails> {	return {		name: definition.name,		label: definition.label,		description: definition.description,		parameters: definition.parameters,		outputSchema: definition.outputSchema,		constrainedSampling: definition.constrainedSampling,		prepareArguments: definition.prepareArguments,		executionMode: definition.executionMode,		execute: (toolCallId, params, signal, onUpdate, ctx?: ExtensionToolContext) =>			definition.execute(				toolCallId,				params,				signal,				onUpdate,				ctx ?? (ctxFactory?.(toolCallId, signal) as ExtensionToolContext),			),	};}

/** * Shared truncation utilities for tool outputs. * * Truncation is based on two independent limits - whichever is hit first wins: * - Line limit (default: 2000 lines) * - Byte limit (default: 50KB) * * Never returns partial lines (except bash tail truncation edge case). */export const DEFAULT_MAX_LINES = 2000;export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KBexport const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line

export function truncateTail(content: string, options: TruncationOptions = {}): TruncationResult {	const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;⋯ lược bớt dòng 171–192	// Work backwards from the end	const outputLinesArr: string[] = [];	let outputBytesCount = 0;	let truncatedBy: "lines" | "bytes" = "lines";	let lastLinePartial = false;	for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {		const line = lines[i];		const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0); // +1 for newline		if (outputBytesCount + lineBytes > maxBytes) {			truncatedBy = "bytes";			// Edge case: if we haven't added ANY lines yet and this line exceeds maxBytes,			// take the end of the line (partial)			if (outputLinesArr.length === 0) {				const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);				outputLinesArr.unshift(truncatedLine);				outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");				lastLinePartial = true;			}			break;		}		outputLinesArr.unshift(line);		outputBytesCount += lineBytes;	}

const readSchema = Type.Object({	path: Type.String({ description: "Path to the file to read (relative or absolute)" }),	offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),});export const readToolSystemPromptContribution = {	snippet: "Read file contents",	guidelines: ["Use read to examine files instead of cat or sed."],} as const;

return {	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: readToolSystemPromptContribution.snippet,	promptGuidelines: [...readToolSystemPromptContribution.guidelines],	parameters: readSchema,	outputSchema: readOutputSchema,	constrainedSampling: { type: "json_schema", strict: "prefer" },

export function normalizePath(input: string, options: PathInputOptions = {}): string {	let normalized = options.trim ? input.trim() : input;	if (options.normalizeUnicodeSpaces) {		normalized = normalized.replace(UNICODE_SPACES, " ");	}	if (options.stripAtPrefix && normalized.startsWith("@")) {		normalized = normalized.slice(1);	}	if (process.platform === "win32") {		normalized = normalizeWindowsShellPath(normalized);	}	if (options.expandTilde ?? true) {		const home = options.homeDir ?? homedir();		if (normalized === "~") return home;		if (normalized.startsWith("~/") || (process.platform === "win32" && normalized.startsWith("~\\"))) {			return join(home, normalized.slice(2));		}	}	if (/^file:\/\//.test(normalized)) {		return fileURLToPath(normalized);	}	return normalized;}export function resolvePath(input: string, baseDir: string = process.cwd(), options: PathInputOptions = {}): string {	const normalized = normalizePath(input, options);	const normalizedBaseDir = normalizePath(baseDir);	return isAbsolute(normalized) ? nodeResolvePath(normalized) : nodeResolvePath(normalizedBaseDir, normalized);}

export async function resolveReadPathAsync(filePath: string, cwd: string): Promise<string> {	const resolved = resolveToCwd(filePath, cwd);	if (await pathExists(resolved)) {		return resolved;	}	// Try macOS AM/PM variant (narrow no-break space before AM/PM)	const amPmVariant = tryMacOSScreenshotPath(resolved);	if (amPmVariant !== resolved && (await pathExists(amPmVariant))) {		return amPmVariant;	}	// Try NFD variant (macOS stores filenames in NFD form)	const nfdVariant = tryNFDVariant(resolved);	if (nfdVariant !== resolved && (await pathExists(nfdVariant))) {		return nfdVariant;	}	// Try curly quote variant (macOS uses U+2019 in screenshot names)	const curlyVariant = tryCurlyQuoteVariant(resolved);	if (curlyVariant !== resolved && (await pathExists(curlyVariant))) {		return curlyVariant;	}	// Try combined NFD + curly quote (for French macOS screenshots like "Capture d'écran")	const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);	if (nfdCurlyVariant !== resolved && (await pathExists(nfdCurlyVariant))) {		return nfdCurlyVariant;	}	return resolved;}

const allLines = textContent.split("\n");const totalFileLines = allLines.length;// Apply offset if specified. Convert from 1-indexed input to 0-indexed array access.const startLine = offset ? Math.max(0, offset - 1) : 0;const startLineDisplay = startLine + 1;// Check if offset is out of bounds.if (startLine >= allLines.length) {	throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);}⋯ lược bớt dòng 166–168if (limit !== undefined) {	const endLine = Math.min(startLine + limit, allLines.length);	selectedContent = allLines.slice(startLine, endLine).join("\n");	userLimitedLines = endLine - startLine;} else {	selectedContent = allLines.slice(startLine).join("\n");}// Apply truncation, respecting both line and byte limits.const truncation = truncateHead(selectedContent);let outputText: string;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}]`;	details = { truncation };} else if (truncation.truncated) {	// Truncation occurred. Build an actionable continuation notice.	const endLineDisplay = startLineDisplay + truncation.outputLines - 1;	const nextOffset = endLineDisplay + 1;	outputText = truncation.content;	if (truncation.truncatedBy === "lines") {		outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;	} else {		outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;	}	details = { truncation };

const mimeType = ops.detectImageMimeType ? await ops.detectImageMimeType(absolutePath) : undefined;let content: (TextContent | ImageContent)[];let details: ReadToolDetails | undefined;const nonVisionImageNote = getNonVisionImageNote(ctx?.model);if (mimeType) {	// Read image as binary.	const buffer = await ops.readFile(absolutePath);	const processed = await processImage(buffer, mimeType, {		autoResizeImages,		resizeOptions: ctx?.model?.inputLimits?.images?.resize ?? fallbackResizeOptions,	});	if (!processed.ok) {		let textNote = `Read image file [${mimeType}]\n${processed.message}`;		if (nonVisionImageNote) textNote += `\n${nonVisionImageNote}`;		content = [{ type: "text", text: textNote }];	} 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 },		];	}

const bashSchema = Type.Object({	command: Type.String({ description: "Shell command to execute" }),	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),});export const bashToolSystemPromptContribution = {	snippet: "Execute bash commands (ls, grep, find, etc.)",	guidelines: ["You can inspect PI_* environment variables for current model and session details."],} as const;

const shellConfig = resolveShellConfig();try {	await fsAccess(cwd, constants.F_OK);} catch {	throw new Error(`Working directory does not exist: ${cwd}\nCannot execute ${shellName} commands.`);}const commandFromStdin = shellConfig.commandTransport === "stdin";const child = spawn(shellConfig.shell, commandFromStdin ? shellConfig.args : [...shellConfig.args, command], {	cwd,	detached: process.platform !== "win32",	env: env ?? getShellEnv(),	stdio: [commandFromStdin ? "pipe" : "ignore", "pipe", "pipe"],	windowsHide: true,});if (commandFromStdin) {	child.stdin?.on("error", () => {});	child.stdin?.end(command);}if (child.pid) trackDetachedChildPid(child.pid);let timedOut = false;let timeoutHandle: NodeJS.Timeout | undefined;const onAbort = () => {	if (child.pid) killProcessTree(child.pid);};

// Set timeout if provided.if (timeoutMs !== undefined) {	timeoutHandle = setTimeout(() => {		timedOut = true;		if (child.pid) killProcessTree(child.pid);	}, timeoutMs);}// Stream stdout and stderr.child.stdout?.on("data", onData);child.stderr?.on("data", onData);// Handle abort signal by killing the entire process tree.if (signal) {	if (signal.aborted) onAbort();	else signal.addEventListener("abort", onAbort, { once: true });}// Handle shell spawn errors and wait for the process to terminate without hanging// on inherited stdio handles held by detached descendants.const exitCode = await waitForChildProcess(child);if (signal?.aborted) {	throw new Error("aborted");}if (timedOut) {	throw new Error(`timeout:${timeout}`);}// A signal-killed shell has no exit code. Use the standard shell convention so// callers do not mistake the termination for a successful command.const signalCode = child.signalCode;return { exitCode: exitCode ?? (signalCode ? 128 + (osConstants.signals[signalCode] ?? 0) : 1) };

/** * Kill a process and all its children (cross-platform) */export function killProcessTree(pid: number): void {	if (process.platform === "win32") {⋯ lược bớt dòng 222–237	} else {		// Use SIGKILL on Unix/Linux/Mac		try {			process.kill(-pid, "SIGKILL");		} catch {			// Fallback to killing just the child if process group kill fails			try {				process.kill(pid, "SIGKILL");			} catch {				// Process already dead			}		}	}

const env = { ...getShellEnv() };delete env.PI_SESSION_ID;delete env.PI_SESSION_FILE;delete env.PI_PROVIDER;delete env.PI_MODEL;delete env.PI_REASONING_LEVEL;if (exposeSessionEnvironment && ctx) {	const model = ctx.model;	env.PI_SESSION_ID = ctx.sessionManager.getSessionId();	const sessionFile = ctx.sessionManager.getSessionFile();	if (sessionFile) env.PI_SESSION_FILE = sessionFile;	if (model) {		env.PI_PROVIDER = model.provider;		env.PI_MODEL = model.id;	}	if (ctx.thinkingLevel) env.PI_REASONING_LEVEL = ctx.thinkingLevel;}const baseContext: BashSpawnContext = { command, cwd, env };return spawnHook ? spawnHook(baseContext) : baseContext;

append(data: Buffer): void {	if (this.finished) {		throw new Error("Cannot append to a finished output accumulator");	}	this.totalRawBytes += data.length;	this.appendDecodedText(this.decoder.decode(data, { stream: true }));	if (this.tempFileStream || this.shouldUseTempFile()) {		this.ensureTempFile();		this.tempFileStream?.write(data);	} else if (data.length > 0) {		this.rawChunks.push(data);	}}⋯ lược bớt dòng 79–238private shouldUseTempFile(): boolean {	return (		this.totalRawBytes > this.maxBytes || this.totalDecodedBytes > this.maxBytes || this.totalLines > this.maxLines	);}private ensureTempFile(): void {	if (this.tempFilePath) {		return;	}	const { path, stream } = createOutputFileStream(this.tempFilePrefix, ".log");	this.tempFilePath = path;	this.tempFileStream = stream;	for (const chunk of this.rawChunks) {		this.tempFileStream.write(chunk);	}	this.rawChunks = [];}

const scheduleOutputUpdate = () => {	if (!onUpdate) return;	updateDirty = true;	const delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);	if (delay <= 0) {		clearUpdateTimer();		emitOutputUpdate();		return;	}	updateTimer ??= setTimeout(() => {		updateTimer = undefined;		emitOutputUpdate();	}, delay);};⋯ lược bớt dòng 317–321const handleData = (data: Buffer) => {	if (!acceptingOutput) return;	output.append(data);	scheduleOutputUpdate();};

} catch (err) {	const snapshot = await finishOutput();	const { text } = formatOutput(snapshot, "");	if (err instanceof Error && err.message === "aborted") {		throw new Error(appendStatus(text, "Command aborted"));	}	if (err instanceof Error && err.message.startsWith("timeout:")) {		const timeoutSecs = err.message.split(":")[1];		throw new Error(appendStatus(text, `Command timed out after ${timeoutSecs} seconds`));	}	throw err;}⋯ lược bớt dòng 383–385if (exitCode === null) {	throw new Error(appendStatus(outputText, "Command terminated without an exit code"));}const wallTimeSeconds = Math.round((performance.now() - startedAt) / 100) / 10;const fullOutput = await output.readFullOutput(STRUCTURED_OUTPUT_MAX_BYTES);const structuredContent: BashToolOutput = {	output: fullOutput.content,	truncated: fullOutput.truncated,	...(fullOutput.truncated && snapshot.fullOutputPath		? { full_output_path: snapshot.fullOutputPath }		: {}),	exit_code: exitCode,	wall_time_seconds: wallTimeSeconds,};if (exitCode !== 0) {	return {		content: [{ type: "text", text: appendStatus(outputText, `Command exited with code ${exitCode}`) }],		details,		structuredContent,		isError: true,	};}return { content: [{ type: "text", text: outputText }], details, structuredContent };

const replaceEditSchema = Type.Object(	{		oldText: Type.String({			description:				"Exact text for one targeted replacement. It must be unique in the original file and must not overlap with any other edits[].oldText in the same call.",		}),		newText: Type.String({ description: "Replacement text for this targeted edit." }),	},	{},);const editSchema = Type.Object(	{		path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),		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.",		}),	},	{},);export const editToolSystemPromptContribution = {	snippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",	guidelines: [		"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.",	],} as const;

function prepareEditArguments(input: unknown): EditToolInput {	if (!input || typeof input !== "object") {		return input as EditToolInput;	}	const args = input as Record<string, unknown>;	// Some models (Opus 4.6, GLM-5.1) send edits as a JSON string instead of an array.	// Others send a single edit object instead of a one-element edits array.	if (typeof args.edits === "string") {		try {			const parsed = JSON.parse(args.edits);			if (Array.isArray(parsed)) {				args.edits = parsed;			} else if (isSingleEditInput(parsed)) {				args.edits = [parsed];			}		} catch {}	} else if (isSingleEditInput(args.edits)) {		args.edits = [args.edits];	}	const legacy = args as LegacyEditToolInput;	if (typeof legacy.oldText !== "string" || typeof legacy.newText !== "string") {		return args as EditToolInput;	}	const edits = Array.isArray(legacy.edits) ? [...legacy.edits] : [];	edits.push({ oldText: legacy.oldText, newText: legacy.newText });	const { oldText: _oldText, newText: _newText, ...rest } = legacy;	return { ...rest, edits } as EditToolInput;}

const { path, edits } = validateEditInput(input);const absolutePath = resolveToCwd(path, ctx?.cwd || cwd);return withFileMutationQueue(absolutePath, async () => {	// Do not reject from an abort event listener here: that would release the	// mutation queue while an in-flight filesystem operation may still finish.	// Checking signal.aborted after each await observes the same aborts while	// keeping the queue locked until the current operation has settled.	const throwIfAborted = (): void => {		if (signal?.aborted) throw new Error("Operation aborted");	};⋯ lược bớt dòng 171–184	// Read the file.	const buffer = await ops.readFile(absolutePath);	const rawContent = buffer.toString("utf-8");	throwIfAborted();	// Strip BOM before matching. The model will not include an invisible BOM in oldText.	const { bom, text: content } = splitBom(rawContent);	const originalEnding = detectLineEnding(content);	const normalizedContent = normalizeToLF(content);	const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);	throwIfAborted();	const finalContent = bom + restoreLineEndings(newContent, originalEnding);	await ops.writeFile(absolutePath, finalContent);	throwIfAborted();	const diffResult = generateDiffString(baseContent, newContent);	const patch = generateUnifiedPatch(path, baseContent, newContent);	return {		content: [			{				type: "text",				text: `Successfully replaced ${edits.length} block(s) in ${path}.`,			},		],		details: { diff: diffResult.diff, patch, firstChangedLine: diffResult.firstChangedLine },	};

const initialMatches = normalizedEdits.map((edit) => fuzzyFindText(normalizedContent, edit.oldText));const usedFuzzyMatch = initialMatches.some((match) => match.usedFuzzyMatch);const replacementBaseContent = usedFuzzyMatch ? normalizeForFuzzyMatch(normalizedContent) : normalizedContent;const matchedEdits: MatchedEdit[] = [];for (let i = 0; i < normalizedEdits.length; i++) {	const edit = normalizedEdits[i];	const matchResult = fuzzyFindText(replacementBaseContent, edit.oldText);	if (!matchResult.found) {		throw getNotFoundError(path, i, normalizedEdits.length);	}	const occurrences = countOccurrences(replacementBaseContent, edit.oldText);	if (occurrences > 1) {		throw getDuplicateError(path, i, normalizedEdits.length, occurrences);	}⋯ lược bớt dòng 332–340matchedEdits.sort((a, b) => a.matchIndex - b.matchIndex);for (let i = 1; i < matchedEdits.length; i++) {	const previous = matchedEdits[i - 1];	const current = matchedEdits[i];	if (previous.matchIndex + previous.matchLength > current.matchIndex) {		throw new Error(			`edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${path}. Merge them into one edit or target disjoint regions.`,		);	}}const baseContent = normalizedContent;const newContent = usedFuzzyMatch	? applyReplacementsPreservingUnchangedLines(normalizedContent, replacementBaseContent, matchedEdits)	: applyReplacements(replacementBaseContent, matchedEdits);if (baseContent === newContent) {	throw getNoChangeError(path, normalizedEdits.length);}

	const absolutePath = resolveToCwd(path, ctx?.cwd || cwd);	const dir = dirname(absolutePath);	return withFileMutationQueue(absolutePath, async () => {		// Do not reject from an abort event listener here: that would release the		// mutation queue while an in-flight filesystem operation may still finish.		// Checking signal.aborted after each await observes the same aborts while		// keeping the queue locked until the current operation has settled.		const throwIfAborted = (): void => {			if (signal?.aborted) throw new Error("Operation aborted");		};		throwIfAborted();		// Create parent directories if needed.		await ops.mkdir(dir);		throwIfAborted();		// Write the file contents.		await ops.writeFile(absolutePath, content);		throwIfAborted();		return {			content: [{ type: "text", text: `Successfully wrote to ${path}` }],			details: undefined,		};	});},

// --no-config: the tool contract (literal, glob, limit, ...) must not depend on// ambient user config like RIPGREP_CONFIG_PATH. Users can customize via bash or extensions.const args: string[] = ["--no-config", "--json", "--line-number", "--color=never", "--hidden"];if (ignoreCase) args.push("--ignore-case");if (literal) args.push("--fixed-strings");if (glob) args.push("--glob", glob);args.push("--", pattern, searchPath);

const args: string[] = ["--glob", "--color=never", "--hidden"];// fd normally ignores .gitignore outside git repos, so keep --no-require-git// there. Inside repos, use fd's default git-aware behavior so parent// .gitignore rules stop at nested repo boundaries:// https://github.com/earendil-works/pi/issues/5960let insideGitRepo = false;for (let current = searchPath; ; ) {	if (await pathExists(path.join(current, ".git"))) {		insideGitRepo = true;		break;	}	const parent = path.dirname(current);	if (parent === current) break;	current = parent;}if (!insideGitRepo) args.push("--no-require-git");args.push("--max-results", String(effectiveLimit));// fd --glob matches against the basename unless --full-path is set; in --full-path// mode it matches against the absolute candidate path, so a path-containing// pattern like 'src/**/*.spec.ts' needs a leading '**/' to match anything.let effectivePattern = pattern;if (pattern.includes("/")) {	args.push("--full-path");	if (!pattern.startsWith("/") && !pattern.startsWith("**/") && pattern !== "**") {		effectivePattern = `**/${pattern}`;	}	// fd matches full paths using native separators on Windows.	if (process.platform === "win32")		effectivePattern = effectivePattern.replaceAll("/", String.raw`[/\\]`);}args.push("--", effectivePattern, searchPath);

case "tool_execution_update": {	const component = this.pendingTools.get(event.toolCallId);	if (component) {		component.updateResult({ ...event.partialResult, isError: false }, true);		this.ui.requestRender();	}	break;}case "tool_execution_end": {	if (event.isError) this.maybeShowInstallChangeWarning();	const component = this.pendingTools.get(event.toolCallId);	if (component) {		component.updateResult({ ...event.result, isError: event.isError, durationMs: event.durationMs });		this.pendingTools.delete(event.toolCallId);		this.ui.requestRender();	}	break;}

if (context.argsComplete && previewInput && !component.preview && !component.previewPending) {	component.previewPending = true;	const requestKey = argsKey;	void computeEditsDiff(previewInput.path, previewInput.edits, context.cwd).then((preview) => {		if (component.previewArgsKey === requestKey) {			setEditPreview(component, preview, requestKey);			context.invalidate();		}	});}

const appendText = (rawText: string) => {	// Sanitize: strip ANSI, replace binary garbage, normalize newlines	const text = sanitizeBinaryOutput(stripAnsi(rawText)).replace(/\r/g, "");	if (!text) {		return;	}	// Start writing to temp file if exceeds threshold	if (totalBytes > DEFAULT_MAX_BYTES) {		ensureTempFile();	}	if (tempFileStream) {		tempFileStream.write(text);	}	// Keep rolling buffer	outputChunks.push(text);	outputBytes += text.length;	while (outputBytes > maxOutputBytes && outputChunks.length > 1) {		const removed = outputChunks.shift()!;		outputBytes -= removed.length;	}	// Stream to callback	if (options?.onChunk) {		options.onChunk(text);	}};

export interface BuildSystemPromptOptions {	/** Custom system prompt (replaces the default prefix). */	customPrompt?: string;	/** Exact full prompt replacement set by a before_agent_start handler. */	forceSystemPrompt?: string;	/** Tools to include in prompt. Default: [read, bash, edit, write]. */	selectedTools?: string[];	/**	 * Selected tools whose declarations requests leave out (`prepareLoadout` hidden declarations).	 * They are reachable only through another tool, so the tool list and rules leave them out too.	 */	hiddenTools?: string[];	/** Optional one-line tool snippets keyed by tool name. */	toolSnippets?: Record<string, string>;	/** Guideline bullets contributed by each tool, keyed by tool name. */	toolGuidelines?: Record<string, string[]>;	/** Additional guideline bullets appended to the default system prompt rules. */	promptGuidelines?: string[];	/** Text appended from user configuration before project context, skills, and cwd. */	appendSystemPrompt?: string;	/** Additional XML-wrapped prompt sections keyed by tag name. */	sections?: Record<string, string>;	/** Working directory. */	cwd: string;	/** Pre-loaded context files. */	contextFiles?: Array<{ path: string; content: string }>;	/** Pre-loaded skills. */	skills?: Skill[];}

const declaredTools = selectedTools.filter((name) => !hiddenTools.includes(name));const promptSections: Record<string, string> = {};if (customPrompt) {	promptSections.preamble = customPrompt;} else {	promptSections.preamble =		"You are an expert coding assistant operating inside pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.";	const visibleTools = declaredTools.filter((name) => !!toolSnippets[name]);	const tools =		visibleTools.length > 0 ? visibleTools.map((name) => `- ${name}: ${toolSnippets[name]}`).join("\n") : "(none)";	promptSections.tools = `${tools}\n\nIn addition to the tools above, you may have access to other custom tools depending on the project.`;	promptSections.rules = buildRules(declaredTools, toolGuidelines, promptGuidelines);⋯ lược bớt dòng 162–171if (appendSystemPrompt) promptSections.addendum = appendSystemPrompt;if (contextFiles.length > 0) promptSections.project_context = renderProjectContext(contextFiles);// A hidden reader is still reachable through another tool, so skills stay but the hint names no tool.const readers = ["read", "bash"] as const;const skillFileReadTool =	readers.find((tool) => declaredTools.includes(tool)) ??	(readers.some((tool) => selectedTools.includes(tool)) ? "indirect" : undefined);if (skillFileReadTool && skills.length > 0) {	const skillsPrompt = formatSkillsForPrompt(skills, skillFileReadTool).trim();	if (skillsPrompt) promptSections.skills = skillsPrompt;}promptSections.cwd = cwd.replace(/\\/g, "/");for (const [name, content] of Object.entries(customSections)) {	if (content) promptSections[name] = content;}const sections: SystemPromptSections = { preamble: promptSections.preamble };for (const [name, content] of Object.entries(promptSections)) {	if (name !== "preamble") sections[name] = `<${name}>\n${content}\n</${name}>`;}return sections;

function buildRules(	selectedTools: string[],	toolGuidelines: Record<string, string[]>,	promptGuidelines: string[],): string {	const rules: string[] = [];	const seen = new Set<string>();	const addRule = (rule: string): void => {		const normalized = rule.trim();		if (!normalized || seen.has(normalized)) return;		seen.add(normalized);		rules.push(normalized);	};	const hasBash = selectedTools.includes("bash");	const hasPowerShell = selectedTools.includes("powershell");	const hasGrep = selectedTools.includes("grep");	const hasFind = selectedTools.includes("find");	const hasLs = selectedTools.includes("ls");	if ((hasBash || hasPowerShell) && !hasGrep && !hasFind && !hasLs) {		if (hasBash && hasPowerShell) {			addRule("Use bash or PowerShell for file operations like listing, searching, and finding files");		} else if (hasPowerShell) {			addRule("Use PowerShell for file operations like listing, searching, and finding files");		} else {			addRule("Use bash for file operations like ls, rg, find");		}	}	for (const name of selectedTools) {		for (const rule of toolGuidelines[name] ?? []) addRule(rule);	}	for (const rule of promptGuidelines) addRule(rule);	addRule("Be concise in your responses");	addRule("Show file paths clearly when working with files");	return rules.map((rule) => `- ${rule}`).join("\n");}

export interface SystemMessage {	role: "system";	/** Instruction text. On the leading message this is the base prompt; later, additional instructions. */	content: string | TextContent[];	/**	 * Named, ordered prompt sections rendered verbatim after `content`. The leading message	 * declares them; later messages replace sections by name, and `null` removes one. Keep	 * each section self-delimiting (a tag, a heading) so the model can relate an update to	 * the original. Avoid integer-like names; JSON objects reorder those.	 */	sections?: Record<string, string | null>;	/** Complete definitions of tools that become available at this point. */	toolsAdded?: Tool[];	/** Tools that stop being available at this point. */	toolsRemoved?: ToolReference[];	timestamp: number; // Unix timestamp in milliseconds}

export function diffSystemPromptSections(	previous: Record<string, string | null>,	current: SystemPromptSections,): Record<string, string | null> | undefined {	const patch: Record<string, string | null> = {};	for (const [name, text] of Object.entries(current)) {		if (previous[name] !== text) patch[name] = text;	}	for (const name of Object.keys(previous)) {		if (current[name] === undefined) patch[name] = null;	}	return Object.keys(patch).length > 0 ? patch : undefined;}

private _rebuildSystemPrompt(toolNames: string[]): void {	const validToolNames = toolNames.filter((name) => this._toolRegistry.has(name));	const toolSnippets: Record<string, string> = {};	for (const name of this._toolRegistry.keys()) {		const snippet = this._toolPromptSnippets.get(name);		// Tools without a snippet are not listed.		if (snippet) toolSnippets[name] = snippet;	}	const loaderSystemPrompt = this._resourceLoader.getSystemPrompt();	const loaderAppendSystemPrompt = this._resourceLoader.getAppendSystemPrompt();	const appendSystemPrompt = loaderAppendSystemPrompt.length > 0 ? loaderAppendSystemPrompt.join("\n\n") : "";	const loadedSkills = this._resourceLoader.getSkills().skills;	const loadedContextFiles = this._resourceLoader.getAgentsFiles().agentsFiles;	this._baseSystemPromptOptions = normalizeBuildSystemPromptOptions({		cwd: this._cwd,		skills: loadedSkills,		contextFiles: loadedContextFiles,		customPrompt: loaderSystemPrompt,		appendSystemPrompt,		selectedTools: validToolNames,		hiddenTools: [...this._hiddenDeclarations],		toolSnippets,		toolGuidelines: Object.fromEntries(this._toolPromptGuidelines),	});}

function loadContextFileFromDir(dir: string): { path: string; content: string } | null {	const candidates = ["AGENTS.override.md", "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];	for (const filename of candidates) {		const filePath = join(dir, filename);		if (existsSync(filePath)) {			try {				if (!statSync(filePath).isFile()) {					continue;				}				return {					path: filePath,					content: stripBom(readFileSync(filePath, "utf-8")),				};			} catch (error) {				console.error(chalk.yellow(`Warning: Could not read ${filePath}: ${error}`));			}		}	}	return null;}

const contextFiles: Array<{ path: string; content: string }> = [];const seenPaths = new Set<string>();const globalContext = loadContextFileFromDir(resolvedAgentDir);if (globalContext) {	contextFiles.push(globalContext);	seenPaths.add(globalContext.path);}⋯ lược bớt dòng 247–250let currentDir = resolvedCwd;while (true) {	const contextFile = loadContextFileFromDir(currentDir);	// Compare the directory's real path, not the file's: a worktree AGENTS.md that	// symlinks to the main repo's file resolves to the shadowed path itself.	const isShadowed =		shadowedContextFile !== undefined &&		contextFile !== null &&		join(canonicalizePath(currentDir), basename(contextFile.path)) === shadowedContextFile;	if (contextFile && !isShadowed && !seenPaths.has(contextFile.path)) {		ancestorContextFiles.unshift(contextFile);		seenPaths.add(contextFile.path);	}	const parentDir = dirname(currentDir);	if (parentDir === currentDir) break;	currentDir = parentDir;}contextFiles.push(...ancestorContextFiles);return contextFiles;

private discoverSystemPromptFile(): string | undefined {	const projectPath = join(this.cwd, CONFIG_DIR_NAME, "SYSTEM.md");	if (this.settingsManager.isProjectTrusted() && existsSync(projectPath)) {		return projectPath;	}	const globalPath = join(this.agentDir, "SYSTEM.md");	if (existsSync(globalPath)) {		return globalPath;	}	return undefined;}private discoverAppendSystemPromptFile(): string | undefined {	const projectPath = join(this.cwd, CONFIG_DIR_NAME, "APPEND_SYSTEM.md");	if (this.settingsManager.isProjectTrusted() && existsSync(projectPath)) {		return projectPath;	}	const globalPath = join(this.agentDir, "APPEND_SYSTEM.md");	if (existsSync(globalPath)) {		return globalPath;	}	return undefined;}

export function formatSkillsForPrompt(skills: Skill[], fileReadTool: "read" | "bash" | "indirect" = "read"): string {	const visibleSkills = skills.filter((s) => !s.disableModelInvocation);	if (visibleSkills.length === 0) {		return "";	}	const lines = [		"\n\nThe following skills provide specialized instructions for specific tasks.",		fileReadTool === "read"			? "Use the read tool to load a skill's file when the task matches its description."			: fileReadTool === "bash"				? "Use bash to load a skill's file when the task matches its description."				: "Load a skill's file when the task matches its description.",		"When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",		"",		"<available_skills>",	];	for (const skill of visibleSkills) {		lines.push("  <skill>");		lines.push(`    <name>${escapeXml(skill.name)}</name>`);		lines.push(`    <description>${escapeXml(skill.description)}</description>`);		lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);		lines.push("  </skill>");	}	lines.push("</available_skills>");	return lines.join("\n");}

const tool = tools.find((t) => t.name === toolCall.name);if (!tool) {	return {		kind: "immediate",		result: createErrorToolResult(`Tool ${toolCall.name} not found`),		isError: true,	};}try {	const preparedToolCall = prepareToolCallArguments(tool, toolCall);	const validatedArgs = validateToolArguments(tool, preparedToolCall);⋯ lược bớt dòng 738–754		if (beforeResult?.block) {			const result = createErrorToolResult(beforeResult.reason || "Tool execution was blocked");			if (beforeResult.terminate === true) {				result.terminate = true;			}			return {				kind: "immediate",				result,				isError: true,			};		}⋯ lược bớt dòng 766–779} catch (error) {	return {		kind: "immediate",		result: createErrorToolResult(error instanceof Error ? error.message : String(error)),		isError: true,	};}