@assemblyline-agents/runtime 0.1.0

package/dist/builtin-tools.js

@@ -0,0 +1,690 @@
+import { approvalNever, normalizeSandboxPath as normalizeCoreSandboxPath } from "@assemblyline-agents/core";
+export const READ_TOOL_NAME = "read";
+export const WRITE_TOOL_NAME = "write";
+export const EDIT_TOOL_NAME = "edit";
+export const DELETE_TOOL_NAME = "delete";
+export const LIST_TOOL_NAME = "list";
+export const GREP_TOOL_NAME = "grep";
+export const BASH_TOOL_NAME = "bash";
+export const ASK_QUESTION_TOOL_NAME = "ask_question";
+export const SPAWN_SUBAGENT_TOOL_NAME = "spawn_subagent";
+export const LOAD_SKILL_TOOL_NAME = "load_skill";
+export const TOOL_SEARCH_TOOL_NAME = "tool_search";
+export const TOOL_DESCRIBE_TOOL_NAME = "tool_describe";
+export const TOOL_CALL_TOOL_NAME = "tool_call";
+export const CORE_HARNESS_TOOL_NAMES = [
+    READ_TOOL_NAME,
+    WRITE_TOOL_NAME,
+    EDIT_TOOL_NAME,
+    DELETE_TOOL_NAME,
+    LIST_TOOL_NAME,
+    GREP_TOOL_NAME,
+    BASH_TOOL_NAME,
+    ASK_QUESTION_TOOL_NAME,
+    SPAWN_SUBAGENT_TOOL_NAME,
+    LOAD_SKILL_TOOL_NAME,
+    TOOL_SEARCH_TOOL_NAME,
+    TOOL_DESCRIBE_TOOL_NAME,
+    TOOL_CALL_TOOL_NAME
+];
+const CORE_HARNESS_TOOL_NAME_SET = new Set(CORE_HARNESS_TOOL_NAMES);
+const BUILTIN_SOURCE = {
+    path: "__builtin__/harness",
+    sha256: "builtin-harness"
+};
+const PATH_SCHEMA = {
+    type: "string",
+    description: "Absolute sandbox path, such as /memory/notes.md, /skills/name/SKILL.md, /workspace/report.txt, or /workspace/app.ts."
+};
+const READ_COMPILED_TOOL = {
+    name: READ_TOOL_NAME,
+    description: "Read a file from the sandbox filesystem. Lazily hydrates logical OpenEve paths before reading.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            path: PATH_SCHEMA,
+            maxBytes: { type: "number", description: "Maximum bytes to return. Defaults to 65536." }
+        },
+        required: ["path"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "sandbox",
+    tags: ["filesystem", "sandbox", "read"],
+    aliases: ["read_file", "cat"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const WRITE_COMPILED_TOOL = {
+    name: WRITE_TOOL_NAME,
+    description: "Write a file in the sandbox filesystem. Mutations are durably queued for async sync before the write.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            path: PATH_SCHEMA,
+            content: { type: "string", description: "File contents to write." },
+            contents: { type: "string", description: "Alias for content." },
+            encoding: { type: "string", enum: ["utf8", "base64"], description: "Input encoding. Defaults to utf8." }
+        },
+        required: ["path"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "sandbox",
+    tags: ["filesystem", "sandbox", "write"],
+    aliases: ["write_file"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const EDIT_COMPILED_TOOL = {
+    name: EDIT_TOOL_NAME,
+    description: "Edit a sandbox file by replacing exact text. Hydrates the path first when it is a logical OpenEve resource.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            path: PATH_SCHEMA,
+            search: { type: "string", description: "Exact text to replace." },
+            replace: { type: "string", description: "Replacement text." },
+            expectedOccurrences: { type: "number", description: "Optional exact occurrence count guard." },
+            all: { type: "boolean", description: "Replace all occurrences. Defaults to true." }
+        },
+        required: ["path", "search", "replace"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "sandbox",
+    tags: ["filesystem", "sandbox", "edit"],
+    aliases: ["patch", "replace"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const DELETE_COMPILED_TOOL = {
+    name: DELETE_TOOL_NAME,
+    description: "Delete a writable sandbox file or directory and record a tombstone for durable async sync.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            path: PATH_SCHEMA,
+            recursive: { type: "boolean", description: "Allow deleting directories recursively. Defaults to true." }
+        },
+        required: ["path"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "sandbox",
+    tags: ["filesystem", "sandbox", "delete"],
+    aliases: ["rm", "remove"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const LIST_COMPILED_TOOL = {
+    name: LIST_TOOL_NAME,
+    description: "List files under a sandbox path. Lazily hydrates bounded logical OpenEve roots before listing.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            path: PATH_SCHEMA,
+            limit: { type: "number", description: "Maximum entries. Defaults to 200." }
+        },
+        required: ["path"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "sandbox",
+    tags: ["filesystem", "sandbox", "list"],
+    aliases: ["ls"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const GREP_COMPILED_TOOL = {
+    name: GREP_TOOL_NAME,
+    description: "Search files under a sandbox path with a regular expression or literal pattern.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            pattern: { type: "string" },
+            path: PATH_SCHEMA,
+            literal: { type: "boolean", description: "Treat pattern as literal text. Defaults to false." },
+            limit: { type: "number", description: "Maximum matches. Defaults to 100." }
+        },
+        required: ["pattern"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "sandbox",
+    tags: ["filesystem", "sandbox", "search"],
+    aliases: ["search", "rg"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const BASH_COMPILED_TOOL = {
+    name: BASH_TOOL_NAME,
+    description: "Run a Bash command in the sandbox. Bash defaults to the workspace cwd; use relative paths in commands for local sandbox portability.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            command: { type: "string" },
+            cwd: { type: "string" },
+            timeoutMs: { type: "number" }
+        },
+        required: ["command"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "sandbox",
+    tags: ["sandbox", "bash", "shell"],
+    aliases: ["shell", "terminal"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const ASK_QUESTION_COMPILED_TOOL = {
+    name: ASK_QUESTION_TOOL_NAME,
+    description: "Ask the user a concise clarifying question and pause the run until the answer is available.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            question: { type: "string" },
+            choices: { type: "array", items: { type: "string" } },
+            allowFreeform: { type: "boolean" },
+            metadata: { type: "object", additionalProperties: true }
+        },
+        required: ["question"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "direct",
+    tags: ["human", "question"],
+    aliases: ["clarify"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const SPAWN_SUBAGENT_COMPILED_TOOL = {
+    name: SPAWN_SUBAGENT_TOOL_NAME,
+    description: "Spawn a configured subagent by name for delegated work.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+            name: { type: "string", description: "Subagent name." },
+            task: { type: "string" },
+            expectedOutput: { type: "string" },
+            constraints: { type: "array", items: { type: "string" } }
+        },
+        required: ["name", "task"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "direct",
+    tags: ["subagent", "delegate"],
+    aliases: ["delegate", "agent"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const LOAD_SKILL_COMPILED_TOOL = {
+    name: LOAD_SKILL_TOOL_NAME,
+    description: "Load a skill's full instructions by name from the durable skill store. Loading a skill does not reveal additional tools.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            name: { type: "string", description: "Skill name, such as skill-creator." },
+            skillName: { type: "string", description: "Alias for name." }
+        }
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "direct",
+    tags: ["skills", "instructions", "progressive-disclosure"],
+    aliases: ["skill_view", "load_instructions"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const TOOL_SEARCH_COMPILED_TOOL = {
+    name: TOOL_SEARCH_TOOL_NAME,
+    description: "Search deferred non-core tools by name, description, tags, aliases, or connection. Returns compact metadata only.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            query: { type: "string" },
+            limit: { type: "number" },
+            kind: { type: "string" },
+            connection: { type: "string" }
+        },
+        required: ["query"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "direct",
+    tags: ["tools", "deferred", "search"],
+    aliases: ["tools"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const TOOL_DESCRIBE_COMPILED_TOOL = {
+    name: TOOL_DESCRIBE_TOOL_NAME,
+    description: "Return the full schema for one deferred tool previously found with tool_search.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            name: { type: "string" }
+        },
+        required: ["name"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "direct",
+    tags: ["tools", "deferred", "describe"],
+    aliases: ["schema"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const TOOL_CALL_COMPILED_TOOL = {
+    name: TOOL_CALL_TOOL_NAME,
+    description: "Call a deferred non-core tool by name with JSON arguments. The underlying tool is logged and policy-checked directly.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            name: { type: "string" },
+            arguments: { type: "object", additionalProperties: true },
+            input: { type: "object", additionalProperties: true }
+        },
+        required: ["name"]
+    },
+    needsApproval: approvalNever(),
+    defaultEnabled: true,
+    visibility: "always",
+    execution: "direct",
+    tags: ["tools", "deferred", "call"],
+    aliases: ["invoke"],
+    hasToModelOutput: true,
+    source: BUILTIN_SOURCE
+};
+const BUILT_IN_COMPILED_TOOLS = [
+    READ_COMPILED_TOOL,
+    WRITE_COMPILED_TOOL,
+    EDIT_COMPILED_TOOL,
+    DELETE_COMPILED_TOOL,
+    LIST_COMPILED_TOOL,
+    GREP_COMPILED_TOOL,
+    BASH_COMPILED_TOOL,
+    ASK_QUESTION_COMPILED_TOOL,
+    SPAWN_SUBAGENT_COMPILED_TOOL,
+    LOAD_SKILL_COMPILED_TOOL,
+    TOOL_SEARCH_COMPILED_TOOL,
+    TOOL_DESCRIBE_COMPILED_TOOL,
+    TOOL_CALL_COMPILED_TOOL
+];
+export function runtimeToolsForManifest(manifest) {
+    const builtInNamed = new Map(manifest.tools.filter((tool) => CORE_HARNESS_TOOL_NAME_SET.has(tool.name)).map((tool) => [tool.name, tool]));
+    return [
+        ...manifest.tools.filter((tool) => !CORE_HARNESS_TOOL_NAME_SET.has(tool.name) && !tool.disabled),
+        ...BUILT_IN_COMPILED_TOOLS.flatMap((builtin) => {
+            const authored = builtInNamed.get(builtin.name);
+            if (!authored)
+                return [builtin];
+            if (authored.disabled)
+                return [];
+            // An authored override keeps the built-in slot's availability so the model
+            // never silently loses a core tool to visibility inference.
+            return [{ ...authored, defaultEnabled: builtin.defaultEnabled, visibility: builtin.visibility }];
+        })
+    ];
+}
+export function builtInToolDefinition(name) {
+    if (name === READ_TOOL_NAME)
+        return readToolDefinition;
+    if (name === WRITE_TOOL_NAME)
+        return writeToolDefinition;
+    if (name === EDIT_TOOL_NAME)
+        return editToolDefinition;
+    if (name === DELETE_TOOL_NAME)
+        return deleteToolDefinition;
+    if (name === LIST_TOOL_NAME)
+        return listToolDefinition;
+    if (name === GREP_TOOL_NAME)
+        return grepToolDefinition;
+    if (name === BASH_TOOL_NAME)
+        return bashToolDefinition;
+    if (name === ASK_QUESTION_TOOL_NAME)
+        return askQuestionToolDefinition;
+    if (name === SPAWN_SUBAGENT_TOOL_NAME)
+        return spawnSubagentToolDefinition;
+    if (name === LOAD_SKILL_TOOL_NAME)
+        return runtimeHandledToolDefinition(LOAD_SKILL_COMPILED_TOOL);
+    if (name === TOOL_SEARCH_TOOL_NAME)
+        return runtimeHandledToolDefinition(TOOL_SEARCH_COMPILED_TOOL);
+    if (name === TOOL_DESCRIBE_TOOL_NAME)
+        return runtimeHandledToolDefinition(TOOL_DESCRIBE_COMPILED_TOOL);
+    if (name === TOOL_CALL_TOOL_NAME)
+        return runtimeHandledToolDefinition(TOOL_CALL_COMPILED_TOOL);
+    return undefined;
+}
+export function isBuiltInToolName(name) {
+    return CORE_HARNESS_TOOL_NAME_SET.has(name);
+}
+const readToolDefinition = {
+    ...toolDefinitionBase(READ_COMPILED_TOOL),
+    async execute(input, ctx) {
+        const raw = recordInput(input);
+        const path = requiredPath(raw.path);
+        const maxBytes = boundedNumber(raw.maxBytes, 65_536, 1, 10 * 1024 * 1024);
+        await ctx.hydrateSandboxPath?.(path);
+        const sandbox = await ctx.getSandbox();
+        const contents = await sandbox.readFile(path);
+        const bytes = Buffer.from(contents);
+        const truncated = bytes.byteLength > maxBytes;
+        return {
+            path,
+            content: bytes.subarray(0, maxBytes).toString("utf8"),
+            bytes: bytes.byteLength,
+            truncated
+        };
+    }
+};
+const writeToolDefinition = {
+    ...toolDefinitionBase(WRITE_COMPILED_TOOL),
+    async execute(input, ctx) {
+        const raw = recordInput(input);
+        const path = requiredWritablePath(raw.path);
+        const content = typeof raw.content === "string" ? raw.content : typeof raw.contents === "string" ? raw.contents : "";
+        const encoding = raw.encoding === "base64" ? "base64" : "utf8";
+        const bytes = encoding === "base64" ? Buffer.from(content, "base64") : content;
+        const sandbox = await ctx.getSandbox();
+        await sandbox.writeFile(path, bytes);
+        return {
+            path,
+            bytes: typeof bytes === "string" ? Buffer.byteLength(bytes) : bytes.byteLength,
+            encoding
+        };
+    }
+};
+const editToolDefinition = {
+    ...toolDefinitionBase(EDIT_COMPILED_TOOL),
+    async execute(input, ctx) {
+        const raw = recordInput(input);
+        const path = requiredWritablePath(raw.path);
+        const search = typeof raw.search === "string" ? raw.search : "";
+        const replace = typeof raw.replace === "string" ? raw.replace : "";
+        if (!search)
+            throw new Error("edit requires a non-empty search string.");
+        await ctx.hydrateSandboxPath?.(path);
+        const sandbox = await ctx.getSandbox();
+        const original = await sandbox.readFile(path);
+        const occurrences = countOccurrences(original, search);
+        if (typeof raw.expectedOccurrences === "number" && occurrences !== raw.expectedOccurrences) {
+            throw new Error(`edit expected ${raw.expectedOccurrences} occurrences but found ${occurrences}.`);
+        }
+        if (occurrences === 0)
+            throw new Error(`edit found no occurrences in ${path}.`);
+        const all = raw.all !== false;
+        const updated = all ? original.split(search).join(replace) : original.replace(search, replace);
+        await sandbox.writeFile(path, updated);
+        return {
+            path,
+            occurrences,
+            replaced: all ? occurrences : 1,
+            bytes: Buffer.byteLength(updated)
+        };
+    }
+};
+const deleteToolDefinition = {
+    ...toolDefinitionBase(DELETE_COMPILED_TOOL),
+    async execute(input, ctx) {
+        const raw = recordInput(input);
+        const path = requiredWritablePath(raw.path);
+        const sandbox = await ctx.getSandbox();
+        await ctx.recordSandboxTombstone?.(path);
+        const recursive = raw.recursive !== false;
+        if (sandbox.deletePath) {
+            await sandbox.deletePath(path, { recursive });
+        }
+        else {
+            const flag = recursive ? "-r" : "";
+            const result = await sandbox.shell(`rm ${flag} -f -- ${shellQuote(path)}`.replace(/\s+/g, " ").trim());
+            if (result.exitCode !== 0)
+                throw new Error(result.stderr || `delete failed for ${path}`);
+        }
+        return { path, deleted: true };
+    }
+};
+const listToolDefinition = {
+    ...toolDefinitionBase(LIST_COMPILED_TOOL),
+    async execute(input, ctx) {
+        const raw = recordInput(input);
+        const path = requiredPath(raw.path);
+        const limit = boundedNumber(raw.limit, 200, 1, 2000);
+        await ctx.hydrateSandboxPath?.(path, { list: true, limit });
+        const sandbox = await ctx.getSandbox();
+        const entries = await listSandboxEntries(sandbox, path, limit);
+        return { path, entries, count: entries.length, truncated: entries.length >= limit };
+    }
+};
+const grepToolDefinition = {
+    ...toolDefinitionBase(GREP_COMPILED_TOOL),
+    async execute(input, ctx) {
+        const raw = recordInput(input);
+        const pattern = typeof raw.pattern === "string" ? raw.pattern : "";
+        if (!pattern)
+            throw new Error("grep requires a non-empty pattern.");
+        const path = typeof raw.path === "string" ? normalizeSandboxPath(raw.path) : "/workspace";
+        const limit = boundedNumber(raw.limit, 100, 1, 2000);
+        await ctx.hydrateSandboxPath?.(path, { list: true, limit });
+        const sandbox = await ctx.getSandbox();
+        const matches = await grepSandbox(sandbox, path, pattern, raw.literal === true, limit);
+        return { pattern, path, matches, count: matches.length, truncated: matches.length >= limit };
+    }
+};
+const bashToolDefinition = {
+    ...toolDefinitionBase(BASH_COMPILED_TOOL),
+    async execute(input, ctx) {
+        const raw = recordInput(input);
+        const command = typeof raw.command === "string" ? raw.command : "";
+        if (!command.trim())
+            throw new Error("bash requires a non-empty command.");
+        const sandbox = await ctx.getSandbox();
+        const options = {};
+        if (typeof raw.cwd === "string")
+            options.cwd = raw.cwd;
+        if (typeof raw.timeoutMs === "number" && Number.isFinite(raw.timeoutMs))
+            options.timeoutMs = raw.timeoutMs;
+        return sandbox.shell(command, options);
+    }
+};
+const askQuestionToolDefinition = {
+    ...toolDefinitionBase(ASK_QUESTION_COMPILED_TOOL),
+    async execute(input, ctx) {
+        const raw = recordInput(input);
+        const question = typeof raw.question === "string" ? raw.question.trim() : "";
+        if (!question)
+            throw new Error("ask_question requires a non-empty question.");
+        const options = {};
+        if (Array.isArray(raw.choices))
+            options.choices = raw.choices.map(String).filter(Boolean);
+        if (typeof raw.allowFreeform === "boolean")
+            options.allowFreeform = raw.allowFreeform;
+        if (raw.metadata && typeof raw.metadata === "object" && !Array.isArray(raw.metadata)) {
+            options.metadata = raw.metadata;
+        }
+        return ctx.askQuestion(question, options);
+    }
+};
+const spawnSubagentToolDefinition = {
+    ...toolDefinitionBase(SPAWN_SUBAGENT_COMPILED_TOOL),
+    async execute(input, ctx) {
+        if (!ctx.spawnSubagent)
+            throw new Error("Subagent spawning is not available in this runtime.");
+        const raw = recordInput(input);
+        const name = typeof raw.name === "string" ? raw.name.trim() : "";
+        const task = typeof raw.task === "string" ? raw.task.trim() : "";
+        if (!name || !task)
+            throw new Error("spawn_subagent requires name and task.");
+        return ctx.spawnSubagent({
+            name,
+            task,
+            ...(typeof raw.expectedOutput === "string" ? { expectedOutput: raw.expectedOutput } : {}),
+            ...(Array.isArray(raw.constraints) ? { constraints: raw.constraints.map(String) } : {})
+        });
+    }
+};
+function toolDefinitionBase(tool) {
+    const definition = {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        needsApproval: false,
+        defaultEnabled: tool.defaultEnabled,
+        capability: {
+            visibility: tool.visibility,
+            execution: tool.execution,
+            tags: tool.tags,
+            aliases: tool.aliases
+        },
+        toModelOutput(output) {
+            return output;
+        }
+    };
+    if (tool.outputSchema)
+        definition.outputSchema = tool.outputSchema;
+    return definition;
+}
+function runtimeHandledToolDefinition(tool) {
+    return {
+        ...toolDefinitionBase(tool),
+        async execute() {
+            throw new Error(`${tool.name} is handled by the OpenEve runtime dispatcher.`);
+        }
+    };
+}
+function recordInput(input) {
+    if (input && typeof input === "object" && !Array.isArray(input))
+        return input;
+    return {};
+}
+function requiredPath(value) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new Error("path is required.");
+    return normalizeCoreSandboxPath(value);
+}
+function requiredWritablePath(value) {
+    const path = requiredPath(value);
+    if (path === "/history" || path.startsWith("/history/") || path === "/files" || path.startsWith("/files/")) {
+        throw new Error(`${path} is read-only.`);
+    }
+    return path;
+}
+function normalizeSandboxPath(path) {
+    return normalizeCoreSandboxPath(path);
+}
+function boundedNumber(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    return Math.max(min, Math.min(max, Math.floor(value)));
+}
+async function listSandboxEntries(sandbox, path, limit) {
+    if (!sandbox.listFiles)
+        throw new Error("This sandbox adapter does not support file listing.");
+    const entries = await sandbox.listFiles(path);
+    return entries.slice(0, limit).map((entry) => {
+        const out = { path: entry.path };
+        if (entry.size !== undefined)
+            out.size = entry.size;
+        return out;
+    });
+}
+async function grepSandbox(sandbox, path, pattern, literal, limit) {
+    if (!sandbox.listFiles)
+        throw new Error("This sandbox adapter does not support grep without file listing.");
+    const entries = await sandbox.listFiles(path);
+    const matches = [];
+    const regexp = literal ? undefined : new RegExp(pattern, "u");
+    for (const entry of entries) {
+        if (matches.length >= limit)
+            break;
+        const contents = entryContents(entry);
+        if (contents === undefined)
+            continue;
+        const lines = contents.split(/\r?\n/u);
+        for (let index = 0; index < lines.length; index += 1) {
+            const text = lines[index] ?? "";
+            const matched = literal ? text.includes(pattern) : regexp?.test(text);
+            if (!matched)
+                continue;
+            matches.push({ path: entry.path, line: index + 1, text });
+            if (matches.length >= limit)
+                break;
+        }
+    }
+    return matches;
+}
+function entryContents(entry) {
+    if (typeof entry.contents === "string")
+        return entry.contents;
+    if (entry.contents instanceof Uint8Array)
+        return Buffer.from(entry.contents).toString("utf8");
+    return undefined;
+}
+function countOccurrences(value, search) {
+    if (!search)
+        return 0;
+    let count = 0;
+    let index = value.indexOf(search);
+    while (index >= 0) {
+        count += 1;
+        index = value.indexOf(search, index + search.length);
+    }
+    return count;
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/gu, "'\\''")}'`;
+}
+export function builtInToolContext(tool) {
+    if (!isBuiltInToolName(tool.name))
+        return undefined;
+    return {
+        builtin: true,
+        source: tool.source.path
+    };
+}
+/**
+ * The built-in tool implementations, exported so an authored override at
+ * `tools/<name>.ts` can wrap the default instead of rewriting it:
+ *
+ *   export default defineTool({ ...builtInToolDefaults.write, execute: guarded });
+ *
+ * The deferred bridge tools (load_skill, tool_search, tool_describe, tool_call)
+ * are runtime-handled and have no wrappable executor, so they are not listed.
+ */
+export const builtInToolDefaults = Object.freeze({
+    read: readToolDefinition,
+    write: writeToolDefinition,
+    edit: editToolDefinition,
+    delete: deleteToolDefinition,
+    list: listToolDefinition,
+    grep: grepToolDefinition,
+    bash: bashToolDefinition,
+    ask_question: askQuestionToolDefinition,
+    spawn_subagent: spawnSubagentToolDefinition
+});
+//# sourceMappingURL=builtin-tools.js.map