wave-agent-sdk 0.5.0 → 0.6.1

package/src/managers/backgroundTaskManager.ts

@@ -69,6 +69,26 @@ export class BackgroundTaskManager {
       status: "running",
       stdout: "",
       stderr: "",
+      onStop: () => {
+        try {
+          if (child.pid) {
+            process.kill(-child.pid, "SIGTERM");
+            setTimeout(() => {
+              if (child.pid && !child.killed) {
+                try {
+                  process.kill(-child.pid, "SIGKILL");
+                } catch (error) {
+                  logger.error("Failed to force kill process:", error);
+                }
+              }
+            }, 1000);
+          } else {
+            child.kill("SIGTERM");
+          }
+        } catch {
+          child.kill("SIGTERM");
+        }
+      },
     };
 
     this.tasks.set(id, shell);
@@ -155,6 +175,26 @@ export class BackgroundTaskManager {
       status: "running",
       stdout: initialStdout,
       stderr: initialStderr,
+      onStop: () => {
+        try {
+          if (child.pid) {
+            process.kill(-child.pid, "SIGTERM");
+            setTimeout(() => {
+              if (child.pid && !child.killed) {
+                try {
+                  process.kill(-child.pid, "SIGKILL");
+                } catch (error) {
+                  logger.error("Failed to force kill process:", error);
+                }
+              }
+            }, 1000);
+          } else {
+            child.kill("SIGTERM");
+          }
+        } catch {
+          child.kill("SIGTERM");
+        }
+      },
     };
 
     this.tasks.set(id, shell);
@@ -232,65 +272,24 @@ export class BackgroundTaskManager {
       return false;
     }
 
-    if (task.type === "shell") {
-      const shell = task as BackgroundShell;
+    if (task.onStop) {
       try {
-        // Try to kill process group first
-        if (shell.process.pid) {
-          process.kill(-shell.process.pid, "SIGTERM");
-
-          // Force kill after timeout
-          setTimeout(() => {
-            if (
-              shell.status === "running" &&
-              shell.process.pid &&
-              !shell.process.killed
-            ) {
-              try {
-                process.kill(-shell.process.pid, "SIGKILL");
-              } catch (error) {
-                logger.error("Failed to force kill process:", error);
-              }
-            }
-          }, 1000);
-        }
-
-        shell.status = "killed";
-        shell.endTime = Date.now();
-        shell.runtime = shell.endTime - shell.startTime;
-        this.notifyTasksChange();
-        return true;
-      } catch {
-        // Fallback to direct process kill
-        try {
-          shell.process.kill("SIGTERM");
-          setTimeout(() => {
-            if (!shell.process.killed) {
-              shell.process.kill("SIGKILL");
-            }
-          }, 1000);
-          shell.status = "killed";
-          shell.endTime = Date.now();
-          shell.runtime = shell.endTime - shell.startTime;
-          this.notifyTasksChange();
-          return true;
-        } catch (directKillError) {
-          logger.error("Failed to kill child process:", directKillError);
-          return false;
+        const result = task.onStop();
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            logger.error("Error in background task onStop callback:", error);
+          });
         }
+      } catch (error) {
+        logger.error("Error in background task onStop callback:", error);
       }
-    } else if (task.type === "subagent") {
-      // Subagent termination logic will be handled by aborting the AI loop
-      // which is already managed by the SubagentManager and AIManager.
-      // Here we just update the status.
-      task.status = "killed";
-      task.endTime = Date.now();
-      task.runtime = task.endTime - task.startTime;
-      this.notifyTasksChange();
-      return true;
     }
 
