wave-agent-sdk 0.11.5 → 0.11.7

package/src/managers/slashCommandManager.ts

@@ -16,8 +16,13 @@ import {
   replaceBashCommandsWithOutput,
   executeBashCommands,
 } from "../utils/markdownParser.js";
+import {
+  countToolBlocks,
+  formatToolTokenSummary,
+} from "../utils/messageOperations.js";
 import type { SkillManager } from "./skillManager.js";
 import type { SkillMetadata } from "../types/skills.js";
+import type { SubagentManager } from "./subagentManager.js";
 
 import { logger } from "../utils/globalLogger.js";
 
@@ -30,6 +35,7 @@ export class SlashCommandManager {
   private customCommands = new Map<string, CustomSlashCommand>();
   private skillCommandIds = new Set<string>();
   private workdir: string;
+  private currentCommandAbortController: AbortController | null = null;
 
   constructor(
     private container: Container,
@@ -71,6 +77,10 @@ export class SlashCommandManager {
     return this.container.get<SkillManager>("SkillManager")!;
   }
 
+  private get subagentManager(): SubagentManager {
+    return this.container.get<SubagentManager>("SubagentManager")!;
+  }
+
   private initializeBuiltinCommands(): void {
     // Register built-in clear command
     this.registerCommand({
@@ -153,7 +163,7 @@ export class SlashCommandManager {
         id: commandId,
         name: skill.name,
         description: `Skill: ${skill.description}`,
-        handler: async (args?: string) => {
+        handler: async (args?: string, signal?: AbortSignal) => {
           try {
             // 1. Prepare skill content immediately
             const prepared = await this.skillManager.prepareSkill({
@@ -176,6 +186,109 @@ export class SlashCommandManager {
               return;
             }
 
+            if (skill.context === "fork") {
+              // Forked skill execution
+              const subagentConfigs =
+                await this.subagentManager.loadConfigurations();
+              const subagentType = skill.agent || "general-purpose";
+              const config = subagentConfigs.find(
+                (c) => c.name === subagentType,
+              );
+              if (!config) {
+                throw new Error(
+                  `Subagent configuration for ${subagentType} not found`,
+                );
+              }
+
+              // Add a ToolBlock to the initial command message for progress tracking
+              const toolBlockId = this.messageManager.addToolBlockToMessage(
+                messageId,
+                {
+                  name: subagentType,
+                  parameters: JSON.stringify({
+                    description: skill.description,
+                    prompt: prepared.content,
+                    subagent_type: subagentType,
+                  }),
+                  stage: "running",
+                },
+              );
+
+              try {
+                const instance = await this.subagentManager.createInstance(
+                  config,
+                  {
+                    description: skill.description,
+                    prompt: prepared.content,
+                    subagent_type: subagentType,
+                    model: skill.model,
+                  },
+                  false,
+                  () => {
+                    // Update the tool block with progress
+                    const subagent = this.subagentManager.getInstance(
+                      instance.subagentId,
+                    );
+                    if (subagent) {
+                      const messages = subagent.messages;
+                      const tokens =
+                        subagent.messageManager.getLatestTotalTokens();
+                      const lastTools = subagent.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;
+
+                      this.messageManager.updateToolBlock({
+                        id: toolBlockId,
+                        messageId,
+                        shortResult,
+                      });
+                    }
+                  },
+                );
+
+                try {
+                  const result = await this.subagentManager.executeAgent(
+                    instance,
+                    prepared.content,
+                    signal,
+                  );
+
+                  // Update the ToolBlock with final result
+                  this.messageManager.updateToolBlock({
+                    id: toolBlockId,
+                    messageId,
+                    result,
+                    success: true,
+                    stage: "end",
+                  });
+                } finally {
+                  this.subagentManager.cleanupInstance(instance.subagentId);
+                }
+              } catch (error) {
+                // Update the ToolBlock with error
+                this.messageManager.updateToolBlock({
+                  id: toolBlockId,
+                  messageId,
+                  success: false,
+                  error: error instanceof Error ? error.message : String(error),
+                  stage: "end",
+                });
+                throw error; // Re-throw to be caught by outer catch for logging/error block
+              }
+              return;
+            }
+
             // 3. Execute bash commands asynchronously
             const result = await this.skillManager.executeSkill({
               skill_name: skill.name,
@@ -228,7 +341,6 @@ export class SlashCommandManager {
         command.description ||
         `Plugin command: ${namespacedName}${hasParameterPlaceholders(command.content) ? " (supports parameters)" : ""}`;
 
-      // Register as a regular command with a handler that executes the custom command
       this.registerCommand({
         id: namespacedId,
         name: namespacedName,
@@ -313,12 +425,22 @@ export class SlashCommandManager {
       return false;
     }
 
+    // Abort any previous command if it's still running
+    this.currentCommandAbortController?.abort();
+    this.currentCommandAbortController = new AbortController();
+
     try {
-      await command.handler(args);
+      await command.handler(args, this.currentCommandAbortController.signal);
       return true;
     } catch (error) {
-      console.error(`Failed to execute slash command ${commandId}:`, error);
+      if (error instanceof Error && error.name === "AbortError") {
+        logger?.debug(`Slash command ${commandId} was aborted`);
+      } else {
+        console.error(`Failed to execute slash command ${commandId}:`, error);
+      }
       return false;
+    } finally {
+      this.currentCommandAbortController = null;
     }
   }
 
@@ -429,5 +551,9 @@ export class SlashCommandManager {
   public abortCurrentCommand(): void {
     // Abort the AI manager if it's running
     this.aiManager.abortAIMessage();
+
+    // Abort the current slash command handler
+    this.currentCommandAbortController?.abort();
+    this.currentCommandAbortController = null;
   }
 }

package/src/managers/toolManager.ts

@@ -1,6 +1,5 @@
 import type { ToolContext, ToolPlugin, ToolResult } from "../tools/types.js";
 import { bashTool } from "../tools/bashTool.js";
-import { taskOutputTool } from "../tools/taskOutputTool.js";
 import { taskStopTool } from "../tools/taskStopTool.js";
 import { editTool } from "../tools/editTool.js";
 import { writeTool } from "../tools/writeTool.js";
@@ -9,6 +8,7 @@ import { askUserQuestionTool } from "../tools/askUserQuestion.js";
 import { cronCreateTool } from "../tools/cronCreateTool.js";
 import { cronDeleteTool } from "../tools/cronDeleteTool.js";
 import { cronListTool } from "../tools/cronListTool.js";
+import { webFetchTool } from "../tools/webFetchTool.js";
 // New tools
 import { globTool } from "../tools/globTool.js";
 import { grepTool } from "../tools/grepTool.js";
@@ -34,6 +34,7 @@ import type { SubagentManager } from "./subagentManager.js";
 import type { SkillManager } from "./skillManager.js";
 
 import { ReversionManager } from "./reversionManager.js";
+import * as aiService from "../services/aiService.js";
 
 import { Container } from "../utils/container.js";
 
@@ -101,7 +102,6 @@ class ToolManager {
   public initializeBuiltInTools(): void {
     const builtInTools = [
       bashTool,
-      taskOutputTool,
       taskStopTool,
       editTool,
       writeTool,
@@ -120,6 +120,7 @@ class ToolManager {
       cronCreateTool,
       cronDeleteTool,
       cronListTool,
+      webFetchTool,
     ];
 
     for (const tool of builtInTools) {
@@ -213,6 +214,14 @@ class ToolManager {
             "CronManager",
           )
         : undefined,
+      aiManager: this.container.has("AIManager")
+        ? this.container.get<import("./aiManager.js").AIManager>("AIManager")
+        : undefined,
+      aiService: aiService,
+      messageManager:
+        this.container.get<import("./messageManager.js").MessageManager>(
+          "MessageManager",
+        )!,
       sessionId: context.sessionId,
       toolCallId: context.toolCallId,
     };

package/src/prompts/index.ts

@@ -151,6 +151,12 @@ Any promises made to the user
 Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.
 Wrap your summary in <summary></summary> tags.`;
 
+export const WEB_CONTENT_SYSTEM_PROMPT = `You are a helpful assistant that extracts information from web content. The content is provided in Markdown format.`;
+export const BTW_SYSTEM_PROMPT = `You are a helpful assistant. Answer the user's side question based on the conversation history. 
+Do NOT say things like "Let me try...", "I'll now...", "Let me check...", or promise to take any action. 
+If you don't know the answer, say so - do not offer to look it up or investigate. 
+Simply answer the question with the information you have.`;
+
 export function buildSystemPrompt(
   basePrompt: string | undefined,
   tools: ToolPlugin[],

package/src/services/GitService.ts

@@ -4,6 +4,17 @@ import { promisify } from "util";
 const execAsync = promisify(exec);
 
 export class GitService {
+  private getTimeout(): number {
+    const envTimeout = process.env.WAVE_PLUGIN_GIT_TIMEOUT_MS;
+    if (envTimeout) {
+      const parsed = parseInt(envTimeout, 10);
+      if (!isNaN(parsed)) {
+        return parsed;
+      }
+    }
+    return 120000; // Default 120 seconds
+  }
+
   /**
    * Checks if git is installed and available in the system path
    */
@@ -50,6 +61,7 @@ export class GitService {
       const refArgs = ref ? `-b "${ref}"` : "--depth 1";
       await execAsync(`git clone ${refArgs} "${url}" "${targetPath}"`, {
         env: { ...process.env, LC_ALL: "C" },
+        timeout: this.getTimeout(),
       });
     } catch (error) {
       throw this.handleGitError(urlOrRepo, error);
@@ -73,6 +85,7 @@ export class GitService {
     try {
       await execAsync(`git -C "${targetPath}" pull`, {
         env: { ...process.env, LC_ALL: "C" },
+        timeout: this.getTimeout(),
       });
     } catch (error) {
       throw this.handleGitError(targetPath, error);
@@ -82,6 +95,13 @@ export class GitService {
   private handleGitError(context: string, error: unknown): Error {
     const stderr = (error as { stderr?: string })?.stderr || "";
     const message = (error as Error)?.message || String(error);
+    const killed = (error as { killed?: boolean })?.killed || false;
+
+    if (message.includes("ETIMEDOUT") || killed) {
+      return new Error(
+        `Git operation timed out after ${this.getTimeout() / 1000}s. The repository may be too large or the network is slow. You can increase the timeout by setting the WAVE_PLUGIN_GIT_TIMEOUT_MS environment variable.`,
+      );
+    }
 
     if (
       stderr.includes("Repository not found") ||