wave-agent-sdk 0.13.6 → 0.14.1

package/dist/utils/microcompact.d.ts

@@ -0,0 +1,7 @@
+import type { Message } from "../types/messaging.js";
+export interface MicrocompactOptions {
+    timeThresholdMS: number;
+    recentResultsToKeep: number;
+}
+export declare function microcompactMessages(messages: Message[], options: MicrocompactOptions): Message[];
+//# sourceMappingURL=microcompact.d.ts.map

package/dist/utils/microcompact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"microcompact.d.ts","sourceRoot":"","sources":["../../src/utils/microcompact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,uBAAuB,CAAC;AAEhE,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAID,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,EAAE,CAwFX"}

package/dist/utils/microcompact.js

@@ -0,0 +1,78 @@
+const CLEARED_RESULT = "[Old tool result content cleared]";
+export function microcompactMessages(messages, options) {
+    const { timeThresholdMS, recentResultsToKeep } = options;
+    // 1. Find the latest tool block timestamp across all assistant messages
+    let lastAssistantTime = 0;
+    for (const msg of messages) {
+        if (msg.role === "assistant") {
+            for (const block of msg.blocks) {
+                if (block.type === "tool" && block.stage === "end" && block.timestamp) {
+                    if (block.timestamp > lastAssistantTime) {
+                        lastAssistantTime = block.timestamp;
+                    }
+                }
+            }
+        }
+    }
+    // 2. If no prior assistant messages with completed tools, return unchanged
+    if (lastAssistantTime === 0) {
+        return messages;
+    }
+    // 3. If within threshold, return unchanged
+    if (Date.now() - lastAssistantTime < timeThresholdMS) {
+        return messages;
+    }
+    const toolRefs = [];
+    for (let mi = 0; mi < messages.length; mi++) {
+        const msg = messages[mi];
+        if (msg.role === "assistant") {
+            for (let bi = 0; bi < msg.blocks.length; bi++) {
+                const block = msg.blocks[bi];
+                if (block.type === "tool" && block.stage === "end" && block.timestamp) {
+                    toolRefs.push({
+                        msgIndex: mi,
+                        blockIndex: bi,
+                        timestamp: block.timestamp,
+                    });
+                }
+            }
+        }
+    }
+    toolRefs.sort((a, b) => b.timestamp - a.timestamp);
+    // 5. Mark the top N as "keep"
+    const keepSet = new Set();
+    for (let i = 0; i < Math.min(recentResultsToKeep, toolRefs.length); i++) {
+        const ref = toolRefs[i];
+        keepSet.add(`${ref.msgIndex}:${ref.blockIndex}`);
+    }
+    // 6. Deep-copy messages and clear result + shortResult on non-kept blocks
+    const result = messages.map((msg) => ({
+        ...msg,
+        blocks: msg.blocks.map((block) => {
+            if (block.type === "tool" && block.stage === "end" && block.timestamp) {
+                return { ...block };
+            }
+            return block;
+        }),
+    }));
+    // Clear non-kept tool blocks
+    for (const ref of toolRefs) {
+        const key = `${ref.msgIndex}:${ref.blockIndex}`;
+        if (!keepSet.has(key)) {
+            result[ref.msgIndex] = {
+                ...result[ref.msgIndex],
+                blocks: result[ref.msgIndex].blocks.map((b, idx) => {
+                    if (idx === ref.blockIndex && b.type === "tool") {
+                        return {
+                            ...b,
+                            result: CLEARED_RESULT,
+                            shortResult: undefined,
+                        };
+                    }
+                    return b;
+                }),
+            };
+        }
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.13.6",
+  "version": "0.14.1",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",
@@ -33,6 +33,7 @@
     "cron-parser": "^5.5.0",
     "fuzzysort": "^3.1.0",
     "glob": "^13.0.0",
+    "lru-cache": "^11.3.5",
     "minimatch": "^10.0.3",
     "openai": "^5.12.2",
     "turndown": "^7.2.2"

package/src/agent.ts

@@ -579,11 +579,13 @@ export class Agent {
 
   /** Unified interrupt method, interrupts both AI messages and command execution */
   public abortMessage(): void {
+    // Clear queue first to prevent processQueuedMessage from dequeuing
+    // when abortAIMessage triggers onLoadingChange(false)
+    this.messageQueue.clear();
+    this.options.callbacks?.onQueuedMessagesChange?.(this.queuedMessages);
     this.abortAIMessage(); // This will abort tools including Agent tool (subagents)
     this.abortBashCommand();
     this.abortSlashCommand();
-    this.messageQueue.clear();
-    this.options.callbacks?.onQueuedMessagesChange?.(this.queuedMessages);
   }
 
   /** Interrupt bash command execution */

package/src/core/plugin.ts

@@ -30,7 +30,10 @@ export class PluginCore {
     this.workdir = workdir;
     this.container = new Container();
     this.configurationService = new ConfigurationService();
-    this.marketplaceService = new MarketplaceService();
+    this.marketplaceService = new MarketplaceService(
+      this.workdir,
+      this.configurationService,
+    );
 
     // Wire up ConfigurationService in the container for PluginManager to use
     this.container.register("ConfigurationService", this.configurationService);
@@ -122,7 +125,7 @@ export class PluginCore {
     for (const m of marketplaces) {
       try {
         const manifest = await this.marketplaceService.loadMarketplaceManifest(
-          this.marketplaceService.getMarketplacePath(m),
+          this.marketplaceService.getMarketplacePath(m.source),
         );
         manifest.plugins.forEach((p) => {
           const pluginId = `${p.name}@${m.name}`;
@@ -154,15 +157,18 @@ export class PluginCore {
   /**
    * Adds a new marketplace
    */
-  async addMarketplace(input: string): Promise<KnownMarketplace> {
-    return await this.marketplaceService.addMarketplace(input);
+  async addMarketplace(
+    input: string,
+    scope: Scope = "user",
+  ): Promise<KnownMarketplace> {
+    return await this.marketplaceService.addMarketplace(input, scope);
   }
 
   /**
    * Removes a marketplace by name
    */
-  async removeMarketplace(name: string): Promise<void> {
-    await this.marketplaceService.removeMarketplace(name);
+  async removeMarketplace(name: string, scope?: Scope): Promise<void> {
+    await this.marketplaceService.removeMarketplace(name, scope);
   }
 
   /**
@@ -208,7 +214,7 @@ export class PluginCore {
    * Resolves the local path for a marketplace
    */
   getMarketplacePath(marketplace: KnownMarketplace): string {
-    return this.marketplaceService.getMarketplacePath(marketplace);
+    return this.marketplaceService.getMarketplacePath(marketplace.source);
   }
 
   /**

package/src/managers/aiManager.ts

@@ -1,6 +1,7 @@
 import { type CallAgentOptions } from "../services/aiService.js";
 import * as aiService from "../services/aiService.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
+import { microcompactMessages } from "../utils/microcompact.js";
 import { parseTaskNotificationXml } from "../utils/notificationXml.js";
 import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
 import * as fs from "node:fs/promises";
@@ -15,7 +16,6 @@ import type { ToolManager } from "./toolManager.js";
 import type { ToolContext, ToolResult } from "../tools/types.js";
 import type { MessageManager } from "./messageManager.js";
 import type { BackgroundTaskManager } from "./backgroundTaskManager.js";
-import type { NotificationQueue } from "./notificationQueue.js";
 import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 import type { HookManager } from "./hookManager.js";
 import type { ExtendedHookExecutionContext } from "../types/hooks.js";
@@ -25,6 +25,7 @@ import type { SkillManager } from "./skillManager.js";
 import { buildSystemPrompt } from "../prompts/index.js";
 import { Container } from "../utils/container.js";
 import { ConfigurationService } from "../services/configurationService.js";
+import type { NotificationQueue } from "./notificationQueue.js";
 
 import { logger } from "../utils/globalLogger.js";
 
@@ -51,11 +52,13 @@ export class AIManager {
   onLoadingChange?: (loading: boolean) => void;
   private toolAbortController: AbortController | null = null;
   private workdir: string;
+  private originalWorkdir: string;
   private systemPrompt?: string;
   private subagentType?: string; // Store subagent type for hook context
   private stream: boolean; // Streaming mode flag
   private modelOverride?: string;
   private _onCwdChange?: (newCwd: string) => void; // Store callback for CWD changes
+  private consecutiveCompressionFailures: number = 0;
 
   // Service overrides
   constructor(
@@ -63,6 +66,7 @@ export class AIManager {
     options: AIManagerOptions,
   ) {
     this.workdir = options.workdir;
+    this.originalWorkdir = options.workdir;
     this.systemPrompt = options.systemPrompt;
     this.subagentType = options.subagentType; // Store subagent type
     this.stream = options.stream ?? true; // Default to true if not specified
@@ -165,6 +169,10 @@ export class AIManager {
     return this.workdir;
   }
 
+  public getOriginalWorkdir(): string {
+    return this.originalWorkdir;
+  }
+
   public setOnCwdChange(callback: (newCwd: string) => void): void {
     this._onCwdChange = callback;
   }
@@ -234,6 +242,7 @@ export class AIManager {
       if (toolPlugin?.formatCompactParams) {
         const context: ToolContext = {
           workdir: this.workdir,
+          originalWorkdir: this.originalWorkdir,
           taskManager: this.taskManager,
         };
         return toolPlugin.formatCompactParams(toolArgs, context);
@@ -248,7 +257,6 @@ export class AIManager {
   private async handleTokenUsageAndCompression(
     usage: Usage | undefined,
     abortController: AbortController,
-    model?: string,
   ): Promise<void> {
     if (!usage) return;
 
@@ -272,6 +280,14 @@ export class AIManager {
 
       // If there are messages to compress, perform compression
       if (messagesToCompress.length > 0) {
+        // Circuit breaker: skip compression after 3 consecutive failures
+        if (this.consecutiveCompressionFailures >= 3) {
+          logger?.warn(
+            `Skipping compression: ${this.consecutiveCompressionFailures} consecutive failures`,
+          );
+          return;
+        }
+
         const recentChatMessages = convertMessagesForAPI(messagesToCompress);
 
         // Save session before compression to preserve original messages
@@ -284,7 +300,7 @@ export class AIManager {
             modelConfig: this.getModelConfig(),
             messages: recentChatMessages,
             abortSignal: abortController.signal,
-            model: model,
+            model: this.getModelConfig().fastModel,
           });
 
           // Handle usage tracking for compression operations
@@ -294,14 +310,91 @@ export class AIManager {
               prompt_tokens: compressionResult.usage.prompt_tokens,
               completion_tokens: compressionResult.usage.completion_tokens,
               total_tokens: compressionResult.usage.total_tokens,
-              model: model || this.getModelConfig().model,
+              model: this.getModelConfig().fastModel,
               operation_type: "compress",
             };
           }
 
+          // Build post-compact context restoration
+          const POST_COMPACT_TOKEN_BUDGET = 50_000;
+          const POST_COMPACT_MAX_TOKENS_PER_FILE = 5_000;
+          const POST_COMPACT_MAX_FILES_TO_RESTORE = 5;
+          const contextParts: string[] = [];
+
+          // 1. File context restoration
+          const recentFiles = this.messageManager.getRecentFileReads(
+            POST_COMPACT_MAX_FILES_TO_RESTORE,
+            POST_COMPACT_MAX_TOKENS_PER_FILE,
+          );
+          let usedTokens = 0;
+          for (const file of recentFiles) {
+            const fileTokens = Math.ceil(file.content.length / 4);
+            if (usedTokens + fileTokens > POST_COMPACT_MAX_TOKENS_PER_FILE)
+              continue;
+            if (fileTokens > 0) usedTokens += fileTokens;
+            contextParts.push(
+              `\n\n## ${file.path}\n\`\`\`\n${file.content}\n\`\`\``,
+            );
+            if (contextParts.length >= POST_COMPACT_MAX_FILES_TO_RESTORE) break;
+            if (usedTokens >= POST_COMPACT_TOKEN_BUDGET) break;
+          }
+
+          // 2. Working directory
+          contextParts.push(
+            `\n\n[Working Directory]\nCurrent working directory: ${this.workdir}`,
+          );
+
+          // 3. Plan mode context
+          const currentMode = this.permissionManager?.getCurrentEffectiveMode(
+            this.getModelConfig().permissionMode,
+          );
+          if (currentMode === "plan") {
+            const planFilePath = this.permissionManager?.getPlanFilePath();
+            if (planFilePath) {
+              let planExists = false;
+              try {
+                await fs.access(planFilePath);
+                planExists = true;
+              } catch {
+                // Plan file doesn't exist yet
+              }
+              contextParts.push(
+                `\n\n[Plan Mode]\nYou are in plan mode. Plan file: ${planFilePath} (exists: ${planExists})`,
+              );
+            }
+          }
+
+          // 4. Skills context
+          const skills =
+            this.skillManager
+              ?.getAvailableSkills()
+              .filter((s) => !s.disableModelInvocation) || [];
+          if (skills.length > 0) {
+            const skillList = skills
+              .map((s) => `- ${s.name}: ${s.description || ""}`)
+              .join("\n");
+            contextParts.push(`\n\n[Available Skills]\n${skillList}`);
+          }
+
+          // 5. Background agents status
+          const agents = this.backgroundTaskManager?.getAllTasks() || [];
+          if (agents.length > 0) {
+            const agentList = agents
+              .map((a) => `- Agent "${a.description}": ${a.status}`)
+              .join("\n");
+            contextParts.push(`\n\n[Background Tasks]\n${agentList}`);
+          }
+
+          // Merge context restoration into summary
+          const enhancedSummary =
+            compressionResult.content +
+            (contextParts.length > 0
+              ? `\n\n[Context Restoration]` + contextParts.join("")
+              : "");
+
           // Execute message reconstruction and sessionId update after compression
           this.messageManager.compressMessagesAndUpdateSession(
-            compressionResult.content,
+            enhancedSummary,
             compressionUsage,
           );
 
@@ -313,8 +406,13 @@ export class AIManager {
           logger?.debug(
             `Successfully compressed ${messagesToCompress.length} messages and updated session`,
           );
+          this.consecutiveCompressionFailures = 0;
         } catch (compressError) {
-          logger?.error("Failed to compress messages:", compressError);
+          this.consecutiveCompressionFailures++;
+          logger?.error(
+            `Failed to compress messages (${this.consecutiveCompressionFailures} consecutive):`,
+            compressError,
+          );
           this.messageManager.addErrorBlock(
             `Failed to compress conversation history: ${compressError instanceof Error ? compressError.message : String(compressError)}. You may encounter context limit issues.`,
           );
@@ -403,10 +501,13 @@ export class AIManager {
       toolAbortController = this.toolAbortController!;
     }
 
-    // Get recent message history
-    const recentMessages = convertMessagesForAPI(
-      this.messageManager.getMessages(),
-    );
+    // Get recent message history with microcompact applied
+    const rawMessages = this.messageManager.getMessages();
+    const microcompactedMessages = microcompactMessages(rawMessages, {
+      timeThresholdMS: 30 * 60 * 1000, // 30 minutes
+      recentResultsToKeep: 3,
+    });
+    const recentMessages = convertMessagesForAPI(microcompactedMessages);
 
     try {
       // Get combined memory content
@@ -472,6 +573,7 @@ export class AIManager {
           filteredToolPlugins,
           {
             workdir: this.workdir,
+            originalWorkdir: this.originalWorkdir,
             memory: combinedMemory,
             language: this.getLanguage(),
             isSubagent: !!this.subagentType,
@@ -658,6 +760,7 @@ export class AIManager {
                   stage: "end",
                   name: toolName,
                   compactParams: "",
+                  timestamp: Date.now(),
                 });
                 return;
               }
@@ -710,6 +813,7 @@ export class AIManager {
                 abortSignal: toolAbortController.signal,
                 backgroundTaskManager: this.backgroundTaskManager,
                 workdir: this.workdir,
+                originalWorkdir: this.originalWorkdir,
                 messageId: this.messageManager.getMessages().slice(-1)[0]?.id,
                 sessionId: this.messageManager.getSessionId(),
                 toolCallId: toolId,
@@ -774,6 +878,7 @@ export class AIManager {
                 shortResult: toolResult.shortResult,
                 isManuallyBackgrounded: toolResult.isManuallyBackgrounded,
                 startLineNumber: toolResult.startLineNumber,
+                timestamp: Date.now(),
               });
 
               // Execute PostToolUse hooks after successful tool completion
@@ -799,6 +904,7 @@ export class AIManager {
                 name: toolName,
                 compactParams,
                 isManuallyBackgrounded: false,
+                timestamp: Date.now(),
               });
             }
           },
@@ -809,11 +915,7 @@ export class AIManager {
       }
 
       // Handle token statistics and message compression
-      await this.handleTokenUsageAndCompression(
-        result.usage,
-        abortController,
-        model,
-      );
+      await this.handleTokenUsageAndCompression(result.usage, abortController);
 
       // Finalize text/reasoning blocks for the final response (no tools)
       this.messageManager.finalizeStreamingBlocks();

package/src/managers/backgroundTaskManager.ts

@@ -2,11 +2,7 @@ import { spawn, type ChildProcess } from "child_process";
 import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
-import {
-  BackgroundTask,
-  BackgroundShell,
-  BackgroundSubagent,
-} from "../types/processes.js";
+import { BackgroundTask, BackgroundShell } from "../types/processes.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
 import { logger } from "../utils/globalLogger.js";
 import { Container } from "../utils/container.js";
@@ -427,21 +423,6 @@ export class BackgroundTaskManager {
     task.runtime = task.endTime - task.startTime;
     this.notifyTasksChange();
 
-    // Enqueue killed notification
-    const notificationQueue = this.container.has("NotificationQueue")
-      ? this.container.get<NotificationQueue>("NotificationQueue")
-      : undefined;
-    if (notificationQueue) {
-      const description = (task as BackgroundSubagent).description || "";
-      const command = (task as BackgroundShell).command || "";
-      const summary =
-        task.type === "subagent"
-          ? `Agent task "${description}" was stopped`
-          : `Command "${command}" was stopped`;
-      notificationQueue.enqueue(
-        `<task-notification>\n<task-id>${id}</task-id>\n<task-type>${task.type}</task-type>\n<status>killed</status>\n<summary>${summary}</summary>\n</task-notification>`,
-      );
-    }
     return true;
   }
 

package/src/managers/messageManager.ts

@@ -16,6 +16,7 @@ import {
   generateMessageId,
 } from "../utils/messageOperations.js";
 import type { Message, Usage } from "../types/index.js";
+import { getLastApiRounds } from "../utils/groupMessagesByApiRound.js";
 import { join, isAbsolute, relative } from "path";
 import {
   appendMessages,
@@ -89,6 +90,8 @@ export class MessageManager {
   private transcriptPath: string; // Cached transcript path
   private savedMessageCount: number; // Track how many messages have been saved to prevent duplication
   private filesInContext: Set<string> = new Set(); // Track files mentioned in the conversation
+  private recentFileReads: Map<string, { content: string; timestamp: number }> =
+    new Map(); // Track file read contents
   private sessionType: "main" | "subagent";
   private subagentType?: string;
   private _usages: Usage[] = [];
@@ -266,11 +269,13 @@ export class MessageManager {
     const newMessages = messages.slice(oldLength);
     for (const message of newMessages) {
       this.addPathsFromMessage(message);
+      this.extractFileReadsFromMessage(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.extractFileReadsFromMessage(messages[messages.length - 1]);
     }
 
     this.callbacks.onMessagesChange?.([...messages]);
@@ -495,8 +500,8 @@ export class MessageManager {
     compressedContent: string,
     usage?: Usage,
   ): void {
-    // Get last 3 messages to preserve
-    const lastThreeMessages = this.messages.slice(-3);
+    // Get last 2 API rounds to preserve (structurally safe boundary)
+    const lastThreeMessages = getLastApiRounds(this.messages, 2);
 
     // Create compressed message
     const compressMessage: Message = {
@@ -994,4 +999,61 @@ export class MessageManager {
 
     return paths;
   }
+
+  /**
+   * Extract file read contents from tool result blocks in a message.
+   */
+  private extractFileReadsFromMessage(message: Message): void {
+    for (const block of message.blocks) {
+      if (
+        block.type === "tool" &&
+        block.name === "read" &&
+        block.stage === "end" &&
+        block.result &&
+        block.parameters
+      ) {
+        let filePath: string | undefined;
+        try {
+          const params = JSON.parse(block.parameters) as Record<
+            string,
+            unknown
+          >;
+          filePath = params.file_path as string | undefined;
+        } catch {
+          // Ignore parse errors
+        }
+        if (filePath) {
+          this.recentFileReads.set(filePath, {
+            content: block.result,
+            timestamp: Date.now(),
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Get recent file read contents, sorted by timestamp (newest first).
+   * @param maxFiles - Maximum number of files to return
+   * @param maxTokensPerFile - Maximum tokens per file (~4 chars/token)
+   * @returns Array of { path, content } sorted by recency
+   */
+  public getRecentFileReads(
+    maxFiles = 5,
+    maxTokensPerFile = 5000,
+  ): Array<{ path: string; content: string }> {
+    const sorted = Array.from(this.recentFileReads.entries())
+      .sort(([, a], [, b]) => b.timestamp - a.timestamp)
+      .slice(0, maxFiles);
+
+    const result: Array<{ path: string; content: string }> = [];
+    for (const [path, { content }] of sorted) {
+      const truncated =
+        content.length > maxTokensPerFile * 4
+          ? content.slice(0, maxTokensPerFile * 4)
+          : content;
+      result.push({ path, content: truncated });
+    }
+    return result;
+  }
 }

package/src/managers/permissionManager.ts

@@ -315,6 +315,13 @@ export class PermissionManager {
     return this.planFilePath;
   }
 
+  /**
+   * Public wrapper for isInsideSafeZone to check if a path is in the safe zone
+   */
+  public isPathInSafeZone(targetPath: string): boolean {
+    return this.isInsideSafeZone(targetPath).isInside;
+  }
+
   /**
    * Check if a path is inside the Safe Zone (workdir + additionalDirectories)
    */

package/src/managers/pluginManager.ts

@@ -72,7 +72,10 @@ export class PluginManager {
         );
       }
 
-      const marketplaceService = new MarketplaceService();
+      const marketplaceService = new MarketplaceService(
+        this.workdir,
+        this.configurationService,
+      );
 
       // Trigger auto-update for marketplaces in the background
       if (!process.env.VITEST) {