@cursor/bdk 0.2.1

package/dist/internal/filesystem/tools.js

@@ -0,0 +1,631 @@
+/**
+ * Native file tools synthesized from a bound {@link FileSystem}.
+ *
+ * Advertised name / input / output match `@cursor/sdk` tool-call types.
+ * Each tool is a `defineTool` whose runtime `inputSchema` accepts those
+ * fields plus the native aliases the harness still sends.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { Buffer } from "node:buffer";
+import { minimatch } from "minimatch";
+import { z } from "zod";
+import { canonicalizeFileSystemToolName, collectGrepMatches, FILE_SYSTEM_SCAN_LIMIT, fileSystemImage, fileSystemText, InvalidGrepPatternError, isFileNotFoundError, shapeGrepUnion, sliceReadContent, strReplaceOnFileSystem, } from "../../filesystem.js";
+import { defineTool } from "../../tools.js";
+import { toolInputJsonSchema, toolOutputJsonSchema, validateToolInput } from "../json-schema.js";
+import { formatGlobOutput, formatGrepOutput, formatLsTree, formatNumberedLines, formatStrReplaceOutput, formatWriteOutput, slicedReadStartLine, } from "./format.js";
+import { nearestNeighborMissHint } from "./nearest.js";
+import { sdkDeleteArgs, sdkDeleteResult, sdkEditResult, sdkGlobArgs, sdkGlobResult, sdkGrepArgs, sdkGrepResult, sdkLsArgs, sdkLsResult, sdkReadArgs, sdkReadResult, sdkSemSearchArgs, sdkSemSearchResult, sdkStrReplaceArgs, sdkWriteArgs, sdkWriteResult, } from "./sdk-schemas.js";
+import { collectGlob, collectListOrStat, lsFromList } from "./walk.js";
+export const SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES = [
+    "Read",
+    "LS",
+    "Glob",
+    "Grep",
+    "Write",
+    "StrReplace",
+    "Delete",
+    "SemanticSearch",
+];
+const SYNTHESIZED_NAME_SET = new Set(SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES);
+export function isSynthesizedFileSystemToolName(name) {
+    if (SYNTHESIZED_NAME_SET.has(name)) {
+        return true;
+    }
+    const canonical = canonicalizeFileSystemToolName(name);
+    return canonical !== undefined && SYNTHESIZED_NAME_SET.has(canonical);
+}
+export function rootFileToolsFromAuthored(tools) {
+    if (tools === undefined) {
+        return undefined;
+    }
+    if (tools.length === 0) {
+        return [];
+    }
+    const files = [];
+    for (const name of tools) {
+        if (name === "edit") {
+            files.push("Write", "StrReplace");
+            continue;
+        }
+        const canonical = canonicalizeFileSystemToolName(name);
+        if (canonical !== undefined) {
+            files.push(canonical);
+        }
+    }
+    return files.length === 0 ? undefined : [...new Set(files)];
+}
+/**
+ * Host-default file-tool filter. Omitted `tools` keeps the default
+ * seven-tool set (`undefined`). A listed allowlist is closed: names that
+ * are not FileSystem methods synthesize nothing, so agents that already
+ * replaced natives with authored VFS tools (`tools: ["updateTodos"]` plus
+ * `agent/tools/Delete.ts`) do not also get host-disk Delete.
+ *
+ * Authored `root` still uses {@link rootFileToolsFromAuthored}, where a
+ * no-file-name allowlist means the default-on file layer.
+ */
+export function hostFileToolsFromAuthored(tools) {
+    var _a;
+    if (tools === undefined) {
+        return undefined;
+    }
+    return (_a = rootFileToolsFromAuthored(tools)) !== null && _a !== void 0 ? _a : [];
+}
+const HOST_DEFAULT_SYNTHESIZED_NAMES = SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES.filter(name => name !== "SemanticSearch");
+/**
+ * Names July will actually synthesize for this agent. Discovery reserves
+ * only this set, not every FileSystem alias.
+ */
+export function synthesizedFileSystemToolNames(options) {
+    const filter = options.hasRoot
+        ? rootFileToolsFromAuthored(options.tools)
+        : hostFileToolsFromAuthored(options.tools);
+    const catalog = options.hasRoot
+        ? SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES
+        : HOST_DEFAULT_SYNTHESIZED_NAMES;
+    if (filter === undefined) {
+        return catalog;
+    }
+    return catalog.filter(name => filter.includes(name));
+}
+function wantsTool(filter, name) {
+    return filter === undefined || filter.includes(name);
+}
+/**
+ * Copy native aliases onto the canonical SDK field when the canonical
+ * field is absent. Zod sees the SDK shape; callers can still send
+ * `contents` / `old_string` / `output_mode`.
+ */
+function aliasKeys(aliases) {
+    return (raw) => {
+        if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+            return raw;
+        }
+        const input = Object.assign({}, raw);
+        for (const [from, to] of Object.entries(aliases)) {
+            if (input[to] === undefined && input[from] !== undefined) {
+                input[to] = input[from];
+            }
+        }
+        return input;
+    };
+}
+function lineCount(content) {
+    return content === "" ? 0 : content.split("\n").length;
+}
+function parseGrepOutputMode(value) {
+    if (value === "files" || value === "files_with_matches") {
+        return "files_with_matches";
+    }
+    if (value === "count") {
+        return "count";
+    }
+    return "content";
+}
+function contextLineCount(specific, both) {
+    const value = specific !== null && specific !== void 0 ? specific : both;
+    if (value === undefined || !Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.floor(value));
+}
+function compileToolGrepPattern(pattern, options) {
+    try {
+        const flags = `${options.caseInsensitive === true ? "i" : ""}${options.multiline === true ? "s" : ""}`;
+        return new RegExp(pattern, flags === "" ? undefined : flags);
+    }
+    catch (_a) {
+        throw new InvalidGrepPatternError(pattern);
+    }
+}
+/**
+ * File discovery for multiline Grep. A file `path` is that file (the
+ * caller spelling, so host-default relative paths stay relative). A
+ * directory or omitted path uses `FileSystem.glob`, which applies the
+ * mount's own root. Slash-free globs are recursive, matching line grep.
+ */
+function collectMultilineGrepFiles(root, input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const listed = yield collectListOrStat(root, input.path);
+        if (listed.kind === "file") {
+            const filePath = (_a = input.path) !== null && _a !== void 0 ? _a : "";
+            if (input.glob !== undefined && !fileMatchesGrepGlob(filePath, input.glob)) {
+                return [];
+            }
+            return [filePath];
+        }
+        if (listed.kind === "missing") {
+            return [];
+        }
+        const entries = yield collectGlob(root, Object.assign({ pattern: recursiveGrepGlob(input.glob) }, (input.path === undefined ? {} : { dir: input.path })));
+        return entries.map(entry => entry.path);
+    });
+}
+function recursiveGrepGlob(glob) {
+    if (glob === undefined || glob.length === 0) {
+        return "**/*";
+    }
+    if (glob.startsWith("**/") || glob.includes("/")) {
+        return glob;
+    }
+    return `**/${glob}`;
+}
+function fileMatchesGrepGlob(filePath, globPattern) {
+    const relative = filePath.replace(/^\//, "");
+    if (minimatch(relative, globPattern, { dot: true }) ||
+        minimatch(filePath, globPattern, { dot: true })) {
+        return true;
+    }
+    if (!globPattern.includes("/")) {
+        const slash = Math.max(relative.lastIndexOf("/"), relative.lastIndexOf("\\"));
+        const base = slash === -1 ? relative : relative.slice(slash + 1);
+        return minimatch(base, globPattern, { dot: true });
+    }
+    return false;
+}
+function multilineHitsInContent(path, content, regex) {
+    var _a;
+    const global = new RegExp(regex.source, regex.flags.includes("g") ? regex.flags : `${regex.flags}g`);
+    const hits = [];
+    let match = global.exec(content);
+    while (match !== null) {
+        hits.push({
+            path,
+            lineNumber: content.slice(0, match.index).split("\n").length,
+            line: (_a = content.slice(match.index).split("\n")[0]) !== null && _a !== void 0 ? _a : "",
+        });
+        if (match[0].length === 0) {
+            global.lastIndex += 1;
+        }
+        match = global.exec(content);
+    }
+    return hits;
+}
+function collectMultilineGrepMatches(root, input, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const regex = compileToolGrepPattern(input.pattern, {
+            caseInsensitive: input.caseInsensitive,
+            multiline: true,
+        });
+        const files = yield collectMultilineGrepFiles(root, input);
+        const matches = [];
+        const offset = opts.offset !== undefined && opts.offset > 0 ? opts.offset : 0;
+        const headLimit = opts.headLimit !== undefined && opts.headLimit > 0 ? opts.headLimit : undefined;
+        let skippedItems = 0;
+        let takenItems = 0;
+        for (const filePath of files) {
+            let content;
+            try {
+                content = yield root.read(filePath);
+            }
+            catch (_a) {
+                continue;
+            }
+            if (typeof content !== "string") {
+                continue;
+            }
+            const hits = multilineHitsInContent(filePath, content, regex);
+            if (hits.length === 0) {
+                continue;
+            }
+            if (opts.outputMode === "content") {
+                for (const hit of hits) {
+                    if (skippedItems < offset) {
+                        skippedItems++;
+                        continue;
+                    }
+                    matches.push(hit);
+                    takenItems++;
+                    if (headLimit !== undefined && takenItems >= headLimit) {
+                        return matches;
+                    }
+                }
+                continue;
+            }
+            if (skippedItems < offset) {
+                skippedItems++;
+                continue;
+            }
+            if (headLimit !== undefined && takenItems >= headLimit) {
+                break;
+            }
+            matches.push(...hits);
+            takenItems++;
+        }
+        return matches;
+    });
+}
+function attachGrepContext(root, matches, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (context.before === 0 && context.after === 0) {
+            return matches;
+        }
+        const linesByPath = new Map();
+        const hits = [];
+        for (const match of matches) {
+            let lines = linesByPath.get(match.path);
+            if (lines === undefined) {
+                try {
+                    const content = yield root.read(match.path);
+                    lines = typeof content === "string" ? content.split("\n") : [];
+                }
+                catch (_a) {
+                    lines = [];
+                }
+                linesByPath.set(match.path, lines);
+            }
+            const index = match.lineNumber - 1;
+            hits.push(Object.assign(Object.assign(Object.assign({}, match), (context.before > 0
+                ? {
+                    beforeContext: lines.slice(Math.max(0, index - context.before), Math.max(0, index)),
+                }
+                : {})), (context.after > 0
+                ? { afterContext: lines.slice(index + 1, index + 1 + context.after) }
+                : {})));
+        }
+        return hits;
+    });
+}
+function discovered(name, definition, contract) {
+    const effect = typeof definition.effect === "function" ? "dynamic" : definition.effect;
+    return Object.assign(Object.assign({ name, description: definition.description, inputSchema: toolInputJsonSchema(contract.input), outputSchema: toolOutputJsonSchema(contract.output), execution: "server", needsApproval: false }, (effect === undefined ? {} : { effect })), { definition });
+}
+const readInputSchema = z.preprocess(aliasKeys({}), z.object({
+    path: z.string(),
+    offset: z.number().int().optional(),
+    limit: z.number().int().optional(),
+}));
+function readTool(root) {
+    return discovered("Read", defineTool({
+        description: "Reads a file from the local filesystem. This tool can also read image files when called with the appropriate path. Formats supported: jpeg/jpg, png, gif, webp.",
+        inputSchema: readInputSchema,
+        effect: "read",
+        execute(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ path, offset, limit }) {
+                let content;
+                try {
+                    content = yield root.read(path);
+                }
+                catch (error) {
+                    if (isFileNotFoundError(error)) {
+                        const hint = yield nearestNeighborMissHint(root, path);
+                        if (hint !== undefined) {
+                            return hint;
+                        }
+                    }
+                    throw error;
+                }
+                const image = fileSystemImage(content, path);
+                if (image !== undefined) {
+                    return {
+                        content: [
+                            { type: "text", text: `Read image file: ${path}` },
+                            {
+                                type: "image",
+                                data: Buffer.from(image.bytes).toString("base64"),
+                                mimeType: image.mimeType,
+                            },
+                        ],
+                    };
+                }
+                const text = fileSystemText(content);
+                const totalLines = lineCount(text);
+                return formatNumberedLines(sliceReadContent(text, offset, limit), {
+                    startLine: slicedReadStartLine(totalLines, offset),
+                    totalLines,
+                });
+            });
+        },
+    }), { input: sdkReadArgs, output: sdkReadResult });
+}
+const lsInputSchema = z.preprocess(aliasKeys({ target_directory: "path", ignore_globs: "ignore" }), z.object({
+    path: z.string(),
+    ignore: z.array(z.string()).optional(),
+}));
+function lsTool(root) {
+    return discovered("LS", defineTool({
+        description: `Lists files and directories in a given path.
+The 'path' parameter must be an absolute path.
+You can optionally provide an array of glob patterns to ignore with the "ignore" parameter.
+
+Other details:
+- The result does not display dot-files and dot-directories.`,
+        inputSchema: lsInputSchema,
+        effect: "read",
+        execute(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ path, ignore }) {
+                const listed = yield lsFromList(root, path, ignore);
+                if (listed.status === "error") {
+                    if (listed.error.message.startsWith("Path is not a directory:")) {
+                        return `not a directory: ${path} — Read it.`;
+                    }
+                    if (listed.error.message.startsWith("Path does not exist:")) {
+                        const hint = yield nearestNeighborMissHint(root, path);
+                        if (hint !== undefined) {
+                            return hint;
+                        }
+                    }
+                    throw new Error(`Error listing directory: ${listed.error.message}`);
+                }
+                return formatLsTree(listed.value.directoryTreeRoot);
+            });
+        },
+    }), { input: sdkLsArgs, output: sdkLsResult });
+}
+const globInputSchema = z.preprocess(aliasKeys({
+    glob_pattern: "globPattern",
+    target_directory: "targetDirectory",
+    path: "targetDirectory",
+}), z.object({
+    targetDirectory: z.string().optional(),
+    globPattern: z.string(),
+}));
+function globTool(root) {
+    return discovered("Glob", defineTool({
+        description: `
+Tool to search for files matching a glob pattern
+
+- Works fast with codebases of any size
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches that are potentially useful as a batch.
+`,
+        inputSchema: globInputSchema,
+        effect: "read",
+        execute(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ globPattern, targetDirectory }) {
+                const dir = targetDirectory !== null && targetDirectory !== void 0 ? targetDirectory : "/";
+                const files = (yield collectGlob(root, Object.assign(Object.assign({ pattern: globPattern }, (targetDirectory === undefined ? {} : { dir: targetDirectory })), { limit: FILE_SYSTEM_SCAN_LIMIT }))).map(entry => entry.path);
+                return formatGlobOutput(dir, files);
+            });
+        },
+    }), { input: sdkGlobArgs, output: sdkGlobResult });
+}
+const grepInputSchema = z.preprocess(raw => {
+    const aliased = aliasKeys({
+        output_mode: "outputMode",
+        head_limit: "headLimit",
+        "-i": "caseInsensitive",
+        "-A": "contextAfter",
+        "-B": "contextBefore",
+        "-C": "context",
+    })(raw);
+    if (aliased !== null && typeof aliased === "object" && !Array.isArray(aliased)) {
+        const input = aliased;
+        if (input.outputMode === "files") {
+            input.outputMode = "files_with_matches";
+        }
+    }
+    return aliased;
+}, z.object({
+    pattern: z.string(),
+    path: z.string().optional(),
+    glob: z.string().optional(),
+    outputMode: z.string().optional(),
+    contextBefore: z.number().optional(),
+    contextAfter: z.number().optional(),
+    context: z.number().optional(),
+    caseInsensitive: z.boolean().optional(),
+    type: z.string().optional(),
+    headLimit: z.number().optional(),
+    offset: z.number().optional(),
+    multiline: z.boolean().optional(),
+    sort: z.string().optional(),
+    sortAscending: z.boolean().optional(),
+}));
+function grepTool(root) {
+    return discovered("Grep", defineTool({
+        description: `A search tool built on ripgrep. Results are capped to several thousand output lines for responsiveness; when truncation occurs, the results report "at least" counts, but are otherwise accurate.`,
+        inputSchema: grepInputSchema,
+        effect: "read",
+        execute(input) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const outputMode = parseGrepOutputMode(input.outputMode);
+                const query = Object.assign(Object.assign(Object.assign({ pattern: input.pattern }, (input.path === undefined ? {} : { path: input.path })), (input.glob === undefined ? {} : { glob: input.glob })), { caseInsensitive: input.caseInsensitive === true });
+                const page = Object.assign(Object.assign({ outputMode }, (input.headLimit === undefined ? {} : { headLimit: input.headLimit })), (input.offset === undefined ? {} : { offset: input.offset }));
+                const matches = input.multiline === true
+                    ? yield collectMultilineGrepMatches(root, query, page)
+                    : yield collectGrepMatches(root, query, page);
+                const before = contextLineCount(input.contextBefore, input.context);
+                const after = contextLineCount(input.contextAfter, input.context);
+                const hits = outputMode === "content"
+                    ? yield attachGrepContext(root, matches, { before, after })
+                    : matches;
+                return formatGrepOutput(shapeGrepUnion(hits, outputMode));
+            });
+        },
+    }), { input: sdkGrepArgs, output: sdkGrepResult });
+}
+const writeInputSchema = z.preprocess(aliasKeys({ contents: "fileText" }), z.object({
+    path: z.string(),
+    fileText: z.string(),
+    returnFileContentAfterWrite: z.boolean().optional(),
+}));
+function writeTool(root) {
+    return discovered("Write", defineTool({
+        description: "Writes a file to the local filesystem.",
+        inputSchema: writeInputSchema,
+        effect: "write",
+        execute(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ path, fileText }) {
+                yield root.write(path, fileText);
+                return formatWriteOutput(path);
+            });
+        },
+    }), { input: sdkWriteArgs, output: sdkWriteResult });
+}
+const strReplaceInputSchema = z.preprocess(aliasKeys({
+    old_string: "oldText",
+    new_string: "newText",
+    replace_all: "replaceAll",
+}), z.object({
+    path: z.string(),
+    oldText: z.string(),
+    newText: z.string(),
+    replaceAll: z.boolean().optional(),
+}));
+function strReplaceTool(root) {
+    return discovered("StrReplace", defineTool({
+        description: "Performs exact string replacements in files.",
+        inputSchema: strReplaceInputSchema,
+        effect: "write",
+        execute(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ path, oldText, newText, replaceAll }) {
+                const { occurrencesModified } = yield strReplaceOnFileSystem(root, Object.assign({ path,
+                    oldText,
+                    newText }, (replaceAll === undefined ? {} : { replaceAll })));
+                return formatStrReplaceOutput({
+                    path,
+                    replaceAll: replaceAll === true,
+                    occurrencesModified,
+                });
+            });
+        },
+    }), { input: sdkStrReplaceArgs, output: sdkEditResult });
+}
+const deleteInputSchema = z.object({
+    path: z.string(),
+});
+function deleteTool(root) {
+    return discovered("Delete", defineTool({
+        description: `Deletes a file at the specified path. The operation will fail gracefully if:
+    - The file doesn't exist
+    - The operation is rejected for security reasons
+    - The file cannot be deleted`,
+        inputSchema: deleteInputSchema,
+        effect: "write",
+        execute(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ path }) {
+                yield root.delete(path);
+                return "";
+            });
+        },
+    }), { input: sdkDeleteArgs, output: sdkDeleteResult });
+}
+const semanticSearchInputSchema = z.preprocess(aliasKeys({ num_results: "numResults" }), z.object({
+    query: z.string(),
+    targetDirectories: z.array(z.string()).optional(),
+    explanation: z.string().optional(),
+    numResults: z.number().optional(),
+}));
+function semanticSearchTool(root) {
+    return discovered("SemanticSearch", defineTool({
+        description: "`SemanticSearch`: semantic search that finds code by meaning, not exact text",
+        inputSchema: semanticSearchInputSchema,
+        effect: "read",
+        execute(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ query, targetDirectories, numResults }) {
+                var _b, e_1, _c, _d;
+                const cap = numResults !== undefined && numResults > 0 ? numResults : undefined;
+                const hits = [];
+                try {
+                    for (var _e = true, _f = __asyncValues(root.search(Object.assign(Object.assign({ query }, (targetDirectories === undefined ? {} : { targetDirectories })), (cap === undefined ? {} : { maxResults: cap })))), _g; _g = yield _f.next(), _b = _g.done, !_b; _e = true) {
+                        _d = _g.value;
+                        _e = false;
+                        const hit = _d;
+                        hits.push(hit);
+                        if (cap !== undefined && hits.length >= cap) {
+                            break;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_e && !_b && (_c = _f.return)) yield _c.call(_f);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                return hits.map(hit => `${hit.path}: ${hit.snippet}`).join("\n");
+            });
+        },
+    }), { input: sdkSemSearchArgs, output: sdkSemSearchResult });
+}
+const FILE_SYSTEM_TOOL_FACTORIES = {
+    Read: readTool,
+    LS: lsTool,
+    Glob: globTool,
+    Grep: grepTool,
+    Write: writeTool,
+    StrReplace: strReplaceTool,
+    Delete: deleteTool,
+    SemanticSearch: semanticSearchTool,
+};
+/**
+ * Look up the `defineTool` factory for a native or allowlist name.
+ * The only name that still inspects `input` is legacy `edit`:
+ * `fileText` / `contents` selects Write, otherwise StrReplace.
+ */
+export function fileSystemTool(root, name, input = {}) {
+    if (name === "edit") {
+        return "fileText" in input || "contents" in input ? writeTool(root) : strReplaceTool(root);
+    }
+    const canonical = canonicalizeFileSystemToolName(name);
+    if (canonical === undefined) {
+        return undefined;
+    }
+    return FILE_SYSTEM_TOOL_FACTORIES[canonical](root);
+}
+/** Validate and run the same tool a turn or `callTool` would. */
+export function runFileSystemTool(root_1, name_1) {
+    return __awaiter(this, arguments, void 0, function* (root, name, input = {}) {
+        const tool = fileSystemTool(root, name, input);
+        if (tool === undefined) {
+            throw new Error(`Unknown file system tool: ${name}`);
+        }
+        const execute = tool.definition.execute;
+        if (typeof execute !== "function") {
+            throw new Error(`File system tool ${name} has no execute`);
+        }
+        const validation = validateToolInput(tool.definition.inputSchema, input);
+        if (!validation.ok) {
+            throw new Error(validation.message);
+        }
+        return execute(validation.value, {});
+    });
+}
+export function synthesizeFileSystemTools(root, filter) {
+    const tools = [];
+    for (const name of SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES) {
+        if (wantsTool(filter, name)) {
+            tools.push(FILE_SYSTEM_TOOL_FACTORIES[name](root));
+        }
+    }
+    return tools;
+}