wave-agent-sdk 0.14.3 → 0.15.0

package/src/managers/aiManager.ts

@@ -24,6 +24,7 @@ import type { SubagentManager } from "./subagentManager.js";
 import type { SkillManager } from "./skillManager.js";
 import { buildSystemPrompt } from "../prompts/index.js";
 import { Container } from "../utils/container.js";
+import { recoverTruncatedJson } from "../utils/stringUtils.js";
 import { ConfigurationService } from "../services/configurationService.js";
 import type { NotificationQueue } from "./notificationQueue.js";
 
@@ -32,7 +33,6 @@ import { logger } from "../utils/globalLogger.js";
 export interface AIManagerCallbacks {
   onCompactionStateChange?: (isCompacting: boolean) => void;
   onUsageAdded?: (usage: Usage) => void;
-  onCwdChange?: (newCwd: string) => void;
 }
 
 export interface AIManagerOptions {
@@ -44,6 +44,8 @@ export interface AIManagerOptions {
   stream?: boolean;
   /**Optional model override (e.g. for subagents) */
   modelOverride?: string;
+  /**Optional max turns limit to prevent runaway recursion (e.g. for auto-memory extraction) */
+  maxTurns?: number;
 }
 
 export class AIManager {
@@ -52,13 +54,12 @@ 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 consecutiveCompactionFailures: number = 0;
+  private readonly maxTurns?: number;
 
   // Service overrides
   constructor(
@@ -66,13 +67,12 @@ 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
     this.callbacks = options.callbacks ?? {};
     this.modelOverride = options.modelOverride;
-    this._onCwdChange = options.callbacks?.onCwdChange; // Initialize onCwdChange
+    this.maxTurns = options.maxTurns;
   }
 
   private get toolManager(): ToolManager {
@@ -169,14 +169,6 @@ export class AIManager {
     return this.workdir;
   }
 
-  public getOriginalWorkdir(): string {
-    return this.originalWorkdir;
-  }
-
-  public setOnCwdChange(callback: (newCwd: string) => void): void {
-    this._onCwdChange = callback;
-  }
-
   private isCompacting: boolean = false;
   private callbacks: AIManagerCallbacks;
 
@@ -242,7 +234,6 @@ export class AIManager {
       if (toolPlugin?.formatCompactParams) {
         const context: ToolContext = {
           workdir: this.workdir,
-          originalWorkdir: this.originalWorkdir,
           taskManager: this.taskManager,
         };
         return toolPlugin.formatCompactParams(toolArgs, context);
@@ -652,7 +643,6 @@ export class AIManager {
           filteredToolPlugins,
           {
             workdir: this.workdir,
-            originalWorkdir: this.originalWorkdir,
             memory: combinedMemory,
             language: this.getLanguage(),
             isSubagent: !!this.subagentType,
@@ -814,34 +804,45 @@ export class AIManager {
             const toolName = functionToolCall.function?.name || "";
             // Safely parse tool parameters, handle tools without parameters
             let toolArgs: Record<string, unknown> = {};
+            let jsonRecovered = false;
             const argsString = functionToolCall.function?.arguments?.trim();
 
             if (!argsString || argsString === "") {
               // Tool without parameters, use empty object
               toolArgs = {};
             } else {
+              let recoveredArgs = argsString;
               try {
                 toolArgs = JSON.parse(argsString);
-              } catch (parseError) {
-                // For non-empty but malformed JSON, still throw exception
-                let errorMessage = `Failed to parse tool arguments`;
-                if (result.finish_reason === "length") {
-                  errorMessage +=
-                    " (output truncated, please reduce your output)";
+              } catch {
+                // Attempt to recover truncated JSON (e.g., missing closing braces)
+                recoveredArgs = recoverTruncatedJson(argsString);
+                try {
+                  toolArgs = JSON.parse(recoveredArgs);
+                  jsonRecovered = true;
+                  logger.warn(
+                    `Recovered truncated JSON for tool "${toolName}"`,
+                  );
+                } catch (parseError) {
+                  let errorMessage = `Failed to parse tool arguments`;
+                  if (result.finish_reason === "length") {
+                    errorMessage +=
+                      " (output truncated, please reduce your output)";
+                  }
+                  logger?.error(errorMessage, parseError);
+                  this.messageManager.updateToolBlock({
+                    id: toolId,
+                    parameters: argsString,
+                    result: errorMessage,
+                    success: false,
+                    error: errorMessage,
+                    stage: "end",
+                    name: toolName,
+                    compactParams: "",
+                    timestamp: Date.now(),
+                  });
+                  return;
                 }
-                logger?.error(errorMessage, parseError);
-                this.messageManager.updateToolBlock({
-                  id: toolId,
-                  parameters: argsString,
-                  result: errorMessage,
-                  success: false,
-                  error: errorMessage,
-                  stage: "end",
-                  name: toolName,
-                  compactParams: "",
-                  timestamp: Date.now(),
-                });
-                return;
               }
             }
 
@@ -892,7 +893,6 @@ 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,
@@ -911,28 +911,6 @@ export class AIManager {
                     stage: "running", // Keep it in running stage while updating result
                   });
                 },
-                onCwdChange: async (newCwd: string) => {
-                  const oldCwd = this.workdir;
-                  this.workdir = newCwd;
-                  this._onCwdChange?.(newCwd);
-                  if (this.hookManager) {
-                    const sessionId = this.messageManager.getSessionId();
-                    const transcriptPath =
-                      this.messageManager.getTranscriptPath();
-                    const env = Object.fromEntries(
-                      Object.entries(process.env).filter(
-                        (e) => e[1] !== undefined,
-                      ),
-                    ) as Record<string, string>;
-                    await this.hookManager.executeCwdChangedHooks(
-                      oldCwd,
-                      newCwd,
-                      sessionId,
-                      transcriptPath,
-                      env,
-                    );
-                  }
-                },
               };
 
               // Execute tool
@@ -942,13 +920,20 @@ export class AIManager {
                 context,
               );
 
+              // Build result content, adding truncation warning if JSON was recovered
+              let toolResultContent =
+                toolResult.content ||
+                (toolResult.error ? `Error: ${toolResult.error}` : "");
+              if (jsonRecovered) {
+                toolResultContent +=
+                  "\n\n⚠️ Tool arguments were truncated (likely exceeded max output tokens). Please reduce your output or split into multiple tool calls.";
+              }
+
               // Update message state - tool execution completed
               this.messageManager.updateToolBlock({
                 id: toolId,
                 parameters: argsString,
-                result:
-                  toolResult.content ||
-                  (toolResult.error ? `Error: ${toolResult.error}` : ""),
+                result: toolResultContent,
                 success: toolResult.success,
                 error: toolResult.error,
                 stage: "end",
@@ -1001,108 +986,116 @@ export class AIManager {
 
       // Check if there are tool operations or response was truncated, if so automatically initiate next AI service call
       if (toolCalls.length > 0 || result.finish_reason === "length") {
-        // Record committed snapshots to message history
-        if (this.reversionManager) {
-          const snapshots =
-            this.reversionManager.getAndClearCommittedSnapshots();
-          if (snapshots.length > 0) {
-            this.messageManager.addFileHistoryBlock(snapshots);
-          }
-        }
-
-        // Check interruption status
-        const isCurrentlyAborted =
-          abortController.signal.aborted || toolAbortController.signal.aborted;
-
-        // Check if all tools were manually backgrounded
-        const lastMessage =
-          this.messageManager.getMessages()[
-            this.messageManager.getMessages().length - 1
-          ];
-        const toolBlocks =
-          lastMessage?.blocks.filter(
-            (block): block is import("../types/messaging.js").ToolBlock =>
-              block.type === "tool",
-          ) || [];
-        const hasBackgrounded =
-          toolBlocks.length > 0 &&
-          toolBlocks.some((block) => block.isManuallyBackgrounded);
-
-        if (hasBackgrounded) {
-          logger?.info(
-            "Some tools were manually backgrounded, stopping recursion.",
+        // Check maxTurns limit before recursing
+        if (this.maxTurns && recursionDepth + 1 >= this.maxTurns) {
+          logger?.debug(
+            `Max turns (${this.maxTurns}) reached, stopping recursion.`,
           );
-        } else if (!isCurrentlyAborted) {
-          // If response was truncated, add a hidden continuation message
-          if (result.finish_reason === "length") {
-            this.messageManager.addUserMessage({
-              content:
-                "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,
-            });
+        } else {
+          // Record committed snapshots to message history
+          if (this.reversionManager) {
+            const snapshots =
+              this.reversionManager.getAndClearCommittedSnapshots();
+            if (snapshots.length > 0) {
+              this.messageManager.addFileHistoryBlock(snapshots);
+            }
           }
 
-          // Duplicate Tool Call Detection
-          if (toolCalls.length > 0) {
-            const messages = this.messageManager.getMessages();
-            // Find the most recent assistant message BEFORE the current one that has tool blocks
-            // The current assistant message is messages[messages.length - 1]
-            let previousAssistantWithTools: Message | undefined;
-            for (let i = messages.length - 2; i >= 0; i--) {
-              const msg = messages[i];
-              if (
-                msg.role === "assistant" &&
-                msg.blocks.some((b) => b.type === "tool")
-              ) {
-                previousAssistantWithTools = msg;
-                break;
-              }
+          // Check interruption status
+          const isCurrentlyAborted =
+            abortController.signal.aborted ||
+            toolAbortController.signal.aborted;
+
+          // Check if all tools were manually backgrounded
+          const lastMessage =
+            this.messageManager.getMessages()[
+              this.messageManager.getMessages().length - 1
+            ];
+          const toolBlocks =
+            lastMessage?.blocks.filter(
+              (block): block is import("../types/messaging.js").ToolBlock =>
+                block.type === "tool",
+            ) || [];
+          const hasBackgrounded =
+            toolBlocks.length > 0 &&
+            toolBlocks.some((block) => block.isManuallyBackgrounded);
+
+          if (hasBackgrounded) {
+            logger?.info(
+              "Some tools were manually backgrounded, stopping recursion.",
+            );
+          } else if (!isCurrentlyAborted) {
+            // If response was truncated, add a hidden continuation message
+            if (result.finish_reason === "length") {
+              this.messageManager.addUserMessage({
+                content:
+                  "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,
+              });
             }
 
-            if (previousAssistantWithTools) {
-              const previousToolBlocks =
-                previousAssistantWithTools.blocks.filter(
-                  (b): b is import("../types/messaging.js").ToolBlock =>
-                    b.type === "tool",
-                );
+            // Duplicate Tool Call Detection
+            if (toolCalls.length > 0) {
+              const messages = this.messageManager.getMessages();
+              // Find the most recent assistant message BEFORE the current one that has tool blocks
+              // The current assistant message is messages[messages.length - 1]
+              let previousAssistantWithTools: Message | undefined;
+              for (let i = messages.length - 2; i >= 0; i--) {
+                const msg = messages[i];
+                if (
+                  msg.role === "assistant" &&
+                  msg.blocks.some((b) => b.type === "tool")
+                ) {
+                  previousAssistantWithTools = msg;
+                  break;
+                }
+              }
 
-              for (const currentToolCall of toolCalls) {
-                const currentName = currentToolCall.function?.name;
-                const currentArgs = currentToolCall.function?.arguments;
+              if (previousAssistantWithTools) {
+                const previousToolBlocks =
+                  previousAssistantWithTools.blocks.filter(
+                    (b): b is import("../types/messaging.js").ToolBlock =>
+                      b.type === "tool",
+                  );
 
-                const isDuplicate = previousToolBlocks.some(
-                  (prevBlock) =>
-                    prevBlock.name === currentName &&
-                    prevBlock.parameters === currentArgs,
-                );
+                for (const currentToolCall of toolCalls) {
+                  const currentName = currentToolCall.function?.name;
+                  const currentArgs = currentToolCall.function?.arguments;
 
-                if (isDuplicate && currentName) {
-                  const toolId = currentToolCall.id;
-                  const lastMessage = messages[messages.length - 1];
-                  const toolBlock = lastMessage.blocks.find(
-                    (b): b is import("../types/messaging.js").ToolBlock =>
-                      b.type === "tool" && b.id === toolId,
+                  const isDuplicate = previousToolBlocks.some(
+                    (prevBlock) =>
+                      prevBlock.name === currentName &&
+                      prevBlock.parameters === currentArgs,
                   );
-                  if (toolBlock) {
-                    const warning = `\n\nNote: You just called this tool with the same arguments in the previous turn. Please ensure you are not in a loop and consider if you need to change your approach.`;
-                    this.messageManager.updateToolBlock({
-                      id: toolId,
-                      result: (toolBlock.result || "") + warning,
-                      stage: "end",
-                    });
+
+                  if (isDuplicate && currentName) {
+                    const toolId = currentToolCall.id;
+                    const lastMessage = messages[messages.length - 1];
+                    const toolBlock = lastMessage.blocks.find(
+                      (b): b is import("../types/messaging.js").ToolBlock =>
+                        b.type === "tool" && b.id === toolId,
+                    );
+                    if (toolBlock) {
+                      const warning = `\n\nNote: You just called this tool with the same arguments in the previous turn. Please ensure you are not in a loop and consider if you need to change your approach.`;
+                      this.messageManager.updateToolBlock({
+                        id: toolId,
+                        result: (toolBlock.result || "") + warning,
+                        stage: "end",
+                      });
+                    }
                   }
                 }
               }
             }
-          }
 
-          // Recursively call AI service, increment recursion depth, and pass same configuration
-          await this.sendAIMessage({
-            recursionDepth: recursionDepth + 1,
-            model,
-            allowedRules,
-            maxTokens,
-          });
+            // Recursively call AI service, increment recursion depth, and pass same configuration
+            await this.sendAIMessage({
+              recursionDepth: recursionDepth + 1,
+              model,
+              allowedRules,
+              maxTokens,
+            });
+          }
         }
       }
     } catch (error) {

package/src/managers/forkedAgentManager.ts

@@ -47,6 +47,7 @@ export class ForkedAgentManager {
       allowedTools?: string[];
       model?: string;
       permissionModeOverride?: PermissionMode;
+      maxTurns?: number;
     },
     prompt: string,
   ): Promise<string> {
@@ -84,6 +85,7 @@ export class ForkedAgentManager {
       allowedTools?: string[];
       model?: string;
       permissionModeOverride?: PermissionMode;
+      maxTurns?: number;
     },
     prompt: string,
   ): Promise<void> {
@@ -103,6 +105,7 @@ export class ForkedAgentManager {
           allowedTools: parameters.allowedTools,
           model: parameters.model,
           permissionModeOverride: parameters.permissionModeOverride,
+          maxTurns: parameters.maxTurns,
         },
         false,
       );

package/src/managers/hookManager.ts

@@ -669,7 +669,6 @@ export class HookManager {
       event === "Stop" ||
       event === "SubagentStop" ||
       event === "WorktreeCreate" ||
-      event === "CwdChanged" ||
       event === "SessionStart" ||
       event === "SessionEnd"
     ) {
@@ -773,7 +772,6 @@ export class HookManager {
           SubagentStop: 0,
           PermissionRequest: 0,
           WorktreeCreate: 0,
-          CwdChanged: 0,
           SessionStart: 0,
           SessionEnd: 0,
         },
@@ -788,7 +786,6 @@ export class HookManager {
       SubagentStop: 0,
       PermissionRequest: 0,
       WorktreeCreate: 0,
-      CwdChanged: 0,
       SessionStart: 0,
       SessionEnd: 0,
     };
@@ -815,35 +812,6 @@ export class HookManager {
     };
   }
 
-  /**
-   * Execute CwdChanged hooks.
-   */
-  async executeCwdChangedHooks(
-    oldCwd: string,
-    newCwd: string,
-    sessionId: string,
-    transcriptPath: string,
-    env: Record<string, string>,
-  ): Promise<HookExecutionResult[]> {
-    const context: ExtendedHookExecutionContext = {
-      event: "CwdChanged",
-      projectDir: this.workdir,
-      timestamp: new Date(),
-      sessionId,
-      transcriptPath,
-      cwd: newCwd,
-      oldCwd,
-      newCwd,
-      env,
-    };
-    const results = await this.executeHooks("CwdChanged", context);
-    if (results.length > 0) {
-      // For CwdChanged hooks, we don't block, just log errors
-      this.processHookResults("CwdChanged", results);
-    }
-    return results;
-  }
-
   /**
    * Register hooks provided by a plugin
    */

package/src/managers/permissionManager.ts

@@ -131,7 +131,7 @@ export class PermissionManager {
   private planFilePath?: string;
   private worktreeName?: string;
   private mainRepoRoot?: string;
-  private originalWorkdir?: string;
+  private workdir?: string;
   private onConfiguredPermissionModeChange?: (mode: PermissionMode) => void;
   private _logger?: Logger;
 
@@ -153,7 +153,7 @@ export class PermissionManager {
 
     this.worktreeName = this.container.get<string>("WorktreeName");
     this.mainRepoRoot = this.container.get<string>("MainRepoRoot");
-    this.originalWorkdir = this.container.get<string>("Workdir");
+    this.workdir = this.container.get<string>("Workdir");
   }
 
   /**
@@ -277,7 +277,7 @@ export class PermissionManager {
    * Update the additional directories (e.g., when configuration reloads)
    */
   updateAdditionalDirectories(directories: string[]): void {
-    const workdir = this.originalWorkdir;
+    const workdir = this.workdir;
     this.additionalDirectories = directories.map((dir) => {
       if (workdir && !path.isAbsolute(dir)) {
         return path.resolve(workdir, dir);
@@ -290,7 +290,7 @@ export class PermissionManager {
    * Add a system-level additional directory that is persistent across configuration reloads
    */
   public addSystemAdditionalDirectory(directory: string): void {
-    const workdir = this.originalWorkdir;
+    const workdir = this.workdir;
     const resolvedPath =
       workdir && !path.isAbsolute(directory)
         ? path.resolve(workdir, directory)
@@ -329,7 +329,7 @@ export class PermissionManager {
     targetPath: string,
     workdir?: string,
   ): { isInside: boolean; resolvedPath: string } {
-    const effectiveWorkdir = this.originalWorkdir || workdir;
+    const effectiveWorkdir = this.workdir || workdir;
 
     // Resolve the target path relative to effectiveWorkdir if it's not absolute
     const absolutePath =
@@ -1068,7 +1068,7 @@ export class PermissionManager {
    * @param rule - The rule to add (e.g., "Bash(ls)")
    */
   public async addPermissionRule(rule: string): Promise<void> {
-    const workdir = this.originalWorkdir;
+    const workdir = this.workdir;
     if (!workdir) {
       throw new Error("Working directory not set in PermissionManager");
     }

package/src/managers/subagentManager.ts

@@ -251,6 +251,7 @@ export class SubagentManager {
       model?: string;
       stream?: boolean;
       permissionModeOverride?: PermissionMode;
+      maxTurns?: number;
     },
     runInBackground?: boolean,
     onUpdate?: () => void,
@@ -356,6 +357,7 @@ export class SubagentManager {
       subagentType: parameters.subagent_type, // Pass subagent type for hook context
       modelOverride: parameters.model || configuration.model, // Pass model override
       stream: parameters.stream ?? this.stream, // Pass streaming mode flag
+      maxTurns: parameters.maxTurns, // Pass maxTurns limit
       callbacks: {
         onUsageAdded: this.onUsageAdded,
       },

package/src/prompts/index.ts

@@ -238,7 +238,6 @@ export function buildSystemPrompt(
   tools: ToolPlugin[],
   options: {
     workdir?: string;
-    originalWorkdir?: string;
     memory?: string;
     language?: string;
     isSubagent?: boolean;
@@ -276,9 +275,8 @@ export function buildSystemPrompt(
     prompt += `\n\n${buildPlanModePrompt(options.planMode.planFilePath, options.planMode.planExists, options.isSubagent)}`;
   }
 
-  const workdirForPrompt = options.originalWorkdir || options.workdir;
-  if (workdirForPrompt) {
-    const isGitRepo = isGitRepository(workdirForPrompt);
+  if (options.workdir) {
+    const isGitRepo = isGitRepository(options.workdir);
     const platform = os.platform();
     const osVersion = `${os.type()} ${os.release()}`;
     const today = new Date().toISOString().split("T")[0];
@@ -293,7 +291,7 @@ export function buildSystemPrompt(
 
 Here is useful information about the environment you are running in:
 <env>
-Working directory: ${workdirForPrompt}
+Working directory: ${options.workdir}
 Is directory a git repo: ${isGitRepo}
 Platform: ${platform}
 Shell: ${shellName}

package/src/services/aiService.ts

@@ -377,10 +377,7 @@ export async function callAgent(
           result.content = finalContent;
         }
 
-        if (
-          typeof finalReasoningContent === "string" &&
-          finalReasoningContent.length > 0
-        ) {
+        if (typeof finalReasoningContent === "string") {
           result.reasoning_content = finalReasoningContent;
         }
 
@@ -544,6 +541,7 @@ async function processStreamingResponse(
 ): Promise<CallAgentResult> {
   let accumulatedContent = "";
   let accumulatedReasoningContent = "";
+  let hasReasoningContent = false;
   const toolCalls: {
     id: string;
     type: "function";
@@ -618,13 +616,13 @@ async function processStreamingResponse(
         }
       }
 
-      if (
-        typeof reasoning_content === "string" &&
-        reasoning_content.length > 0
-      ) {
-        accumulatedReasoningContent += reasoning_content;
-        if (onReasoningUpdate) {
-          onReasoningUpdate(accumulatedReasoningContent);
+      if (typeof reasoning_content === "string") {
+        hasReasoningContent = true;
+        if (reasoning_content.length > 0) {
+          accumulatedReasoningContent += reasoning_content;
+          if (onReasoningUpdate) {
+            onReasoningUpdate(accumulatedReasoningContent);
+          }
         }
       }
 
@@ -716,7 +714,7 @@ async function processStreamingResponse(
     result.content = accumulatedContent.trim();
   }
 
-  if (accumulatedReasoningContent) {
+  if (hasReasoningContent) {
     result.reasoning_content = accumulatedReasoningContent.trim();
   }
 

package/src/services/autoMemoryService.ts

@@ -164,6 +164,7 @@ export class AutoMemoryService {
         ],
         model: "fastModel", // Use fast model for background tasks to reduce latency and cost
         permissionModeOverride: "dontAsk", // Auto-deny out-of-scope writes without prompting user
+        maxTurns: 5, // Limit turns to prevent verification rabbit-holes
       },
       `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`,
     );