wave-agent-sdk 0.6.5 → 0.7.0

package/src/tools/readTool.ts

@@ -3,6 +3,7 @@ import { extname } from "path";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
+import { formatLineNumberPrefix } from "../utils/stringUtils.js";
 import {
   isBinaryDocument,
   getBinaryDocumentError,
@@ -142,7 +143,6 @@ Usage:
 - Any lines longer than 2000 characters will be truncated
 - Results are returned using cat -n format, with line numbers starting at 1
 - This tool allows Agent to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Agent is a multimodal LLM.
-- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.
 - You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
 - You will regularly be asked to read screenshots. If the user provides a path to a screenshot ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths like /var/folders/123/abc/T/TemporaryItems/NSIRD_screencaptureui_ZfB1tD/Screenshot.png
 - If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
@@ -294,7 +294,7 @@ Usage:
           // Truncate overly long lines
           const truncatedLine =
             line.length > 2000 ? line.substring(0, 2000) + "..." : line;
-          return `${lineNumber.toString().padStart(6)}\t${truncatedLine}`;
+          return `${formatLineNumberPrefix(lineNumber)}${truncatedLine}`;
         })
         .join("\n");
 

package/src/tools/skillTool.ts

@@ -1,87 +1,91 @@
-import type { ToolPlugin, ToolResult } from "./types.js";
-import type { SkillManager } from "../managers/skillManager.js";
+import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { SKILL_TOOL_NAME } from "../constants/tools.js";
+import type { SkillMetadata } from "../types/skills.js";
 
 /**
- * Create a skill tool plugin that uses the provided SkillManager
- * Note: SkillManager should be initialized before calling this function
+ * Skill tool plugin for invoking Wave skills
  */
-export function createSkillTool(skillManager: SkillManager): ToolPlugin {
-  // Ensure SkillManager is initialized
-  skillManager.getAvailableSkills();
-
-  return {
-    name: SKILL_TOOL_NAME,
-    get config() {
-      const availableSkills = skillManager.getAvailableSkills();
-
-      const getToolDescription = (): string => {
-        if (availableSkills.length === 0) {
-          return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. No skills are currently available.";
-        }
-
-        const skillList = availableSkills
-          .map(
-            (skill) =>
-              `• **${skill.name}** (${skill.type}): ${skill.description}`,
-          )
-          .join("\n");
-
-        return `Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.\n\nAvailable skills:\n${skillList}`;
-      };
-
-      return {
-        type: "function" as const,
-        function: {
-          name: SKILL_TOOL_NAME,
-          description: getToolDescription(),
-          parameters: {
-            type: "object",
-            properties: {
-              skill_name: {
-                type: "string",
-                description: "Name of the skill to invoke",
-                enum: availableSkills.map((skill) => skill.name),
-              },
-            },
-            required: ["skill_name"],
+export const skillTool: ToolPlugin = {
+  name: SKILL_TOOL_NAME,
+  config: {
+    type: "function" as const,
+    function: {
+      name: SKILL_TOOL_NAME,
+      description:
+        "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.",
+      parameters: {
+        type: "object",
+        properties: {
+          skill_name: {
+            type: "string",
+            description: "Name of the skill to invoke",
           },
         },
-      };
+        required: ["skill_name"],
+      },
     },
-    execute: async (args: Record<string, unknown>): Promise<ToolResult> => {
-      try {
-        // Validate arguments
-        const skillName = args.skill_name as string;
-        if (!skillName || typeof skillName !== "string") {
-          return {
-            success: false,
-            content: "",
-            error: "skill_name parameter is required and must be a string",
-          };
-        }
+  },
+
+  prompt: (args?: { availableSkills?: SkillMetadata[] }) => {
+    const availableSkills = args?.availableSkills;
+    if (!availableSkills || availableSkills.length === 0) {
+      return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. No skills are currently available.";
+    }
 
-        // Execute the skill
-        const result = await skillManager.executeSkill({
-          skill_name: skillName,
-        });
+    const skillList = availableSkills
+      .map(
+        (skill) => `• **${skill.name}** (${skill.type}): ${skill.description}`,
+      )
+      .join("\n");
 
+    return `Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.\n\nAvailable skills:\n${skillList}`;
+  },
+
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    try {
+      const skillManager = context.skillManager;
+      if (!skillManager) {
         return {
-          success: true,
-          content: result.content,
-          shortResult: `Invoked skill: ${skillName}`,
+          success: false,
+          content: "",
+          error: "Skill manager not available in tool context",
         };
-      } catch (error) {
+      }
+
+      // Validate arguments
+      const skillName = args.skill_name as string;
+      if (!skillName || typeof skillName !== "string") {
         return {
           success: false,
           content: "",
-          error: error instanceof Error ? error.message : String(error),
+          error: "skill_name parameter is required and must be a string",
         };
       }
-    },
-    formatCompactParams: (params: Record<string, unknown>) => {
-      const skillName = params.skill_name as string;
-      return skillName || "unknown-skill";
-    },
-  };
-}
+
+      // Execute the skill
+      const result = await skillManager.executeSkill({
+        skill_name: skillName,
+      });
+
+      return {
+        success: true,
+        content: result.content,
+        shortResult: `Invoked skill: ${skillName}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        content: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+
+  formatCompactParams: (params: Record<string, unknown>) => {
+    const skillName = params.skill_name as string;
+    return skillName || "unknown-skill";
+  },
+};

package/src/tools/taskOutputTool.ts

@@ -190,7 +190,7 @@ export const taskOutputTool: ToolPlugin = {
   },
   formatCompactParams: (params: Record<string, unknown>) => {
     const taskId = params.task_id as string;
-    const block = params.block as boolean;
+    const block = (params.block as boolean | undefined) ?? true;
     return `${taskId}${block ? " (blocking)" : ""}`;
   },
 };

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"}`;
+  },
+};