minimal-agent 0.10.0 → 0.12.0

package/src/tools/read/read.js

@@ -1,30 +1,20 @@
-/**
- * ============================================================
- *  src/tools/read.ts —— Read 工具（读文件）
- * ------------------------------------------------------------
- *  对应 kakadeai 主仓库的 FileReadTool。
- *  prompt 文本和 Zod schema 与 kakadeai 一致，让"模型可见接口"完全对齐；
- *  call() 实现用最简单的 fs/promises，剥离了 UI/权限/PDF/Notebook/图片支持。
- *
- *  输入：
- *    file_path  必填，绝对路径（建议）或相对项目根
- *    offset     可选，1-indexed 起始行号
- *    limit      可选，最大读多少行（默认 2000）
- *
- *  输出：
- *    带行号前缀的文本（格式："${line}\t${content}"），与 Read 工具的 prompt 约定一致
- * ============================================================
- */
 import { createReadStream } from 'node:fs';
-import { readFile, stat } from 'node:fs/promises';
+import { open, readFile, stat, writeFile } from 'node:fs/promises';
+import { extname } from 'node:path';
 import { createInterface } from 'node:readline';
+import { execFile } from 'node:child_process';
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
-import { DEFAULT_MAX_RESULT_SIZE_CHARS, MAX_FILE_SIZE_BYTES, MAX_LINES_TO_READ } from '../types.js';
 import { toToolParameters } from '../../utils/zodToJson.js';
-import { hasBinaryExtension, isBlockedDevicePath, resolveToolPath } from '../shared/fileUtils.js';
+import { DEFAULT_MAX_RESULT_SIZE_CHARS, MAX_FILE_SIZE_BYTES, MAX_LINES_TO_READ, } from '../types.js';
+import { fileActivityMetadata } from '../shared/fileActivity.js';
+import { hashFileBytes, recordRead, } from '../shared/fileState.js';
+import { hasBinaryExtension, isBlockedDevicePath, readTextFile, resolveToolPath, } from '../shared/fileUtils.js';
 import { filePathField } from '../shared/schemas.js';
