@sema-agent/core 1.451.0 → 2.0.0

package/dist/tools/fs/fs-write.js

@@ -0,0 +1,423 @@
+import { randomUUID } from "node:crypto";
+import { Type } from "typebox";
+import { defineTool, errorResult } from "../../core/tools.js";
+import { sha256, resolveKey, violationText, requireRead, checkStale, checkEditMatch, checkNoChange, fileArgPath, resolveQuoteMatch, adaptNewStringQuotes, deletionOldString, countOccurrences, } from "./safety.js";
+import { decodeTextBytes, encodeTextForFile, normalizeEditText, normalizeFileText, splitLeadingBom } from "./encoding.js";
+import { MAX_EDIT_BYTES, formatByteSize, decodeEditBytes, persistedTextOf, notReadRefusalText, enoentMessage, FILE_STATE_TRAILER, FILE_PATH_PARAMS, ipynbRedirect, countLines, } from "./fs-shared.js";
+async function gateToolWrite(hook, tool, path, key, content) {
+    if (hook === undefined)
+        return undefined;
+    let res;
+    try {
+        res = await hook({ tool, path, key, content });
+    }
+    catch (err) {
+        return `Error (${tool}): the write gate failed (${err instanceof Error ? err.message : String(err)}) — nothing was written.`;
+    }
+    if (res !== undefined && res.ok === false)
+        return `Error (${tool}): write rejected by the write gate (${res.code}): ${res.reason}`;
+    return undefined;
+}
+export function createEditFileTool(env, state, rootCanonical, cwdRef, additionalRoots, beforeWrite) {
+    return defineTool({
+        name: "Edit",
+        contract: { contractId: "core.edit@1", implementationRevision: "1" },
+        description: "Performs exact string replacement in a file.\n" +
+            "\n" +
+            "- You must Read the file in this conversation before editing, or the call will fail.\n" +
+            "- `old_string` must match the file exactly, including indentation, and be unique — the edit fails otherwise. Strip the Read line prefix (line number + tab) before matching.\n" +
+            "- `replace_all: true` replaces every occurrence instead.\n" +
+            "- The edit also fails if the file changed on disk since you read it — Read it again first.",
+        aliases: ["MultiEdit"],
+        parameters: Type.Object({
+            ...FILE_PATH_PARAMS,
+            old_string: Type.Optional(Type.String({ description: "The text to replace" })),
+            new_string: Type.Optional(Type.String({ description: "The text to replace it with (must be different from old_string)" })),
+            replace_all: Type.Optional(Type.Boolean({ description: "Replace all occurrences of old_string (default false)" })),
+        }),
+        effect: "write",
+        execute: async (args, ctx) => {
+            const a = args;
+            const batch = Array.isArray(a.edits) && a.edits.length > 0;
+            const edits = batch
+                ? a.edits
+                : [{ old_string: a.old_string ?? "", new_string: a.new_string ?? "", ...(a.replace_all !== undefined ? { replace_all: a.replace_all } : {}) }];
+            if (!batch && (typeof a.old_string !== "string" || typeof a.new_string !== "string")) {
+                return errorResult(`Error (Edit): old_string and new_string are required.`);
+            }
+            for (let i = 0; i < edits.length; i++) {
+                const e = edits[i];
+                if (!e || typeof e.old_string !== "string" || typeof e.new_string !== "string") {
+                    return errorResult(`Error (Edit): edit ${i + 1} of ${edits.length}: old_string and new_string must both be strings (no changes written — the batch is atomic).`);
+                }
+            }
+            const path = fileArgPath(args);
+            if (path === undefined)
+                return errorResult(`Error (Edit): file_path is required.`);
+            const ipynb = ipynbRedirect("Edit", path);
+            if (ipynb)
+                return errorResult(ipynb);
+            const r = await resolveKey(env, rootCanonical, path, ctx.signal, cwdRef?.current, additionalRoots);
+            if (!r.ok)
+                return errorResult(violationText("Edit", r.violation));
+            const singleOld = batch ? undefined : a.old_string;
+            const exists = await env.exists(r.key, ctx.signal);
+            if (!exists.ok)
+                return errorResult(`Error (Edit): cannot stat "${path}": ${exists.error.message}`);
+            if (!exists.value) {
+                if (singleOld === "") {
+                    const created = a.new_string ?? "";
+                    if (created === "")
+                        return errorResult(violationText("Edit", { code: "invalid", message: "No changes to make: old_string and new_string are exactly the same." }));
+                    const gated = await gateToolWrite(beforeWrite, "Edit", path, r.key, created);
+                    if (gated !== undefined)
+                        return errorResult(gated);
+                    const write = env.writeFileExclusive !== undefined
+                        ? await env.writeFileExclusive(r.key, created, ctx.signal)
+                        : await env.writeFile(r.key, created, ctx.signal);
+                    if (!write.ok) {
+                        if (write.error.code === "already_exists") {
+                            return errorResult(`Error (Edit): cannot create "${path}": file already exists (created concurrently since the existence check). Read the file first, then edit it normally (or Write after the Read to overwrite it).`);
+                        }
+                        return errorResult(`Error (Edit): cannot write "${path}": ${write.error.message}`);
+                    }
+                    const createdNorm = normalizeFileText(created);
+                    state.set(r.key, { hash: sha256(createdNorm), totalLines: countLines(createdNorm), truncated: false, lastReadAt: Date.now() });
+                    return {
+                        content: `Created ${path} (${countLines(createdNorm)} lines).`,
+                        details: { type: "create", filePath: path, content: created },
+                    };
+                }
+                return errorResult(`Error (Edit): ${await enoentMessage(env, r.key, cwdRef?.current ?? rootCanonical, ctx.signal)}`);
+            }
+            const editInfo = await env.fileInfo(r.key, ctx.signal);
+            if (editInfo.ok && editInfo.value.size > MAX_EDIT_BYTES) {
+                return errorResult(`Error (Edit): "${path}" is too large to edit (${formatByteSize(editInfo.value.size)}). Maximum editable file size is ${formatByteSize(MAX_EDIT_BYTES)}.`);
+            }
+            if (singleOld === "") {
+                const preBin = await env.readBinaryFile(r.key, ctx.signal);
+                if (!preBin.ok)
+                    return errorResult(`Error (Edit): cannot read "${path}": ${preBin.error.message}`);
+                if (preBin.value.byteLength > MAX_EDIT_BYTES) {
+                    return errorResult(`Error (Edit): "${path}" is too large to edit (${formatByteSize(preBin.value.byteLength)}). Maximum editable file size is ${formatByteSize(MAX_EDIT_BYTES)}.`);
+                }
+                const preDecResult = decodeEditBytes(preBin.value, path);
+                if (!preDecResult.ok)
+                    return errorResult(preDecResult.message);
+                const preDec = preDecResult.value;
+                if (preDec.malformed)
+                    return errorResult(`Error (Edit): "${path}" has a truncated UTF-16 body; repair/convert it with bash first.`);
+                if (preDec.text.trim() !== "")
+                    return errorResult(`Error (Edit): Cannot create new file - file already exists.`);
+                const priorRead = state.get(r.key);
+                if (priorRead !== undefined) {
+                    const staleCreate = checkStale(priorRead, sha256(preDec.text));
+                    if (staleCreate)
+                        return errorResult(violationText("Edit", staleCreate));
+                }
+                const newContent = normalizeEditText(a.new_string ?? "");
+                if (newContent === preDec.text)
+                    return errorResult(violationText("Edit", { code: "invalid", message: "No changes to make: old_string and new_string are exactly the same." }));
+                const gated = await gateToolWrite(beforeWrite, "Edit", path, r.key, newContent);
+                if (gated !== undefined)
+                    return errorResult(gated);
+                const encodedOverwrite = encodeTextForFile(newContent, preDec.encoding, preDec.endings);
+                const write = await env.writeFile(r.key, encodedOverwrite, ctx.signal);
+                if (!write.ok)
+                    return errorResult(`Error (Edit): cannot write "${path}": ${write.error.message}`);
+                const persistedOverwrite = persistedTextOf(encodedOverwrite);
+                state.set(r.key, { hash: sha256(persistedOverwrite), totalLines: countLines(persistedOverwrite), truncated: false, lastReadAt: Date.now() });
+                return {
+                    content: `The file ${path} has been updated successfully.${FILE_STATE_TRAILER}`,
+                    details: { type: "edit", filePath: path, originalFile: preDec.text, oldString: "", newString: newContent, replaceAll: false, edits: [{ oldString: "", newString: newContent, replaceAll: false }] },
+                };
+            }
+            const notRead = requireRead(state, r.key);
+            if (notRead)
+                return errorResult(await notReadRefusalText(env, "Edit", r.key, notRead, ctx.signal));
+            const readBin = await env.readBinaryFile(r.key, ctx.signal);
+            if (!readBin.ok)
+                return errorResult(`Error (Edit): cannot read "${path}": ${readBin.error.message}`);
+            if (readBin.value.byteLength > MAX_EDIT_BYTES) {
+                return errorResult(`Error (Edit): "${path}" is too large to edit (${formatByteSize(readBin.value.byteLength)}). Maximum editable file size is ${formatByteSize(MAX_EDIT_BYTES)}.`);
+            }
+            const decodedResult = decodeEditBytes(readBin.value, path);
+            if (!decodedResult.ok)
+                return errorResult(decodedResult.message);
+            const decoded = decodedResult.value;
+            if (decoded.malformed)
+                return errorResult(`Error (Edit): "${path}" has a truncated UTF-16 body; repair/convert it with bash first.`);
+            const original = decoded.text;
+            const entry = state.get(r.key);
+            const stale = checkStale(entry, sha256(original));
+            if (stale)
+                return errorResult(violationText("Edit", stale));
+            let working = original;
+            let replacements = 0;
+            const appliedEdits = [];
+            for (let i = 0; i < edits.length; i++) {
+                const e = edits[i];
+                const where = batch ? `edit ${i + 1} of ${edits.length}: ` : "";
+                let oldS = normalizeEditText(e.old_string);
+                let newS = normalizeEditText(e.new_string);
+                const noChange = checkNoChange(oldS, newS);
+                if (noChange)
+                    return errorResult(batch ? `Error (Edit): ${where}${noChange.message}` : violationText("Edit", noChange));
+                if (oldS !== "" && !working.includes(oldS)) {
+                    const resolved = resolveQuoteMatch(working, oldS);
+                    if (resolved !== undefined && resolved !== oldS) {
+                        newS = adaptNewStringQuotes(resolved, newS);
+                        oldS = resolved;
+                    }
+                }
+                const match = checkEditMatch(working, oldS, e.replace_all === true, entry.truncated);
+                if (match)
+                    return errorResult(batch ? `Error (Edit): ${where}${match.message} (no changes written — the batch is atomic).` : violationText("Edit", match));
+                replacements += e.replace_all === true ? countOccurrences(working, oldS) : 1;
+                const effOld = e.replace_all === true ? oldS : deletionOldString(working, oldS, newS);
+                working = e.replace_all === true ? working.split(effOld).join(newS) : working.replace(effOld, () => newS);
+                appliedEdits.push({ oldString: effOld, newString: newS, replaceAll: e.replace_all === true });
+            }
+            const gated = await gateToolWrite(beforeWrite, "Edit", path, r.key, working);
+            if (gated !== undefined)
+                return errorResult(gated);
+            const encodedEdit = encodeTextForFile(working, decoded.encoding, decoded.endings);
+            const write = await env.writeFile(r.key, encodedEdit, ctx.signal);
+            if (!write.ok)
+                return errorResult(`Error (Edit): cannot write "${path}": ${write.error.message}`);
+            const persistedEdit = persistedTextOf(encodedEdit);
+            state.set(r.key, { hash: sha256(persistedEdit), totalLines: countLines(persistedEdit), truncated: false, lastReadAt: Date.now() });
+            const a0 = appliedEdits[0];
+            return {
+                content: batch
+                    ? `Edited ${path} (${edits.length} edit${edits.length === 1 ? "" : "s"}, ${replacements} replacement${replacements === 1 ? "" : "s"}).`
+                    : a0.replaceAll
+                        ? `The file ${path} has been updated. All occurrences were successfully replaced.${FILE_STATE_TRAILER}`
+                        : `The file ${path} has been updated successfully.${FILE_STATE_TRAILER}`,
+                details: {
+                    type: "edit",
+                    filePath: path,
+                    originalFile: original,
+                    edits: appliedEdits,
+                    ...(batch ? {} : { oldString: a0.oldString, newString: a0.newString, replaceAll: a0.replaceAll }),
+                },
+            };
+        },
+    });
+}
+export function createWriteFileTool(env, state, rootCanonical, cwdRef, additionalRoots, beforeWrite) {
+    return defineTool({
+        name: "Write",
+        contract: { contractId: "core.write@1", implementationRevision: "1" },
+        description: "Writes a file to the local filesystem, overwriting if one exists.\n" +
+            "\n" +
+            "When to use: creating a new file, or fully replacing one you've already Read. Overwriting an existing " +
+            "file you haven't Read will fail. For partial changes, use Edit instead. The overwrite also fails if the " +
+            "file changed on disk since you read it — Read it again first.",
+        parameters: Type.Object({
+            ...FILE_PATH_PARAMS,
+            content: Type.String({ description: "The content to write to the file" }),
+        }),
+        effect: "idempotent",
+        execute: async (args, ctx) => {
+            const { content } = args;
+            const path = fileArgPath(args);
+            if (path === undefined)
+                return errorResult(`Error (Write): file_path is required.`);
+            const ipynb = ipynbRedirect("Write", path);
+            if (ipynb)
+                return errorResult(ipynb);
+            const r = await resolveKey(env, rootCanonical, path, ctx.signal, cwdRef?.current, additionalRoots);
+            if (!r.ok)
+                return errorResult(violationText("Write", r.violation));
+            const exists = await env.exists(r.key, ctx.signal);
+            if (!exists.ok)
+                return errorResult(`Error (Write): cannot stat "${path}": ${exists.error.message}`);
+            let originalFile;
+            if (exists.value) {
+                const notRead = requireRead(state, r.key);
+                if (notRead) {
+                    return errorResult(`${violationText("Write", notRead)} ` +
+                        `(If the Read tool refuses this file (binary/unknown encoding), overwrite or convert it with bash instead — e.g. \`rm\` + rewrite, or \`iconv\`.)`);
+                }
+                const readBin = await env.readBinaryFile(r.key, ctx.signal);
+                if (!readBin.ok)
+                    return errorResult(`Error (Write): cannot re-read "${path}" to verify it is unchanged: ${readBin.error.message}`);
+                const decodedPrev = decodeTextBytes(readBin.value);
+                if (decodedPrev.malformed)
+                    return errorResult(`Error (Write): "${path}" has a truncated UTF-16 body; repair/convert it with bash first.`);
+                const stale = checkStale(state.get(r.key), sha256(decodedPrev.text));
+                if (stale)
+                    return errorResult(violationText("Write", stale));
+                originalFile = decodedPrev.text;
+                const gated = await gateToolWrite(beforeWrite, "Write", path, r.key, content);
+                if (gated !== undefined)
+                    return errorResult(gated);
+                const outgoing = splitLeadingBom(content);
+                const writeEncoding = outgoing.hadBom && !decodedPrev.encoding.hadBom ? { ...decodedPrev.encoding, hadBom: true } : decodedPrev.encoding;
+                const write = await env.writeFile(r.key, encodeTextForFile(outgoing.text, writeEncoding, "preserve"), ctx.signal);
+                if (!write.ok)
+                    return errorResult(`Error (Write): cannot write "${path}": ${write.error.message}`);
+                const totalLines = countLines(outgoing.text);
+                state.set(r.key, { hash: sha256(normalizeFileText(content)), totalLines, truncated: false, lastReadAt: Date.now() });
+                return {
+                    content: `The file ${path} has been updated successfully.${FILE_STATE_TRAILER}`,
+                    details: { type: "update", filePath: path, content: normalizeFileText(content), originalFile },
+                };
+            }
+            const gatedCreate = await gateToolWrite(beforeWrite, "Write", path, r.key, content);
+            if (gatedCreate !== undefined)
+                return errorResult(gatedCreate);
+            const write = await env.writeFile(r.key, content, ctx.signal);
+            if (!write.ok)
+                return errorResult(`Error (Write): cannot write "${path}": ${write.error.message}`);
+            const totalLines = countLines(content);
+            state.set(r.key, { hash: sha256(normalizeFileText(content)), totalLines, truncated: false, lastReadAt: Date.now() });
+            void originalFile;
+            return {
+                content: `File created successfully at: ${path}${FILE_STATE_TRAILER}`,
+                details: { type: "create", filePath: path, content },
+            };
+        },
+    });
+}
+export function createNotebookEditTool(env, state, rootCanonical, cwdRef, additionalRoots, beforeWrite) {
+    return defineTool({
+        name: "NotebookEdit",
+        contract: { contractId: "core.notebook_edit@1", implementationRevision: "1" },
+        description: "Replaces, inserts, or deletes a single cell in a Jupyter notebook (.ipynb file).\n" +
+            "\n" +
+            "Usage:\n" +
+            "- You must use the Read tool on the notebook in this conversation before editing — this tool will fail otherwise.\n" +
+            "- `cell_id` is the `id` attribute shown in the Read tool's `<cell id=\"...\">` output. It is required for `replace` and `delete`.\n" +
+            "- `edit_mode` defaults to `replace`. Use `insert` to add a new cell after the cell with the given `cell_id` " +
+            "(or at the beginning of the notebook if `cell_id` is omitted) — `cell_type` is required when inserting. " +
+            "Use `delete` to remove the cell.",
+        parameters: Type.Object({
+            notebook_path: Type.String({ description: "The path to the Jupyter notebook file to edit (within the configured root)." }),
+            cell_id: Type.Optional(Type.String({
+                description: "The ID of the cell to edit. When inserting a new cell, the new cell will be inserted after the cell with this ID, or at the beginning if not specified.",
+            })),
+            new_source: Type.String({ description: "The new source for the cell" }),
+            cell_type: Type.Optional(Type.Union([Type.Literal("code"), Type.Literal("markdown")], {
+                description: "The type of the cell (code or markdown). If not specified, it defaults to the current cell type. If using edit_mode=insert, this is required.",
+            })),
+            edit_mode: Type.Optional(Type.Union([Type.Literal("replace"), Type.Literal("insert"), Type.Literal("delete")], {
+                description: "The type of edit to make (replace, insert, delete). Defaults to replace.",
+            })),
+        }),
+        effect: "write",
+        execute: async (args, ctx) => {
+            const a = args;
+            const { notebook_path, cell_id, new_source } = a;
+            let cellType = a.cell_type;
+            const mode = a.edit_mode ?? "replace";
+            if (!notebook_path.toLowerCase().endsWith(".ipynb")) {
+                return errorResult(`Error (NotebookEdit): "${notebook_path}" is not a .ipynb file; use Edit for other file types.`);
+            }
+            if (mode === "insert" && !cellType)
+                return errorResult(`Error (NotebookEdit): Cell type is required when using edit_mode=insert.`);
+            if (mode !== "insert" && !cell_id)
+                return errorResult(`Error (NotebookEdit): cell_id is required for replace/delete.`);
+            const r = await resolveKey(env, rootCanonical, notebook_path, ctx.signal, cwdRef?.current, additionalRoots);
+            if (!r.ok)
+                return errorResult(violationText("NotebookEdit", r.violation));
+            const notRead = requireRead(state, r.key);
+            if (notRead)
+                return errorResult(await notReadRefusalText(env, "NotebookEdit", r.key, notRead, ctx.signal));
+            const readBin = await env.readBinaryFile(r.key, ctx.signal);
+            if (!readBin.ok)
+                return errorResult(`Error (NotebookEdit): cannot read "${notebook_path}": ${readBin.error.message}`);
+            const decodedNb = decodeTextBytes(readBin.value);
+            if (decodedNb.malformed)
+                return errorResult(`Error (NotebookEdit): "${notebook_path}" has a truncated UTF-16 body; repair/convert it with bash first.`);
+            const nbText = decodedNb.text;
+            const stale = checkStale(state.get(r.key), sha256(nbText));
+            if (stale)
+                return errorResult(violationText("NotebookEdit", stale));
+            let nb;
+            try {
+                nb = JSON.parse(nbText);
+            }
+            catch {
+                return errorResult(`Error (NotebookEdit): "${notebook_path}" is not valid JSON.`);
+            }
+            if (!nb || typeof nb !== "object" || !Array.isArray(nb.cells)) {
+                return errorResult(`Error (NotebookEdit): "${notebook_path}" is not a valid notebook (no cells array).`);
+            }
+            const cells = nb.cells;
+            let h;
+            if (!cell_id) {
+                h = 0;
+            }
+            else {
+                h = cells.findIndex((c) => c && c.id === cell_id);
+                if (h === -1) {
+                    const m = /^cell-(\d+)$/.exec(cell_id);
+                    if (m) {
+                        const idx = parseInt(m[1], 10);
+                        if (idx >= 0 && idx < cells.length)
+                            h = idx;
+                    }
+                }
+                if (h === -1)
+                    return errorResult(`Error (NotebookEdit): Cell with ID "${cell_id}" not found in notebook.`);
+                if (mode === "insert")
+                    h += 1;
+            }
+            let g = mode;
+            if (g === "replace" && h === cells.length) {
+                g = "insert";
+                cellType = cellType ?? "code";
+            }
+            const supportsId = (nb.nbformat ?? 0) > 4 || ((nb.nbformat ?? 0) === 4 && (nb.nbformat_minor ?? 0) >= 5);
+            const newId = supportsId && g === "insert" ? randomUUID().slice(0, 8) : undefined;
+            let oldSource;
+            if (g === "delete") {
+                const prev = cells[h];
+                oldSource = Array.isArray(prev.source) ? prev.source.join("") : typeof prev.source === "string" ? prev.source : undefined;
+                cells.splice(h, 1);
+            }
+            else if (g === "insert") {
+                const cell = cellType === "markdown"
+                    ? { cell_type: "markdown", id: newId, source: new_source, metadata: {} }
+                    : { cell_type: "code", id: newId, source: new_source, metadata: {}, execution_count: null, outputs: [] };
+                cells.splice(h, 0, cell);
+            }
+            else {
+                const cell = cells[h];
+                oldSource = Array.isArray(cell.source) ? cell.source.join("") : typeof cell.source === "string" ? cell.source : undefined;
+                cell.source = new_source;
+                if (cell.cell_type === "code") {
+                    cell.execution_count = null;
+                    cell.outputs = [];
+                }
+                if (cellType && cellType !== cell.cell_type)
+                    cell.cell_type = cellType;
+            }
+            const updated = JSON.stringify(nb, null, 1);
+            const gated = await gateToolWrite(beforeWrite, "NotebookEdit", notebook_path, r.key, updated);
+            if (gated !== undefined)
+                return errorResult(gated);
+            const w = await env.writeFile(r.key, encodeTextForFile(updated, decodedNb.encoding, decodedNb.endings), ctx.signal);
+            if (!w.ok)
+                return errorResult(`Error (NotebookEdit): cannot write "${notebook_path}": ${w.error.message}`);
+            state.set(r.key, { hash: sha256(updated), totalLines: countLines(updated), truncated: false, lastReadAt: Date.now() });
+            const nbDetails = {
+                type: "notebook-edit",
+                notebookPath: notebook_path,
+                ...(cell_id ? { cellId: cell_id } : {}),
+                editMode: g,
+                ...(cellType ? { cellType } : {}),
+                newSource: new_source,
+                ...(oldSource !== undefined ? { oldSource } : {}),
+                originalFile: nbText,
+            };
+            if (g === "delete")
+                return { content: `Deleted cell ${cell_id}`, details: nbDetails };
+            if (g === "insert")
+                return { content: `Inserted cell${newId ? ` ${newId}` : ""} with ${new_source}`, details: { ...nbDetails, ...(newId ? { newCellId: newId } : {}) } };
+            return { content: `Updated cell ${cell_id} with ${new_source}`, details: nbDetails };
+        },
+    });
+}

