wave-agent-sdk 0.18.3 → 0.18.5

package/src/services/memory.ts

@@ -8,24 +8,26 @@ import { getGitCommonDir } from "../utils/gitUtils.js";
 import { pathEncoder } from "../utils/pathEncoder.js";
 
 export class MemoryService {
-  private _cachedProjectMemory: string = "";
-  private _cachedUserMemory: string = "";
+  private _cachedProjectMemory: string | null = null;
+  private _cachedUserMemory: string | null = null;
   private _cachedCombinedMemory: string | null = null;
+  private _cachedAutoMemoryContent: string | null = null;
 
   constructor(private container: Container) {}
 
   public get cachedProjectMemory(): string {
-    return this._cachedProjectMemory;
+    return this._cachedProjectMemory ?? "";
   }
 
   public get cachedUserMemory(): string {
-    return this._cachedUserMemory;
+    return this._cachedUserMemory ?? "";
   }
 
   public clearCache(): void {
-    this._cachedProjectMemory = "";
-    this._cachedUserMemory = "";
+    this._cachedProjectMemory = null;
+    this._cachedUserMemory = null;
     this._cachedCombinedMemory = null;
+    this._cachedAutoMemoryContent = null;
   }
 
   /**
@@ -76,15 +78,20 @@ export class MemoryService {
    * Get the first 200 lines of MEMORY.md.
    */
   async getAutoMemoryContent(workdir: string): Promise<string> {
+    if (this._cachedAutoMemoryContent !== null) {
+      return this._cachedAutoMemoryContent;
+    }
     const memoryDir = this.getAutoMemoryDirectory(workdir);
     const memoryFile = path.join(memoryDir, "MEMORY.md");
 
     try {
       const content = await fs.readFile(memoryFile, "utf-8");
       const lines = content.split("\n").slice(0, 200);
-      return lines.join("\n");
+      this._cachedAutoMemoryContent = lines.join("\n");
+      return this._cachedAutoMemoryContent;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        this._cachedAutoMemoryContent = "";
         return "";
       }
       logger.error("Failed to read auto-memory content:", error);
@@ -123,6 +130,9 @@ export class MemoryService {
   }
 
   async getUserMemoryContent(): Promise<string> {
+    if (this._cachedUserMemory !== null) {
+      return this._cachedUserMemory;
+    }
     try {
       await this.ensureUserMemoryFile();
       const content = await fs.readFile(USER_MEMORY_FILE, "utf-8");
@@ -145,13 +155,15 @@ export class MemoryService {
               contentLength: claudeContent.length,
             },
           );
-          return claudeContent;
+          this._cachedUserMemory = claudeContent;
+          return this._cachedUserMemory;
         } catch {
           // CLAUDE.md doesn't exist or can't be read, return the default template
         }
       }
 
-      return content;
+      this._cachedUserMemory = content;
+      return this._cachedUserMemory;
     } catch (error) {
       logger.error("Failed to read user memory:", error);
       return "";
@@ -159,6 +171,9 @@ export class MemoryService {
   }
 
   async readMemoryFile(workdir: string): Promise<string> {
+    if (this._cachedProjectMemory !== null) {
+      return this._cachedProjectMemory;
+    }
     const memoryFilePath = path.join(workdir, "AGENTS.md");
     try {
       const content = await fs.readFile(memoryFilePath, "utf-8");
@@ -166,7 +181,8 @@ export class MemoryService {
         memoryFilePath,
         contentLength: content.length,
       });
-      return content;
+      this._cachedProjectMemory = content;
+      return this._cachedProjectMemory;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === "ENOENT") {
         // Fallback to CLAUDE.md
@@ -177,12 +193,14 @@ export class MemoryService {
             memoryFilePath: claudeMemoryPath,
             contentLength: content.length,
           });
-          return content;
+          this._cachedProjectMemory = content;
+          return this._cachedProjectMemory;
         } catch (claudeError) {
           if ((claudeError as NodeJS.ErrnoException).code === "ENOENT") {
             logger.debug("Neither AGENTS.md nor CLAUDE.md found", {
               memoryFilePath,
             });
+            this._cachedProjectMemory = "";
             return "";
           }
           logger.error("Failed to read CLAUDE.md fallback", {
@@ -201,14 +219,14 @@ export class MemoryService {
     if (this._cachedCombinedMemory !== null) {
       return this._cachedCombinedMemory;
     }
-    this._cachedProjectMemory = await this.readMemoryFile(workdir);
-    this._cachedUserMemory = await this.getUserMemoryContent();
+    const projectMemory = await this.readMemoryFile(workdir);
+    const userMemory = await this.getUserMemoryContent();
 
     let combined = "";
-    if (this._cachedProjectMemory.trim()) combined += this._cachedProjectMemory;
-    if (this._cachedUserMemory.trim()) {
+    if (projectMemory.trim()) combined += projectMemory;
+    if (userMemory.trim()) {
       if (combined) combined += "\n\n";
-      combined += this._cachedUserMemory;
+      combined += userMemory;
     }
     this._cachedCombinedMemory = combined;
     return combined;

package/src/tools/agentTool.ts

@@ -266,10 +266,32 @@ When using the Agent tool, you must specify a subagent_type parameter to select
             });
           } catch (error) {
             if (!isBackgrounded) {
+              // Extract content from the subagent's last assistant message.
+              // aiManager.sendAIMessage() catch block already added an error
+              // block via addErrorBlock(), so the error info is in the message
+              // history — just return it directly.
+              let content = "";
+              try {
+                const messages = instance.messageManager.getMessages();
+                const lastAssistant = messages
+                  .filter((m) => m.role === "assistant")
+                  .pop();
+                if (lastAssistant) {
+                  content = lastAssistant.blocks
+                    .filter((b) => b.type === "text" || b.type === "error")
+                    .map((b) => (b as { content: string }).content)
+                    .join("\n")
+                    .trim();
+                }
+              } catch {
+                // Ignore errors when extracting messages
+              }
+
+              const errorMsg = `Agent delegation failed: ${error instanceof Error ? error.message : String(error)}`;
               resolve({
                 success: false,
-                content: "",
-                error: `Agent delegation failed: ${error instanceof Error ? error.message : String(error)}`,
+                content: content || errorMsg,
+                error: errorMsg,
                 shortResult: "Delegation error",
               });
             }

package/src/tools/bashTool.ts

@@ -4,6 +4,7 @@ import * as path from "path";
 import * as os from "os";
 import { logger } from "../utils/globalLogger.js";
 import { resolveShellPath } from "../utils/shellResolver.js";
+import { toPosixPath } from "../utils/path.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
 import { processToolResult } from "../utils/toolResultStorage.js";
 import { BASH_MAX_OUTPUT_CHARS } from "../constants/toolLimits.js";
@@ -246,7 +247,8 @@ The working directory persists between commands. Try to maintain your current wo
         os.tmpdir(),
         `wave_cwd_${Date.now()}_${Math.random().toString(36).substring(2, 11)}.tmp`,
       );
-      const wrappedCommand = `${command} && pwd -P >| ${tempCwdFile}`;
+      const tempCwdFileForBash = toPosixPath(tempCwdFile);
+      const wrappedCommand = `${command} && pwd -P >| ${tempCwdFileForBash}`;
 
       const child: ChildProcess = spawn(wrappedCommand, {
         shell: shellPath || true,
@@ -264,6 +266,17 @@ The working directory persists between commands. Try to maintain your current wo
       let isBackgrounded = false;
       let isFinished = false;
 
+      // Best-effort cleanup of the temp CWD file — used by abort/error/exit paths
+      const cleanupTempFile = () => {
+        try {
+          if (fs.existsSync(tempCwdFile)) {
+            fs.unlinkSync(tempCwdFile);
+          }
+        } catch {
+          // ignore — best-effort cleanup
+        }
+      };
+
       const updateRealtimeResults = () => {
         if (isAborted || isBackgrounded || isFinished) return;
 
@@ -420,6 +433,8 @@ The working directory persists between commands. Try to maintain your current wo
             }
           }
 
+          cleanupTempFile();
+
           const processedOutput = processToolResult(
             outputBuffer + (errorBuffer ? "\n" + errorBuffer : ""),
             BASH_MAX_OUTPUT_CHARS,
@@ -491,14 +506,7 @@ The working directory persists between commands. Try to maintain your current wo
             );
             newCwd = undefined;
           } finally {
-            // Ensure temp file is cleaned up even if reading fails
-            try {
-              if (fs.existsSync(tempCwdFile)) {
-                fs.unlinkSync(tempCwdFile);
-              }
-            } catch (fileError) {
-              logger.error("Failed to clean up temp CWD file:", fileError);
-            }
+            cleanupTempFile();
           }
 
           // If CWD changed, call the onCwdChange callback and add notification
@@ -560,6 +568,7 @@ The working directory persists between commands. Try to maintain your current wo
           if (timeoutHandle) {
             clearTimeout(timeoutHandle);
           }
+          cleanupTempFile();
           resolve({
             success: false,
             content: "",

package/src/tools/editTool.ts

@@ -109,14 +109,14 @@ Usage:
       };
     }
 
-    // Touch file to track it in context
-    context.messageManager?.touchFile(filePath);
+    // Trigger conditional rule loading for this file
+    context.messageManager?.triggerFileRead(filePath);
 
-    // Enforce read-before-edit: the file must have been read first
-    if (
-      context.messageManager &&
-      !context.messageManager.hasFileInContext(filePath)
-    ) {
+    // Enforce read-before-edit: the file must have been read or written first.
+    // readFileState is populated by Read, Write, and Edit tools — single source
+    // of truth, aligned with Claude Code's readFileState approach.
+    const resolvedPath = resolvePath(filePath, context.workdir);
+    if (!context.readFileState?.has(resolvedPath)) {
       return {
         success: false,
         content: "",
@@ -125,8 +125,6 @@ Usage:
     }
 
     try {
-      const resolvedPath = resolvePath(filePath, context.workdir);
-
       // Read file content
       let originalContent: string;
       try {

package/src/tools/readTool.ts

@@ -195,8 +195,8 @@ Usage:
       };
     }
 
-    // Touch file to track it in context
-    context.messageManager?.touchFile(filePath);
+    // Trigger conditional rule loading for this file
+    context.messageManager?.triggerFileRead(filePath);
 
     // Check for binary document formats
     if (isBinaryDocument(filePath)) {

package/src/tools/writeTool.ts

@@ -68,8 +68,8 @@ Usage:
       };
     }
 
-    // Touch file to track it in context
-    context.messageManager?.touchFile(filePath);
+    // Trigger conditional rule loading for this file
+    context.messageManager?.triggerFileRead(filePath);
 
     try {
       const resolvedPath = resolvePath(filePath, context.workdir);

package/src/utils/constants.ts

@@ -30,4 +30,4 @@ export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
  * AI related constants
  */
 export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 200000; // Default token limit
-export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 16384; // Default output token limit
+export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 32000; // Default output token limit (aligned with Claude Code)

package/src/utils/containerSetup.ts

@@ -117,6 +117,7 @@ export function setupAgentContainer(
             logger.error("Failed to sync task list with session:", error);
           });
         }
+        memoryService.clearCache();
         callbacks.onSessionIdChange?.(sessionId);
       },
     },

