wave-agent-sdk 0.4.0 → 0.6.1

package/src/types/tasks.ts

@@ -0,0 +1,13 @@
+export type TaskStatus = "pending" | "in_progress" | "completed" | "deleted";
+
+export interface Task {
+  id: string;
+  subject: string;
+  description: string;
+  status: TaskStatus;
+  activeForm?: string;
+  owner?: string;
+  blocks: string[];
+  blockedBy: string[];
+  metadata: Record<string, unknown>;
+}

package/src/types/tools.ts

@@ -8,7 +8,6 @@
 export interface AskUserQuestionOption {
   label: string;
   description?: string;
-  isRecommended?: boolean;
 }
 
 export interface AskUserQuestion {
@@ -20,6 +19,10 @@ export interface AskUserQuestion {
 
 export interface AskUserQuestionInput {
   questions: AskUserQuestion[];
+  answers?: Record<string, string>;
+  metadata?: {
+    source?: string;
+  };
 }
 
 /**

package/src/utils/builtinSubagents.ts

@@ -1,4 +1,9 @@
-import { GENERAL_PURPOSE_SYSTEM_PROMPT } from "../constants/prompts.js";
+import {
+  BASH_SUBAGENT_SYSTEM_PROMPT,
+  GENERAL_PURPOSE_SYSTEM_PROMPT,
+  PLAN_SUBAGENT_SYSTEM_PROMPT,
+} from "../constants/prompts.js";
+import { BASH_TOOL_NAME } from "../constants/tools.js";
 import type { SubagentConfiguration } from "./subagentParser.js";
 
 /**
@@ -7,12 +12,32 @@ import type { SubagentConfiguration } from "./subagentParser.js";
  */
 export function getBuiltinSubagents(): SubagentConfiguration[] {
   return [
+    createBashSubagent(),
     createExploreSubagent(),
     createGeneralPurposeSubagent(),
+    createPlanSubagent(),
     // Add more built-in subagents here as needed
   ];
 }
 
+/**
+ * Create the Bash built-in subagent configuration
+ * Specialized for executing bash commands and git operations
+ */
+function createBashSubagent(): SubagentConfiguration {
+  return {
+    name: "Bash",
+    description:
+      "Command execution specialist for running bash commands. Use this for git operations, command execution, and other terminal tasks.",
+    systemPrompt: BASH_SUBAGENT_SYSTEM_PROMPT,
+    tools: [BASH_TOOL_NAME],
+    model: "inherit",
+    filePath: "<builtin:Bash>",
+    scope: "builtin",
+    priority: 3,
+  };
+}
+
 /**
  * Create the General-Purpose built-in subagent configuration
  * Specialized for multi-step research and implementation tasks
@@ -87,3 +112,24 @@ Complete the user's search request efficiently and report your findings clearly.
     priority: 3, // Lowest priority - can be overridden by user configs
   };
 }
+
+/**
+ * Create the Plan built-in subagent configuration
+ * Specialized for designing implementation plans and exploring codebases in read-only mode
+ */
+function createPlanSubagent(): SubagentConfiguration {
+  // Define allowed tools for read-only operations
+  const allowedTools = ["Glob", "Grep", "Read", "Bash", "LS", "LSP"];
+
+  return {
+    name: "Plan",
+    description:
+      "Software architect agent for designing implementation plans. Use this when you need to plan the implementation strategy for a task. Returns step-by-step plans, identifies critical files, and considers architectural trade-offs.",
+    systemPrompt: PLAN_SUBAGENT_SYSTEM_PROMPT,
+    tools: allowedTools,
+    model: "inherit", // Uses parent agent's model
+    filePath: "<builtin:Plan>",
+    scope: "builtin",
+    priority: 3, // Lowest priority - can be overridden by user configs
+  };
+}

package/src/utils/cacheControlUtils.ts

@@ -316,14 +316,8 @@ export function transformMessagesForClaudeCache(
   // Find the latest interval message index (20th, 40th, 60th, etc.)
   const intervalMessageIndex = findIntervalMessageIndex(messages);
 
-  // Find last system message index
-  let lastSystemIndex = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === "system") {
-      lastSystemIndex = i;
-      break;
-    }
-  }
+  // Find first system message index
+  const firstSystemIndex = messages.findIndex((m) => m.role === "system");
 
   const result = messages.map((message, index) => {
     // Validate message structure
@@ -332,14 +326,27 @@ export function transformMessagesForClaudeCache(
       return message; // Return as-is to avoid breaking the flow
     }
 
-    // Last system message: always cached (hardcoded)
-    if (message.role === "system" && index === lastSystemIndex) {
+    // First system message: always cached (hardcoded)
+    if (message.role === "system" && index === firstSystemIndex) {
+      const content =
+        (message.content as string | ChatCompletionContentPart[]) || "";
+      // If content is already an array, check if it already has cache control
+      if (Array.isArray(content)) {
+        const hasCacheControl = content.some(
+          (part) =>
+            part.type === "text" &&
+            (part as ClaudeChatCompletionContentPartText).cache_control,
+        );
+        if (hasCacheControl) {
+          return message;
+        }
+      }
+
+      const transformedContent = addCacheControlToContent(content, true);
+
       return {
         ...message,
-        content: addCacheControlToContent(
-          (message.content as string | ChatCompletionContentPart[]) || "",
-          true,
-        ),
+        content: transformedContent,
       } as ChatCompletionMessageParam;
     }
 
@@ -364,12 +371,13 @@ export function transformMessagesForClaudeCache(
         } as ChatCompletionMessageParam;
       } else {
         // For other message types without tool calls, cache the content
+        const content =
+          (message.content as string | ChatCompletionContentPart[]) || "";
+        const transformedContent = addCacheControlToContent(content, true);
+
         return {
           ...message,
-          content: addCacheControlToContent(
-            (message.content as string | ChatCompletionContentPart[]) || "",
-            true,
-          ),
+          content: transformedContent,
         } as ChatCompletionMessageParam;
       }
     }

package/src/utils/constants.ts

@@ -31,8 +31,3 @@ export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
  */
 export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 96000; // Default token limit
 export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 8192; // Default output token limit
-
-/**
- * Default number of messages to keep uncompressed
- */
-export const DEFAULT_KEEP_LAST_MESSAGES_COUNT = 7;

package/src/utils/convertMessagesForAPI.ts

@@ -57,8 +57,8 @@ export function convertMessagesForAPI(
       );
       if (compressBlock && compressBlock.type === "compress") {
         recentMessages.unshift({
-          role: "system",
-          content: `[Compressed Message Summary] ${compressBlock.content}`,
+          role: "assistant",
+          content: compressBlock.content,
         });
       }
       break;

package/src/utils/editUtils.ts

@@ -1,128 +1,90 @@
-import { mkdir, writeFile } from "fs/promises";
-import path from "path";
-import os from "os";
-import { logger } from "./globalLogger.js";
-
 /**
  * Utility functions for file editing tools
  */
 
 /**
- * Find a match in content that is identical to searchString except for a consistent indentation offset.
- *
- * Priority:
- * 1. If exact matches exist, returns searchString (letting the tool handle uniqueness/replaceAll).
- * 2. If no exact match, but exactly one unique indentation-insensitive match exists, returns that match.
- * 3. Otherwise returns null.
+ * Escape regular expression special characters
+ */
+export function escapeRegExp(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Analyze why an edit failed by finding the best partial match and highlighting mismatches.
  */
-export function findIndentationInsensitiveMatch(
+export function analyzeEditMismatch(
   content: string,
   searchString: string,
-): string | null {
-  // 1. If exact match exists, return it
-  if (content.includes(searchString)) {
-    return searchString;
-  }
-
+): string {
+  const contentLines = content.split("\n");
   const searchLines = searchString.split("\n");
-  if (searchLines.length === 0) return null;
 
-  const contentLines = content.split("\n");
-  let foundMatch: string | null = null;
+  if (searchLines.length === 0 || contentLines.length === 0) {
+    return "old_string not found in file (empty search or content)";
+  }
 
-  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
-    let offset: number | null = null;
-    let isMatch = true;
+  let bestMatchIndex = -1;
+  let bestMatchScore = -1;
 
+  // Sliding window to find the best partial match
+  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+    let currentScore = 0;
     for (let j = 0; j < searchLines.length; j++) {
-      const sLine = searchLines[j];
-      const cLine = contentLines[i + j];
-
-      const sTrimmed = sLine.trimStart();
-      const cTrimmed = cLine.trimStart();
-
-      // If trimmed content doesn't match, it's not a match
-      if (sTrimmed !== cTrimmed) {
-        isMatch = false;
-        break;
+      if (contentLines[i + j] === searchLines[j]) {
+        currentScore++;
       }
+    }
 
-      // For non-empty lines, check for consistent indentation offset
-      if (sTrimmed !== "") {
-        const sIndent = sLine.length - sTrimmed.length;
-        const cIndent = cLine.length - cTrimmed.length;
-        const currentOffset = cIndent - sIndent;
+    // Heuristic: prioritize matches where first or last lines match
+    if (contentLines[i] === searchLines[0]) currentScore += 0.5;
+    if (
+      contentLines[i + searchLines.length - 1] ===
+      searchLines[searchLines.length - 1]
+    )
+      currentScore += 0.5;
 
-        if (offset === null) {
-          offset = currentOffset;
-        } else if (offset !== currentOffset) {
-          isMatch = false;
-          break;
-        }
+    // Also consider trimmed matches to catch indentation issues
+    for (let j = 0; j < searchLines.length; j++) {
+      if (
+        contentLines[i + j].trim() === searchLines[j].trim() &&
+        contentLines[i + j] !== searchLines[j]
+      ) {
+        currentScore += 0.1;
       }
     }
 
-    if (isMatch) {
-      const matchCandidate = contentLines
-        .slice(i, i + searchLines.length)
-        .join("\n");
-      if (foundMatch !== null && foundMatch !== matchCandidate) {
-        // Multiple different smart matches found
-        return null;
-      }
-      foundMatch = matchCandidate;
+    if (currentScore > bestMatchScore) {
+      bestMatchScore = currentScore;
+      bestMatchIndex = i;
     }
   }
 
-  // If we found exactly one unique smart match (or multiple instances of the same smart match)
-  // return it. The tool will then check for uniqueness if replaceAll is false.
-  return foundMatch;
-}
-
-/**
- * Escape regular expression special characters
- */
-export function escapeRegExp(string: string): string {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/**
- * Save a snapshot of the old string and current file content for debugging
- */
-export async function saveEditErrorSnapshot(
-  filePath: string,
-  oldString: string,
-  currentContent: string,
-  toolName: string,
-): Promise<string | null> {
-  try {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const fileName = path.basename(filePath);
-    const snapshotDirName = `${timestamp}_${toolName}_${fileName}`;
-    const snapshotDir = path.join(
-      os.tmpdir(),
-      "wave-agent-edit-errors",
-      snapshotDirName,
-    );
-
-    await mkdir(snapshotDir, { recursive: true });
-
-    await Promise.all([
-      writeFile(path.join(snapshotDir, "old_string.txt"), oldString, "utf-8"),
-      writeFile(
-        path.join(snapshotDir, "file_content.txt"),
-        currentContent,
-        "utf-8",
-      ),
-    ]);
-
-    logger.error(
-      `Edit error snapshot saved to: ${snapshotDir}\nFile: ${filePath}\nTool: ${toolName}`,
-    );
+  // If no decent match found (score <= 0), return generic message
+  if (bestMatchScore <= 0) {
+    return "old_string not found in file (no similar block found)";
+  }
 
-    return snapshotDir;
-  } catch (error) {
-    logger.error(`Failed to save edit error snapshot: ${error}`);
-    return null;
+  // Generate detailed report
+  const reportLines: string[] = [
+    `old_string not found in file. Best partial match found at line ${bestMatchIndex + 1}:`,
+  ];
+
+  for (let j = 0; j < searchLines.length; j++) {
+    const lineNum = bestMatchIndex + j + 1;
+    const actualLine = contentLines[bestMatchIndex + j];
+    const expectedLine = searchLines[j];
+
+    if (actualLine === expectedLine) {
+      reportLines.push(`${lineNum.toString().padStart(4)} | ${actualLine}`);
+    } else {
+      reportLines.push(
+        `${lineNum.toString().padStart(4)} | - ${expectedLine} (expected)`,
+      );
+      reportLines.push(
+        `${lineNum.toString().padStart(4)} | + ${actualLine} (actual)`,
+      );
+    }
   }
+
+  return reportLines.join("\n");
 }

package/src/utils/messageOperations.ts

@@ -1,6 +1,5 @@
 import type { Message, Usage } from "../types/index.js";
 import { MessageSource } from "../types/index.js";
-import { DEFAULT_KEEP_LAST_MESSAGES_COUNT } from "./constants.js";
 import type { SubagentConfiguration } from "./subagentParser.js";
 import { readFileSync } from "fs";
 import { extname } from "path";
@@ -40,6 +39,7 @@ export interface UpdateToolBlockParams {
   images?: Array<{ data: string; mediaType?: string }>;
   compactParams?: string;
   parametersChunk?: string; // Incremental parameter updates for streaming
+  isManuallyBackgrounded?: boolean;
 }
 
 // Agent specific interfaces (without messages parameter)
@@ -53,14 +53,6 @@ export interface AddErrorBlockParams {
   error: string;
 }
 
-export interface AddMemoryBlockParams {
-  messages: Message[];
-  content: string;
-  isSuccess: boolean;
-  memoryType?: "project" | "user";
-  storagePath?: string;
-}
-
 export interface AddCommandOutputParams {
   messages: Message[];
   command: string;
@@ -78,26 +70,6 @@ export interface CompleteCommandParams {
   exitCode: number;
 }
 
-/**
- * Extract text content from user messages in the messages array
- * Excludes messages with source HOOK to prevent hook-generated content from entering user history
- */
-export const extractUserInputHistory = (messages: Message[]): string[] => {
-  return messages
-    .filter((message) => message.role === "user")
-    .map((message) => {
-      // Extract text block content, excluding HOOK-sourced blocks
-      const textBlocks = message.blocks.filter(
-        (block) => block.type === "text" && block.source !== MessageSource.HOOK,
-      );
-      return textBlocks
-        .map((block) => (block as { content: string }).content)
-        .join(" ")
-        .trim();
-    })
-    .filter((text) => text.length > 0); // Filter out empty text
-};
-
 /**
  * Convert image file path to base64 format
  * @param imagePath Image file path
@@ -230,6 +202,7 @@ export const updateToolBlockInMessage = ({
   images,
   compactParams,
   parametersChunk,
+  isManuallyBackgrounded,
 }: UpdateToolBlockParams): Message[] => {
   const newMessages = [...messages];
   // Find the last assistant message
@@ -253,6 +226,8 @@ export const updateToolBlockInMessage = ({
             toolBlock.compactParams = compactParams;
           if (parametersChunk !== undefined)
             toolBlock.parametersChunk = parametersChunk;
+          if (isManuallyBackgrounded !== undefined)
+            toolBlock.isManuallyBackgrounded = isManuallyBackgrounded;
         }
       } else {
         // If existing block not found, create new one
@@ -270,6 +245,7 @@ export const updateToolBlockInMessage = ({
           stage: stage ?? "start",
           compactParams: compactParams,
           parametersChunk: parametersChunk,
+          isManuallyBackgrounded: isManuallyBackgrounded,
         });
       }
       break;
@@ -315,113 +291,6 @@ export const addErrorBlockToMessage = ({
   return newMessages;
 };
 
-// Add Memory Block as new assistant message
-export const addMemoryBlockToMessage = ({
-  messages,
-  content,
-  isSuccess,
-  memoryType,
-  storagePath,
-}: AddMemoryBlockParams): Message[] => {
-  const newMessages = [...messages];
-
-  // Create new assistant message containing MemoryBlock
-  const memoryMessage: Message = {
-    role: "assistant",
-    blocks: [
-      {
-        type: "memory",
-        content,
-        isSuccess,
-        memoryType,
-        storagePath,
-      },
-    ],
-  };
-
-  // Add to end of message list
-  newMessages.push(memoryMessage);
-  return newMessages;
-};
-
-/**
- * Count valid blocks from the end
- * Only text, image, and tool type blocks are counted
- * @param messages Message array
- * @param targetCount Number of valid blocks to count
- * @returns { messageIndex: number, blockCount: number } Message index and actual counted block count
- */
-export const countValidBlocksFromEnd = (
-  messages: Message[],
-  targetCount: number,
-): { messageIndex: number; blockCount: number } => {
-  let validBlockCount = 0;
-
-  // Iterate messages from end to beginning
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i];
-
-    // Iterate through all blocks of current message
-    for (const block of message.blocks) {
-      // Only count valid block types
-      if (
-        block.type === "text" ||
-        block.type === "image" ||
-        block.type === "tool"
-      ) {
-        validBlockCount++;
-
-        // If target count reached, return current message index
-        if (validBlockCount >= targetCount) {
-          return { messageIndex: i, blockCount: validBlockCount };
-        }
-      }
-    }
-  }
-
-  // If target count not reached, return index 0
-  return { messageIndex: 0, blockCount: validBlockCount };
-};
-
-/**
- * Get messages to be compressed and insertion position
- * @param messages Message array
- * @param keepLastCount Keep the last few valid blocks uncompressed
- * @returns { messagesToCompress: Message[], insertIndex: number }
- */
-export const getMessagesToCompress = (
-  messages: Message[],
-  keepLastCount: number = DEFAULT_KEEP_LAST_MESSAGES_COUNT,
-): { messagesToCompress: Message[]; insertIndex: number } => {
-  // Calculate message position to keep from end to beginning
-  const { messageIndex } = countValidBlocksFromEnd(messages, keepLastCount);
-
-  // Find the last message containing compression block
-  let lastCompressIndex = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const hasCompressBlock = messages[i].blocks.some(
-      (block) => block.type === "compress",
-    );
-    if (hasCompressBlock) {
-      lastCompressIndex = i;
-      break;
-    }
-  }
-
-  // Determine compression start position
-  // If compression block exists, start from compression block position (include compression block)
-  // If no compression block, start from beginning
-  const startIndex = lastCompressIndex >= 0 ? lastCompressIndex : 0;
-
-  // Messages to compress are all messages from start position to before calculated position
-  const messagesToCompress = messages.slice(startIndex, messageIndex);
-
-  // Change insertion position to negative number, indicating position from end
-  const insertIndex = messageIndex - messages.length;
-
-  return { messagesToCompress, insertIndex };
-};
-
 // Add command output block to message list
 export const addCommandOutputMessage = ({
   messages,
@@ -504,6 +373,7 @@ export interface AddSubagentBlockParams {
   status: "active" | "completed" | "error" | "aborted";
   sessionId: string;
   configuration: SubagentConfiguration;
+  runInBackground?: boolean;
 }
 
 export interface UpdateSubagentBlockParams {
@@ -520,6 +390,7 @@ export const addSubagentBlockToMessage = ({
   status,
   sessionId,
   configuration,
+  runInBackground,
 }: AddSubagentBlockParams): Message[] => {
   const newMessages = [...messages];
 
@@ -544,6 +415,7 @@ export const addSubagentBlockToMessage = ({
     status,
     sessionId,
     configuration,
+    runInBackground,
   });
 
   return newMessages;
@@ -555,6 +427,7 @@ export const updateSubagentBlockInMessage = (
   updates: Partial<{
     status: "active" | "completed" | "error" | "aborted";
     sessionId: string;
+    runInBackground: boolean;
   }>,
 ): Message[] => {
   const newMessages = [...messages];
@@ -571,6 +444,9 @@ export const updateSubagentBlockInMessage = (
           if (updates.sessionId !== undefined) {
             block.sessionId = updates.sessionId;
           }
+          if (updates.runInBackground !== undefined) {
+            block.runInBackground = updates.runInBackground;
+          }
           return newMessages;
         }
       }

package/src/utils/nameGenerator.ts

@@ -71,8 +71,25 @@ const nouns = [
 /**
  * Generates a random English name (adjective-noun)
  */
-export function generateRandomName(): string {
-  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
-  const noun = nouns[Math.floor(Math.random() * nouns.length)];
+export function generateRandomName(seed?: string): string {
+  let adjIndex: number;
+  let nounIndex: number;
+
+  if (seed) {
+    // Simple hash function to derive indices from seed
+    let hash = 0;
+    for (let i = 0; i < seed.length; i++) {
+      hash = (hash << 5) - hash + seed.charCodeAt(i);
+      hash |= 0; // Convert to 32bit integer
+    }
+    adjIndex = Math.abs(hash) % adjectives.length;
+    nounIndex = Math.abs(hash >> 8) % nouns.length;
+  } else {
+    adjIndex = Math.floor(Math.random() * adjectives.length);
+    nounIndex = Math.floor(Math.random() * nouns.length);
+  }
+
+  const adj = adjectives[adjIndex];
+  const noun = nouns[nounIndex];
   return `${adj}-${noun}`;
 }

package/dist/tools/todoWriteTool.d.ts

@@ -1,6 +0,0 @@
-import type { ToolPlugin } from "./types.js";
-/**
- * TodoWrite tool for creating and managing structured task lists
- */
-export declare const todoWriteTool: ToolPlugin;
-//# sourceMappingURL=todoWriteTool.d.ts.map

package/dist/tools/todoWriteTool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"todoWriteTool.d.ts","sourceRoot":"","sources":["../../src/tools/todoWriteTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAStE;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,UAoP3B,CAAC"}