package/dist/tools/fs/index.d.ts

@@ -1,70 +1,17 @@
-import type { AgentTool, ExecutionEnv } from "../../internal/harness.js";
-import type { BeforeWriteHook, ToolEffect } from "../../core/types.js";
+import type { AgentTool, ExecutionEnv } from "../../internal/harness-types.js";
+import type { BeforeWriteHook } from "../../core/types.js";
 import { type TaskRegistry } from "../../core/task-registry.js";
 import { type ReadFileState } from "./safety.js";
-import { type ImageDownsampler } from "../../core/mcp.js";
-import { type PdfModelCapabilities } from "./pdf.js";
-export { pdfModelCapabilitiesOf, type PdfModelCapabilities } from "./pdf.js";
-export declare const SLICED_READ_MAX_BYTES: number;
-export declare const MAX_EDIT_BYTES: number;
-export type ReadImageDownsamplerOption = ImageDownsampler | false | undefined;
-export declare function msTimeoutToSec(timeoutMs: number | undefined): number;
-export declare function seededFileUnchangedReminder(filePath: string): string;
-export declare function isReadDedupStubResult(resultText: string): boolean;
-export declare function seedReadFileStateFromContext(state: ReadFileState, key: string, content: string): void;
-export declare function applyCompactionToReadFileState(state: ReadFileState, attachedComplete: ReadonlyArray<{
-    path: string;
-    content: string;
-}>, preserveKeys?: ReadonlyArray<string>): void;
-export interface CwdRef {
-    current: string;
-}
-export declare function makeReadFileTool(env: ExecutionEnv, state: ReadFileState, rootCanonical: string, cwdRef?: CwdRef, additionalRoots?: readonly string[], imageDownsampler?: ReadImageDownsamplerOption, pdfCapabilities?: PdfModelCapabilities, bgOutputReadExemption?: (canonicalKey: string, ctx: {
-    taskId?: string;
-    principal?: string;
-}) => boolean): AgentTool;
-export type { BeforeWriteRequest, BeforeWriteResult, BeforeWriteHook } from "../../core/types.js";
-export declare function makeEditFileTool(env: ExecutionEnv, state: ReadFileState, rootCanonical: string, cwdRef?: CwdRef, additionalRoots?: readonly string[], beforeWrite?: BeforeWriteHook): AgentTool;
-export declare function makeWriteFileTool(env: ExecutionEnv, state: ReadFileState, rootCanonical: string, cwdRef?: CwdRef, additionalRoots?: readonly string[], beforeWrite?: BeforeWriteHook): AgentTool;
-export declare function makeNotebookEditTool(env: ExecutionEnv, state: ReadFileState, rootCanonical: string, cwdRef?: CwdRef, additionalRoots?: readonly string[], beforeWrite?: BeforeWriteHook): AgentTool;
-export declare function makeGrepTool(env: ExecutionEnv, rootCanonical: string, additionalRoots?: readonly string[]): AgentTool;
-export declare function makeGlobTool(env: ExecutionEnv, rootCanonical: string, additionalRoots?: readonly string[]): AgentTool;
-export declare const HAND_TOOL_EFFECTS: Readonly<Record<string, ToolEffect>>;
-export declare const BASH_READONLY_DEFAULT_ALLOW: readonly string[];
-export declare function parseLeadingCommandName(command: string): {
-    name: string;
-} | {
-    reject: string;
-};
-export declare function classifyCompoundReadonly(command: string, allow: ReadonlySet<string>): string | undefined;
-export declare function bashReversibilityProbe(allow?: readonly string[]): (args: unknown) => {
-    reversible: boolean;
-};
-export interface ExecClampOption {
-    deadlineMs: () => number | undefined;
-    onClamp?: (requestedSec: number, clampedSec: number) => void;
-    registerKillHandle?: (toolCallId: string, handle: {
-        pid: number;
-        kill: () => void;
-    }) => () => void;
-}
-export declare function bashExitOneInterpretation(command: string): string | undefined;
-export declare function canAutoBackground(command: string): boolean;
-export declare function makeBashTool(env: ExecutionEnv, rootCanonical: string, coAuthor?: string | false, cwdRef?: CwdRef, taskOpts?: {
-    taskRegistry?: TaskRegistry;
-    taskOwner?: string;
-    taskScope?: string;
-    sessionId?: string;
-    onTaskNotification?: (n: import("../../core/task-notification.js").TaskNotificationPayload, opts?: {
-        priority?: "now" | "next" | "later";
-    }) => void;
-    detachHub?: import("../../core/tool-detach.js").ToolDetachHub;
-    execClamp?: ExecClampOption;
-    autoBackgroundOnTimeout?: boolean;
-}): AgentTool;
-export declare function makeBashReadonlyTool(env: ExecutionEnv, rootCanonical: string, allow: ReadonlySet<string>, execClamp?: ExecClampOption): AgentTool;
-export declare function makeBashOutputTool(env: ExecutionEnv): AgentTool;
-export declare function makeKillShellTool(env: ExecutionEnv, registry?: TaskRegistry): AgentTool;
+import type { PdfModelCapabilities } from "./pdf.js";
+export * from "./fs-shared.js";
+export * from "./fs-pdf.js";
+export * from "./fs-read.js";
+export * from "./fs-write.js";
+export * from "./fs-search-tools.js";
+export * from "./bash-readonly-classifier.js";
+export * from "./fs-bash.js";
+import { type CwdRef, type ReadImageDownsamplerOption } from "./fs-shared.js";
+import { type ExecClampOption } from "./fs-bash.js";
 export interface HandsToolkitOptions {
     additionalRoots?: readonly string[];
     includeShell?: boolean;