package/src/utils/gitUtils.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import * as fsSync from "node:fs";
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 
 /**
  * Check if a directory is a git repository
@@ -31,7 +31,7 @@ export function isGitRepository(dirPath: string): string {
  */
 export function getGitRepoRoot(cwd: string): string {
   try {
-    return execSync("git rev-parse --show-toplevel", {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -48,7 +48,7 @@ export function getGitRepoRoot(cwd: string): string {
  */
 export function getGitCommonDir(cwd: string): string {
   try {
-    const commonDir = execSync("git rev-parse --git-common-dir", {
+    const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -66,7 +66,7 @@ export function getGitCommonDir(cwd: string): string {
  */
 export function getGitMainRepoRoot(cwd: string): string {
   try {
-    const output = execSync("git worktree list --porcelain", {
+    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -229,7 +229,7 @@ export function getDefaultRemoteBranch(cwd: string): string {
  */
 export function hasUncommittedChanges(cwd: string): boolean {
   try {
-    const status = execSync("git status --porcelain", {
+    const status = execFileSync("git", ["status", "--porcelain"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -249,7 +249,7 @@ export function hasUncommittedChanges(cwd: string): boolean {
 export function hasNewCommits(cwd: string, baseBranch?: string): boolean {
   try {
     const range = baseBranch ? `${baseBranch}..HEAD` : "@{u}..HEAD";
-    const log = execSync(`git log ${range} --oneline`, {
+    const log = execFileSync("git", ["log", range, "--oneline"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],

package/src/utils/openaiClient.ts

@@ -7,6 +7,28 @@ import {
 import { GatewayConfig } from "../types/config.js";
 import { logger } from "./globalLogger.js";
 
+const MAX_RETRIES = 10;
+const BASE_DELAY_MS = 500;
+const MAX_DELAY_MS = 32000;
+
+function getRetryDelay(
+  attempt: number,
+  retryAfterHeader: string | null,
+): number {
+  if (retryAfterHeader) {
+    const seconds = parseInt(retryAfterHeader, 10);
+    if (!isNaN(seconds)) {
+      return seconds * 1000;
+    }
+  }
+  const baseDelay = Math.min(
+    BASE_DELAY_MS * Math.pow(2, attempt - 1),
+    MAX_DELAY_MS,
+  );
+  const jitter = Math.random() * 0.25 * baseDelay;
+  return baseDelay + jitter;
+}
+
 type CreateParams =
   | ChatCompletionCreateParamsNonStreaming
   | ChatCompletionCreateParamsStreaming;
@@ -88,12 +110,11 @@ export class OpenAIClient {
 
     const fetchFn = (customFetch as typeof fetch) || fetch;
     let lastError: (Error & { status?: number; body?: unknown }) | undefined;
-    const maxRetries = 5;
-    const initialDelay = 2000;
+    let lastRetryAfter: string | null = null;
 
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       if (attempt > 0) {
-        const delay = initialDelay * Math.pow(2, attempt - 1);
+        const delay = getRetryDelay(attempt, lastRetryAfter);
         await new Promise((resolve) => setTimeout(resolve, delay));
       }
 
@@ -110,12 +131,13 @@ export class OpenAIClient {
         if (e instanceof Error && e.name === "AbortError") {
           throw e;
         }
-        if (attempt < maxRetries) {
+        if (attempt < MAX_RETRIES) {
           logger.warn("OpenAI API network error, retrying...", {
             attempt: attempt + 1,
             error: e,
           });
           lastError = e as Error;
+          lastRetryAfter = null;
           continue;
         }
         throw e;
@@ -144,45 +166,28 @@ export class OpenAIClient {
         }
       }
 
-      let errorBody: unknown;
+      let responseText = "";
       try {
-        const text = await response.text();
-        try {
-          errorBody = JSON.parse(text);
-        } catch (e) {
-          logger.error("Failed to parse error response body as JSON", {
-            error: e,
-            text,
-          });
-          errorBody = text;
-        }
+        responseText = await response.text();
       } catch (e) {
         logger.error("Failed to read error response text", { error: e });
-        errorBody = {};
       }
 
       const error = new Error(
-        typeof errorBody === "object" &&
-        errorBody !== null &&
-        "error" in errorBody &&
-        typeof (errorBody as { error: unknown }).error === "object" &&
-        (errorBody as { error: object }).error !== null &&
-        "message" in (errorBody as { error: { message: unknown } }).error
-          ? String((errorBody as { error: { message: string } }).error.message)
-          : typeof errorBody === "string"
-            ? errorBody
-            : response.statusText,
+        `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}: ${responseText}`,
       ) as Error & { status?: number; body?: unknown };
       error.status = response.status;
-      error.body = errorBody;
+      error.body = responseText;
 
       const retryableStatus =
         response.status === 429 ||
         (response.status >= 500 && response.status !== 501);
-      if (retryableStatus && attempt < maxRetries) {
+      if (retryableStatus && attempt < MAX_RETRIES) {
+        lastRetryAfter = response.headers.get("retry-after");
         logger.warn("OpenAI API error, retrying...", {
           attempt: attempt + 1,
           status: response.status,
+          retryAfter: lastRetryAfter,
         });
         lastError = error;
         continue;
@@ -191,7 +196,7 @@ export class OpenAIClient {
       logger.error("OpenAI API Error:", {
         status: response.status,
         statusText: response.statusText,
-        errorBody,
+        body: responseText,
       });
       throw error;
     }
@@ -222,12 +227,16 @@ export class OpenAIClient {
 
           const data = trimmedLine.slice(5).trim();
           if (data === "[DONE]") return;
+          if (!data) continue; // Skip empty data lines (keepalive heartbeats)
 
           try {
             const json = JSON.parse(data);
             yield json as ChatCompletionChunk;
           } catch (e) {
-            logger.error("Failed to parse stream chunk", { error: e, data });
+            logger.error("Failed to parse stream chunk", {
+              error: e instanceof Error ? e.message : String(e),
+              data,
+            });
           }
         }
       }

package/src/utils/path.ts

@@ -54,3 +54,13 @@ export function getDisplayPath(filePath: string, workdir: string): string {
   }
   return filePath;
 }
+
+/**
+ * Convert backslashes to forward slashes for shell compatibility on Windows.
+ * On Windows, os.tmpdir() returns paths with backslashes (e.g., C:\Users\foo\Temp),
+ * which are treated as escape characters when interpolated into shell command strings.
+ * Returns the path as-is on non-Windows platforms.
+ */
+export function toPosixPath(p: string): string {
+  return process.platform === "win32" ? p.replace(/\\/g, "/") : p;
+}

package/src/utils/taskReminder.ts

@@ -1,18 +1,12 @@
 import type { Message } from "../types/messaging.js";
 import type { Task } from "../types/tasks.js";
-import type { ChatCompletionMessageParam } from "openai/resources.js";
 
 export const TASK_REMINDER_CONFIG = {
   TURNS_SINCE_WRITE: 10,
   TURNS_BETWEEN_REMINDERS: 10,
 };
 
-const TASK_MANAGEMENT_TOOLS = new Set([
-  "TaskCreate",
-  "TaskUpdate",
-  "TaskList",
-  "TaskGet",
-]);
+const TASK_MANAGEMENT_TOOLS = new Set(["TaskCreate", "TaskUpdate"]);
 const TASK_REMINDER_MARKER = "<!-- task-reminder -->";
 
 function isQualifyingAssistantMessage(message: Message): boolean {
@@ -66,43 +60,37 @@ export function getTaskReminderTurnCounts(messages: Message[]): {
 export function buildTaskReminderText(tasks: Task[]): string {
   let text = `${TASK_REMINDER_MARKER}\n`;
   text +=
-    "Here is a gentle reminder about the task list. The user may not have explicitly asked for the following to be done, but you should check the task list to see if any tasks need attention.\n";
+    "The task tools haven't been used recently. If you're working on tasks that would benefit from tracking progress, consider using TaskCreate to add new tasks and TaskUpdate to update task status (set to in_progress when starting, completed when done). Also consider cleaning up the task list if it has become stale. Only use these if relevant to the current work. This is just a gentle reminder - ignore if not applicable. Make sure that you never mention this reminder to the user";
 
   if (tasks.length > 0) {
-    text += "\n";
+    text += "\n\nHere are the existing tasks:\n";
     for (const task of tasks) {
       text += `#${task.id} [${task.status}] ${task.subject}\n`;
     }
-  } else {
-    text += "The task list is currently empty.\n";
   }
 
   return text;
 }
 
 export function maybeInjectTaskReminder(
-  messages: ChatCompletionMessageParam[],
   turnCounts: {
     turnsSinceLastTaskManagement: number;
     turnsSinceLastReminder: number;
   },
   tasks: Task[],
-): void {
+): string | null {
   if (
     turnCounts.turnsSinceLastTaskManagement <
     TASK_REMINDER_CONFIG.TURNS_SINCE_WRITE
   ) {
-    return;
+    return null;
   }
   if (
     turnCounts.turnsSinceLastReminder <
     TASK_REMINDER_CONFIG.TURNS_BETWEEN_REMINDERS
   ) {
-    return;
+    return null;
   }
 
-  messages.push({
-    role: "user",
-    content: buildTaskReminderText(tasks),
-  } as ChatCompletionMessageParam);
+  return buildTaskReminderText(tasks);
 }