-    return false;
+    task.status = "killed";
+    task.endTime = Date.now();
+    task.runtime = task.endTime - task.startTime;
+    this.notifyTasksChange();
+    return true;
   }
 
   public cleanup(): void {

package/src/managers/foregroundTaskManager.ts

@@ -14,8 +14,9 @@ export class ForegroundTaskManager implements IForegroundTaskManager {
   }
 
   public async backgroundCurrentTask(): Promise<void> {
-    const task = this.activeForegroundTasks.pop();
-    if (task) {
+    const tasks = [...this.activeForegroundTasks].reverse();
+    this.activeForegroundTasks = [];
+    for (const task of tasks) {
       await task.backgroundHandler();
     }
   }

package/src/managers/mcpManager.ts

@@ -3,7 +3,7 @@ import { join } from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { ChatCompletionFunctionTool } from "openai/resources.js";
-import { createMcpToolPlugin, findToolServer } from "@/utils/mcpUtils.js";
+import { createMcpToolPlugin, findToolServer } from "../utils/mcpUtils.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "../tools/types.js";
 import type {
   Logger,
@@ -476,8 +476,11 @@ export class McpManager {
       const server = findToolServer(tool.name, servers);
 
       if (server) {
-        const plugin = createMcpToolPlugin(tool, server.name, (name, args) =>
-          this.executeMcpTool(name, args),
+        const plugin = createMcpToolPlugin(
+          tool,
+          server.name,
+          (name: string, args: Record<string, unknown>) =>
+            this.executeMcpTool(name, args),
         );
         mcpTools.set(plugin.name, plugin);
       }

package/src/managers/messageManager.ts

@@ -3,7 +3,6 @@ import {
   updateToolBlockInMessage,
   addErrorBlockToMessage,
   addUserMessageToMessages,
-  extractUserInputHistory,
   addCommandOutputMessage,
   updateCommandOutputInMessage,
   completeCommandInMessage,
@@ -33,7 +32,6 @@ export interface MessageManagerCallbacks {
   onMessagesChange?: (messages: Message[]) => void;
   onSessionIdChange?: (sessionId: string) => void;
   onLatestTotalTokensChange?: (latestTotalTokens: number) => void;
-  onUserInputHistoryChange?: (history: string[]) => void;
   onUsagesChange?: (usages: Usage[]) => void;
   // Incremental callback
   onUserMessageAdded?: (params: UserMessageParams) => void;
@@ -45,7 +43,7 @@ export interface MessageManagerCallbacks {
   onAssistantReasoningUpdated?: (chunk: string, accumulated: string) => void;
   onToolBlockUpdated?: (params: AgentToolBlockUpdateParams) => void;
   onErrorBlockAdded?: (error: string) => void;
-  onCompressBlockAdded?: (insertIndex: number, content: string) => void;
+  onCompressBlockAdded?: (content: string) => void;
   onCompressionStateChange?: (isCompressing: boolean) => void;
   onMemoryBlockAdded?: (
     content: string,
@@ -74,6 +72,10 @@ export interface MessageManagerCallbacks {
     subagentId: string,
     status: "active" | "completed" | "error" | "aborted",
   ) => void;
+  onFileHistoryBlockAdded?: (
+    snapshots: import("../types/reversion.js").FileSnapshot[],
+  ) => void;
+  onSubagentTaskStopRequested?: (subagentId: string) => void;
 }
 
 export interface MessageManagerOptions {
@@ -88,9 +90,10 @@ export interface MessageManagerOptions {
 export class MessageManager {
   // Private state properties
   private sessionId: string;
+  private rootSessionId: string;
+  private parentSessionId?: string;
   private messages: Message[];
   private latestTotalTokens: number;
-  private userInputHistory: string[];
   private workdir: string;
   private encodedWorkdir: string; // Cached encoded workdir
   private logger?: Logger; // Add optional logger property
@@ -104,9 +107,9 @@ export class MessageManager {
 
   constructor(options: MessageManagerOptions) {
     this.sessionId = generateSessionId();
+    this.rootSessionId = this.sessionId;
     this.messages = [];
     this.latestTotalTokens = 0;
-    this.userInputHistory = [];
     this.workdir = options.workdir;
     this.encodedWorkdir = pathEncoder.encodeSync(this.workdir); // Cache encoded workdir
     this.callbacks = options.callbacks;
@@ -125,6 +128,14 @@ export class MessageManager {
     return this.sessionId;
   }
 
+  public getRootSessionId(): string {
+    return this.rootSessionId;
+  }
+
+  public getParentSessionId(): string | undefined {
+    return this.parentSessionId;
+  }
+
   public getMessages(): Message[] {
     return [...this.messages];
   }
@@ -133,10 +144,6 @@ export class MessageManager {
     return this.latestTotalTokens;
   }
 
-  public getUserInputHistory(): string[] {
-    return [...this.userInputHistory];
-  }
-
   public getWorkdir(): string {
     return this.workdir;
   }
@@ -247,6 +254,8 @@ export class MessageManager {
         unsavedMessages, // Only append new messages
         this.workdir,
         this.sessionType,
+        this.rootSessionId,
+        this.parentSessionId,
       );
 
       // Update the saved message count
@@ -264,18 +273,13 @@ export class MessageManager {
     }
   }
 
-  public setUserInputHistory(userInputHistory: string[]): void {
-    this.userInputHistory = [...userInputHistory];
-    this.callbacks.onUserInputHistoryChange?.(this.userInputHistory);
-  }
-
   /**
-   * Clear messages and input history
+   * Clear messages
    */
   public clearMessages(): void {
     this.setMessages([]);
-    this.setUserInputHistory([]);
     this.setSessionId(generateSessionId());
+    this.rootSessionId = this.sessionId;
     this.setlatestTotalTokens(0);
     this.savedMessageCount = 0; // Reset saved message count
   }
@@ -297,36 +301,17 @@ export class MessageManager {
   // Initialize state from session data
   public initializeFromSession(sessionData: SessionData): void {
     this.setSessionId(sessionData.id);
+    this.rootSessionId = sessionData.rootSessionId || sessionData.id;
+    this.parentSessionId = sessionData.parentSessionId;
     this.setMessages([...sessionData.messages]);
     this.updateFilesInContext(sessionData.messages);
     this.setlatestTotalTokens(sessionData.metadata.latestTotalTokens);
 
-    // Extract user input history from session messages
-    this.setUserInputHistory(extractUserInputHistory(sessionData.messages));
-
     // Set saved message count to the number of loaded messages since they're already saved
     // This must be done after setSessionId which resets it to 0
     this.savedMessageCount = sessionData.messages.length;
   }
 
-  // Add to input history
-  public addToInputHistory(input: string): void {
-    // Avoid adding duplicate inputs
-    if (
-      this.userInputHistory.length > 0 &&
-      this.userInputHistory[this.userInputHistory.length - 1] === input
-    ) {
-      return;
-    }
-    // Limit history records, keep the latest 100
-    this.setUserInputHistory([...this.userInputHistory, input].slice(-100));
-  }
-
-  // Clear input history
-  public clearInputHistory(): void {
-    this.setUserInputHistory([]);
-  }
-
   // Encapsulated message operation functions
   public addUserMessage(params: UserMessageParams): void {
     const newMessages = addUserMessageToMessages({
@@ -402,17 +387,7 @@ export class MessageManager {
   public updateToolBlock(params: AgentToolBlockUpdateParams): void {
     const newMessages = updateToolBlockInMessage({
       messages: this.messages,
-      id: params.id,
-      parameters: params.parameters,
-      result: params.result,
-      success: params.success,
-      error: params.error,
-      stage: params.stage,
-      name: params.name,
-      shortResult: params.shortResult,
-      images: params.images,
-      compactParams: params.compactParams,
-      parametersChunk: params.parametersChunk,
+      ...params,
     });
     this.setMessages(newMessages);
     this.callbacks.onToolBlockUpdated?.(params);
@@ -442,14 +417,14 @@ export class MessageManager {
   }
 
   /**
-   * Compress messages and update session, delete compressed messages, only keep compressed messages and subsequent messages
+   * Compress messages and update session, delete compressed messages, only keep compressed messages and last 3 messages
    */
   public compressMessagesAndUpdateSession(
-    insertIndex: number,
     compressedContent: string,
     usage?: Usage,
   ): void {
-    const currentMessages = this.messages;
+    // Get last 3 messages to preserve
+    const lastThreeMessages = this.messages.slice(-3);
 
     // Create compressed message
     const compressMessage: Message = {
@@ -464,24 +439,24 @@ export class MessageManager {
       ...(usage && { usage }),
     };
 
-    // Convert negative index to positive index
-    const actualIndex =
-      insertIndex < 0 ? currentMessages.length + insertIndex : insertIndex;
+    // Build new message array: keep the compressed message and last 3 messages
+    const newMessages: Message[] = [compressMessage, ...lastThreeMessages];
 
-    // Build new message array: keep compressed message and all messages from actualIndex onwards
-    const newMessages: Message[] = [
-      compressMessage,
-      ...currentMessages.slice(actualIndex),
-    ];
-
-    // Update sessionId
+    // Update sessionId and parentSessionId
+    const oldSessionId = this.sessionId;
     this.setSessionId(generateSessionId());
+    this.parentSessionId = oldSessionId;
+
+    // Trigger task list update if this is the main session to ensure continuity
+    if (this.sessionType === "main") {
+      this.callbacks.onSessionIdChange?.(this.sessionId);
+    }
 
     // Set new message list
     this.setMessages(newMessages);
 
-    // Trigger compression callback, insertIndex remains unchanged
-    this.callbacks.onCompressBlockAdded?.(insertIndex, compressedContent);
+    // Trigger compression callback
+    this.callbacks.onCompressBlockAdded?.(compressedContent);
   }
 
   public addFileHistoryBlock(
@@ -496,6 +471,7 @@ export class MessageManager {
         snapshots,
       } as unknown as import("../types/index.js").MessageBlock);
       this.setMessages([...this.messages]);
+      this.callbacks.onFileHistoryBlockAdded?.(snapshots);
     }
   }
 
@@ -703,6 +679,14 @@ export class MessageManager {
     this.setMessages(newMessages);
   }
 
+  public async getFullMessageThread(): Promise<{
+    messages: Message[];
+    sessionIds: string[];
+  }> {
+    const { loadFullMessageThread } = await import("../services/session.js");
+    return loadFullMessageThread(this.sessionId, this.workdir);
+  }
+
   /**
    * Truncate history to a specific index and revert file changes.
    * @param index - The index of the user message to truncate to.
@@ -712,30 +696,110 @@ export class MessageManager {
     index: number,
     reversionManager?: import("./reversionManager.js").ReversionManager,
   ): Promise<void> {
-    if (index < 0 || index >= this.messages.length) {
+    const { messages, sessionIds } = await this.getFullMessageThread();
+
+    if (index < 0 || index >= messages.length) {
       throw new Error(`Invalid message index: ${index}`);
     }
 
-    // Identify messages to be removed
-    const messagesToRemove = this.messages.slice(index);
+    // Find which session the index belongs to
+    let targetSessionId = this.sessionId;
+    let targetIndexInSession = index;
+
+    // We need to be careful here because loadFullMessageThread might have removed "compress" blocks
+    // Let's re-calculate based on the actual messages returned.
+    // Actually, it's easier to just load sessions one by one again or keep track of counts.
+
+    // For simplicity, let's assume we want to truncate the WHOLE thread.
+    // If the index is in a previous session, we need to:
+    // 1. Load that session.
+    // 2. Truncate it.
+    // 3. Make it the current session.
+    // 4. Delete/Invalidate subsequent sessions.
+
+    // To correctly map 'index' to a session, we need to know the message count of each session
+    // as they appear in the concatenated 'messages' array.
+
+    let remainingIndex = index;
+    const { loadSessionFromJsonl } = await import("../services/session.js");
+
+    for (const sid of sessionIds) {
+      const sessionData = await loadSessionFromJsonl(sid, this.workdir);
+      if (!sessionData) continue;
+
+      const sessionMessages = sessionData.messages;
+      // If this is not the first session in the thread, it might have a compress block at the start
+      // that was removed in getFullMessageThread.
+      const hasCompressBlock = sessionMessages[0]?.blocks.some(
+        (b) => b.type === "compress",
+      );
+      const effectiveMessages =
+        hasCompressBlock && sid !== sessionIds[0]
+          ? sessionMessages.slice(1)
+          : sessionMessages;
+
+      if (remainingIndex < effectiveMessages.length) {
+        targetSessionId = sid;
+        targetIndexInSession = hasCompressBlock
+          ? remainingIndex + 1
+          : remainingIndex;
+        break;
+      }
+      remainingIndex -= effectiveMessages.length;
+    }
+
+    // Load the target session to perform truncation
+    const targetSessionData = await loadSessionFromJsonl(
+      targetSessionId,
+      this.workdir,
+    );
+    if (!targetSessionData)
+      throw new Error(`Target session ${targetSessionId} not found`);
+
+    // Identify messages to be removed (from the whole thread)
+    const messagesToRemove = messages.slice(index);
     const messageIdsToRemove = messagesToRemove
       .map((m) => m.id as string)
       .filter((id) => !!id);
 
     // Revert file changes if manager is provided
     if (reversionManager && messageIdsToRemove.length > 0) {
-      await reversionManager.revertTo(messageIdsToRemove, this.messages);
+      await reversionManager.revertTo(messageIdsToRemove, messages);
     }
 
-    // Truncate messages in memory
-    const newMessages = this.messages.slice(0, index);
-    this.setMessages(newMessages);
+    // Truncate messages in the target session
+    const newMessagesInSession = targetSessionData.messages.slice(
+      0,
+      targetIndexInSession,
+    );
+
+    // Identify subagent tasks to stop
+    for (const message of messagesToRemove) {
+      for (const block of message.blocks) {
+        if (block.type === "subagent" && block.subagentId) {
+          this.callbacks.onSubagentTaskStopRequested?.(block.subagentId);
+        }
+      }
+    }
+
+    // Update target session file
+    this.sessionId = targetSessionId;
+    this.rootSessionId = targetSessionData.rootSessionId || targetSessionId;
+    this.parentSessionId = targetSessionData.parentSessionId;
+    this.transcriptPath = this.computeTranscriptPath();
+
+    await this.rewriteSessionFile(newMessagesInSession);
 
-    // Update persistence: rewrite the session file
-    await this.rewriteSessionFile(newMessages);
+    // Update in-memory messages to the truncated session messages
+    // We do NOT include ancestor messages here to avoid exceeding context limits.
+    // The 'compress' block at the start of the session (if any) already summarizes them.
+    this.setMessages(newMessagesInSession);
 
     // Update saved message count
-    this.savedMessageCount = newMessages.length;
+    this.savedMessageCount = newMessagesInSession.length;
+
+    // Notify session ID change if it changed
+    this.callbacks.onSessionIdChange?.(this.sessionId);
   }
 
   /**

package/src/managers/permissionManager.ts

@@ -323,40 +323,30 @@ export class PermissionManager {
             workdir,
           );
           if (!isInside) {
-            this.logger?.warn(
-              "File operation outside the Safe Zone in acceptEdits mode",
+            this.logger?.info(
+              "File operation outside the Safe Zone in acceptEdits mode, falling back to manual confirmation",
               {
                 toolName: context.toolName,
                 targetPath,
                 resolvedPath,
               },
             );
-            return {
-              behavior: "deny",
-              message: `Tool '${context.toolName}' attempted to modify a file outside the Safe Zone: ${targetPath}. Operations outside the Safe Zone always require manual confirmation.`,
-            };
+            // Fall through to normal permission check flow to trigger confirmation prompt
+          } else {
+            this.logger?.debug(
+              "Permission automatically accepted for tool in acceptEdits mode",
+              {
+                toolName: context.toolName,
+              },
+            );
+            return { behavior: "allow" };
           }
         }
-
-        this.logger?.debug(
-          "Permission automatically accepted for tool in acceptEdits mode",
-          {
-            toolName: context.toolName,
-          },
-        );
-        return { behavior: "allow" };
       }
     }
 
     // 1.3 If plan mode, allow Read-only tools and Edit/Write for plan file
     if (context.permissionMode === "plan") {
-      if (context.toolName === BASH_TOOL_NAME) {
-        return {
-          behavior: "deny",
-          message: "Bash commands are not allowed in plan mode.",
-        };
-      }
-
       const writeTools = [
         EDIT_TOOL_NAME,
         MULTI_EDIT_TOOL_NAME,
@@ -492,6 +482,27 @@ export class PermissionManager {
       suggestedPrefix,
     };
 
+    // Set hidePersistentOption for out-of-bounds file operations
+    const fileTools = [
+      EDIT_TOOL_NAME,
+      MULTI_EDIT_TOOL_NAME,
+      DELETE_FILE_TOOL_NAME,
+      WRITE_TOOL_NAME,
+    ];
+    if (fileTools.includes(toolName)) {
+      const targetPath = (toolInput?.file_path || toolInput?.target_file) as
+        | string
+        | undefined;
+      const workdir = toolInput?.workdir as string | undefined;
+
+      if (targetPath) {
+        const { isInside } = this.isInsideSafeZone(targetPath, workdir);
+        if (!isInside) {
+          context.hidePersistentOption = true;
+        }
+      }
+    }
+
     // Set hidePersistentOption for dangerous or out-of-bounds bash commands
     if (toolName === BASH_TOOL_NAME && toolInput?.command) {
       const command = String(toolInput.command);

package/src/managers/planManager.ts

@@ -17,7 +17,7 @@ export class PlanManager {
   /**
    * Ensures the plan directory exists and generates a new plan file path with a random name
    */
-  public async getOrGeneratePlanFilePath(): Promise<{
+  public async getOrGeneratePlanFilePath(seed?: string): Promise<{
     path: string;
     name: string;
   }> {
@@ -30,7 +30,7 @@ export class PlanManager {
       );
       throw error;
     }
-    const name = generateRandomName();
+    const name = generateRandomName(seed);
     const filePath = path.join(this.planDir, `${name}.md`);
     this.logger?.info(`Generated plan file path: ${filePath}`);
     return { path: filePath, name };

package/src/managers/slashCommandManager.ts

@@ -1,6 +1,7 @@
 import type { MessageManager } from "./messageManager.js";
 import type { AIManager } from "./aiManager.js";
 import type { BackgroundTaskManager } from "./backgroundTaskManager.js";
+import type { TaskManager } from "../services/taskManager.js";
 import type {
   SlashCommand,
   CustomSlashCommand,
@@ -28,6 +29,7 @@ export interface SlashCommandManagerOptions {
   messageManager: MessageManager;
   aiManager: AIManager;
   backgroundTaskManager: BackgroundTaskManager;
+  taskManager: TaskManager;
   workdir: string;
   logger?: Logger;
 }
@@ -38,6 +40,7 @@ export class SlashCommandManager {
   private messageManager: MessageManager;
   private aiManager: AIManager;
   private backgroundTaskManager: BackgroundTaskManager;
+  private taskManager: TaskManager;
   private workdir: string;
   private logger?: Logger;
 
@@ -45,6 +48,7 @@ export class SlashCommandManager {
     this.messageManager = options.messageManager;
     this.aiManager = options.aiManager;
     this.backgroundTaskManager = options.backgroundTaskManager;
+    this.taskManager = options.taskManager;
     this.workdir = options.workdir;
     this.logger = options.logger;
 
@@ -61,8 +65,13 @@ export class SlashCommandManager {
       handler: () => {
         // Clear chat messages
         this.messageManager.clearMessages();
-        // Clear terminal screen
-        process.stdout.write("\x1Bc");
+
+        // Reset task list if WAVE_TASK_LIST_ID is not set
+        if (!process.env.WAVE_TASK_LIST_ID) {
+          const newTaskListId = this.messageManager.getRootSessionId();
+          this.taskManager.setTaskListId(newTaskListId);
+          this.taskManager.emit("tasksChange", newTaskListId);
+        }
       },
     });