@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/tool-system/builtin/agent.js

@@ -0,0 +1,364 @@
+/**
+ * Built-in Agent tool — spawn a sub-agent to handle a task.
+ *
+ * Creates a new Engine instance with its own transcript,
+ * runs the task to completion, and returns the result text.
+ * Supports AbortSignal for cascading cancellation.
+ * Supports onStream for real-time output passthrough.
+ */
+import { asyncAgentRegistry } from "./agent-registry.js";
+import { createTranscriptTranslator } from "./agent-transcript-translator.js";
+import { notificationQueue } from "./agent-notifications.js";
+import { nanoid } from "nanoid";
+import { logger } from "../../logging/logger.js";
+/**
+ * Invoke a stream callback that came from outside the engine's own
+ * TurnLoop wrap (e.g. `subAgentSpawner.parentStream`, which is the
+ * parent Engine.run's caller-supplied onStream forwarded straight
+ * through). A throw here would otherwise bubble out of the Agent tool
+ * and abort the parent turn, even though the underlying emit is a UI
+ * marker the parent doesn't need to succeed.
+ */
+function safeEmit(sink, event) {
+    if (!sink)
+        return;
+    try {
+        sink(event);
+    }
+    catch (err) {
+        logger.warn("agent.stream_handler_threw", {
+            eventType: event.type,
+            error: err.message,
+        });
+    }
+}
+export const agentToolDef = {
+    name: "Agent",
+    description: "Launch a sub-agent to handle a complex task autonomously. " +
+        "The sub-agent has access to the same tools and runs independently. " +
+        "Use this for tasks that can be delegated, parallelized, or require deep exploration. " +
+        "Provide a clear, complete description of what the agent should do.\n\n" +
+        "When you launch multiple agents for independent work, send them in a single " +
+        "message with multiple tool uses so they run concurrently.\n\n" +
+        "You can optionally run agents in the background using the run_in_background " +
+        "parameter. When an agent runs in the background, you will be automatically " +
+        "notified when it completes — do NOT sleep, poll, or proactively check on its " +
+        "progress. Continue with other work or respond to the user instead.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Short label for the agent kind (e.g. 'Explore', 'Plan', 'Research'). " +
+                    "Shown in the agent dock to identify what kind of work this sub-agent is doing. " +
+                    "Keep it 1-2 words. Defaults to 'Agent' if omitted.",
+            },
+            description: {
+                type: "string",
+                description: "A short (3-5 word) description of the task",
+            },
+            prompt: {
+                type: "string",
+                description: "The detailed task for the agent to perform",
+            },
+            max_turns: {
+                type: "number",
+                description: "Maximum turns for the sub-agent (default: 15)",
+            },
+            run_in_background: {
+                type: "boolean",
+                description: "Set to true to run this agent in the background. " +
+                    "You will be notified automatically when it completes — do NOT sleep, poll, " +
+                    "or proactively check on its progress. Use AgentCancel(agent_id) to stop it. " +
+                    "The agent runs in this process; restarting loses its state. " +
+                    "Default: false (synchronous wait).",
+            },
+        },
+        required: ["description", "prompt"],
+    },
+};
+/**
+ * Build and run a sub-agent. Returns the produced text or throws.
+ * Used by both the synchronous and background paths.
+ */
+async function runSubAgent(spawner, opts, 
+/**
+ * Optional sink for the user-visible `agent_start` / `agent_end` markers.
+ * Background path passes the parent's real onStream here; sync calls leave
+ * it undefined and we fall back to `spawner.parentStream`.
+ */
+uiStream, 
+/**
+ * Optional override for the spawned child Engine's per-event stream.
+ * Background path passes a transcriptSink here so per-event detail is
+ * captured into the agent's transcript rather than the main feed. Sync
+ * calls leave undefined; engine.ts falls back to `spawner.parentStream`
+ * (the parent UI), preserving the inline rendering of synchronous
+ * sub-agents.
+ */
+streamOverride) {
+    const { agentId, name, description } = opts;
+    const startEndSink = uiStream ?? spawner.parentStream;
+    safeEmit(startEndSink, { type: "agent_start", agentId, name, description });
+    // `resetPlanMode` / `restorePlanMode` operated on a module-level singleton
+    // that no longer exists. The child Engine is a fresh instance; plan-mode
+    // isolation between parent and child is enforced via separate Engine
+    // instances (finalized in T6).
+    const text = await spawner.spawn({ ...opts, streamOverride });
+    const finalText = text || `Agent completed but produced no text output.`;
+    safeEmit(startEndSink, { type: "agent_end", agentId, name, description, text: finalText });
+    return finalText;
+}
+export async function agentTool(args, ctx) {
+    const prompt = args.prompt;
+    const description = args.description || "sub-agent";
+    const rawName = args.name?.trim();
+    const name = rawName && rawName.length > 0 ? rawName : undefined;
+    if (!prompt)
+        return "Error: prompt is required";
+    if (!ctx?.subAgentSpawner) {
+        return "Error: Agent tool is not configured (no subAgentSpawner in ctx).";
+    }
+    // Belt-and-suspenders: the spawner already strips Agent / AgentStatus /
+    // AgentCancel from a child Engine's tool pool (see engine.ts spawn()), so
+    // a sub-agent's LLM should never see this tool. If it does call it anyway
+    // (registry regression, custom-tools injection, future refactor), refuse
+    // here — no grandchildren. Matches Claude Code's flat-hierarchy rule.
+    if (ctx.isSubAgent === true) {
+        return "Error: nested agents are not supported. Sub-agents cannot spawn their own sub-agents. Complete the task directly using your available tools.";
+    }
+    const spawner = ctx.subAgentSpawner;
+    const parentSignal = args.__signal;
+    if (parentSignal?.aborted) {
+        return "Agent aborted before starting.";
+    }
+    const maxTurns = args.max_turns || 15;
+    const runInBackground = args.run_in_background === true;
+    const agentId = nanoid(8);
+    const parentStream = spawner.parentStream;
+    // ─── Background path ───────────────────────────────────────────
+    // Register the agent, kick off execution detached from the current turn,
+    // return immediately with the agent_id. Parent abort does NOT cascade
+    // (background agents survive the spawning turn). Cancellation goes
+    // through AgentCancel(agent_id).
+    if (runInBackground) {
+        const controller = new AbortController();
+        asyncAgentRegistry.register({
+            agentId,
+            name,
+            description,
+            status: "running",
+            startedAt: Date.now(),
+            abort: () => controller.abort(),
+        });
+        // Translate this background agent's per-event stream into ChatEntry-
+        // shaped rows inside its own transcript. The dock detail view reuses
+        // App.renderEntry which only understands ChatEntry types — storing
+        // raw StreamEvents would render as blanks. The translator mirrors
+        // App.tsx#handleStreamEvent's reduction but is scoped to one agent
+        // (per-instance closure state), so it doesn't interleave with other
+        // agents.
+        //
+        // Sub-agent runs detached from the parent turn — the parent feed only
+        // sees the agent_start / agent_end markers via `parentStream` (the
+        // 4th arg to runSubAgent); per-event detail goes through the
+        // `streamOverride` (5th arg → SubAgentSpawnRequest.streamOverride →
+        // engine.ts spawn closure routes to it instead of the main UI).
+        const transcriptSink = createTranscriptTranslator(agentId);
+        void runSubAgent(spawner, {
+            agentId,
+            name,
+            description,
+            prompt,
+            maxTurns,
+            signal: controller.signal,
+        }, parentStream, // uiStream: agent_start/end → main feed
+        transcriptSink)
+            .then((text) => {
+            asyncAgentRegistry.markCompleted(agentId);
+            // B2 / Gate 1: attribute completion to the session that spawned
+            // this agent so concurrent sessions don't drain each other's
+            // notifications. Engine.run() always populates ctx.sessionId; the
+            // missing-session branch is only reachable from ad-hoc tool calls
+            // outside Engine.run() (notably tests) — we log and drop rather
+            // than crash the agent path.
+            if (ctx?.sessionId) {
+                notificationQueue.enqueue({
+                    agentId,
+                    name,
+                    description,
+                    status: "completed",
+                    finalText: text,
+                    enqueuedAt: Date.now(),
+                }, ctx.sessionId);
+            }
+            else {
+                logger.warn("agent_completion_without_session", {
+                    agentId,
+                    name,
+                    status: "completed",
+                });
+            }
+            // notification hook: fire-and-forget. ctx.hooks may be absent in
+            // legacy callers; treat as opt-in observability rather than a
+            // required publish step. We deliberately do not await — bg-agent
+            // bookkeeping should never block on a slow handler.
+            void ctx?.hooks?.emit("notification", {
+                kind: "agent_completed",
+                agentId,
+                name,
+                description,
+                finalText: text,
+            });
+        })
+            .catch((err) => {
+            if (controller.signal.aborted) {
+                // User-initiated cancel: mark status but do NOT enqueue —
+                // the main agent doesn't need a follow-up turn. Dock still
+                // shows the "cancelled" badge for the fade window.
+                asyncAgentRegistry.markCancelled(agentId);
+                void ctx?.hooks?.emit("notification", {
+                    kind: "agent_cancelled",
+                    agentId,
+                    name,
+                    description,
+                });
+                return;
+            }
+            asyncAgentRegistry.markFailed(agentId);
+            if (ctx?.sessionId) {
+                notificationQueue.enqueue({
+                    agentId,
+                    name,
+                    description,
+                    status: "failed",
+                    error: err.message,
+                    enqueuedAt: Date.now(),
+                }, ctx.sessionId);
+            }
+            else {
+                logger.warn("agent_completion_without_session", {
+                    agentId,
+                    name,
+                    status: "failed",
+                });
+            }
+            void ctx?.hooks?.emit("notification", {
+                kind: "agent_failed",
+                agentId,
+                name,
+                description,
+                error: err.message,
+            });
+        });
+        return [
+            `Async agent launched successfully.`,
+            `agent_id: ${agentId} (internal — do not show to user)`,
+            `description: ${description}`,
+            ``,
+            `The agent is working in the background. You will be notified automatically when it completes.`,
+            `Briefly tell the user what you launched and end your response. Do not generate any other text — agent results will arrive in a subsequent message.`,
+            `If you need to stop it: AgentCancel(agent_id="${agentId}").`,
+        ].join("\n");
+    }
+    // ─── Synchronous path ──────────────────────────────────────────
+    try {
+        return await runSubAgent(spawner, {
+            agentId,
+            name,
+            description,
+            prompt,
+            maxTurns,
+            signal: parentSignal ?? new AbortController().signal,
+        });
+    }
+    catch (err) {
+        safeEmit(parentStream, { type: "agent_end", agentId, name, description, error: err.message });
+        if (parentSignal?.aborted)
+            return "Agent was aborted.";
+        return `Agent error: ${err.message}`;
+    }
+}
+// ─── AgentStatus / AgentCancel — companions to run_in_background ─
+export const agentStatusToolDef = {
+    name: "AgentStatus",
+    description: "Check the status of a background agent launched with Agent(run_in_background=true). " +
+        "Returns running / completed / failed / cancelled, plus the result text once finished. " +
+        "Omit agent_id to list all background agents in this process.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            agent_id: {
+                type: "string",
+                description: "The agent_id returned by Agent(run_in_background=true). Omit to list all.",
+            },
+        },
+    },
+};
+export async function agentStatusTool(args) {
+    const agentId = args.agent_id;
+    if (!agentId) {
+        const all = asyncAgentRegistry.list();
+        if (all.length === 0)
+            return "No background agents in this process.";
+        return all
+            .map((e) => {
+            const dur = ((e.finishedAt ?? Date.now()) - e.startedAt) / 1000;
+            return `${e.agentId} [${e.status}] ${e.description} (${dur.toFixed(1)}s)`;
+        })
+            .join("\n");
+    }
+    const e = asyncAgentRegistry.get(agentId);
+    if (!e)
+        return `Error: agent_id "${agentId}" not found.`;
+    const dur = ((e.finishedAt ?? Date.now()) - e.startedAt) / 1000;
+    const lines = [
+        `agent_id: ${e.agentId}`,
+        `status:   ${e.status}`,
+        `description: ${e.description}`,
+        `duration: ${dur.toFixed(1)}s`,
+    ];
+    if (e.status === "completed") {
+        lines.push("", "(completed — result was delivered to the conversation when the agent finished)");
+    }
+    else if (e.status === "failed") {
+        lines.push("", "(failed — error was delivered to the conversation when the agent finished)");
+    }
+    else if (e.status === "cancelled") {
+        lines.push("", "(cancelled — no result delivered)");
+    }
+    else if (e.status === "running") {
+        lines.push("", "(still running — call AgentStatus again later)");
+    }
+    return lines.join("\n");
+}
+export const agentCancelToolDef = {
+    name: "AgentCancel",
+    description: "Cancel a background agent launched with Agent(run_in_background=true). " +
+        "The agent's current LLM call and any in-flight tools will be aborted.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            agent_id: {
+                type: "string",
+                description: "The agent_id to cancel.",
+            },
+        },
+        required: ["agent_id"],
+    },
+};
+export async function agentCancelTool(args) {
+    const agentId = args.agent_id;
+    if (!agentId)
+        return "Error: agent_id is required.";
+    const e = asyncAgentRegistry.get(agentId);
+    if (!e)
+        return `Error: agent_id "${agentId}" not found.`;
+    if (e.status !== "running") {
+        return `Agent ${agentId} is already ${e.status}; nothing to cancel.`;
+    }
+    const ok = asyncAgentRegistry.cancel(agentId);
+    return ok
+        ? `Agent ${agentId} cancelled.`
+        : `Failed to cancel agent ${agentId}.`;
+}

