wave-agent-sdk 0.13.2 → 0.13.3

package/src/managers/notificationQueue.ts

@@ -0,0 +1,19 @@
+export class NotificationQueue {
+  private queue: string[] = [];
+  onNotificationsEnqueued?: () => void;
+
+  enqueue(notification: string): void {
+    this.queue.push(notification);
+    this.onNotificationsEnqueued?.();
+  }
+
+  dequeueAll(): string[] {
+    const items = [...this.queue];
+    this.queue = [];
+    return items;
+  }
+
+  hasPending(): boolean {
+    return this.queue.length > 0;
+  }
+}

package/src/managers/permissionManager.ts

@@ -50,6 +50,7 @@ const SAFE_COMMANDS = [
   "wc",
   "sleep",
   "find",
+  "sort",
 ];
 
 const DEFAULT_ALLOWED_RULES = [
@@ -867,6 +868,7 @@ export class PermissionManager {
                   cmd === "tail" ||
                   cmd === "wc" ||
                   cmd === "sleep" ||
+                  cmd === "sort" ||
                   (cmd === "find" && !isDangerousFind(part))
                 ) {
                   return true;

package/src/managers/subagentManager.ts

@@ -13,6 +13,7 @@ import {
   createAbortPromise,
 } from "../utils/abortUtils.js";
 import { BackgroundTaskManager } from "./backgroundTaskManager.js";
+import { NotificationQueue } from "./notificationQueue.js";
 import { logger } from "../utils/globalLogger.js";
 import {
   UserMessageParams,
@@ -220,6 +221,23 @@ export class SubagentManager {
     // Create a child container for the subagent to isolate its managers
     const subagentContainer = this.container.createChild();
 
+    // Register a modified AgentOptions without onLoadingChange to prevent subagent loading
+    // from affecting the parent agent's loading state
+    const parentOptions =
+      this.container.get<import("../types/agent.js").AgentOptions>(
+        "AgentOptions",
+      );
+    if (parentOptions) {
+      const subagentOptions: import("../types/agent.js").AgentOptions = {
+        ...parentOptions,
+        callbacks: {
+          ...parentOptions.callbacks,
+          onLoadingChange: undefined,
+        },
+      };
+      subagentContainer.register("AgentOptions", subagentOptions);
+    }
+
     // Create isolated PermissionManager for the subagent
     const { PermissionManager } = await import("./permissionManager.js");
     const parentPermissionManager =
@@ -289,6 +307,22 @@ export class SubagentManager {
     });
     subagentContainer.register("AIManager", aiManager);
 
+    // Create isolated NotificationQueue for the subagent/forked agent
+    const subagentNotificationQueue = new NotificationQueue();
+    subagentContainer.register("NotificationQueue", subagentNotificationQueue);
+
+    // Create isolated BackgroundTaskManager for the subagent/forked agent
+    const subagentBackgroundTaskManager = new BackgroundTaskManager(
+      subagentContainer,
+      {
+        workdir: this.workdir,
+      },
+    );
+    subagentContainer.register(
+      "BackgroundTaskManager",
+      subagentBackgroundTaskManager,
+    );
+
     const instance: SubagentInstance = {
       subagentId,
       configuration,
@@ -310,43 +344,6 @@ export class SubagentManager {
     return instance;
   }
 
-  /**
-   * Create a new subagent instance initialized with a copy of the current message history.
-   * This is used for background tasks like auto-memory extraction.
-   */
-  async forkAgent(
-    subagentType: string,
-    messages: Message[],
-    parameters: {
-      description: string;
-      allowedTools?: string[];
-      model?: string;
-      permissionModeOverride?: PermissionMode;
-    },
-    onUpdate?: () => void,
-  ): Promise<SubagentInstance> {
-    const configuration = await this.findSubagent(subagentType);
-    if (!configuration) {
-      throw new Error(`Subagent type ${subagentType} not found`);
-    }
-
-    const instance = await this.createInstance(
-      configuration,
-      {
-        ...parameters,
-        subagent_type: subagentType,
-        prompt: "", // Forked agents start with history
-      },
-      false,
-      onUpdate,
-    );
-
-    // Initialize the message manager with provided messages
-    instance.messageManager.setMessages(messages);
-
-    return instance;
-  }
-
   /**
    * Execute agent using subagent instance
    *
@@ -416,6 +413,17 @@ export class SubagentManager {
               task.endTime = Date.now();
               task.runtime = task.endTime - startTime;
             }
+
+            // Enqueue completion notification
+            const notificationQueue = this.container.has("NotificationQueue")
+              ? this.container.get<NotificationQueue>("NotificationQueue")
+              : undefined;
+            if (notificationQueue) {
+              const summary = `Agent task "${instance.description}" completed`;
+              notificationQueue.enqueue(
+                `<task-notification>\n<task-id>${taskId}</task-id>\n<task-type>agent</task-type>\n<status>completed</status>\n<summary>${summary}</summary>\n</task-notification>`,
+              );
+            }
           } catch (error) {
             const task = backgroundTaskManager?.getTask(taskId);
             if (task) {
@@ -425,6 +433,19 @@ export class SubagentManager {
               task.endTime = Date.now();
               task.runtime = task.endTime - startTime;
             }
+
+            // Enqueue error notification
+            const notificationQueue = this.container.has("NotificationQueue")
+              ? this.container.get<NotificationQueue>("NotificationQueue")
+              : undefined;
+            if (notificationQueue) {
+              const errorMsg =
+                error instanceof Error ? error.message : String(error);
+              const summary = `Agent task "${instance.description}" failed: ${errorMsg}`;
+              notificationQueue.enqueue(
+                `<task-notification>\n<task-id>${taskId}</task-id>\n<task-type>agent</task-type>\n<status>failed</status>\n<summary>${summary}</summary>\n</task-notification>`,
+              );
+            }
           }
         })();
 
@@ -568,6 +589,17 @@ export class SubagentManager {
             task.runtime = task.endTime - task.startTime;
           }
         }
+
+        // Enqueue completion notification
+        const notificationQueue = this.container.has("NotificationQueue")
+          ? this.container.get<NotificationQueue>("NotificationQueue")
+          : undefined;
+        if (notificationQueue) {
+          const summary = `Agent task "${instance.description}" completed`;
+          notificationQueue.enqueue(
+            `<task-notification>\n<task-id>${instance.backgroundTaskId}</task-id>\n<task-type>agent</task-type>\n<status>completed</status>\n<summary>${summary}</summary>\n</task-notification>`,
+          );
+        }
       }
 
       return response || "Agent completed with no text response";
@@ -592,6 +624,19 @@ export class SubagentManager {
             task.runtime = task.endTime - task.startTime;
           }
         }
+
+        // Enqueue error notification
+        const notificationQueue = this.container.has("NotificationQueue")
+          ? this.container.get<NotificationQueue>("NotificationQueue")
+          : undefined;
+        if (notificationQueue) {
+          const errorMsg =
+            error instanceof Error ? error.message : String(error);
+          const summary = `Agent task "${instance.description}" failed: ${errorMsg}`;
+          notificationQueue.enqueue(
+            `<task-notification>\n<task-id>${instance.backgroundTaskId}</task-id>\n<task-type>agent</task-type>\n<status>failed</status>\n<summary>${summary}</summary>\n</task-notification>`,
+          );
+        }
       }
       throw error;
     } finally {
@@ -721,12 +766,11 @@ export class SubagentManager {
 
             // Log tool execution to file
             if (instance.logStream) {
-              const compactParams = (params.parameters || "{}").substring(
-                0,
-                100,
-              );
+              const displayParams =
+                params.compactParams ||
+                (params.parameters || "{}").substring(0, 100);
               instance.logStream.write(
-                `[${new Date().toISOString()}] Running tool: ${params.name} with params: ${compactParams}${compactParams.length >= 100 ? "..." : ""}\n`,
+                `[${new Date().toISOString()}] ${params.name}${displayParams ? ` ${displayParams}` : ""}\n`,
               );
             }
           }

package/src/services/autoMemoryService.ts

@@ -2,7 +2,7 @@ import * as path from "node:path";
 import * as fs from "node:fs/promises";
 import { Container } from "../utils/container.js";
 import { MessageManager } from "../managers/messageManager.js";
-import { SubagentManager } from "../managers/subagentManager.js";
+import { ForkedAgentManager } from "../managers/forkedAgentManager.js";
 import { MemoryService } from "./memory.js";
 import { ConfigurationService } from "./configurationService.js";
 import { logger } from "../utils/globalLogger.js";
@@ -24,8 +24,8 @@ export class AutoMemoryService {
     return this.container.get<MessageManager>("MessageManager")!;
   }
 
-  private get subagentManager(): SubagentManager {
-    return this.container.get<SubagentManager>("SubagentManager")!;
+  private get forkedAgentManager(): ForkedAgentManager {
+    return this.container.get<ForkedAgentManager>("ForkedAgentManager")!;
   }
 
   private get memoryService(): MemoryService {
@@ -143,8 +143,13 @@ export class AutoMemoryService {
       }
     }
 
-    // Fork the general-purpose agent with restricted tool access
-    const instance = await this.subagentManager.forkAgent(
+    const prompt = buildAutoMemoryExtractionPrompt(
+      newMessageCount,
+      existingMemoriesManifest,
+    );
+
+    // Execute the forked agent in background (fire-and-forget, decoupled from BackgroundTaskManager)
+    await this.forkedAgentManager.forkAndExecute(
       "general-purpose",
       messages,
       {
@@ -157,21 +162,9 @@ export class AutoMemoryService {
           `Edit(${memoryDir}/**/*)`,
         ],
         model: "fastModel", // Use fast model for background tasks to reduce latency and cost
-        permissionModeOverride: "default", // Force default mode to prevent acceptEdits bypass
+        permissionModeOverride: "dontAsk", // Auto-deny out-of-scope writes without prompting user
       },
-    );
-
-    const prompt = buildAutoMemoryExtractionPrompt(
-      newMessageCount,
-      existingMemoriesManifest,
-    );
-
-    // Execute in background so it doesn't block the main conversation flow
-    await this.subagentManager.executeAgent(
-      instance,
       `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`,
-      undefined,
-      true, // runInBackground
     );
 
     logger.debug("Auto-memory extraction started in background.");

package/src/services/interactionService.ts

@@ -7,6 +7,7 @@ import type { ConfigurationService } from "./configurationService.js";
 import type { AIManager } from "../managers/aiManager.js";
 import type { SubagentManager } from "../managers/subagentManager.js";
 import type { TaskManager } from "./taskManager.js";
+import type { NotificationQueue } from "../managers/notificationQueue.js";
 
 export interface InteractionContext {
   messageManager: MessageManager;
@@ -58,6 +59,23 @@ export class InteractionService {
         // Don't add to history, let normal message processing logic below handle it
       }
 
+      // Inject pending notifications from background tasks
+      const notificationQueue = context.aiManager["container"].has(
+        "NotificationQueue",
+      )
+        ? context.aiManager["container"].get<NotificationQueue>(
+            "NotificationQueue",
+          )
+        : undefined;
+      if (notificationQueue && notificationQueue.hasPending()) {
+        const notifications = notificationQueue.dequeueAll();
+        for (const notification of notifications) {
+          messageManager.addUserMessage({
+            content: notification,
+          });
+        }
+      }
+
       // Handle normal AI message
       // Add user message first, will automatically sync to UI
       messageManager.addUserMessage({

package/src/types/agent.ts

@@ -95,4 +95,5 @@ export interface AgentCallbacks
   onBackgroundCurrentTask?: () => void;
   onModelChange?: (model: string) => void;
   onConfiguredModelsChange?: (models: string[]) => void;
+  onLoadingChange?: (loading: boolean) => void;
 }

package/src/types/messaging.ts

@@ -27,7 +27,8 @@ export type MessageBlock =
   | BangBlock
   | CompressBlock
   | ReasoningBlock
-  | FileHistoryBlock;
+  | FileHistoryBlock
+  | TaskNotificationBlock;
 
 export interface TextBlock {
   type: "text";
@@ -99,3 +100,12 @@ export interface FileHistoryBlock {
   type: "file_history";
   snapshots: import("./reversion.js").FileSnapshot[];
 }
+
+export interface TaskNotificationBlock {
+  type: "task_notification";
+  taskId: string;
+  taskType: "shell" | "agent";
+  status: "completed" | "failed" | "killed";
+  summary: string;
+  outputFile?: string;
+}

package/src/utils/containerSetup.ts

@@ -1,6 +1,7 @@
 import { Container } from "./container.js";
 import { ForegroundTaskManager } from "../managers/foregroundTaskManager.js";
 import { BackgroundTaskManager } from "../managers/backgroundTaskManager.js";
+import { NotificationQueue } from "../managers/notificationQueue.js";
 import { TaskManager } from "../services/taskManager.js";
 import { MessageManager } from "../managers/messageManager.js";
 import { AIManager } from "../managers/aiManager.js";
@@ -18,6 +19,7 @@ import { CronManager } from "../managers/cronManager.js";
 import { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
 import { ReversionManager } from "../managers/reversionManager.js";
 import { SubagentManager } from "../managers/subagentManager.js";
+import { ForkedAgentManager } from "../managers/forkedAgentManager.js";
 import { LiveConfigManager } from "../managers/liveConfigManager.js";
 import { ConfigurationService } from "../services/configurationService.js";
 import { ReversionService } from "../services/reversionService.js";
@@ -75,6 +77,9 @@ export function setupAgentContainer(
   const container = new Container();
   container.register("AgentOptions", options);
 
+  const notificationQueue = new NotificationQueue();
+  container.register("NotificationQueue", notificationQueue);
+
   const foregroundTaskManager = new ForegroundTaskManager(container);
   container.register("ForegroundTaskManager", foregroundTaskManager);
   container.register("ConfigurationService", configurationService);
@@ -283,6 +288,9 @@ export function setupAgentContainer(
   });
   container.register("SubagentManager", subagentManager);
 
+  const forkedAgentManager = new ForkedAgentManager(container);
+  container.register("ForkedAgentManager", forkedAgentManager);
+
   const aiManager = new AIManager(container, {
     callbacks: {
       ...callbacks,

package/src/utils/convertMessagesForAPI.ts

@@ -1,5 +1,6 @@
 import type { Message } from "../types/index.js";
 import { convertImageToBase64 } from "./messageOperations.js";
+import { taskNotificationToXml } from "./notificationXml.js";
 import { ChatCompletionMessageToolCall } from "openai/resources";
 import { stripAnsiColors } from "./stringUtils.js";
 import {
@@ -239,6 +240,14 @@ export function convertMessagesForAPI(
             text: `<local-command-stdout>\n${stripAnsiColors(block.result)}\n</local-command-stdout>`,
           });
         }
+
+        // If there is a task notification block, convert it back to XML
+        if (block.type === "task_notification") {
+          contentParts.push({
+            type: "text",
+            text: taskNotificationToXml(block),
+          });
+        }
       });
 
       // Only add user message if there is meaningful content

package/src/utils/messageOperations.ts

@@ -1,5 +1,10 @@
 import { randomUUID } from "crypto";
-import type { Message, Usage, ToolBlock } from "../types/index.js";
+import type {
+  Message,
+  Usage,
+  ToolBlock,
+  TaskNotificationBlock,
+} from "../types/index.js";
 import { MessageSource } from "../types/index.js";
 import { readFileSync } from "fs";
 import { extname } from "path";
@@ -135,6 +140,7 @@ export const addUserMessageToMessages = ({
   const textBlock = {
     type: "text" as const,
     content,
+    stage: "end" as const,
     ...(customCommandContent && { customCommandContent }),
     ...(source && { source }),
   };
@@ -584,3 +590,38 @@ export function getMessageContent(message: Message): string {
 
   return "";
 }
+
+export interface AddNotificationMessageParams {
+  messages: Message[];
+  taskId: string;
+  taskType: "shell" | "agent";
+  status: "completed" | "failed" | "killed";
+  summary: string;
+  outputFile?: string;
+}
+
+export const addNotificationMessageToMessages = ({
+  messages,
+  taskId,
+  taskType,
+  status,
+  summary,
+  outputFile,
+}: AddNotificationMessageParams): Message[] => {
+  const block: TaskNotificationBlock = {
+    type: "task_notification",
+    taskId,
+    taskType,
+    status,
+    summary,
+    ...(outputFile !== undefined && { outputFile }),
+  };
+
+  const notificationMessage: Message = {
+    id: generateMessageId(),
+    role: "user",
+    blocks: [block],
+  };
+
+  return [...messages, notificationMessage];
+};

package/src/utils/notificationXml.ts

@@ -0,0 +1,52 @@
+import type { TaskNotificationBlock } from "../types/messaging.js";
+
+export function taskNotificationToXml(block: TaskNotificationBlock): string {
+  let xml = `<task-notification>\n`;
+  xml += `<task-id>${block.taskId}</task-id>\n`;
+  xml += `<task-type>${block.taskType}</task-type>\n`;
+  if (block.outputFile) {
+    xml += `<output-file>${block.outputFile}</output-file>\n`;
+  }
+  xml += `<status>${block.status}</status>\n`;
+  xml += `<summary>${block.summary}</summary>\n`;
+  xml += `</task-notification>`;
+  return xml;
+}
+
+function extractTag(xml: string, tag: string): string | null {
+  const regex = new RegExp(`<${tag}>(.*?)</${tag}>`, "s");
+  const match = xml.match(regex);
+  return match ? match[1] : null;
+}
+
+export function parseTaskNotificationXml(
+  xml: string,
+): TaskNotificationBlock | null {
+  try {
+    const taskId = extractTag(xml, "task-id");
+    const taskType = extractTag(xml, "task-type") as "shell" | "agent" | null;
+    const status = extractTag(xml, "status") as
+      | "completed"
+      | "failed"
+      | "killed"
+      | null;
+    const summary = extractTag(xml, "summary");
+
+    if (!taskId || !taskType || !status || !summary) {
+      return null;
+    }
+
+    const outputFile = extractTag(xml, "output-file") || undefined;
+
+    return {
+      type: "task_notification",
+      taskId,
+      taskType,
+      status,
+      summary,
+      ...(outputFile && { outputFile }),
+    };
+  } catch {
+    return null;
+  }
+}

package/src/utils/pathEncoder.ts

@@ -27,7 +27,6 @@ export interface PathEncodingOptions {
   pathSeparatorReplacement?: string; // Default: '-'
   spaceReplacement?: string; // Default: '_'
   invalidCharReplacement?: string; // Default: '_'
-  preserveCase?: boolean; // Default: false (convert to lowercase)
   hashLength?: number; // Default: 8 characters
 }
 
@@ -65,7 +64,6 @@ export class PathEncoder {
       pathSeparatorReplacement: options.pathSeparatorReplacement ?? "-",
       spaceReplacement: options.spaceReplacement ?? "_",
       invalidCharReplacement: options.invalidCharReplacement ?? "_",
-      preserveCase: options.preserveCase ?? false,
       hashLength: options.hashLength ?? 8,
     };
     this.constraints = this.getFilesystemConstraints();
@@ -109,10 +107,7 @@ export class PathEncoder {
       this.options.invalidCharReplacement,
     );
 
-    // Convert to lowercase unless preserveCase is true
-    if (!this.options.preserveCase) {
-      encoded = encoded.toLowerCase();
-    }
+    // Case is preserved
 
     // Handle length limit with hash
     if (encoded.length > this.options.maxLength) {