-import { recordRead } from '../shared/fileState.js';
-// ---------------- 1. Zod 输入 schema ----------------
+import { pruneRuntimeOutputs, sessionRuntimeDir, } from '../../session/runtimeStore.js';
 const inputSchema = z.object({
     file_path: filePathField('读取'),
     offset: z
@@ -32,186 +22,404 @@ const inputSchema = z.object({
         .int()
         .positive()
         .optional()
-        .describe('起始行号（1-indexed）；不填则从文件开头读'),
+        .describe('文本文件为 1-indexed 起始行；Jupyter Notebook 为 1-indexed 起始 cell'),
     limit: z
         .number()
         .int()
         .positive()
         .optional()
-        .describe(`最多读多少行；不填则用默认值 ${MAX_LINES_TO_READ}`),
+        .describe(`最多读取的文本行或 Notebook cells；默认 ${MAX_LINES_TO_READ}`),
+    pages: z
+        .string()
+        .regex(/^\d+(?:-\d+)?(?:,\d+(?:-\d+)?)*$/)
+        .optional()
+        .describe('PDF 页码，例如 "1-5,8"；每次最多 20 页'),
+    pdf_mode: z
+        .enum(['auto', 'text', 'visual', 'both'])
+        .default('auto')
+        .optional(),
 });
-// ---------------- 2. JSON Schema（给 LLM 看） ----------------
-//
-// 与上面的 Zod schema 保持一致；改动时两边都要改。
-// ---------------- 2. JSON Schema（由 Zod 自动派生） ----------------
-const parameters = toToolParameters(inputSchema);
-// ---------------- 3. Description（给 LLM 看的工具说明） ----------------
-//
-// 这段文本直接搬自 kakadeai/tools/FileReadTool/prompt.ts 的 DESCRIPTION，
-// 只是去掉了和 PDF/Notebook/图片相关的能力描述（最小版不支持）。
-const description = `Reads a file from the local filesystem. You can access any file directly by using this tool.
-Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+const IMAGE_EXTENSIONS = new Set([
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.gif',
+    '.webp',
+    '.bmp',
+]);
+const MAX_IMAGE_BYTES = 25 * 1024 * 1024;
+const MAX_NOTEBOOK_BYTES = 32 * 1024 * 1024;
+const SMALL_TEXT_BYTES = 16 * 1024 * 1024;
+const description = `Reads local text files, images, and Jupyter notebooks.
 
 Usage:
-- The file_path parameter is preferably an absolute path. Relative paths are accepted and will be resolved against the agent's working directory (locked at startup via \`-d <dir>\` or process cwd).
-- By default, it reads up to ${MAX_LINES_TO_READ} lines starting from the beginning of the file
-- You can optionally specify a line offset and limit (especially handy for long files)
-- Results are returned using cat -n format, with line numbers starting at 1
-- This tool can only read text files, not directories. To read a directory, use the Glob tool.
-- If you read a file that exists but has empty contents you will receive a warning in place of file contents.
-- This tool cannot read binary files. Files whose extensions are on the binary blocklist (images: .png/.jpg/.gif/.webp/..., documents: .pdf/.docx/.xlsx/..., executables: .exe/.dll/.so/..., archives: .zip/.tar/.gz/..., and others) will be rejected with a clear error. If the file is actually text despite the extension (e.g., a misnamed log), rename it or use Bash \`cat\` to read it directly — do not retry Read with the same path.`;
-// ---------------- 4. call() —— 真正干活 ----------------
-const STREAM_THRESHOLD = 1024 * 1024;
-/** "同区重读空转"提示：同一区间 + 文件未变 + 第二次起，前置到结果头部（仅提示，不拦截）。 */
-const REREAD_HINT = '⚠️ 你本轮已经读过该文件的这一区间，且文件未发生变化——请直接基于上次读到的内容操作，不要重复读取空转。如果你其实在找别的内容，改用不同的 offset/limit，或用 Grep 精确定位。\n\n';
-async function call(input) {
+- Relative paths resolve against the current working directory.
+- Text results use 1-based line numbers. Use offset/limit for targeted ranges.
+- PNG, JPEG, WebP, GIF, and BMP files are attached for visual inspection.
+- For .ipynb files, offset/limit select cells; results include cell id, type, source, and bounded outputs.
+- PDF supports page-selected text extraction and optional visual page rendering; office files use the matching project Skill.
+- This tool reads files, not directories; use Glob for directory discovery.`;
+function notebookSource(value) {
+    if (Array.isArray(value))
+        return value
+            .filter((item) => typeof item === 'string')
+            .join('');
+    return typeof value === 'string' ? value : '';
+}
+function renderNotebook(raw, offset, limit) {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.cells))
+        throw new Error('Notebook 缺少 cells 数组');
+    const start = offset - 1;
+    const cells = parsed.cells.slice(start, start + limit);
+    const parts = cells.map((value, index) => {
+        const cell = value && typeof value === 'object'
+            ? value
+            : {};
+        const outputs = Array.isArray(cell.outputs) ? cell.outputs : [];
+        const renderedOutputs = outputs
+            .slice(0, 8)
+            .map((output) => {
+            if (!output || typeof output !== 'object')
+                return String(output ?? '');
+            const item = output;
+            const text = item.text ??
+                (item.data && typeof item.data === 'object'
+                    ? item.data['text/plain']
+                    : undefined);
+            return notebookSource(text).slice(0, 2_000);
+        })
+            .filter(Boolean)
+            .join('\n');
+        return [
+            `## Cell ${start + index + 1} [selector=cell-${start + index + 1}${typeof cell.id === 'string' ? `; id=${cell.id}` : ''}; type=${String(cell.cell_type ?? 'unknown')}]`,
+            notebookSource(cell.source),
+            ...(renderedOutputs ? [`\nOutput:\n${renderedOutputs}`] : []),
+        ].join('\n');
+    });
+    const end = start + cells.length;
+    if (end < parsed.cells.length)
+        parts.push(`... (${parsed.cells.length - end} cells remain; continue with offset=${end + 1})`);
+    return {
+        content: parts.join('\n\n'),
+        total: parsed.cells.length,
+        partial: start > 0 || end < parsed.cells.length,
+    };
+}
+async function readStreamedText(filePath, offset, limit) {
+    const handle = await open(filePath, 'r');
+    const prefix = Buffer.alloc(3);
+    const { bytesRead } = await handle.read(prefix, 0, 3, 0);
+    await handle.close();
+    const utf16 = bytesRead >= 2 && prefix[0] === 0xff && prefix[1] === 0xfe;
+    const stream = createReadStream(filePath, {
+        encoding: utf16 ? 'utf16le' : 'utf8',
+        start: utf16
+            ? 2
+            : bytesRead >= 3 &&
+                prefix[0] === 0xef &&
+                prefix[1] === 0xbb &&
+                prefix[2] === 0xbf
+                ? 3
+                : 0,
+    });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    const lines = [];
+    let line = 0;
+    let hasMore = false;
+    for await (const value of rl) {
+        line += 1;
+        if (line >= offset && lines.length < limit)
+            lines.push(`${line}\t${value}`);
+        else if (line >= offset + limit) {
+            hasMore = true;
+            rl.close();
+            stream.destroy();
+            break;
+        }
+    }
+    return { numbered: lines.join('\n'), totalKnown: line, hasMore };
+}
+async function call(input, state, cwd, runtimeIdentity) {
     const offset = input.offset ?? 1;
     const limit = input.limit ?? MAX_LINES_TO_READ;
-    // 4a. 路径规范化 + 安全校验（替换原来的手动 resolve + validatePath）
-    const pathResult = resolveToolPath(input.file_path);
-    if (!pathResult.ok)
-        return pathResult;
-    const filePath = pathResult.resolvedPath;
-    // 4b. 设备文件双重拦截（虽然 validateAndResolvePath 已包含，但双重保险）
-    if (isBlockedDevicePath(filePath)) {
-        return { ok: false, error: `不允许读取设备文件：${filePath}。该路径可能产生无限输出或阻塞进程。` };
-    }
-    // 4b'. 二进制扩展名黑名单：在 stat 之前快速短路，避免把 .png/.exe/.pdf 等塞回 LLM
-    if (hasBinaryExtension(filePath)) {
+    const resolved = resolveToolPath(input.file_path, cwd);
+    if (!resolved.ok)
+        return resolved;
+    const filePath = resolved.resolvedPath;
+    if (isBlockedDevicePath(filePath))
+        return { ok: false, error: `不允许读取设备文件：${filePath}` };
+    const info = await stat(filePath).catch((error) => ({ error }));
+    if ('error' in info)
         return {
             ok: false,
-            error: `不支持读取二进制文件：${filePath}（扩展名命中二进制黑名单）。若该文件实际为文本，可改后缀或用 Bash cat 旁路。`,
+            error: `文件不存在或无法读取：${filePath}（${info.error.message}）`,
         };
+    if (!info.isFile())
+        return { ok: false, error: `${filePath} 不是文件；目录请用 Glob。` };
+    const ext = extname(filePath).toLowerCase();
+    if (ext === '.pdf') {
+        try {
+            const bytes = await readFile(filePath);
+            if (bytes.subarray(0, 5).toString() !== '%PDF-') {
+                return {
+                    ok: false,
+                    error: '文件扩展名是 PDF，但缺少有效 %PDF- 文件头',
+                };
+            }
+            const pdfjs = await import('pdfjs-dist/legacy/build/pdf.mjs');
+            const document = await pdfjs.getDocument({
+                data: new Uint8Array(bytes),
+                useSystemFonts: true,
+            }).promise;
+            try {
+                const requested = parsePdfPages(input.pages, document.numPages);
+                if (requested.length > 20)
+                    return { ok: false, error: '一次最多读取 20 个 PDF 页面' };
+                const chunks = [];
+                for (const pageNumber of requested) {
+                    const page = await document.getPage(pageNumber);
+                    const text = await page.getTextContent();
+                    chunks.push(`## Page ${pageNumber}\n${text.items
+                        .map((item) => 'str' in item && typeof item.str === 'string' ? item.str : '')
+                        .filter(Boolean)
+                        .join(' ')}`);
+                }
+                const mode = input.pdf_mode ?? 'auto';
+                const sparse = chunks.join('').replace(/\s/g, '').length < requested.length * 80;
+                const wantVisual = mode === 'visual' || mode === 'both' || (mode === 'auto' && sparse);
+                const images = wantVisual
+                    ? await renderPdfPages(document, filePath, requested.slice(0, 10), runtimeIdentity)
+                    : [];
+                recordRead(filePath, { contentHash: hashFileBytes(bytes) }, state);
+                const rawText = mode === 'visual' ? '[visual-only mode]' : chunks.join('\n\n');
+                const text = rawText.length > DEFAULT_MAX_RESULT_SIZE_CHARS
+                    ? `${rawText.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS)}\n... (PDF 文本输出已截断；请缩小 pages 范围继续读取)`
+                    : rawText;
+                return {
+                    ok: true,
+                    content: `PDF ${document.numPages} pages; selected ${requested.join(', ')}.\n\n${text}${wantVisual && !images.length ? '\n\n视觉渲染不可用（Canvas 与 pdftoppm 均不可用）；文本提取结果仍可用。' : ''}`,
+                    metadata: await fileActivityMetadata(filePath, 'read', 'not_run', 'source', cwd),
+                    ...(images.length
+                        ? {
+                            visionImages: images.map((source) => ({ source })),
+                            visionNote: '这是所选 PDF 页面的视觉渲染，请检查版式、图表和扫描内容。',
+                        }
+                        : {}),
+                };
+            }
+            finally {
+                await document.destroy().catch(() => undefined);
+            }
+        }
+        catch (error) {
+            const message = error.message;
+            return {
+                ok: false,
+                error: `PDF 解析失败${/password/i.test(message) ? '（文件可能已加密）' : ''}：${message}`,
+            };
+        }
     }
-    // 4c. 文件存在性 / 大小检查
-    let st;
-    try {
-        st = await stat(filePath);
+    if (IMAGE_EXTENSIONS.has(ext)) {
+        if (info.size > MAX_IMAGE_BYTES)
+            return { ok: false, error: `图片超过 ${MAX_IMAGE_BYTES} 字节上限` };
+        const bytes = await readFile(filePath);
+        recordRead(filePath, { contentHash: hashFileBytes(bytes) }, state);
+        return {
+            ok: true,
+            content: `已读取图片：${filePath}（${info.size} 字节）。图像已附加供视觉模型检查；非视觉模型只能确认文件元数据，不能解读像素内容。`,
+            metadata: await fileActivityMetadata(filePath, 'read', 'not_run', 'source', cwd),
+            visionImages: [{ source: filePath }],
+            visionNote: '这是 Read 工具读取的本地图片，请直接检查图像内容。',
+        };
+    }
+    if (ext === '.ipynb') {
+        if (info.size > MAX_NOTEBOOK_BYTES)
+            return {
+                ok: false,
+                error: `Notebook 超过 ${MAX_NOTEBOOK_BYTES} 字节上限`,
+            };
+        try {
+            const snapshot = await readTextFile(filePath);
+            const rendered = renderNotebook(snapshot.content, offset, Math.min(limit, 200));
+            let content = rendered.content;
+            let truncated = false;
+            if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+                content = `${content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS)}\n\n... (Notebook 输出已截断)`;
+                truncated = true;
+            }
+            recordRead(filePath, {
+                offset,
+                limit,
+                partial: rendered.partial,
+                truncated,
+                ...(!rendered.partial && !truncated
+                    ? { contentHash: hashFileBytes(snapshot.bytes) }
+                    : {}),
+            }, state);
+            return {
+                ok: true,
+                content,
+                metadata: await fileActivityMetadata(filePath, 'read', 'not_run', 'source', cwd),
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: `Notebook 解析失败：${error.message}`,
+            };
+        }
     }
-    catch (e) {
+    if (hasBinaryExtension(filePath)) {
         return {
             ok: false,
-            error: `读取失败：${filePath} 不存在或无法访问（${e.message}）`,
+            error: `不支持直接读取 ${ext || '该二进制格式'}；PDF/Office 文件请使用对应 Skill。`,
         };
     }
-    if (!st.isFile()) {
-        return { ok: false, error: `${filePath} 不是文件（可能是目录）。要列目录用 Glob 工具。` };
-    }
-    if (st.size > MAX_FILE_SIZE_BYTES) {
+    if (info.size > MAX_FILE_SIZE_BYTES) {
         return {
             ok: false,
-            error: `文件过大（${st.size} 字节 > ${MAX_FILE_SIZE_BYTES}）。请用 offset/limit 分段读。`,
+            error: `文件超过 ${MAX_FILE_SIZE_BYTES} 字节硬上限。请用 Grep 定位，或用 Bash 做流式处理。`,
         };
     }
-    // 4d. 根据文件大小选择读取策略
-    let numbered;
-    let totalLines;
-    if (st.size <= STREAM_THRESHOLD) {
-        // 小文件：原有 readFile 路径
-        const result = await readSmallFile(filePath, offset, limit);
-        numbered = result.numbered;
-        totalLines = result.totalLines;
-        if (result.isEmpty) {
-            recordRead(filePath);
-            return { ok: true, content: '<file is empty>' };
+    try {
+        let content;
+        let totalLines;
+        let hasMore;
+        let completeBytes;
+        if (info.size <= SMALL_TEXT_BYTES) {
+            const snapshot = await readTextFile(filePath);
+            completeBytes = snapshot.bytes;
+            const all = snapshot.content.length === 0 ? [] : snapshot.content.split('\n');
+            const start = offset - 1;
+            const selected = all.slice(start, start + limit);
+            content = selected
+                .map((line, index) => `${start + index + 1}\t${line}`)
+                .join('\n');
+            totalLines = all.length;
+            hasMore = start + selected.length < all.length;
+        }
+        else {
+            const streamed = await readStreamedText(filePath, offset, limit);
+            content = streamed.numbered;
+            totalLines = streamed.totalKnown;
+            hasMore = streamed.hasMore;
+        }
+        if (!content)
+            content = '<file is empty>';
+        let truncated = false;
+        if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+            content = `${content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS)}\n\n⚠️ 重要：Read 输出已截断；截断范围外仍有内容。需要整文件覆盖时必须分段完整读取，精确修改可继续使用 Edit。`;
+            truncated = true;
         }
+        const partial = offset !== 1 || hasMore;
+        if (hasMore)
+            content += `\n\n... (还有更多内容；继续使用 offset=${offset + limit})`;
+        const reads = recordRead(filePath, {
+            offset,
+            limit,
+            partial,
+            truncated,
+            ...(!partial && !truncated && completeBytes
+                ? { contentHash: hashFileBytes(completeBytes) }
+                : {}),
+        }, state);
+        if (info.size > 100 * 1024 && offset === 1) {
+            content = `⚠️ 大文件：结果受行数和输出字符上限约束，请按需分段读取。\n\n${content}`;
+        }
+        if (reads >= 2)
+            content = `⚠️ 重复读取空转：该区间未变化，前一次 Read 结果仍然有效。\n\n${content}`;
+        return {
+            ok: true,
+            content,
+            metadata: await fileActivityMetadata(filePath, 'read', 'not_run', 'source', cwd),
+        };
     }
-    else {
-        // 大文件（>1MB 且 <= MAX_FILE_SIZE_BYTES）：流式读取
-        const result = await readLargeFileStream(filePath, offset, limit);
-        numbered = result.numbered;
-        totalLines = result.totalLines;
+    catch (error) {
+        return { ok: false, error: `读取失败：${error.message}` };
     }
-    // 4e. 空文件处理
-    if (totalLines === 0 || !numbered) {
-        recordRead(filePath);
-        return { ok: true, content: '<file is empty>' };
+}
+async function renderPdfPages(document, filePath, pages, identity) {
+    const outputDir = join(sessionRuntimeDir(identity ?? {}), 'outputs');
+    const outputPrefix = `pdf_${randomUUID()}`;
+    await mkdir(outputDir, { recursive: true, mode: 0o700 });
+    const images = [];
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    let createCanvas;
+    try {
+        ({ createCanvas } = await dynamicImport('@napi-rs/canvas'));
     }
-    // 4f. 大小兜底 + 自动分段提示
-    let content = numbered;
-    let truncated = false;
-    if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
-        content =
-            content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) +
-                `\n\n... (输出超过 ${DEFAULT_MAX_RESULT_SIZE_CHARS} 字符，已截断)` +
-                `\n\n⚠️ **重要：本次返回的是截断内容**。直接基于这部分内容写 Edit/Write 会失败 —— old_string 可能在截断范围外，Write 会丢失截断范围外的内容。必须做以下之一：(1) 用更小的 limit + 精确的 offset 缩小读取范围；(2) 已知改动位置时直接 offset 到目标行号附近；(3) 整文件覆盖请用多次 Edit 而非 Write。`;
-        truncated = true;
+    catch {
+        /* optional adapter */
     }
-    const startIdx = Math.max(0, offset - 1);
-    const endIdx = Math.min(totalLines, startIdx + limit);
-    if (endIdx < totalLines) {
-        const nextOffset = endIdx + 1;
-        const returnedLines = content.split('\n').filter(l => l.trim()).length;
-        content += `\n\n... (本次返回 ${returnedLines} 行 / 文件共 ${totalLines} 行；用 offset=${nextOffset} 继续读)`;
+    if (createCanvas) {
+        try {
+            for (const pageNumber of pages) {
+                const page = await document.getPage(pageNumber);
+                const viewport = page.getViewport({ scale: 2 });
+                const canvas = createCanvas(Math.ceil(viewport.width), Math.ceil(viewport.height));
+                await page.render({
+                    canvasContext: canvas.getContext('2d'),
+                    viewport,
+                }).promise;
+                const target = join(outputDir, `${outputPrefix}-page-${pageNumber}.png`);
+                await writeFile(target, canvas.toBuffer('image/png'), { mode: 0o600 });
+                images.push(target);
+            }
+            void pruneRuntimeOutputs();
+            return images;
+        }
+        catch {
+            images.length = 0;
+        }
     }
-    if (st.size > 100 * 1024 && offset === 1) {
-        content += `\n\n⚠️ 注意：这是一个大文件（${(st.size / 1024).toFixed(1)} KB）。建议用 offset/limit 分段读取，例如先读关键部分（imports、exports、函数签名）。`;
+    for (const pageNumber of pages) {
+        const prefix = join(outputDir, `${outputPrefix}-page-${pageNumber}`);
+        try {
+            await promisify(execFile)('pdftoppm', [
+                '-f',
+                String(pageNumber),
+                '-l',
+                String(pageNumber),
+                '-singlefile',
+                '-png',
+                '-r',
+                '144',
+                filePath,
+                prefix,
+            ], { maxBuffer: 1024 * 1024 });
+            images.push(`${prefix}.png`);
+        }
+        catch {
+            break;
+        }
     }
-    const readCount = recordRead(filePath, { truncated, offset, limit });
-    if (readCount >= 2)
-        content = REREAD_HINT + content;
-    return { ok: true, content };
+    void pruneRuntimeOutputs();
+    return images;
 }
-async function readSmallFile(filePath, offset, limit) {
-    const raw = await readFile(filePath, 'utf8');
-    if (raw.length === 0) {
-        return { numbered: '', totalLines: 0, isEmpty: true };
+function parsePdfPages(spec, total) {
+    if (!spec)
+        return Array.from({ length: Math.min(total, 20) }, (_, index) => index + 1);
+    const pages = new Set();
+    for (const part of spec.split(',')) {
+        const [first, last] = part.split('-').map(Number);
+        for (let page = first; page <= (last ?? first); page += 1) {
+            if (page < 1 || page > total)
+                throw new Error(`PDF 页码超出范围：${page}（共 ${total} 页）`);
+            pages.add(page);
+        }
     }
-    const allLines = raw.split('\n');
-    const totalLines = allLines.length;
-    const startIdx = Math.max(0, offset - 1);
-    const endIdx = Math.min(totalLines, startIdx + limit);
-    const slice = allLines.slice(startIdx, endIdx);
-    const numbered = slice
-        .map((line, i) => `${(startIdx + i + 1).toString()}\t${line}`)
-        .join('\n');
-    return { numbered, totalLines, isEmpty: false };
-}
-async function readLargeFileStream(filePath, offset, limit) {
-    return new Promise((resolvePromise, reject) => {
-        const lines = [];
-        let currentLine = 0;
-        const startIdx = Math.max(0, offset - 1);
-        const endLine = startIdx + limit;
-        const input = createReadStream(filePath, { encoding: 'utf8' });
-        const rl = createInterface({
-            input,
-            crlfDelay: Infinity,
-        });
-        input.on('error', (err) => {
-            reject(err);
-        });
-        rl.on('line', (line) => {
-            currentLine++;
-            if (currentLine > endLine) {
-                rl.close();
-                rl.removeAllListeners();
-                return;
-            }
-            if (currentLine >= offset) {
-                lines.push(`${currentLine}\t${line}`);
-            }
-        });
-        rl.on('close', () => {
-            resolvePromise({
-                numbered: lines.join('\n'),
-                totalLines: currentLine,
-            });
-        });
-        rl.on('error', (err) => {
-            reject(err);
-        });
-    });
+    return [...pages].sort((left, right) => left - right);
 }
-// ---------------- 5. 导出工具对象 ----------------
 export const readTool = {
     name: 'Read',
     description,
     inputSchema,
-    parameters,
+    parameters: toToolParameters(inputSchema),
     isReadOnly: true,
     isConcurrencySafe: true,
     maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
     interruptBehavior: () => 'cancel',
-    call,
+    call: (input) => call(input),
+    callWithContext: (input, _signal, context) => call(input, context.sessionState?.fileReads, context.cwd, context),
 };