package/dist/tool-system/builtin/apply-patch/applier.d.ts

@@ -0,0 +1,26 @@
+import { Hunk } from "./types.js";
+export interface ApplyPatchOptions {
+    /** Working directory for resolving relative paths in the patch. */
+    cwd: string;
+    /**
+     * If true, skip the snapshot/rollback safety net and apply each planned
+     * change one at a time, leaving partial work on disk if a later write
+     * fails. Mostly useful for codex-parity testing. Default: false.
+     */
+    allowPartialOnCommit?: boolean;
+}
+export interface ApplyPatchResult {
+    added: string[];
+    modified: string[];
+    deleted: string[];
+}
+/**
+ * Plan and commit the patch atomically.
+ *
+ * Phase 1 (plan): walk every hunk, compute the resulting file content in
+ * memory. Throws if any hunk cannot be applied; nothing is written.
+ *
+ * Phase 2 (commit): write all planned changes. If any write fails, restore
+ * from the in-memory snapshot captured in phase 1 and rethrow.
+ */
+export declare function applyPatch(hunks: Hunk[], options: ApplyPatchOptions): Promise<ApplyPatchResult>;

package/dist/tool-system/builtin/apply-patch/applier.js

@@ -0,0 +1,250 @@
+// Atomic patch applier — dry-runs all hunks, then commits all-or-nothing.
+//
+// This deliberately diverges from codex-rs/apply-patch which applies hunks
+// one-by-one and leaves partial changes on disk if a later hunk fails (see
+// fixture 015_failure_after_partial_success_leaves_changes for codex's
+// behavior). We treat the patch as a transaction: either every hunk applies
+// or none do. Set `allowPartialOnCommit` to mimic codex semantics for the
+// rare case where you want it.
+//
+// Algorithm uses code adapted from codex-rs/apply-patch/src/lib.rs (Apache-2.0)
+// for the chunk-replacement phase (compute_replacements, apply_replacements).
+import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { seekSequence } from "./seek-sequence.js";
+/**
+ * Plan and commit the patch atomically.
+ *
+ * Phase 1 (plan): walk every hunk, compute the resulting file content in
+ * memory. Throws if any hunk cannot be applied; nothing is written.
+ *
+ * Phase 2 (commit): write all planned changes. If any write fails, restore
+ * from the in-memory snapshot captured in phase 1 and rethrow.
+ */
+export async function applyPatch(hunks, options) {
+    if (hunks.length === 0) {
+        throw new Error("No files were modified.");
+    }
+    const planned = await planHunks(hunks, options.cwd);
+    return commitPlanned(planned, !!options.allowPartialOnCommit);
+}
+async function planHunks(hunks, cwd) {
+    const set = {
+        byPath: new Map(),
+        added: [],
+        modified: [],
+        deleted: [],
+    };
+    function schedule(path, change) {
+        if (set.byPath.has(path)) {
+            throw new Error(`Patch references ${path} more than once. Combine the operations into a single hunk.`);
+        }
+        set.byPath.set(path, change);
+    }
+    for (const hunk of hunks) {
+        const original = hunk.path;
+        const sourcePath = resolveAgainst(original, cwd);
+        if (hunk.kind === "add") {
+            const existed = await readIfExists(sourcePath);
+            schedule(sourcePath, {
+                path: sourcePath,
+                newContent: hunk.contents,
+                originalContent: existed,
+            });
+            set.added.push(original);
+            continue;
+        }
+        if (hunk.kind === "delete") {
+            const stats = await safeStat(sourcePath);
+            if (!stats)
+                throw new Error(`Failed to delete file: ${sourcePath} not found`);
+            if (stats.isDirectory()) {
+                throw new Error(`Failed to delete file: ${sourcePath} is a directory`);
+            }
+            const content = await readFile(sourcePath, "utf-8");
+            schedule(sourcePath, {
+                path: sourcePath,
+                newContent: null,
+                originalContent: content,
+            });
+            set.deleted.push(original);
+            continue;
+        }
+        // Update (with optional rename).
+        const stats = await safeStat(sourcePath);
+        if (!stats) {
+            throw new Error(`Failed to update file: ${sourcePath} does not exist`);
+        }
+        const originalText = await readFile(sourcePath, "utf-8");
+        const newText = applyChunksToText(originalText, hunk.chunks, sourcePath);
+        if (hunk.movePath !== undefined) {
+            const destPath = resolveAgainst(hunk.movePath, cwd);
+            if (destPath === sourcePath) {
+                // Rename to self → degenerate update.
+                schedule(sourcePath, {
+                    path: sourcePath,
+                    newContent: newText,
+                    originalContent: originalText,
+                });
+            }
+            else {
+                const destOriginal = await readIfExists(destPath);
+                schedule(sourcePath, {
+                    path: sourcePath,
+                    newContent: null,
+                    originalContent: originalText,
+                });
+                schedule(destPath, {
+                    path: destPath,
+                    newContent: newText,
+                    originalContent: destOriginal,
+                });
+            }
+            set.modified.push(original);
+        }
+        else {
+            schedule(sourcePath, {
+                path: sourcePath,
+                newContent: newText,
+                originalContent: originalText,
+            });
+            set.modified.push(original);
+        }
+    }
+    return set;
+}
+/** Apply the chunk list to a file's text and return the new text. */
+function applyChunksToText(original, chunks, pathForError) {
+    // split('\n') leaves an empty trailing element when the file ends with \n;
+    // drop it so line indices match standard diff semantics. We re-add the
+    // trailing newline at the end.
+    const lines = original.split("\n");
+    if (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    // Each replacement: [startIndex, oldLen, newLines]
+    const replacements = [];
+    let lineIndex = 0;
+    for (const chunk of chunks) {
+        if (chunk.changeContext !== undefined) {
+            const found = seekSequence(lines, [chunk.changeContext], lineIndex, false);
+            if (found === null) {
+                throw new Error(`Failed to find context '${chunk.changeContext}' in ${pathForError}`);
+            }
+            lineIndex = found + 1;
+        }
+        if (chunk.oldLines.length === 0) {
+            // Pure addition — append at end. Mirrors codex behavior: even when the
+            // chunk has a `@@ <context>` anchor, pure additions are inserted at
+            // EOF rather than near the anchor. Models should include at least one
+            // `-` or ` ` line if they want positional insertion.
+            const insertionIdx = lines.length > 0 && lines[lines.length - 1] === ""
+                ? lines.length - 1
+                : lines.length;
+            replacements.push([insertionIdx, 0, [...chunk.newLines]]);
+            continue;
+        }
+        let pattern = chunk.oldLines;
+        let newSlice = chunk.newLines;
+        let found = seekSequence(lines, pattern, lineIndex, chunk.isEndOfFile);
+        if (found === null && pattern.length > 0 && pattern[pattern.length - 1] === "") {
+            // Retry without trailing empty sentinel that represents the file's final newline.
+            pattern = pattern.slice(0, -1);
+            if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "") {
+                newSlice = newSlice.slice(0, -1);
+            }
+            found = seekSequence(lines, pattern, lineIndex, chunk.isEndOfFile);
+        }
+        if (found === null) {
+            throw new Error(`Failed to find expected lines in ${pathForError}:\n${chunk.oldLines.join("\n")}`);
+        }
+        replacements.push([found, pattern.length, [...newSlice]]);
+        lineIndex = found + pattern.length;
+    }
+    // Apply in descending start-index order so indices stay valid.
+    replacements.sort((a, b) => a[0] - b[0]);
+    const working = lines.slice();
+    for (let i = replacements.length - 1; i >= 0; i--) {
+        const [start, oldLen, newSeg] = replacements[i];
+        working.splice(start, oldLen, ...newSeg);
+    }
+    // Always end with a trailing newline.
+    if (working.length === 0 || working[working.length - 1] !== "") {
+        working.push("");
+    }
+    return working.join("\n");
+}
+// ─── Phase 2: commit ──────────────────────────────────────────────
+async function commitPlanned(set, allowPartial) {
+    // Iterate insertion order (Map iteration is spec-guaranteed).
+    const ordered = [...set.byPath.values()];
+    if (allowPartial) {
+        for (const change of ordered) {
+            await writeChange(change);
+        }
+        return { added: set.added, modified: set.modified, deleted: set.deleted };
+    }
+    // Track which writes have completed so rollback only touches them. We use
+    // the originalContent captured during plan() rather than re-reading from
+    // disk — this avoids a TOCTOU window between planning and committing.
+    const committed = [];
+    try {
+        for (const change of ordered) {
+            await writeChange(change);
+            committed.push(change);
+        }
+    }
+    catch (err) {
+        for (let i = committed.length - 1; i >= 0; i--) {
+            const c = committed[i];
+            try {
+                if (c.originalContent === null) {
+                    // File did not exist before we wrote it — remove our write.
+                    if (existsSync(c.path))
+                        await unlink(c.path);
+                }
+                else {
+                    await writeFile(c.path, c.originalContent, "utf-8");
+                }
+            }
+            catch {
+                // Best-effort restore — surface the original error to the caller.
+            }
+        }
+        throw err;
+    }
+    return { added: set.added, modified: set.modified, deleted: set.deleted };
+}
+async function writeChange(change) {
+    if (change.newContent === null) {
+        if (existsSync(change.path))
+            await unlink(change.path);
+        return;
+    }
+    const parent = dirname(change.path);
+    if (!existsSync(parent)) {
+        await mkdir(parent, { recursive: true });
+    }
+    await writeFile(change.path, change.newContent, "utf-8");
+}
+// ─── helpers ──────────────────────────────────────────────────────
+function resolveAgainst(p, cwd) {
+    return isAbsolute(p) ? p : resolve(cwd, p);
+}
+async function safeStat(path) {
+    try {
+        return await stat(path);
+    }
+    catch {
+        return null;
+    }
+}
+async function readIfExists(path) {
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tool-system/builtin/apply-patch/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ApplyPatch tool — atomic, multi-file V4A patch application.
+ *
+ * Adapted from openai/codex codex-rs/apply-patch (Apache-2.0). See LICENSE-codex.
+ *
+ * Compared to Codex's reference implementation:
+ *   - We dry-run all hunks first; nothing is written until every hunk
+ *     successfully resolves.
+ *   - On commit we snapshot every target file, so a write failure rolls back
+ *     to the pre-patch state instead of leaving partial changes.
+ *
+ * Compared to CodeShell's existing Edit:
+ *   - Multi-file in one call (cuts LLM round-trips for large changes).
+ *   - Supports create / update / delete / rename in one transaction.
+ *   - Context-anchor matching tolerates whitespace and Unicode quirks.
+ */
+import type { ToolDefinition } from "../../../types.js";
+import type { ToolContext } from "../../context.js";
+export declare const applyPatchToolDef: ToolDefinition;
+export declare function applyPatchTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;