wave-agent-sdk 0.6.4 → 0.7.0

package/src/tools/taskTool.ts

@@ -1,245 +1,244 @@
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import type { SubagentManager } from "../managers/subagentManager.js";
 import { EXPLORE_SUBAGENT_TYPE } from "../constants/subagents.js";
 import { TASK_TOOL_NAME } from "../constants/tools.js";
+import type { SubagentConfiguration } from "../utils/subagentParser.js";
 
 /**
- * Create a task tool plugin that uses the provided SubagentManager
- * Note: SubagentManager should be initialized before calling this function
+ * Task tool plugin for delegating tasks to specialized subagents
  */
-export function createTaskTool(subagentManager: SubagentManager): ToolPlugin {
-  // Ensure SubagentManager is initialized
-  subagentManager.getConfigurations();
-
-  return {
-    name: TASK_TOOL_NAME,
-    get config() {
-      // Get available subagents from the initialized subagent manager
-      const availableSubagents = subagentManager.getConfigurations();
-      const subagentList = availableSubagents
-        .map((config) => `- ${config.name}: ${config.description}`)
-        .join("\n");
-
-      const description = `Delegate a task to a specialized subagent. Use this when you need specialized expertise or want to break down complex work into focused subtasks.
-    
-    Available subagents:
-    ${subagentList || "No subagents configured"}`;
-
-      return {
-        type: "function" as const,
-        function: {
-          name: TASK_TOOL_NAME,
-          description,
-          parameters: {
-            type: "object",
-            properties: {
-              description: {
-                type: "string",
-                description:
-                  "A clear, concise description of what needs to be accomplished",
-              },
-              prompt: {
-                type: "string",
-                description:
-                  "The specific instructions or prompt to send to the subagent",
-              },
-              subagent_type: {
-                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"],
+export const taskTool: ToolPlugin = {
+  name: TASK_TOOL_NAME,
+  config: {
+    type: "function" as const,
+    function: {
+      name: TASK_TOOL_NAME,
+      description:
+        "Delegate a task to a specialized subagent. Use this when you need specialized expertise or want to break down complex work into focused subtasks.",
+      parameters: {
+        type: "object",
+        properties: {
+          description: {
+            type: "string",
+            description: "A short (3-5 word) description of the task",
+          },
+          prompt: {
+            type: "string",
+            description: "The task for the agent to perform",
+          },
+          subagent_type: {
+            type: "string",
+            description: "The type of specialized agent to use for this task",
+          },
+          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"],
+      },
     },
+  },
+
+  prompt: (args?: { availableSubagents?: SubagentConfiguration[] }) => {
+    const subagentList = args?.availableSubagents
+      ? args.availableSubagents
+          .map((config) => `- ${config.name}: ${config.description}`)
+          .join("\n")
+      : "";
+
+    return `
+Delegate a task to a specialized subagent. Use this when you need specialized expertise or want to break down complex work into focused subtasks.
+
+Available subagents:
+${subagentList || "No subagents configured"}
 
-    prompt: () => `
 - When doing file search, prefer to use the ${TASK_TOOL_NAME} tool in order to reduce context usage.
 - You should proactively use the ${TASK_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.
-- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${TASK_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.`,
-
-    execute: async (
-      args: Record<string, unknown>,
-      context: ToolContext,
-    ): Promise<ToolResult> => {
-      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",
-            });
-          }
+- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${TASK_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.`;
+  },
+
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const subagentManager = context.subagentManager;
+    if (!subagentManager) {
+      return {
+        success: false,
+        content: "",
+        error: "Subagent manager not available in tool context",
+        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",
-            });
-          }
+    // 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;
 
-          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",
-              });
-            }
-
-            // Set up callback to update shortResult with tool names, tool count and tokens
-            const updateShortResult = () => {
-              const messages = instance.messageManager.getMessages();
-              const tokens = instance.messageManager.getlatestTotalTokens();
-              const lastTools = instance.lastTools;
-
-              // Count tool blocks in messages
-              let toolCount = 0;
-              messages.forEach((msg) => {
-                msg.blocks.forEach((block) => {
-                  if (block.type === "tool") {
-                    toolCount++;
-                  }
-                });
-              });
-
-              let shortResult = "";
-              if (toolCount > 2) {
-                shortResult += "... ";
-              }
-              if (lastTools.length > 0) {
-                shortResult += `${lastTools.join(", ")} `;
-              }
+    if (!description || typeof description !== "string") {
+      return {
+        success: false,
+        content: "",
+        error: "description parameter is required and must be a string",
+        shortResult: "Task delegation failed",
+      };
+    }
 
-              shortResult += `(${toolCount} tools`;
-              if (tokens > 0) {
-                shortResult += ` | ${tokens.toLocaleString()} tokens`;
-              }
-              shortResult += ")";
-
-              context.onShortResultUpdate?.(shortResult);
-            };
-
-            // Create subagent instance and execute task
-            const instance = await subagentManager.createInstance(
-              configuration,
-              {
-                description,
-                prompt,
-                subagent_type,
-              },
-              run_in_background,
-              updateShortResult,
-            );
-
-            // Initial update
-            updateShortResult();
-
-            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}.`,
-                    shortResult: "Task backgrounded",
-                    isManuallyBackgrounded: true,
-                  });
-                },
-              });
-            }
-
-            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}`,
-                });
-              }
+    if (!prompt || typeof prompt !== "string") {
+      return {
+        success: false,
+        content: "",
+        error: "prompt parameter is required and must be a string",
+        shortResult: "Task delegation failed",
+      };
+    }
 
-              // Cleanup subagent instance after task completion
-              subagentManager.cleanupInstance(instance.subagentId);
-
-              return resolve({
-                success: true,
-                content: result,
-                shortResult: `Task completed by ${configuration.name}`,
-              });
-            } finally {
-              if (!run_in_background && context.foregroundTaskManager) {
-                context.foregroundTaskManager.unregisterForegroundTask(
-                  instance.subagentId,
-                );
+    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",
+        };
+      }
+
+      let isBackgrounded = false;
+
+      // Create subagent instance and execute task
+      const instance = await subagentManager.createInstance(
+        configuration,
+        {
+          description,
+          prompt,
+          subagent_type,
+        },
+        run_in_background,
+        () => {
+          // Do not update shortResult if it is running in background
+          if (run_in_background || isBackgrounded) return;
+
+          const messages = instance.messageManager.getMessages();
+          const tokens = instance.messageManager.getlatestTotalTokens();
+          const lastTools = instance.lastTools;
+
+          // Count tool blocks in messages
+          let toolCount = 0;
+          messages.forEach((msg) => {
+            msg.blocks.forEach((block) => {
+              if (block.type === "tool") {
+                toolCount++;
               }
-            }
-          } catch (error) {
-            return resolve({
-              success: false,
-              content: "",
-              error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
-              shortResult: "Delegation error",
             });
+          });
+
+          let shortResult = "";
+          if (toolCount > 2) {
+            shortResult += "... ";
+          }
+          if (lastTools.length > 0) {
+            shortResult += `${lastTools.join(", ")} `;
           }
-        })();
-      });
-    },
 
-    formatCompactParams: (params: Record<string, unknown>) => {
-      const subagent_type = params.subagent_type as string;
-      const description = params.description as string;
-      return `${subagent_type || "unknown"}: ${description || "no description"}`;
-    },
-  };
-}
+          shortResult += `(${toolCount} tools`;
+          if (tokens > 0) {
+            shortResult += ` | ${tokens.toLocaleString()} tokens`;
+          }
+          shortResult += ")";
+
+          context.onShortResultUpdate?.(shortResult);
+        },
+      );
+
+      // Register for backgrounding if not already in background
+      if (!run_in_background && context.foregroundTaskManager) {
+        context.foregroundTaskManager.registerForegroundTask({
+          id: instance.subagentId,
+          backgroundHandler: async () => {
+            isBackgrounded = true;
+            await subagentManager.backgroundInstance(instance.subagentId);
+          },
+        });
+      }
+
+      try {
+        const result = await subagentManager.executeTask(
+          instance,
+          prompt,
+          context.abortSignal,
+          run_in_background,
+        );
+
+        if (isBackgrounded) {
+          // If it was backgrounded during execution, the backgroundHandler already returned/will return
+          // But wait, the backgroundHandler is async and returns a ToolResult.
+          // In the current ToolManager/AIManager implementation, the backgroundHandler's return value
+          // is what's used when backgrounding happens.
+          // However, executeTask might still be running.
+          // We should return a special value or just let it be.
+          return {
+            success: true,
+            content: "Task backgrounded",
+            shortResult: "Task backgrounded",
+            isManuallyBackgrounded: true,
+          };
+        }
+
+        if (run_in_background) {
+          return {
+            success: true,
+            content: `Task started in background with ID: ${result}`,
+            shortResult: `Task started in background: ${result}`,
+          };
+        }
+
+        // Cleanup subagent instance after task completion
+        subagentManager.cleanupInstance(instance.subagentId);
+
+        return {
+          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 {
+        success: false,
+        content: "",
+        error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
+        shortResult: "Delegation error",
+      };
+    }
+  },
+
+  formatCompactParams: (params: Record<string, unknown>) => {
+    const subagent_type = params.subagent_type as string;
+    const description = params.description as string;
+    return `${subagent_type || "unknown"}: ${description || "no description"}`;
+  },
+};

