wave-agent-sdk 0.4.0 → 0.5.1

package/dist/tools/bashTool.js

@@ -1,7 +1,7 @@
 import { spawn } from "child_process";
 import { logger } from "../utils/globalLogger.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
-import { BASH_TOOL_NAME, BASH_OUTPUT_TOOL_NAME, KILL_BASH_TOOL_NAME, GLOB_TOOL_NAME, GREP_TOOL_NAME, READ_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, } from "../constants/tools.js";
+import { BASH_TOOL_NAME, TASK_OUTPUT_TOOL_NAME, GLOB_TOOL_NAME, GREP_TOOL_NAME, READ_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, } from "../constants/tools.js";
 const MAX_OUTPUT_LENGTH = 30000;
 const BASH_DEFAULT_TIMEOUT_MS = 120000;
 /**
@@ -76,7 +76,7 @@ Usage notes:
                     },
                     run_in_background: {
                         type: "boolean",
-                        description: `Set to true to run this command in the background. Use ${BASH_OUTPUT_TOOL_NAME} to read the output later.`,
+                        description: `Set to true to run this command in the background. Use ${TASK_OUTPUT_TOOL_NAME} to read the output later.`,
                     },
                 },
                 required: ["command"],
@@ -135,19 +135,19 @@ Usage notes:
         }
         if (runInBackground) {
             // Background execution
-            const backgroundBashManager = context?.backgroundBashManager;
-            if (!backgroundBashManager) {
+            const backgroundTaskManager = context?.backgroundTaskManager;
+            if (!backgroundTaskManager) {
                 return {
                     success: false,
                     content: "",
-                    error: "Background bash manager not available",
+                    error: "Background task manager not available",
                 };
             }
-            const shellId = backgroundBashManager.startShell(command, timeout);
+            const { id: taskId } = backgroundTaskManager.startShell(command, timeout);
             return {
                 success: true,
-                content: `Command started in background with ID: ${shellId}. Use ${BASH_OUTPUT_TOOL_NAME} tool with bash_id="${shellId}" to monitor output.`,
-                shortResult: `Background process ${shellId} started`,
+                content: `Command started in background with ID: ${taskId}. Use TaskOutput tool with task_id="${taskId}" to monitor output.`,
+                shortResult: `Background process ${taskId} started`,
             };
         }
         // Foreground execution (original behavior)
@@ -163,6 +163,32 @@ Usage notes:
             let outputBuffer = "";
             let errorBuffer = "";
             let isAborted = false;
+            let isBackgrounded = false;
+            const foregroundTaskId = `bash_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            // Register as foreground task
+            if (context.foregroundTaskManager && command) {
+                context.foregroundTaskManager.registerForegroundTask({
+                    id: foregroundTaskId,
+                    backgroundHandler: async () => {
+                        isBackgrounded = true;
+                        if (timeoutHandle) {
+                            clearTimeout(timeoutHandle);
+                        }
+                        const backgroundTaskManager = context.backgroundTaskManager;
+                        if (backgroundTaskManager) {
+                            const taskId = backgroundTaskManager.adoptProcess(child, command, outputBuffer, errorBuffer);
+                            resolve({
+                                success: true,
+                                content: `Command moved to background with ID: ${taskId}. Use TaskOutput tool with task_id="${taskId}" to monitor output.`,
+                                shortResult: `Process ${taskId} backgrounded`,
+                            });
+                        }
+                        else {
+                            handleAbort("Failed to background: Background task manager not available");
+                        }
+                    },
+                });
+            }
             // Set up timeout
             let timeoutHandle;
             if (timeout && timeout > 0) {
@@ -230,17 +256,20 @@ Usage notes:
                 });
             }
             child.stdout?.on("data", (data) => {
-                if (!isAborted) {
+                if (!isAborted && !isBackgrounded) {
                     outputBuffer += stripAnsiColors(data.toString());
                 }
             });
             child.stderr?.on("data", (data) => {
-                if (!isAborted) {
+                if (!isAborted && !isBackgrounded) {
                     errorBuffer += stripAnsiColors(data.toString());
                 }
             });
             child.on("exit", (code) => {
-                if (!isAborted) {
+                if (context.foregroundTaskManager) {
+                    context.foregroundTaskManager.unregisterForegroundTask(foregroundTaskId);
+                }
+                if (!isAborted && !isBackgrounded) {
                     if (timeoutHandle) {
                         clearTimeout(timeoutHandle);
                     }
@@ -262,7 +291,10 @@ Usage notes:
                 }
             });
             child.on("error", (error) => {
-                if (!isAborted) {
+                if (context.foregroundTaskManager) {
+                    context.foregroundTaskManager.unregisterForegroundTask(foregroundTaskId);
+                }
+                if (!isAborted && !isBackgrounded) {
                     if (timeoutHandle) {
                         clearTimeout(timeoutHandle);
                     }
@@ -285,163 +317,3 @@ Usage notes:
         return `${command}${runInBackground ? " (background)" : ""}`;
     },
 };
-/**
- * BashOutput tool - retrieves output from background bash shells
- */
-export const bashOutputTool = {
-    name: BASH_OUTPUT_TOOL_NAME,
-    config: {
-        type: "function",
-        function: {
-            name: BASH_OUTPUT_TOOL_NAME,
-            description: "Retrieves output from a running or completed background bash shell",
-            parameters: {
-                type: "object",
-                properties: {
-                    bash_id: {
-                        type: "string",
-                        description: "The ID of the background shell to retrieve output from",
-                    },
-                    filter: {
-                        type: "string",
-                        description: "Optional regular expression to filter the output lines. Only lines matching this regex will be included in the result. Any lines that do not match will no longer be available to read.",
-                    },
-                },
-                required: ["bash_id"],
-            },
-        },
-    },
-    execute: async (args, context) => {
-        const bashId = args.bash_id;
-        const filter = args.filter;
-        if (!bashId || typeof bashId !== "string") {
-            return {
-                success: false,
-                content: "",
-                error: "bash_id parameter is required and must be a string",
-            };
-        }
-        const backgroundBashManager = context?.backgroundBashManager;
-        if (!backgroundBashManager) {
-            return {
-                success: false,
-                content: "",
-                error: "Background bash manager not available",
-            };
-        }
-        const output = backgroundBashManager.getOutput(bashId, filter);
-        if (!output) {
-            return {
-                success: false,
-                content: "",
-                error: `Background shell with ID ${bashId} not found`,
-            };
-        }
-        const shell = backgroundBashManager.getShell(bashId);
-        if (!shell) {
-            return {
-                success: false,
-                content: "",
-                error: `Background shell with ID ${bashId} not found`,
-            };
-        }
-        let content = "";
-        if (output.stdout) {
-            content += stripAnsiColors(output.stdout);
-        }
-        if (output.stderr) {
-            content += (content ? "\n" : "") + stripAnsiColors(output.stderr);
-        }
-        const finalContent = content || "No output available";
-        const processedContent = finalContent.length > MAX_OUTPUT_LENGTH
-            ? finalContent.substring(0, MAX_OUTPUT_LENGTH) +
-                "\n\n... (output truncated)"
-            : finalContent;
-        return {
-            success: true,
-            content: processedContent,
-            shortResult: `${bashId}: ${output.status}${shell.exitCode !== undefined ? ` (${shell.exitCode})` : ""}`,
-            error: undefined,
-        };
-    },
-    formatCompactParams: (params) => {
-        const bashId = params.bash_id;
-        const filter = params.filter;
-        return filter ? `${bashId} filtered: ${filter}` : bashId;
-    },
-};
-/**
- * KillBash tool - kills a running background bash shell
- */
-export const killBashTool = {
-    name: KILL_BASH_TOOL_NAME,
-    config: {
-        type: "function",
-        function: {
-            name: KILL_BASH_TOOL_NAME,
-            description: "Kills a running background bash shell by its ID",
-            parameters: {
-                type: "object",
-                properties: {
-                    shell_id: {
-                        type: "string",
-                        description: "The ID of the background shell to kill",
-                    },
-                },
-                required: ["shell_id"],
-            },
-        },
-    },
-    execute: async (args, context) => {
-        const shellId = args.shell_id;
-        if (!shellId || typeof shellId !== "string") {
-            return {
-                success: false,
-                content: "",
-                error: "shell_id parameter is required and must be a string",
-            };
-        }
-        const backgroundBashManager = context?.backgroundBashManager;
-        if (!backgroundBashManager) {
-            return {
-                success: false,
-                content: "",
-                error: "Background bash manager not available",
-            };
-        }
-        const shell = backgroundBashManager.getShell(shellId);
-        if (!shell) {
-            return {
-                success: false,
-                content: "",
-                error: `Background shell with ID ${shellId} not found`,
-            };
-        }
-        if (shell.status !== "running") {
-            return {
-                success: false,
-                content: "",
-                error: `Background shell ${shellId} is not running (status: ${shell.status})`,
-            };
-        }
-        const killed = backgroundBashManager.killShell(shellId);
-        if (killed) {
-            return {
-                success: true,
-                content: `Background shell ${shellId} has been killed`,
-                shortResult: `Killed ${shellId}`,
-            };
-        }
-        else {
-            return {
-                success: false,
-                content: "",
-                error: `Failed to kill background shell ${shellId}`,
-            };
-        }
-    },
-    formatCompactParams: (params) => {
-        const shellId = params.shell_id;
-        return shellId;
-    },
-};

