wave-agent-sdk 0.11.6 → 0.11.7

package/dist/utils/messageOperations.js

@@ -44,7 +44,7 @@ export const convertImageToBase64 = (imagePath) => {
 };
 export const generateMessageId = () => `msg-${randomUUID()}`;
 // Add user message
-export const addUserMessageToMessages = ({ messages, content, images, customCommandContent, source, id, }) => {
+export const addUserMessageToMessages = ({ messages, content, images, customCommandContent, source, id, isMeta, }) => {
     const blocks = [];
     // Create text block with optional customCommandContent and source
     const textBlock = {
@@ -66,6 +66,7 @@ export const addUserMessageToMessages = ({ messages, content, images, customComm
         id: id || generateMessageId(),
         role: "user",
         blocks,
+        ...(isMeta !== undefined && { isMeta }),
     };
     return [...messages, userMessage];
 };
@@ -88,7 +89,11 @@ export const updateUserMessageInMessages = (messages, id, params) => {
                 }
                 return block;
             });
-            return { ...msg, blocks: newBlocks };
+            return {
+                ...msg,
+                blocks: newBlocks,
+                ...(params.isMeta !== undefined && { isMeta: params.isMeta }),
+            };
         }
         return msg;
     });
@@ -122,12 +127,74 @@ export const addAssistantMessageToMessages = (messages, content, toolCalls, usag
     };
     return [...messages, initialAssistantMessage];
 };