package/src/tools/types.ts

@@ -8,6 +8,9 @@ import type {
   PermissionCallback,
 } from "../types/permissions.js";
 
+import type { SubagentConfiguration } from "../utils/subagentParser.js";
+import type { SkillMetadata } from "../types/skills.js";
+
 export interface ToolPlugin {
   name: string;
   config: ChatCompletionFunctionTool;
@@ -22,7 +25,11 @@ export interface ToolPlugin {
   /**
    * Optional function to provide a prompt to be added to the system prompt
    */
-  prompt?: () => string;
+  prompt?: (args?: {
+    availableSubagents?: SubagentConfiguration[];
+    availableSkills?: SkillMetadata[];
+    workdir?: string;
+  }) => string;
 }
 
 export interface ToolResult {
@@ -65,6 +72,10 @@ export interface ToolContext {
   foregroundTaskManager?: import("../types/processes.js").IForegroundTaskManager;
   /** Task manager instance for task management */
   taskManager: import("../services/taskManager.js").TaskManager;
+  /** Subagent manager instance for task delegation */
+  subagentManager?: import("../managers/subagentManager.js").SubagentManager;
+  /** Skill manager instance for skill invocation */
+  skillManager?: import("../managers/skillManager.js").SkillManager;
   /** Current session ID */
   sessionId?: string;
   /** Callback to update the short result of the current tool block */

package/src/tools/writeTool.ts

@@ -3,6 +3,7 @@ import { dirname } from "path";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
+import { READ_TOOL_NAME } from "../constants/tools.js";
 
 /**
  * File Write Tool Plugin
@@ -32,10 +33,11 @@ export const writeTool: ToolPlugin = {
       },
     },
   },
-  prompt: () => `
+  prompt: () => `Writes a file to the local filesystem.
+
 Usage:
 - This tool will overwrite the existing file if there is one at the provided path.
-- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- If this is an existing file, you MUST use the \`${READ_TOOL_NAME}\` tool first to read the file's contents. This tool will fail if you did not read the file first.
 - ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
 - NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
 - Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.

package/src/types/marketplace.ts

@@ -11,6 +11,15 @@ export interface MarketplacePluginEntry {
   description: string;
 }
 
+export interface MarketplacePluginStatus extends MarketplacePluginEntry {
+  marketplace: string;
+  installed: boolean;
+  version?: string;
+  cachePath?: string;
+  projectPath?: string;
+  scope?: Scope;
+}
+
 export interface MarketplaceManifest {
   name: string;
   owner: MarketplaceOwner;

package/src/types/permissions.ts

@@ -10,8 +10,6 @@ import {
 } from "./tools.js";
 import {
   EDIT_TOOL_NAME,
-  MULTI_EDIT_TOOL_NAME,
-  DELETE_FILE_TOOL_NAME,
   BASH_TOOL_NAME,
   WRITE_TOOL_NAME,
   EXIT_PLAN_MODE_TOOL_NAME,
@@ -61,8 +59,6 @@ export interface ToolPermissionContext {
 /** List of tools that require permission checks in default mode */
 export const RESTRICTED_TOOLS = [
   EDIT_TOOL_NAME,
-  MULTI_EDIT_TOOL_NAME,
-  DELETE_FILE_TOOL_NAME,
   BASH_TOOL_NAME,
   WRITE_TOOL_NAME,
   EXIT_PLAN_MODE_TOOL_NAME,

package/src/types/skills.ts

@@ -3,8 +3,6 @@
  * Dependencies: Core (Logger)
  */
 
-import type { Logger } from "./core.js";
-
 export interface SkillMetadata {
   name: string;
   description: string;
@@ -60,7 +58,6 @@ export interface SkillToolArgs {
 export interface SkillManagerOptions {
   personalSkillsPath?: string;
   scanTimeout?: number;
-  logger?: Logger;
   workdir?: string;
 }
 

package/src/types/tools.ts

@@ -33,15 +33,6 @@ export interface WriteToolParameters {
   content: string;
 }
 
-/**
- * Parameters for a single edit operation in the Edit tool
- */
-export interface EditOperation {
-  old_string: string;
-  new_string: string;
-  replace_all?: boolean;
-}
-
 /**
  * Parameters for the Edit tool
  */
@@ -51,11 +42,3 @@ export interface EditToolParameters {
   new_string: string;
   replace_all?: boolean;
 }
-
-/**
- * Parameters for the MultiEdit tool
- */
-export interface MultiEditToolParameters {
-  file_path: string;
-  edits: EditOperation[];
-}