package/dist/tools/editTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editTool.d.ts","sourceRoot":"","sources":["../../src/tools/editTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAoBtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UAwNtB,CAAC"}
+{"version":3,"file":"editTool.d.ts","sourceRoot":"","sources":["../../src/tools/editTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAgBtE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UAiNtB,CAAC"}

package/dist/tools/editTool.js

@@ -1,7 +1,7 @@
 import { readFile, writeFile } from "fs/promises";
 import { logger } from "../utils/globalLogger.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
-import { findIndentationInsensitiveMatch, escapeRegExp, saveEditErrorSnapshot, } from "../utils/editUtils.js";
+import { escapeRegExp, analyzeEditMismatch } from "../utils/editUtils.js";
 import { EDIT_TOOL_NAME, READ_TOOL_NAME } from "../constants/tools.js";
 /**
  * Format compact parameter display
@@ -95,14 +95,15 @@ export const editTool = {
                     error: `Failed to read file: ${readError instanceof Error ? readError.message : String(readError)}`,
                 };
             }
-            // Check if old_string exists (with smart indentation matching)
-            const matchedOldString = findIndentationInsensitiveMatch(originalContent, oldString);
+            // Check if old_string exists
+            const matchedOldString = originalContent.includes(oldString)
+                ? oldString
+                : null;
             if (!matchedOldString) {
-                await saveEditErrorSnapshot(resolvedPath, oldString, originalContent, EDIT_TOOL_NAME);
                 return {
                     success: false,
                     content: "",
-                    error: `old_string not found in file`,
+                    error: analyzeEditMismatch(originalContent, oldString),
                 };
             }
             let newContent;

package/dist/tools/multiEditTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiEditTool.d.ts","sourceRoot":"","sources":["../../src/tools/multiEditTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAiCtE;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,UAsR3B,CAAC"}
+{"version":3,"file":"multiEditTool.d.ts","sourceRoot":"","sources":["../../src/tools/multiEditTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AA6BtE;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,UA+Q3B,CAAC"}

package/dist/tools/multiEditTool.js

@@ -1,7 +1,7 @@
 import { readFile, writeFile } from "fs/promises";
 import { logger } from "../utils/globalLogger.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
-import { findIndentationInsensitiveMatch, escapeRegExp, saveEditErrorSnapshot, } from "../utils/editUtils.js";
+import { escapeRegExp, analyzeEditMismatch } from "../utils/editUtils.js";
 import { MULTI_EDIT_TOOL_NAME, EDIT_TOOL_NAME, READ_TOOL_NAME, } from "../constants/tools.js";
 /**
  * Format compact parameter display
@@ -147,20 +147,21 @@ export const multiEditTool = {
                     appliedEdits.push(`Created file with content (${edit.new_string.length} characters)`);
                     continue;
                 }
-                // Check if old_string exists (with smart indentation matching)
-                const matchedOldString = findIndentationInsensitiveMatch(currentContent, edit.old_string);
+                // Check if old_string exists
+                const matchedOldString = currentContent.includes(edit.old_string)
+                    ? edit.old_string
+                    : null;
                 if (!matchedOldString) {
-                    await saveEditErrorSnapshot(resolvedPath, edit.old_string, currentContent, MULTI_EDIT_TOOL_NAME);
                     return {
                         success: false,
                         content: "",
-                        error: `Edit operation ${i + 1}: old_string not found in current content`,
+                        error: `Edit operation ${i + 1}: ${analyzeEditMismatch(currentContent, edit.old_string)}`,
                     };
                 }
                 let replacementCount;
                 if (replaceAll) {
                     // Replace all matches
-                    const regex = new RegExp(escapeRegExp(matchedOldString), "g");
+                    const regex = new RegExp(escapeRegExp(edit.old_string), "g");
                     currentContent = currentContent.replace(regex, edit.new_string);
                     replacementCount = (currentContent.match(regex) || []).length;
                     appliedEdits.push(`Replaced ${replacementCount} instances of "${edit.old_string.substring(0, 50)}${edit.old_string.length > 50 ? "..." : ""}"`);

package/dist/tools/taskOutputTool.d.ts

@@ -0,0 +1,3 @@
+import { ToolPlugin } from "./types.js";
+export declare const taskOutputTool: ToolPlugin;
+//# sourceMappingURL=taskOutputTool.d.ts.map

package/dist/tools/taskOutputTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskOutputTool.d.ts","sourceRoot":"","sources":["../../src/tools/taskOutputTool.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,UAAU,EAAc,MAAM,YAAY,CAAC;AAKjE,eAAO,MAAM,cAAc,EAAE,UAuK5B,CAAC"}

package/dist/tools/taskOutputTool.js

@@ -0,0 +1,149 @@
+import { TASK_OUTPUT_TOOL_NAME } from "../constants/tools.js";
+import { stripAnsiColors } from "../utils/stringUtils.js";
+const MAX_OUTPUT_LENGTH = 30000;
+export const taskOutputTool = {
+    name: TASK_OUTPUT_TOOL_NAME,
+    config: {
+        type: "function",
+        function: {
+            name: TASK_OUTPUT_TOOL_NAME,
+            description: "Retrieves output from a running or completed background task",
+            parameters: {
+                type: "object",
+                properties: {
+                    task_id: {
+                        type: "string",
+                        description: "The ID of the background task to retrieve output from",
+                    },
+                    filter: {
+                        type: "string",
+                        description: "Optional regular expression to filter the output lines.",
+                    },
+                    block: {
+                        type: "boolean",
+                        description: "If true, wait for the task to complete before returning output. If false, return current output immediately.",
+                    },
+                },
+                required: ["task_id"],
+            },
+        },
+    },
+    execute: async (args, context) => {
+        const taskId = args.task_id;
+        const filter = args.filter;
+        const block = args.block;
+        if (!taskId || typeof taskId !== "string") {
+            return {
+                success: false,
+                content: "",
+                error: "task_id parameter is required and must be a string",
+            };
+        }
+        const backgroundTaskManager = context?.backgroundTaskManager;
+        if (!backgroundTaskManager) {
+            return {
+                success: false,
+                content: "",
+                error: "Background task manager not available",
+            };
+        }
+        const getResult = () => {
+            const output = backgroundTaskManager.getOutput(taskId, filter);
+            if (!output)
+                return null;
+            let content = "";
+            if (output.stdout) {
+                content += stripAnsiColors(output.stdout);
+            }
+            if (output.stderr) {
+                content += (content ? "\n" : "") + stripAnsiColors(output.stderr);
+            }
+            const finalContent = content || "No output available";
+            const processedContent = finalContent.length > MAX_OUTPUT_LENGTH
+                ? finalContent.substring(0, MAX_OUTPUT_LENGTH) +
+                    "\n\n... (output truncated)"
+                : finalContent;
+            return {
+                success: true,
+                content: processedContent,
+                shortResult: `${taskId}: ${output.status}`,
+            };
+        };
+        if (block) {
+            // Polling for completion
+            return new Promise((resolve) => {
+                let timeoutHandle = null;
+                let isAborted = false;
+                const cleanup = () => {
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                        timeoutHandle = null;
+                    }
+                };
+                const onAbort = () => {
+                    isAborted = true;
+                    cleanup();
+                    resolve({
+                        success: false,
+                        content: "",
+                        error: "Task output retrieval was aborted",
+                    });
+                };
+                if (context.abortSignal) {
+                    if (context.abortSignal.aborted) {
+                        onAbort();
+                        return;
+                    }
+                    context.abortSignal.addEventListener("abort", onAbort, {
+                        once: true,
+                    });
+                }
+                const check = () => {
+                    if (isAborted)
+                        return;
+                    const task = backgroundTaskManager.getTask(taskId);
+                    if (!task) {
+                        if (context.abortSignal) {
+                            context.abortSignal.removeEventListener("abort", onAbort);
+                        }
+                        resolve({
+                            success: false,
+                            content: "",
+                            error: `Task with ID ${taskId} not found`,
+                        });
+                        return;
+                    }
+                    if (task.status !== "running") {
+                        if (context.abortSignal) {
+                            context.abortSignal.removeEventListener("abort", onAbort);
+                        }
+                        const result = getResult();
+                        resolve(result || {
+                            success: false,
+                            content: "",
+                            error: "Task not found",
+                        });
+                    }
+                    else {
+                        timeoutHandle = setTimeout(check, 500);
+                    }
+                };
+                check();
+            });
+        }
+        const result = getResult();
+        if (!result) {
+            return {
+                success: false,
+                content: "",
+                error: `Task with ID ${taskId} not found`,
+            };
+        }
+        return result;
+    },
+    formatCompactParams: (params) => {
+        const taskId = params.task_id;
+        const block = params.block;
+        return `${taskId}${block ? " (blocking)" : ""}`;
+    },
+};

package/dist/tools/taskStopTool.d.ts

@@ -0,0 +1,3 @@
+import { ToolPlugin } from "./types.js";
+export declare const taskStopTool: ToolPlugin;
+//# sourceMappingURL=taskStopTool.d.ts.map

package/dist/tools/taskStopTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskStopTool.d.ts","sourceRoot":"","sources":["../../src/tools/taskStopTool.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,UAAU,EAAc,MAAM,YAAY,CAAC;AAEjE,eAAO,MAAM,YAAY,EAAE,UAoE1B,CAAC"}

package/dist/tools/taskStopTool.js

@@ -0,0 +1,65 @@
+import { TASK_STOP_TOOL_NAME } from "../constants/tools.js";
+export const taskStopTool = {
+    name: TASK_STOP_TOOL_NAME,
+    config: {
+        type: "function",
+        function: {
+            name: TASK_STOP_TOOL_NAME,
+            description: "Stops a running background task",
+            parameters: {
+                type: "object",
+                properties: {
+                    task_id: {
+                        type: "string",
+                        description: "The ID of the background task to stop",
+                    },
+                },
+                required: ["task_id"],
+            },
+        },
+    },
+    execute: async (args, context) => {
+        const taskId = args.task_id;
+        if (!taskId || typeof taskId !== "string") {
+            return {
+                success: false,
+                content: "",
+                error: "task_id parameter is required and must be a string",
+            };
+        }
+        const backgroundTaskManager = context?.backgroundTaskManager;
+        if (!backgroundTaskManager) {
+            return {
+                success: false,
+                content: "",
+                error: "Background task manager not available",
+            };
+        }
+        const stopped = backgroundTaskManager.stopTask(taskId);
+        if (stopped) {
+            return {
+                success: true,
+                content: `Task ${taskId} has been stopped`,
+                shortResult: `Stopped ${taskId}`,
+            };
+        }
+        else {
+            const task = backgroundTaskManager.getTask(taskId);
+            if (!task) {
+                return {
+                    success: false,
+                    content: "",
+                    error: `Task with ID ${taskId} not found`,
+                };
+            }
+            return {
+                success: false,
+                content: "",
+                error: `Failed to stop task ${taskId} (status: ${task.status})`,
+            };
+        }
+    },
+    formatCompactParams: (params) => {
+        return params.task_id;
+    },
+};

package/dist/tools/taskTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taskTool.d.ts","sourceRoot":"","sources":["../../src/tools/taskTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAGtE;;;GAGG;AACH,wBAAgB,cAAc,CAAC,eAAe,EAAE,eAAe,GAAG,UAAU,CAqI3E"}
+{"version":3,"file":"taskTool.d.ts","sourceRoot":"","sources":["../../src/tools/taskTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAGtE;;;GAGG;AACH,wBAAgB,cAAc,CAAC,eAAe,EAAE,eAAe,GAAG,UAAU,CA6L3E"}