REQUIRED_PARAM_GROUPS,

assertRequiredParams,

getToolParamsRecord,

stripMalformedXmlArgValueSuffix,

stripMalformedXmlArgValueSuffixFromKeys,

wrapToolParamValidation,

} from "./agent-tools.params.js";

import type { AnyAgentTool } from "./agent-tools.types.js";

return clamp(fromContext, DEFAULT_READ_PAGE_MAX_BYTES, MAX_ADAPTIVE_READ_MAX_BYTES);

}

function malformedXmlArgValuePathError(key: string): Error {

return new Error(`Malformed path parameter: ${key}. Supply correct parameters before retrying.`);

}

function formatBytes(bytes: number): string {

if (bytes >= 1024 * 1024) {

return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;

description: `${tool.description} During memory flush, this tool may only append to ${options.relativePath}.`,

execute: async (toolCallId, args, signal, onUpdate) => {

const record = getToolParamsRecord(args);

assertRequiredParams(record, REQUIRED_PARAM_GROUPS.write, tool.name);

const normalizedRecord = record

? stripMalformedXmlArgValueSuffixFromKeys(record, ["path"])

: undefined;

assertRequiredParams(normalizedRecord, REQUIRED_PARAM_GROUPS.write, tool.name);

const filePath =

typeof record?.path === "string" && record.path.trim() ? record.path : undefined;

typeof normalizedRecord?.path === "string" && normalizedRecord.path.trim()

? normalizedRecord.path

: undefined;

const content = typeof record?.content === "string" ? record.content : undefined;

if (!filePath || content === undefined) {

return tool.execute(toolCallId, args, signal, onUpdate);

const record = getToolParamsRecord(args);

let normalizedRecord: Record<string, unknown> | undefined;

for (const key of pathParamKeys) {

const filePath = record?.[key];

if (typeof filePath !== "string" || !filePath.trim()) {

const rawFilePath = record?.[key];

if (typeof rawFilePath !== "string" || !rawFilePath.trim()) {

continue;

}

const filePath = stripMalformedXmlArgValueSuffix(rawFilePath);

if (!filePath.trim()) {

throw malformedXmlArgValuePathError(key);

}

if (filePath !== rawFilePath && record) {

normalizedRecord ??= { ...record };

normalizedRecord[key] = filePath;

}

let guardedRoot = root;

const workspaceMapping = mapContainerPathToRoot({

filePath,

...base,

execute: async (toolCallId, params, signal) => {

const record = getToolParamsRecord(params);

assertRequiredParams(record, REQUIRED_PARAM_GROUPS.read, base.name);

const normalizedRecord = record

? stripMalformedXmlArgValueSuffixFromKeys(record, ["path"])

: undefined;

assertRequiredParams(normalizedRecord, REQUIRED_PARAM_GROUPS.read, base.name);

const result = await executeReadWithAdaptivePaging({

base,

toolCallId,

args: record ?? {},

args: normalizedRecord ?? {},

signal,

maxBytes: resolveAdaptiveReadMaxBytes(options),

});

const filePath = typeof record?.path === "string" ? record.path : "<unknown>";

const filePath =

typeof normalizedRecord?.path === "string" ? normalizedRecord.path : "<unknown>";

const strippedDetailsResult = stripReadTruncationContentDetails(result);

const normalizedResult = await normalizeReadImageResult(strippedDetailsResult, filePath);

return sanitizeToolResultImages(