-// Update Tool Block of the last assistant message
-export const updateToolBlockInMessage = ({ messages, id, parameters, result, success, error, stage, name, shortResult, startLineNumber, images, compactParams, parametersChunk, isManuallyBackgrounded, }) => {
+/**
+ * Add a tool block to a specific message by ID.
+ */
+export const addToolBlockToMessageInMessages = (messages, messageId, params) => {
+    const toolBlockId = randomUUID();
+    const newMessages = messages.map((msg) => {
+        if (msg.id === messageId) {
+            return {
+                ...msg,
+                blocks: [
+                    ...msg.blocks,
+                    {
+                        type: "tool",
+                        id: toolBlockId,
+                        name: params.name || "unknown",
+                        parameters: params.parameters || "",
+                        result: params.result || "",
+                        stage: "start",
+                        ...params,
+                    },
+                ],
+            };
+        }
+        return msg;
+    });
+    return { messages: newMessages, toolBlockId };
+};
+// Update Tool Block of the last assistant or user message
+export const updateToolBlockInMessage = ({ messages, id, messageId, parameters, result, success, error, stage, name, shortResult, startLineNumber, images, compactParams, parametersChunk, isManuallyBackgrounded, }) => {
     const newMessages = [...messages];
-    // Find the last assistant message
+    // If messageId is provided, target that specific message
+    if (messageId) {
+        const messageIndex = newMessages.findIndex((msg) => msg.id === messageId);
+        if (messageIndex !== -1) {
+            const toolBlockIndex = newMessages[messageIndex].blocks.findIndex((block) => block.type === "tool" && block.id === id);
+            if (toolBlockIndex !== -1) {
+                const toolBlock = newMessages[messageIndex].blocks[toolBlockIndex];
+                if (toolBlock.type === "tool") {
+                    if (parameters !== undefined)
+                        toolBlock.parameters = parameters;
+                    if (result !== undefined)
+                        toolBlock.result = result;
+                    if (shortResult !== undefined)
+                        toolBlock.shortResult = shortResult;
+                    if (startLineNumber !== undefined)
+                        toolBlock.startLineNumber = startLineNumber;
+                    if (images !== undefined)
+                        toolBlock.images = images;
+                    if (success !== undefined)
+                        toolBlock.success = success;
+                    if (error !== undefined)
+                        toolBlock.error = error;
+                    if (stage !== undefined)
+                        toolBlock.stage = stage;
+                    if (compactParams !== undefined)
+                        toolBlock.compactParams = compactParams;
+                    if (parametersChunk !== undefined)
+                        toolBlock.parametersChunk = parametersChunk;
+                    if (isManuallyBackgrounded !== undefined)
+                        toolBlock.isManuallyBackgrounded = isManuallyBackgrounded;
+                }
+            }
+        }
+        return newMessages;
+    }
+    // Find the last assistant or user message
     for (let i = newMessages.length - 1; i >= 0; i--) {
-        if (newMessages[i].role === "assistant") {
+        if (newMessages[i].role === "assistant" || newMessages[i].role === "user") {
             const toolBlockIndex = newMessages[i].blocks.findIndex((block) => block.type === "tool" && block.id === id);
             if (toolBlockIndex !== -1) {
                 const toolBlock = newMessages[i].blocks[toolBlockIndex];
@@ -155,9 +222,10 @@ export const updateToolBlockInMessage = ({ messages, id, parameters, result, suc
                     if (isManuallyBackgrounded !== undefined)
                         toolBlock.isManuallyBackgrounded = isManuallyBackgrounded;
                 }
+                break; // Found and updated, stop searching
             }
-            else {
-                // If existing block not found, create new one
+            else if (newMessages[i].role === "assistant") {
+                // If existing block not found in assistant message, create new one
                 // This handles cases where we're streaming tool parameters before execution
                 newMessages[i].blocks.push({
                     type: "tool",
@@ -175,8 +243,8 @@ export const updateToolBlockInMessage = ({ messages, id, parameters, result, suc
                     parametersChunk: parametersChunk,
                     isManuallyBackgrounded: isManuallyBackgrounded,
                 });
+                break; // Created and added, stop searching
             }
-            break;
         }
     }
     return newMessages;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.11.6",
+  "version": "0.11.7",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",
@@ -34,9 +34,11 @@
     "fuzzysort": "^3.1.0",
     "glob": "^13.0.0",
     "minimatch": "^10.0.3",
-    "openai": "^5.12.2"
+    "openai": "^5.12.2",
+    "turndown": "^7.2.2"
   },
   "devDependencies": {
+    "@types/turndown": "^5.0.6",
     "@vitest/coverage-v8": "^4.0.18",
     "rimraf": "^6.1.2",
     "tsc-alias": "^1.8.16",

package/src/agent.ts

@@ -35,6 +35,8 @@ import { LiveConfigManager } from "./managers/liveConfigManager.js";
 import { configValidator } from "./utils/configValidator.js";
 import { SkillManager } from "./managers/skillManager.js";
 import { TaskManager } from "./services/taskManager.js";
+import { btw } from "./services/aiService.js";
+import { convertMessagesForAPI } from "./utils/convertMessagesForAPI.js";
 import { InitializationService } from "./services/initializationService.js";
 import { InteractionService } from "./services/interactionService.js";
 import { ConfigurationService } from "./services/configurationService.js";
@@ -196,7 +198,7 @@ export class Agent {
   }
 
   public get latestTotalTokens(): number {
-    return this.messageManager.getlatestTotalTokens();
+    return this.messageManager.getLatestTotalTokens();
   }
 
   /** Get working directory */
@@ -495,6 +497,22 @@ export class Agent {
     this.messageManager.triggerShowRewind();
   }
 
+  /**
+   * Ask a side question without tool use
+   * @param question - The side question to ask
+   * @returns Promise that resolves to the AI's answer
+   */
+  public async askBtw(question: string): Promise<string> {
+    const messages = convertMessagesForAPI(this.messageManager.getMessages());
+    const result = await btw({
+      gatewayConfig: this.getGatewayConfig(),
+      modelConfig: this.getModelConfig(),
+      messages,
+      question,
+    });
+    return result.content;
+  }
+
   /**
    * Send a message to the AI agent with optional images
    *

package/src/constants/tools.ts

@@ -1,6 +1,5 @@
 export const ASK_USER_QUESTION_TOOL_NAME = "AskUserQuestion";
 export const BASH_TOOL_NAME = "Bash";
-export const TASK_OUTPUT_TOOL_NAME = "TaskOutput";
 export const TASK_STOP_TOOL_NAME = "TaskStop";
 export const EDIT_TOOL_NAME = "Edit";
 export const EXIT_PLAN_MODE_TOOL_NAME = "ExitPlanMode";
@@ -18,3 +17,4 @@ export const WRITE_TOOL_NAME = "Write";
 export const CRON_CREATE_TOOL_NAME = "CronCreate";
 export const CRON_DELETE_TOOL_NAME = "CronDelete";
 export const CRON_LIST_TOOL_NAME = "CronList";
+export const WEB_FETCH_TOOL_NAME = "WebFetch";

package/src/managers/MemoryRuleManager.ts

@@ -55,17 +55,8 @@ export class MemoryRuleManager {
 
     this.state.rules = newRules;
     const ruleCount = Object.keys(newRules).length;
+    // Removed verbose logging of all discovered rules
     logger.debug(`Discovered ${ruleCount} modular memory rules`);
-
-    if (ruleCount > 0) {
-      logger.debug("Loaded memory rules:");
-      for (const [id, rule] of Object.entries(newRules)) {
-        const pathInfo = rule.metadata.paths
-          ? `paths: ${JSON.stringify(rule.metadata.paths)}`
-          : "global (no path restriction)";
-        logger.debug(`  - ${id} (${rule.source}): ${pathInfo}`);
-      }
-    }
   }
 
   private async scanDirectory(

package/src/managers/aiManager.ts

@@ -339,6 +339,25 @@ export class AIManager {
       return;
     }
 
+    // Scan for file mentions in the last user message
+    if (recursionDepth === 0) {
+      const messages = this.messageManager.getMessages();
+      const lastMessage = messages[messages.length - 1];
+      if (lastMessage && lastMessage.role === "user") {
+        for (const block of lastMessage.blocks) {
+          if (block.type === "text") {
+            const content = block.content;
+            const fileMentionRegex = /(?:^|\s)@([\w.\-/]+)/g;
+            let match;
+            while ((match = fileMentionRegex.exec(content)) !== null) {
+              const filePath = match[1];
+              this.messageManager.touchFile(filePath);
+            }
+          }
+        }
+      }
+    }
+
     // Save session in each recursion to ensure message persistence
     await this.messageManager.saveSession();
 
@@ -798,11 +817,12 @@ export class AIManager {
             "Some tools were manually backgrounded, stopping recursion.",
           );
         } else if (!isCurrentlyAborted) {
-          // If response was truncated and no tools were called, add a continuation message
-          if (result.finish_reason === "length" && toolCalls.length === 0) {
+          // If response was truncated, add a hidden continuation message
+          if (result.finish_reason === "length") {
             this.messageManager.addUserMessage({
               content:
-                "Your response was cut off because it exceeded the output token limit. Please break your work into smaller pieces. Continue from where you left off.",
+                "Output token limit hit. Resume directly — no apology, no recap of what you were doing. Pick up mid-thought if that is where the cut happened. Break remaining work into smaller pieces.",
+              isMeta: true,
             });
           }
 

package/src/managers/messageManager.ts

@@ -8,12 +8,13 @@ import {
   updateBangInMessage,
   completeBangInMessage,
   removeLastUserMessage,
+  addToolBlockToMessageInMessages,
   UserMessageParams,
   type AgentToolBlockUpdateParams,
   generateMessageId,
 } from "../utils/messageOperations.js";
 import type { Message, Usage } from "../types/index.js";
-import { join } from "path";
+import { join, isAbsolute, relative } from "path";
 import {
   appendMessages,
   createSession,
@@ -137,7 +138,7 @@ export class MessageManager {
     return [...this._usages];
   }
 
-  public getlatestTotalTokens(): number {
+  public getLatestTotalTokens(): number {
     return this.latestTotalTokens;
   }
 
@@ -172,12 +173,7 @@ export class MessageManager {
       const filesInContext = this.getFilesInContext();
       const activeRules = this.memoryRuleManager.getActiveRules(filesInContext);
       if (activeRules.length > 0) {
-        logger?.debug(
-          `Active modular rules (${activeRules.length}): ${activeRules.map((r) => r.id).join(", ")}`,
-        );
-        if (combined) {
-          combined += "\n\n";
-        }
+        combined += "\n\n";
         combined += activeRules.map((r) => r.content).join("\n\n");
       }
     }
@@ -221,9 +217,53 @@ export class MessageManager {
     }
   }
 
+  /**
+   * Adds a file path to the set of files in context, normalizing it if necessary.
+   */
+  public touchFile(filePath: string): void {
+    const normalizedPath = isAbsolute(filePath)
+      ? relative(this.workdir, filePath)
+      : filePath;
+    this.filesInContext.add(normalizedPath);
+  }
+
+  /**
+   * Extracts and adds file paths from a message's tool blocks.
+   */
+  private addPathsFromMessage(message: Message): void {
+    for (const block of message.blocks) {
+      if (block.type === "tool" && block.parameters) {
+        try {
+          const params = JSON.parse(block.parameters) as Record<
+            string,
+            unknown
+          >;
+          const paths = this.extractPathsFromParams(params);
+          for (const p of paths) {
+            this.touchFile(p);
+          }
+        } catch {
+          // Ignore parse errors
+        }
+      }
+    }
+  }
+
   public setMessages(messages: Message[]): void {
+    const oldLength = this.messages.length;
     this.messages = [...messages];
-    this.updateFilesInContext(messages);
+
+    // Incrementally add paths from new messages
+    const newMessages = messages.slice(oldLength);
+    for (const message of newMessages) {
+      this.addPathsFromMessage(message);
+    }
+
+    // Also check if the last message was updated (common for tool blocks)
+    if (messages.length > 0 && messages.length === oldLength) {
+      this.addPathsFromMessage(messages[messages.length - 1]);
+    }
+
     this.callbacks.onMessagesChange?.([...messages]);
   }
 
@@ -296,7 +336,6 @@ export class MessageManager {
     this.rootSessionId = sessionData.rootSessionId || sessionData.id;
     this.parentSessionId = sessionData.parentSessionId;
     this.setMessages([...sessionData.messages]);
-    this.updateFilesInContext(sessionData.messages);
     this.setlatestTotalTokens(sessionData.metadata.latestTotalTokens);
 
     // Set saved message count to the number of loaded messages since they're already saved
@@ -401,6 +440,20 @@ export class MessageManager {
     // Note: Subagent-specific callbacks are now handled by SubagentManager
   }
 
+  /**
+   * Add a tool block to a specific message by ID.
+   */
+  public addToolBlockToMessage(
+    messageId: string,
+    params: Omit<AgentToolBlockUpdateParams, "id">,
+  ): string {
+    const { messages: newMessages, toolBlockId } =
+      addToolBlockToMessageInMessages(this.messages, messageId, params);
+    this.setMessages(newMessages);
+    this.callbacks.onToolBlockUpdated?.({ ...params, id: toolBlockId });
+    return toolBlockId;
+  }
+
   public addErrorBlock(error: string): void {
     const newMessages = addErrorBlockToMessage({
       messages: this.messages,
@@ -462,6 +515,19 @@ export class MessageManager {
     // Set new message list
     this.setMessages(newMessages);
 
+    // Reset and re-populate filesInContext
+    this.filesInContext.clear();
+    for (const message of this.messages) {
+      this.addPathsFromMessage(message);
+    }
+
+    // Scan compressedContent for file mentions
+    const fileMentionRegex = /(?:^|\s)@([\w.\-/]+)/g;
+    let match;
+    while ((match = fileMentionRegex.exec(compressedContent)) !== null) {
+      this.touchFile(match[1]);
+    }
+
     // Trigger compression callback
     this.callbacks.onCompressBlockAdded?.(compressedContent);
   }
@@ -794,34 +860,6 @@ export class MessageManager {
     }
   }
 
-  /**
-   * Updates the set of files mentioned in the conversation.
-   */
-  private updateFilesInContext(messages: Message[]): void {
-    this.filesInContext.clear();
-    for (const message of messages) {
-      for (const block of message.blocks) {
-        if (block.type === "tool") {
-          // Extract file paths from common tool parameters
-          if (block.parameters) {
-            try {
-              const params = JSON.parse(block.parameters) as Record<
-                string,
-                unknown
-              >;
-              const paths = this.extractPathsFromParams(params);
-              for (const p of paths) {
-                this.filesInContext.add(p);
-              }
-            } catch {
-              // Ignore parse errors
-            }
-          }
-        }
-      }
-    }
-  }
-
   private extractPathsFromParams(params: Record<string, unknown>): string[] {
     const paths: string[] = [];
     if (typeof params !== "object" || params === null) return paths;

package/src/managers/pluginManager.ts

@@ -74,9 +74,11 @@ export class PluginManager {
 
       const marketplaceService = new MarketplaceService();
 
-      // Trigger auto-update for marketplaces
+      // Trigger auto-update for marketplaces in the background
       if (!process.env.VITEST) {
-        await marketplaceService.autoUpdateAll();
+        marketplaceService.autoUpdateAll().catch((error) => {
+          logger?.error("Background marketplace auto-update failed:", error);
+        });
       }
 
       let installedRegistry = await marketplaceService.getInstalledPlugins();

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;
   }
 }