wave-agent-sdk 0.4.0 → 0.5.1

package/src/tools/taskTool.ts

@@ -46,6 +46,11 @@ export function createTaskTool(subagentManager: SubagentManager): ToolPlugin {
                 type: "string",
                 description: `The type or name of subagent to use. Available options: ${availableSubagents.map((c) => c.name).join(", ") || "none"}`,
               },
+              run_in_background: {
+                type: "boolean",
+                description:
+                  "Set to true to run this command in the background. Use TaskOutput to read the output later.",
+              },
             },
             required: ["description", "prompt", "subagent_type"],
           },
@@ -57,80 +62,131 @@ export function createTaskTool(subagentManager: SubagentManager): ToolPlugin {
       args: Record<string, unknown>,
       context: ToolContext,
     ): Promise<ToolResult> => {
-      // Input validation
-      const description = args.description as string;
-      const prompt = args.prompt as string;
-      const subagent_type = args.subagent_type as string;
-
-      if (!description || typeof description !== "string") {
-        return {
-          success: false,
-          content: "",
-          error: "description parameter is required and must be a string",
-          shortResult: "Task delegation failed",
-        };
-      }
-
-      if (!prompt || typeof prompt !== "string") {
-        return {
-          success: false,
-          content: "",
-          error: "prompt parameter is required and must be a string",
-          shortResult: "Task delegation failed",
-        };
-      }
-
-      if (!subagent_type || typeof subagent_type !== "string") {
-        return {
-          success: false,
-          content: "",
-          error: "subagent_type parameter is required and must be a string",
-          shortResult: "Task delegation failed",
-        };
-      }
-
-      try {
-        // Subagent selection logic with explicit name matching only
-        const configuration = await subagentManager.findSubagent(subagent_type);
-
-        if (!configuration) {
-          // Error handling for nonexistent subagents with available subagents listing
-          const allConfigs = subagentManager.getConfigurations();
-          const availableNames = allConfigs.map((c) => c.name).join(", ");
-
-          return {
-            success: false,
-            content: "",
-            error: `No subagent found matching "${subagent_type}". Available subagents: ${availableNames || "none"}`,
-            shortResult: "Subagent not found",
-          };
-        }
-
-        // Create subagent instance and execute task
-        const instance = await subagentManager.createInstance(configuration, {
-          description,
-          prompt,
-          subagent_type,
-        });
-        const response = await subagentManager.executeTask(
-          instance,
-          prompt,
-          context.abortSignal,
-        );
-
-        return {
-          success: true,
-          content: response,
-          shortResult: `Task completed by ${configuration.name}`,
-        };
-      } catch (error) {
-        return {
-          success: false,
-          content: "",
-          error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
-          shortResult: "Delegation error",
-        };
-      }
+      return new Promise((resolve) => {
+        (async () => {
+          // Input validation
+          const description = args.description as string;
+          const prompt = args.prompt as string;
+          const subagent_type = args.subagent_type as string;
+          const run_in_background = args.run_in_background as boolean;
+
+          if (!description || typeof description !== "string") {
+            return resolve({
+              success: false,
+              content: "",
+              error: "description parameter is required and must be a string",
+              shortResult: "Task delegation failed",
+            });
+          }
+
+          if (!prompt || typeof prompt !== "string") {
+            return resolve({
+              success: false,
+              content: "",
+              error: "prompt parameter is required and must be a string",
+              shortResult: "Task delegation failed",
+            });
+          }
+
+          if (!subagent_type || typeof subagent_type !== "string") {
+            return resolve({
+              success: false,
+              content: "",
+              error: "subagent_type parameter is required and must be a string",
+              shortResult: "Task delegation failed",
+            });
+          }
+
+          try {
+            // Subagent selection logic with explicit name matching only
+            const configuration =
+              await subagentManager.findSubagent(subagent_type);
+
+            if (!configuration) {
+              // Error handling for nonexistent subagents with available subagents listing
+              const allConfigs = subagentManager.getConfigurations();
+              const availableNames = allConfigs.map((c) => c.name).join(", ");
+
+              return resolve({
+                success: false,
+                content: "",
+                error: `No subagent found matching "${subagent_type}". Available subagents: ${availableNames || "none"}`,
+                shortResult: "Subagent not found",
+              });
+            }
+
+            // Create subagent instance and execute task
+            const instance = await subagentManager.createInstance(
+              configuration,
+              {
+                description,
+                prompt,
+                subagent_type,
+              },
+              run_in_background,
+            );
+
+            let isBackgrounded = false;
+
+            // Register for backgrounding if not already in background
+            if (!run_in_background && context.foregroundTaskManager) {
+              context.foregroundTaskManager.registerForegroundTask({
+                id: instance.subagentId,
+                backgroundHandler: async () => {
+                  isBackgrounded = true;
+                  const taskId = await subagentManager.backgroundInstance(
+                    instance.subagentId,
+                  );
+                  // Resolve the tool execution early so the main agent can continue
+                  resolve({
+                    success: true,
+                    content: `Task moved to background with ID: ${taskId}. Use TaskOutput to monitor progress.`,
+                    shortResult: "Task backgrounded",
+                  });
+                },
+              });
+            }
+
+            try {
+              const result = await subagentManager.executeTask(
+                instance,
+                prompt,
+                context.abortSignal,
+                run_in_background,
+              );
+
+              if (isBackgrounded) return;
+
+              if (run_in_background) {
+                return resolve({
+                  success: true,
+                  content: `Task started in background with ID: ${result}`,
+                  shortResult: `Task started in background: ${result}`,
+                });
+              }
+
+              return resolve({
+                success: true,
+                content: result,
+                shortResult: `Task completed by ${configuration.name}`,
+              });
+            } finally {
+              if (!run_in_background && context.foregroundTaskManager) {
+                context.foregroundTaskManager.unregisterForegroundTask(
+                  instance.subagentId,
+                );
+              }
+            }
+          } catch (error) {
+            return resolve({
+              success: false,
+              content: "",
+              error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
+              shortResult: "Delegation error",
+            });
+          }
+        })();
+      });
     },
 
     formatCompactParams: (params: Record<string, unknown>) => {

package/src/tools/types.ts

@@ -39,6 +39,7 @@ export interface ToolResult {
 export interface ToolContext {
   abortSignal?: AbortSignal;
   backgroundBashManager?: import("../managers/backgroundBashManager.js").BackgroundBashManager;
+  backgroundTaskManager?: import("../managers/backgroundTaskManager.js").BackgroundTaskManager;
   workdir: string;
   /** Permission mode for this tool execution */
   permissionMode?: PermissionMode;
@@ -54,4 +55,6 @@ export interface ToolContext {
   reversionManager?: import("../managers/reversionManager.js").ReversionManager;
   /** Current message ID for associating snapshots */
   messageId?: string;
+  /** Foreground task manager for backgrounding tasks */
+  foregroundTaskManager?: import("../types/processes.js").IForegroundTaskManager;
 }

package/src/types/marketplace.ts

@@ -49,6 +49,7 @@ export interface InstalledPlugin {
   version: string;
   cachePath: string;
   scope?: Scope;
+  projectPath?: string;
 }
 
 export interface InstalledPluginsRegistry {

package/src/types/messaging.ts

@@ -103,6 +103,7 @@ export interface SubagentBlock {
   status: "active" | "completed" | "error" | "aborted";
   sessionId: string;
   configuration: SubagentConfiguration;
+  runInBackground?: boolean;
 }
 
 export interface ReasoningBlock {

package/src/types/processes.ts

@@ -5,14 +5,43 @@
 
 import type { ChildProcess } from "child_process";
 
-export interface BackgroundShell {
+export type BackgroundTaskStatus =
+  | "running"
+  | "completed"
+  | "failed"
+  | "killed";
+export type BackgroundTaskType = "shell" | "subagent";
+
+export interface BackgroundTask {
   id: string;
-  process: ChildProcess;
-  command: string;
+  type: BackgroundTaskType;
+  status: BackgroundTaskStatus;
   startTime: number;
-  status: "running" | "completed" | "killed";
+  endTime?: number;
+  command?: string; // for shell
+  description?: string; // for subagent
   stdout: string;
   stderr: string;
   exitCode?: number;
   runtime?: number;
 }
+
+export interface BackgroundShell extends BackgroundTask {
+  type: "shell";
+  process: ChildProcess;
+}
+
+export interface ForegroundTask {
+  id: string;
+  backgroundHandler: () => Promise<void>;
+}
+
+export interface IForegroundTaskManager {
+  registerForegroundTask(task: ForegroundTask): void;
+  unregisterForegroundTask(id: string): void;
+}
+
+export interface IForegroundTaskManager {
+  registerForegroundTask(task: ForegroundTask): void;
+  unregisterForegroundTask(id: string): void;
+}

package/src/utils/editUtils.ts

@@ -1,128 +1,90 @@
-import { mkdir, writeFile } from "fs/promises";
-import path from "path";
-import os from "os";
-import { logger } from "./globalLogger.js";
-
 /**
  * Utility functions for file editing tools
  */
 
 /**
- * Find a match in content that is identical to searchString except for a consistent indentation offset.
- *
- * Priority:
- * 1. If exact matches exist, returns searchString (letting the tool handle uniqueness/replaceAll).
- * 2. If no exact match, but exactly one unique indentation-insensitive match exists, returns that match.
- * 3. Otherwise returns null.
+ * Escape regular expression special characters
+ */
+export function escapeRegExp(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Analyze why an edit failed by finding the best partial match and highlighting mismatches.
  */
-export function findIndentationInsensitiveMatch(
+export function analyzeEditMismatch(
   content: string,
   searchString: string,
-): string | null {
-  // 1. If exact match exists, return it
-  if (content.includes(searchString)) {
-    return searchString;
-  }
-
+): string {
+  const contentLines = content.split("\n");
   const searchLines = searchString.split("\n");
-  if (searchLines.length === 0) return null;
 
-  const contentLines = content.split("\n");
-  let foundMatch: string | null = null;
+  if (searchLines.length === 0 || contentLines.length === 0) {
+    return "old_string not found in file (empty search or content)";
+  }
 
-  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
-    let offset: number | null = null;
-    let isMatch = true;
+  let bestMatchIndex = -1;
+  let bestMatchScore = -1;
 
+  // Sliding window to find the best partial match
+  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+    let currentScore = 0;
     for (let j = 0; j < searchLines.length; j++) {
-      const sLine = searchLines[j];
-      const cLine = contentLines[i + j];
-
-      const sTrimmed = sLine.trimStart();
-      const cTrimmed = cLine.trimStart();
-
-      // If trimmed content doesn't match, it's not a match
-      if (sTrimmed !== cTrimmed) {
-        isMatch = false;
-        break;
+      if (contentLines[i + j] === searchLines[j]) {
+        currentScore++;
       }
+    }
 
-      // For non-empty lines, check for consistent indentation offset
-      if (sTrimmed !== "") {
-        const sIndent = sLine.length - sTrimmed.length;
-        const cIndent = cLine.length - cTrimmed.length;
-        const currentOffset = cIndent - sIndent;
+    // Heuristic: prioritize matches where first or last lines match
+    if (contentLines[i] === searchLines[0]) currentScore += 0.5;
+    if (
+      contentLines[i + searchLines.length - 1] ===
+      searchLines[searchLines.length - 1]
+    )
+      currentScore += 0.5;
 
-        if (offset === null) {
-          offset = currentOffset;
-        } else if (offset !== currentOffset) {
-          isMatch = false;
-          break;
-        }
+    // Also consider trimmed matches to catch indentation issues
+    for (let j = 0; j < searchLines.length; j++) {
+      if (
+        contentLines[i + j].trim() === searchLines[j].trim() &&
+        contentLines[i + j] !== searchLines[j]
+      ) {
+        currentScore += 0.1;
       }
     }
 
-    if (isMatch) {
-      const matchCandidate = contentLines
-        .slice(i, i + searchLines.length)
-        .join("\n");
-      if (foundMatch !== null && foundMatch !== matchCandidate) {
-        // Multiple different smart matches found
-        return null;
-      }
-      foundMatch = matchCandidate;
+    if (currentScore > bestMatchScore) {
+      bestMatchScore = currentScore;
+      bestMatchIndex = i;
     }
   }
 
-  // If we found exactly one unique smart match (or multiple instances of the same smart match)
-  // return it. The tool will then check for uniqueness if replaceAll is false.
-  return foundMatch;
-}
-
-/**
- * Escape regular expression special characters
- */
-export function escapeRegExp(string: string): string {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/**
- * Save a snapshot of the old string and current file content for debugging
- */
-export async function saveEditErrorSnapshot(
-  filePath: string,
-  oldString: string,
-  currentContent: string,
-  toolName: string,
-): Promise<string | null> {
-  try {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const fileName = path.basename(filePath);
-    const snapshotDirName = `${timestamp}_${toolName}_${fileName}`;
-    const snapshotDir = path.join(
-      os.tmpdir(),
-      "wave-agent-edit-errors",
-      snapshotDirName,
-    );
-
-    await mkdir(snapshotDir, { recursive: true });
-
-    await Promise.all([
-      writeFile(path.join(snapshotDir, "old_string.txt"), oldString, "utf-8"),
-      writeFile(
-        path.join(snapshotDir, "file_content.txt"),
-        currentContent,
-        "utf-8",
-      ),
-    ]);
-
-    logger.error(
-      `Edit error snapshot saved to: ${snapshotDir}\nFile: ${filePath}\nTool: ${toolName}`,
-    );
+  // If no decent match found (score <= 0), return generic message
+  if (bestMatchScore <= 0) {
+    return "old_string not found in file (no similar block found)";
+  }
 
-    return snapshotDir;
-  } catch (error) {
-    logger.error(`Failed to save edit error snapshot: ${error}`);
-    return null;
+  // Generate detailed report
+  const reportLines: string[] = [
+    `old_string not found in file. Best partial match found at line ${bestMatchIndex + 1}:`,
+  ];
+
+  for (let j = 0; j < searchLines.length; j++) {
+    const lineNum = bestMatchIndex + j + 1;
+    const actualLine = contentLines[bestMatchIndex + j];
+    const expectedLine = searchLines[j];
+
+    if (actualLine === expectedLine) {
+      reportLines.push(`${lineNum.toString().padStart(4)} | ${actualLine}`);
+    } else {
+      reportLines.push(
+        `${lineNum.toString().padStart(4)} | - ${expectedLine} (expected)`,
+      );
+      reportLines.push(
+        `${lineNum.toString().padStart(4)} | + ${actualLine} (actual)`,
+      );
+    }
   }
+
+  return reportLines.join("\n");
 }

package/src/utils/messageOperations.ts

@@ -504,6 +504,7 @@ export interface AddSubagentBlockParams {
   status: "active" | "completed" | "error" | "aborted";
   sessionId: string;
   configuration: SubagentConfiguration;
+  runInBackground?: boolean;
 }
 
 export interface UpdateSubagentBlockParams {
@@ -520,6 +521,7 @@ export const addSubagentBlockToMessage = ({
   status,
   sessionId,
   configuration,
+  runInBackground,
 }: AddSubagentBlockParams): Message[] => {
   const newMessages = [...messages];
 
@@ -544,6 +546,7 @@ export const addSubagentBlockToMessage = ({
     status,
     sessionId,
     configuration,
+    runInBackground,
   });
 
   return newMessages;
@@ -555,6 +558,7 @@ export const updateSubagentBlockInMessage = (
   updates: Partial<{
     status: "active" | "completed" | "error" | "aborted";
     sessionId: string;
+    runInBackground: boolean;
   }>,
 ): Message[] => {
   const newMessages = [...messages];
@@ -571,6 +575,9 @@ export const updateSubagentBlockInMessage = (
           if (updates.sessionId !== undefined) {
             block.sessionId = updates.sessionId;
           }
+          if (updates.runInBackground !== undefined) {
+            block.runInBackground = updates.runInBackground;
+          }
           return newMessages;
         }
       }