wave-agent-sdk 0.7.1 → 0.8.0

package/src/tools/lspTool.ts

@@ -14,6 +14,9 @@ import type {
   LspCallHierarchyOutgoingCall as CallHierarchyOutgoingCall,
 } from "../types/lsp.js";
 
+export const MAX_RESULTS = 1000;
+export const MAX_FILES = 100;
+
 /**
  * Formats an LSP URI into a readable file path
  */
@@ -126,10 +129,16 @@ function formatGoToDefinitionResult(
       return `Defined in ${formatLocation(validLocations[0], workdir)}`;
     }
 
-    const formatted = validLocations
+    const shownLocations = validLocations.slice(0, MAX_RESULTS);
+    const formatted = shownLocations
       .map((loc) => `  ${formatLocation(loc, workdir)}`)
       .join("\n");
-    return `Found ${validLocations.length} definitions:\n${formatted}`;
+
+    let header = `Found ${validLocations.length} definitions:`;
+    if (validLocations.length > MAX_RESULTS) {
+      header += ` (showing first ${MAX_RESULTS})`;
+    }
+    return `${header}\n${formatted}`;
   }
 
   const loc = isLocationLink(result) ? locationLinkToLocation(result) : result;
@@ -157,18 +166,42 @@ function formatFindReferencesResult(
   }
 
   const grouped = groupItemsByUri(validLocations, workdir);
-  const lines = [
-    `Found ${validLocations.length} references across ${grouped.size} files:`,
-  ];
+  const totalResults = validLocations.length;
+  const totalFiles = grouped.size;
+
+  let resultsShown = 0;
+  let filesShown = 0;
+  const lines: string[] = [];
 
   for (const [path, locs] of grouped) {
+    if (resultsShown >= MAX_RESULTS || filesShown >= MAX_FILES) break;
+
+    filesShown++;
+    const remainingResults = MAX_RESULTS - resultsShown;
+    const locsToShow = locs.slice(0, remainingResults);
+    const isTruncated = locsToShow.length < locs.length;
+
     lines.push(`\n${path}:`);
-    for (const loc of locs) {
+    for (const loc of locsToShow) {
       const line = loc.range.start.line + 1;
       const character = loc.range.start.character + 1;
       lines.push(`  Line ${line}:${character}`);
     }
+
+    if (isTruncated) {
+      lines.push(
+        `  ... and ${locs.length - locsToShow.length} more in this file`,
+      );
+    }
+
+    resultsShown += locsToShow.length;
+  }
+
+  let header = `Found ${totalResults} references across ${totalFiles} files:`;
+  if (totalResults > resultsShown || totalFiles > filesShown) {
+    header += ` (showing first ${resultsShown} results and ${filesShown} files)`;
   }
+  lines.unshift(header);
 
   return lines.join("\n");
 }
@@ -243,23 +276,32 @@ function getSymbolKindName(kind: number): string {
 /**
  * Formats a single document symbol recursively
  */
-function formatDocumentSymbol(symbol: DocumentSymbol, depth = 0): string[] {
+function formatDocumentSymbol(
+  symbol: DocumentSymbol,
+  state: { count: number; total: number },
+  depth = 0,
+): string[] {
+  state.total++;
   const results: string[] = [];
-  const indent = "  ".repeat(depth);
-  const kindName = getSymbolKindName(symbol.kind);
-  let line = `${indent}${symbol.name} (${kindName})`;
 
-  if (symbol.detail) {
-    line += ` ${symbol.detail}`;
-  }
+  if (state.count < MAX_RESULTS) {
+    const indent = "  ".repeat(depth);
+    const kindName = getSymbolKindName(symbol.kind);
+    let line = `${indent}${symbol.name} (${kindName})`;
+
+    if (symbol.detail) {
+      line += ` ${symbol.detail}`;
+    }
 
-  const startLine = symbol.range.start.line + 1;
-  line += ` - Line ${startLine}`;
-  results.push(line);
+    const startLine = symbol.range.start.line + 1;
+    line += ` - Line ${startLine}`;
+    results.push(line);
+    state.count++;
+  }
 
   if (symbol.children && symbol.children.length > 0) {
     for (const child of symbol.children) {
-      results.push(...formatDocumentSymbol(child, depth + 1));
+      results.push(...formatDocumentSymbol(child, state, depth + 1));
     }
   }
 
@@ -282,10 +324,18 @@ function formatDocumentSymbolResult(
     return formatWorkspaceSymbolResult(result as SymbolInformation[], workdir);
   }
 
-  const lines = ["Document symbols:"];
+  const state = { count: 0, total: 0 };
+  const lines: string[] = [];
   for (const symbol of result as DocumentSymbol[]) {
-    lines.push(...formatDocumentSymbol(symbol));
+    lines.push(...formatDocumentSymbol(symbol, state));
   }
+
+  let header = "Document symbols:";
+  if (state.total > MAX_RESULTS) {
+    header += ` (showing first ${MAX_RESULTS} of ${state.total})`;
+  }
+  lines.unshift(header);
+
   return lines.join("\n");
 }
 
@@ -305,14 +355,24 @@ function formatWorkspaceSymbolResult(
     return "No symbols found in workspace. This may occur if the workspace is empty, or if the LSP server has not finished indexing the project.";
   }
 
-  const lines = [
-    `Found ${validSymbols.length} symbol${validSymbols.length === 1 ? "" : "s"} in workspace:`,
-  ];
   const grouped = groupItemsByUri(validSymbols, workdir);
+  const totalResults = validSymbols.length;
+  const totalFiles = grouped.size;
+
+  let resultsShown = 0;
+  let filesShown = 0;
+  const lines: string[] = [];
 
   for (const [path, symbols] of grouped) {
+    if (resultsShown >= MAX_RESULTS || filesShown >= MAX_FILES) break;
+
+    filesShown++;
+    const remainingResults = MAX_RESULTS - resultsShown;
+    const symbolsToShow = symbols.slice(0, remainingResults);
+    const isTruncated = symbolsToShow.length < symbols.length;
+
     lines.push(`\n${path}:`);
-    for (const s of symbols) {
+    for (const s of symbolsToShow) {
       const kindName = getSymbolKindName(s.kind);
       const startLine = s.location.range.start.line + 1;
       let line = `  ${s.name} (${kindName}) - Line ${startLine}`;
@@ -321,7 +381,21 @@ function formatWorkspaceSymbolResult(
       }
       lines.push(line);
     }
+
+    if (isTruncated) {
+      lines.push(
+        `  ... and ${symbols.length - symbolsToShow.length} more in this file`,
+      );
+    }
+
+    resultsShown += symbolsToShow.length;
+  }
+
+  let header = `Found ${totalResults} symbol${totalResults === 1 ? "" : "s"} in workspace:`;
+  if (totalResults > resultsShown || totalFiles > filesShown) {
+    header += ` (showing first ${resultsShown} results and ${filesShown} files)`;
   }
+  lines.unshift(header);
 
   return lines.join("\n");
 }
@@ -364,10 +438,18 @@ function formatPrepareCallHierarchyResult(
     return `Call hierarchy item: ${formatCallHierarchyItem(result[0], workdir)}`;
   }
 
-  const lines = [`Found ${result.length} call hierarchy items:`];
-  for (const item of result) {
+  const shownItems = result.slice(0, MAX_RESULTS);
+  const lines: string[] = [];
+  for (const item of shownItems) {
     lines.push(`  ${formatCallHierarchyItem(item, workdir)}`);
   }
+
+  let header = `Found ${result.length} call hierarchy items:`;
+  if (result.length > MAX_RESULTS) {
+    header += ` (showing first ${MAX_RESULTS})`;
+  }
+  lines.unshift(header);
+
   return lines.join("\n");
 }
 
@@ -382,10 +464,8 @@ function formatIncomingCallsResult(
     return "No incoming calls found (nothing calls this function)";
   }
 
-  const lines = [
-    `Found ${result.length} incoming call${result.length === 1 ? "" : "s"}:`,
-  ];
   const grouped = new Map<string, CallHierarchyIncomingCall[]>();
+  const totalResults = result.length;
 
   for (const call of result) {
     if (!call.from) {
@@ -403,9 +483,21 @@ function formatIncomingCallsResult(
     }
   }
 
+  const totalFiles = grouped.size;
+  let resultsShown = 0;
+  let filesShown = 0;
+  const lines: string[] = [];
+
   for (const [path, calls] of grouped) {
+    if (resultsShown >= MAX_RESULTS || filesShown >= MAX_FILES) break;
+
+    filesShown++;
+    const remainingResults = MAX_RESULTS - resultsShown;
+    const callsToShow = calls.slice(0, remainingResults);
+    const isTruncated = callsToShow.length < calls.length;
+
     lines.push(`\n${path}:`);
-    for (const call of calls) {
+    for (const call of callsToShow) {
       if (!call.from) continue;
       const kindName = getSymbolKindName(call.from.kind);
       const startLine = call.from.range.start.line + 1;
@@ -419,8 +511,22 @@ function formatIncomingCallsResult(
       }
       lines.push(line);
     }
+
+    if (isTruncated) {
+      lines.push(
+        `  ... and ${calls.length - callsToShow.length} more in this file`,
+      );
+    }
+
+    resultsShown += callsToShow.length;
   }
 
+  let header = `Found ${totalResults} incoming call${totalResults === 1 ? "" : "s"}:`;
+  if (totalResults > resultsShown || totalFiles > filesShown) {
+    header += ` (showing first ${resultsShown} results and ${filesShown} files)`;
+  }
+  lines.unshift(header);
+
   return lines.join("\n");
 }
 
@@ -435,10 +541,8 @@ function formatOutgoingCallsResult(
     return "No outgoing calls found (this function calls nothing)";
   }
 
-  const lines = [
-    `Found ${result.length} outgoing call${result.length === 1 ? "" : "s"}:`,
-  ];
   const grouped = new Map<string, CallHierarchyOutgoingCall[]>();
+  const totalResults = result.length;
 
   for (const call of result) {
     if (!call.to) {
@@ -456,9 +560,21 @@ function formatOutgoingCallsResult(
     }
   }
 
+  const totalFiles = grouped.size;
+  let resultsShown = 0;
+  let filesShown = 0;
+  const lines: string[] = [];
+
   for (const [path, calls] of grouped) {
+    if (resultsShown >= MAX_RESULTS || filesShown >= MAX_FILES) break;
+
+    filesShown++;
+    const remainingResults = MAX_RESULTS - resultsShown;
+    const callsToShow = calls.slice(0, remainingResults);
+    const isTruncated = callsToShow.length < calls.length;
+
     lines.push(`\n${path}:`);
-    for (const call of calls) {
+    for (const call of callsToShow) {
       if (!call.to) continue;
       const kindName = getSymbolKindName(call.to.kind);
       const startLine = call.to.range.start.line + 1;
@@ -472,7 +588,21 @@ function formatOutgoingCallsResult(
       }
       lines.push(line);
     }
+
+    if (isTruncated) {
+      lines.push(
+        `  ... and ${calls.length - callsToShow.length} more in this file`,
+      );
+    }
+
+    resultsShown += callsToShow.length;
+  }
+
+  let header = `Found ${totalResults} outgoing call${totalResults === 1 ? "" : "s"}:`;
+  if (totalResults > resultsShown || totalFiles > filesShown) {
+    header += ` (showing first ${resultsShown} results and ${filesShown} files)`;
   }
+  lines.unshift(header);
 
   return lines.join("\n");
 }
@@ -486,25 +616,7 @@ export const lspTool: ToolPlugin = {
     type: "function",
     function: {
       name: LSP_TOOL_NAME,
-      description: `Interact with Language Server Protocol (LSP) servers to get code intelligence features.
-
-Supported operations:
-- goToDefinition: Find where a symbol is defined
-- findReferences: Find all references to a symbol
-- hover: Get hover information (documentation, type info) for a symbol
-- documentSymbol: Get all symbols (functions, classes, variables) in a document
-- workspaceSymbol: Search for symbols across the entire workspace
-- goToImplementation: Find implementations of an interface or abstract method
-- prepareCallHierarchy: Get call hierarchy item at a position (functions/methods)
-- incomingCalls: Find all functions/methods that call the function at a position
-- outgoingCalls: Find all functions/methods called by the function at a position
-
-All operations require:
-- filePath: The file to operate on
-- line: The line number (1-based, as shown in editors)
-- character: The character offset (1-based, as shown in editors)
-
-Note: LSP servers must be configured for the file type. If no server is available, an error will be returned.`,
+      description: `Interact with Language Server Protocol (LSP) servers to get code intelligence features.`,
       parameters: {
         type: "object",
         properties: {
@@ -540,6 +652,26 @@ Note: LSP servers must be configured for the file type. If no server is availabl
       },
     },
   },
+  prompt:
+    () => `Interact with Language Server Protocol (LSP) servers to get code intelligence features.
+
+Supported operations:
+- goToDefinition: Find where a symbol is defined
+- findReferences: Find all references to a symbol
+- hover: Get hover information (documentation, type info) for a symbol
+- documentSymbol: Get all symbols (functions, classes, variables) in a document
+- workspaceSymbol: Search for symbols across the entire workspace
+- goToImplementation: Find implementations of an interface or abstract method
+- prepareCallHierarchy: Get call hierarchy item at a position (functions/methods)
+- incomingCalls: Find all functions/methods that call the function at a position
+- outgoingCalls: Find all functions/methods called by the function at a position
+
+All operations require:
+- filePath: The file to operate on
+- line: The line number (1-based, as shown in editors)
+- character: The character offset (1-based, as shown in editors)
+
+Note: LSP servers must be configured for the file type. If no server is available, an error will be returned.`,
   execute: async (
     args: Record<string, unknown>,
     context: ToolContext,

package/src/tools/skillTool.ts

@@ -1,6 +1,12 @@
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { SKILL_TOOL_NAME } from "../constants/tools.js";
+import { GENERAL_PURPOSE_SUBAGENT_TYPE } from "../constants/subagents.js";
 import type { SkillMetadata } from "../types/skills.js";
+import { logger } from "../utils/globalLogger.js";
+import {
+  countToolBlocks,
+  formatToolTokenSummary,
+} from "../utils/messageOperations.js";
 
 /**
  * Skill tool plugin for invoking Wave skills
@@ -20,6 +26,10 @@ export const skillTool: ToolPlugin = {
             type: "string",
             description: "Name of the skill to invoke",
           },
+          args: {
+            type: "string",
+            description: "Optional arguments to pass to the skill",
+          },
         },
         required: ["skill_name"],
       },
@@ -27,7 +37,9 @@ export const skillTool: ToolPlugin = {
   },
 
   prompt: (args?: { availableSkills?: SkillMetadata[] }) => {
-    const availableSkills = args?.availableSkills;
+    const availableSkills = args?.availableSkills?.filter(
+      (skill) => !skill.disableModelInvocation,
+    );
     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.";
     }
@@ -57,6 +69,8 @@ export const skillTool: ToolPlugin = {
 
       // Validate arguments
       const skillName = args.skill_name as string;
+      const skillArgs = args.args as string | undefined;
+
       if (!skillName || typeof skillName !== "string") {
         return {
           success: false,
@@ -65,11 +79,122 @@ export const skillTool: ToolPlugin = {
         };
       }
 
-      // Execute the skill
+      const skillMetadata = skillManager.getSkillMetadata(skillName);
+
+      if (skillMetadata?.disableModelInvocation) {
+        return {
+          success: false,
+          content: "",
+          error: `Skill "${skillName}" is not available for model invocation.`,
+        };
+      }
+
+      // Handle fork context
+      if (skillMetadata?.context === "fork") {
+        const subagentManager = context.subagentManager;
+        if (!subagentManager) {
+          return {
+            success: false,
+            content: "",
+            error: "Subagent manager not available in tool context",
+          };
+        }
+
+        const agentType = skillMetadata.agent || GENERAL_PURPOSE_SUBAGENT_TYPE;
+        const configuration = await subagentManager.findSubagent(agentType);
+
+        if (!configuration) {
+          return {
+            success: false,
+            content: "",
+            error: `No subagent found matching "${agentType}" for skill "${skillName}"`,
+          };
+        }
+
+        // Execute the skill to get the content
+        const skillResult = await skillManager.executeSkill({
+          skill_name: skillName,
+          args: skillArgs,
+        });
+
+        logger.debug(`Skill ${skillName} executed, allowedTools:`, {
+          allowedTools: skillResult.allowedTools,
+        });
+
+        // Create subagent instance
+        const instance = await subagentManager.createInstance(
+          configuration,
+          {
+            description: `Skill: ${skillName}`,
+            prompt: skillResult.content,
+            subagent_type: agentType,
+            allowedTools: skillResult.allowedTools,
+            model: skillMetadata.model,
+          },
+          false, // run_in_background
+          () => {
+            // Update shortResult
+            const messages = instance.messageManager.getMessages();
+            const tokens = instance.messageManager.getlatestTotalTokens();
+            const lastTools = instance.lastTools;
+
+            const toolCount = countToolBlocks(messages);
+            const summary = formatToolTokenSummary(toolCount, tokens);
+
+            let shortResult = "";
+            if (toolCount > 2) {
+              shortResult += "... ";
+            }
+            if (lastTools.length > 0) {
+              shortResult += `${lastTools.join(", ")} `;
+            }
+            shortResult += summary;
+
+            context.onShortResultUpdate?.(shortResult);
+          },
+        );
+
+        try {
+          const result = await subagentManager.executeTask(
+            instance,
+            skillResult.content,
+            context.abortSignal,
+            false,
+          );
+
+          // Cleanup subagent instance after task completion
+          subagentManager.cleanupInstance(instance.subagentId);
+
+          const messages = instance.messageManager.getMessages();
+          const tokens = instance.messageManager.getlatestTotalTokens();
+          const toolCount = countToolBlocks(messages);
+          const summary = formatToolTokenSummary(toolCount, tokens);
+
+          return {
+            success: true,
+            content: result,
+            shortResult: `Invoked skill: ${skillName}${summary ? ` ${summary}` : ""}`,
+          };
+        } catch (error) {
+          return {
+            success: false,
+            content: "",
+            error: `Skill fork failed: ${error instanceof Error ? error.message : String(error)}`,
+          };
+        }
+      }
+
+      // Standard execution
       const result = await skillManager.executeSkill({
         skill_name: skillName,
+        args: skillArgs,
       });
 
+      // Add temporary rules if allowedTools are present
+      if (result.allowedTools && result.allowedTools.length > 0) {
+        context.permissionManager?.addTemporaryRules(result.allowedTools);
+      }
+
       return {
         success: true,
         content: result.content,

package/src/tools/taskManagementTools.ts

@@ -116,11 +116,12 @@ NOTE that you should not use this tool if there is only one trivial task to do.
 
     if (context.reversionManager && context.messageId) {
       const taskPath = taskManager.getTaskPath(taskId);
-      await context.reversionManager.recordSnapshot(
+      const snapshotId = await context.reversionManager.recordSnapshot(
         context.messageId,
         taskPath,
         "create",
       );
+      await context.reversionManager.commitSnapshot(snapshotId);
     }
 
     return {
@@ -333,9 +334,10 @@ Set up task dependencies:
       };
     }
 
+    let snapshotId: string | undefined;
     if (context.reversionManager && context.messageId) {
       const taskPath = taskManager.getTaskPath(taskId);
-      await context.reversionManager.recordSnapshot(
+      snapshotId = await context.reversionManager.recordSnapshot(
         context.messageId,
         taskPath,
         "modify",
@@ -402,10 +404,22 @@ Set up task dependencies:
         for (const targetId of blocksToAdd) {
           const targetTask = await taskManager.getTask(targetId);
           if (targetTask && !targetTask.blockedBy.includes(taskId)) {
+            let targetSnapshotId: string | undefined;
+            if (context.reversionManager && context.messageId) {
+              const targetPath = taskManager.getTaskPath(targetId);
+              targetSnapshotId = await context.reversionManager.recordSnapshot(
+                context.messageId,
+                targetPath,
+                "modify",
+              );
+            }
             await taskManager.updateTask({
               ...targetTask,
               blockedBy: [...targetTask.blockedBy, taskId],
             });
+            if (context.reversionManager && targetSnapshotId) {
+              await context.reversionManager.commitSnapshot(targetSnapshotId);
+            }
           }
         }
       }
@@ -423,10 +437,22 @@ Set up task dependencies:
         for (const targetId of blockedByToAdd) {
           const targetTask = await taskManager.getTask(targetId);
           if (targetTask && !targetTask.blocks.includes(taskId)) {
+            let targetSnapshotId: string | undefined;
+            if (context.reversionManager && context.messageId) {
+              const targetPath = taskManager.getTaskPath(targetId);
+              targetSnapshotId = await context.reversionManager.recordSnapshot(
+                context.messageId,
+                targetPath,
+                "modify",
+              );
+            }
             await taskManager.updateTask({
               ...targetTask,
               blocks: [...targetTask.blocks, taskId],
             });
+            if (context.reversionManager && targetSnapshotId) {
+              await context.reversionManager.commitSnapshot(targetSnapshotId);
+            }
           }
         }
       }
@@ -434,6 +460,10 @@ Set up task dependencies:
 
     await taskManager.updateTask(updatedTask);
 
+    if (context.reversionManager && snapshotId) {
+      await context.reversionManager.commitSnapshot(snapshotId);
+    }
+
     let content = `Updated task #${taskId} ${updatedFields.join(", ")}`;
     if (updatedTask.status === "completed") {
       content += `\n\nTask completed. Call TaskList now to find your next available task or see if your work unblocked others.`;

package/src/tools/taskTool.ts

@@ -2,6 +2,10 @@ import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { EXPLORE_SUBAGENT_TYPE } from "../constants/subagents.js";
 import { TASK_TOOL_NAME } from "../constants/tools.js";
 import type { SubagentConfiguration } from "../utils/subagentParser.js";
+import {
+  countToolBlocks,
+  formatToolTokenSummary,
+} from "../utils/messageOperations.js";
 
 /**
  * Task tool plugin for delegating tasks to specialized subagents
@@ -141,15 +145,8 @@ ${subagentList || "No subagents configured"}
           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++;
-              }
-            });
-          });
+          const toolCount = countToolBlocks(messages);
+          const summary = formatToolTokenSummary(toolCount, tokens);
 
           let shortResult = "";
           if (toolCount > 2) {
@@ -159,11 +156,7 @@ ${subagentList || "No subagents configured"}
             shortResult += `${lastTools.join(", ")} `;
           }
 
-          shortResult += `(${toolCount} tools`;
-          if (tokens > 0) {
-            shortResult += ` | ${tokens.toLocaleString()} tokens`;
-          }
-          shortResult += ")";
+          shortResult += summary;
 
           context.onShortResultUpdate?.(shortResult);
         },
@@ -214,10 +207,15 @@ ${subagentList || "No subagents configured"}
         // Cleanup subagent instance after task completion
         subagentManager.cleanupInstance(instance.subagentId);
 
+        const messages = instance.messageManager.getMessages();
+        const tokens = instance.messageManager.getlatestTotalTokens();
+        const toolCount = countToolBlocks(messages);
+        const summary = formatToolTokenSummary(toolCount, tokens);
+
         return {
           success: true,
           content: result,
-          shortResult: `Task completed by ${configuration.name}`,
+          shortResult: `Task completed${summary ? ` ${summary}` : ""}`,
         };
       } finally {
         if (!run_in_background && context.foregroundTaskManager) {

package/src/tools/types.ts

@@ -23,7 +23,7 @@ export interface ToolPlugin {
     context: ToolContext,
   ) => string;
   /**
-   * Optional function to provide a prompt to be added to the system prompt
+   * Function to provide a prompt to be added to the tool description
    */
   prompt?: (args?: {
     availableSubagents?: SubagentConfiguration[];
@@ -53,7 +53,6 @@ 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 */