wave-agent-sdk 0.17.9 → 0.17.11

package/src/tools/readTool.ts

@@ -244,18 +244,26 @@ Usage:
 
       const stats = await stat(actualFilePath);
 
-      // Deduplication
+      // Deduplication: only dedup if the exact same range was read before
       if (context.readFileState) {
         const state = context.readFileState.get(actualFilePath);
-        if (state && state.mtime === stats.mtime.getTime()) {
-          return {
-            success: true,
-            content: `File ${filePath} has not changed since last read.`,
-            shortResult: "File unchanged",
-            metadata: {
-              type: "file_unchanged",
-            },
-          };
+        // Only dedup entries from a prior Read with explicit offset (not Edit/Write entries)
+        if (
+          state &&
+          state.mtime === stats.mtime.getTime() &&
+          state.offset !== undefined
+        ) {
+          const rangeMatch = state.offset === offset && state.limit === limit;
+          if (rangeMatch) {
+            return {
+              success: true,
+              content: `File ${filePath} has not changed since last read. The content from the earlier Read tool_result in this conversation is still current — refer to that instead of re-reading.`,
+              shortResult: "File unchanged",
+              metadata: {
+                type: "file_unchanged",
+              },
+            };
+          }
         }
       }
 
@@ -287,6 +295,8 @@ Usage:
         context.readFileState.set(actualFilePath, {
           mtime: stats.mtime.getTime(),
           hash,
+          offset, // undefined for full reads
+          limit, // undefined for full reads
         });
       }
 

package/src/tools/types.ts

@@ -31,6 +31,12 @@ export interface ToolPlugin {
     workdir?: string;
     isSubagent?: boolean;
   }) => string;
+  /**
+   * Whether this tool is safe to run in parallel with other tools.
+   * Default (undefined) = true (parallel). Set to false for tools that
+   * perform read-modify-write on shared resources (e.g. Edit, Write).
+   */
+  isConcurrencySafe?: boolean;
 }
 
 export interface ToolResult {
@@ -104,15 +110,21 @@ export interface ToolContext {
     maxTokens: number;
   };
   /** State of files read in the current session for deduplication */
-  readFileState?: Map<string, { mtime: number; hash: string }>;
+  readFileState?: Map<
+    string,
+    {
+      mtime: number;
+      hash: string;
+      offset?: number; // undefined = full read or Edit/Write entry (never dedup)
+      limit?: number;
+    }
+  >;
   /** Hook manager instance for executing hooks */
   hookManager?: import("../managers/hookManager.js").HookManager;
   /** Callback to notify when the current working directory changes */
   onCwdChange?: (newCwd: string) => void;
   /** Original working directory (before any cd changes) for CWD reset */
   originalWorkdir?: string;
-  /** Merged environment variables (process.env + agent env) for child processes */
-  env?: Record<string, string>;
   /** Workflow manager instance for workflow orchestration */
   workflowManager?: import("../managers/workflowManager.js").WorkflowManager;
 }

package/src/tools/writeTool.ts

@@ -1,4 +1,5 @@
-import { readFile, writeFile, mkdir } from "fs/promises";
+import { readFile, writeFile, mkdir, stat } from "fs/promises";
+import { createHash } from "crypto";
 import { dirname } from "path";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
@@ -10,6 +11,7 @@ import { READ_TOOL_NAME } from "../constants/tools.js";
  */
 export const writeTool: ToolPlugin = {
   name: "Write",
+  isConcurrencySafe: false,
   config: {
     type: "function",
     function: {
@@ -164,6 +166,18 @@ Usage:
         };
       }
 
+      // Update readFileState so subsequent serialized edits pass staleness check
+      if (context.readFileState) {
+        const newStats = await stat(resolvedPath);
+        const hash = createHash("sha256").update(content).digest("hex");
+        context.readFileState.set(resolvedPath, {
+          mtime: newStats.mtime.getTime(),
+          hash,
+          offset: undefined,
+          limit: undefined,
+        });
+      }
+
       const shortResult = isExistingFile ? "File overwritten" : "File created";
 
       const lines = content.split("\n").length;

package/src/types/agent.ts

@@ -97,8 +97,6 @@ export interface AgentOptions {
    * File-based hooks (from config.json/.waverc.json) merge on top of these.
    */
   hooks?: PartialHookConfiguration;
-  /** Per-agent environment variables, merged on top of process.env for bash, MCP, and hooks */
-  env?: Record<string, string>;
   [key: string]: unknown;
 }
 

package/src/types/config.ts

@@ -19,5 +19,6 @@ export interface ModelConfig {
   fastModel?: string;
   maxTokens?: number;
   permissionMode?: PermissionMode;
+  fastModelConfig?: Record<string, unknown>;
   [key: string]: unknown;
 }

package/src/utils/cacheControlUtils.ts

@@ -10,7 +10,6 @@ import type {
   ChatCompletionMessageParam,
   ChatCompletionContentPart,
   ChatCompletionContentPartText,
-  ChatCompletionFunctionTool,
   CompletionUsage,
 } from "openai/resources";
 import { logger } from "./globalLogger.js";
@@ -36,16 +35,6 @@ export interface ClaudeChatCompletionContentPartText
   cache_control?: CacheControl;
 }
 
-/**
- * Extended tool definition with cache control support
- */
-export interface ClaudeChatCompletionFunctionTool
-  extends ChatCompletionFunctionTool {
-  type: "function";
-  function: ChatCompletionFunctionTool["function"];
-  cache_control?: CacheControl;
-}
-
 /**
  * Extended prompt_tokens_details with cache_creation_input_tokens
  * Some models (e.g. Gemini, DeepSeek) return this field inside prompt_tokens_details
@@ -229,68 +218,53 @@ export function addCacheControlToContent(
 }
 
 /**
- * Adds cache control to the last tool in tools array
- * @param tools - Array of tool definitions
- * @returns Tools array with cache control on last tool
+ * Counts the total number of content blocks across all messages.
+ * Each element in a message's content array counts as one block.
+ * String content counts as one block. Null/undefined content counts as zero
+ * (e.g. assistant messages with only tool_calls).
+ * @param messages - Array of chat messages
+ * @returns Total content block count
  */
-export function addCacheControlToLastTool(
-  tools: ChatCompletionFunctionTool[],
-): ClaudeChatCompletionFunctionTool[] {
-  // Handle null, undefined, or empty arrays
-  if (!tools || !Array.isArray(tools) || tools.length === 0) {
-    return [];
-  }
-
-  // Validate tools structure
-  const validTools = tools.filter((tool) => {
-    if (!tool || typeof tool !== "object") {
-      logger.warn("Invalid tool structure detected, skipping:", tool);
-      return false;
-    }
-    if (tool.type !== "function" || !tool.function) {
-      logger.warn(
-        "Tool is not a function type or missing function property:",
-        tool,
-      );
-      return false;
+export function countContentBlocks(
+  messages: ChatCompletionMessageParam[],
+): number {
+  let count = 0;
+  for (const message of messages) {
+    if (!message || typeof message !== "object") continue;
+    const content = message.content;
+    if (typeof content === "string") {
+      count += 1;
+    } else if (Array.isArray(content)) {
+      count += content.length;
     }
-    return true;
-  });
-
-  if (validTools.length === 0) {
-    logger.warn("No valid tools found for cache control");
-    return [];
   }
-
-  // Create a copy of the valid tools array
-  const result = validTools.map((tool) => ({
-    ...tool,
-  })) as ClaudeChatCompletionFunctionTool[];
-
-  // Add cache control to the last tool only
-  const lastIndex = result.length - 1;
-  result[lastIndex] = {
-    ...result[lastIndex],
-    cache_control: { type: "ephemeral" },
-  };
-
-  return result;
+  return count;
 }
 
 /**
- * Transforms messages for Claude cache control with hardcoded strategy
+ * Transforms messages for explicit cache control.
+ *
+ * Cache breakpoints (following Claude Code's "last message marker" strategy):
+ * 1. System message — always marked (stable prefix)
+ * 2. Last message — the last user/assistant message with content is marked.
+ *    The API scans backward from this marker within 20 blocks. Since each
+ *    turn adds ~2 blocks (< 20), the previous request's marker position
+ *    always falls within the scan window, ensuring cache hits.
+ *
+ * Tools are marked separately via addCacheControlToLastTool (called by aiService).
+ *
  * @param messages - Original OpenAI message array
  * @param modelName - Model name for cache detection
  * @returns Messages with cache control markers applied
  */
-export function transformMessagesForClaudeCache(
+export function transformMessagesForExplicitCache(
   messages: ChatCompletionMessageParam[],
   modelName: string,
 ): ChatCompletionMessageParam[] {
   // Validate inputs
   if (!messages || !Array.isArray(messages)) {
     logger.warn(
-      "Invalid messages array provided to transformMessagesForClaudeCache",
+      "Invalid messages array provided to transformMessagesForExplicitCache",
     );
     return [];
   }
@@ -307,60 +281,68 @@ export function transformMessagesForClaudeCache(
   // Find first system message index
   const firstSystemIndex = messages.findIndex((m) => m.role === "system");
 
-  // Find last user message index
-  let lastUserIndex = -1;
+  // Determine which message indices should receive cache_control markers
+  const cacheIndices = new Set<number>();
+
+  // Marker 1: First system message (always — stable prefix)
+  if (firstSystemIndex !== -1) {
+    cacheIndices.add(firstSystemIndex);
+  }
+
+  // Marker 2: Last message with content (user or assistant).
+  // This marker moves each turn (~2 blocks), but since the move is < 20 blocks,
+  // the previous marker position is always within the API's 20-block scan window.
+  // This ensures the entire conversation prefix is cached.
   for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === "user") {
-      lastUserIndex = i;
+    const msg = messages[i];
+    if (!msg || typeof msg !== "object") continue;
+    if (i === firstSystemIndex) continue;
+    if (msg.role !== "user" && msg.role !== "assistant") continue;
+
+    const content = msg.content;
+    const hasContent =
+      (typeof content === "string" && content.length > 0) ||
+      (Array.isArray(content) && content.length > 0);
+
+    if (hasContent) {
+      cacheIndices.add(i);
       break;
     }
   }
 
+  // Apply cache_control markers to selected messages
   const result = messages.map((message, index) => {
     // Validate message structure
     if (!message || typeof message !== "object" || !message.role) {
       logger.warn("Invalid message structure at index", index, ":", message);
-      return message; // Return as-is to avoid breaking the flow
+      return message;
     }
 
-    // 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: transformedContent,
-      } as ChatCompletionMessageParam;
+    if (!cacheIndices.has(index)) {
+      return message;
     }
 
-    // Last user message: cache recent conversation history
-    if (message.role === "user" && index === lastUserIndex) {
-      const content =
-        (message.content as string | ChatCompletionContentPart[]) || "";
-      const transformedContent = addCacheControlToContent(content, true);
+    const content =
+      (message.content as string | ChatCompletionContentPart[]) || "";
 
-      return {
-        ...message,
-        content: transformedContent,
-      } as ChatCompletionMessageParam;
+    // Idempotency: skip if content already has cache_control (system message)
+    if (message.role === "system" && Array.isArray(content)) {
+      const hasCacheControl = content.some(
+        (part) =>
+          part.type === "text" &&
+          (part as ClaudeChatCompletionContentPartText).cache_control,
+      );
+      if (hasCacheControl) {
+        return message;
+      }
     }
 
-    // Return message unchanged
-    return message;
+    const transformedContent = addCacheControlToContent(content, true);
+
+    return {
+      ...message,
+      content: transformedContent,
+    } as ChatCompletionMessageParam;
   });
 
   return result;

package/src/utils/constants.ts

@@ -29,5 +29,5 @@ export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
 /**
  * AI related constants
  */
-export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 128000; // Default token limit
+export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 200000; // Default token limit
 export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 16384; // Default output token limit

package/src/utils/containerSetup.ts

@@ -83,12 +83,6 @@ export function setupAgentContainer(
   container.register("AgentOptions", options);
   container.register("Workdir", workdir);
 
-  const mergedEnv: Record<string, string> = {
-    ...(process.env as Record<string, string>),
-    ...(options.env || {}),
-  };
-  container.register("MergedEnv", mergedEnv);
-
   if (options.worktreeName) {
     container.register("WorktreeName", options.worktreeName);
     container.register("MainRepoRoot", getGitMainRepoRoot(workdir));
@@ -227,7 +221,9 @@ export function setupAgentContainer(
             toolName: context.toolName,
             toolInput: context.toolInput,
             planFilePath: permissionManager.getPlanFilePath(),
-            env: mergedEnv,
+            env: Object.fromEntries(
+              Object.entries(process.env).filter((e) => e[1] !== undefined),
+            ) as Record<string, string>,
           });
 
           if (results.length > 0) {

package/src/utils/taskReminder.ts

@@ -0,0 +1,108 @@
+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_REMINDER_MARKER = "<!-- task-reminder -->";
+
+function isQualifyingAssistantMessage(message: Message): boolean {
+  if (message.role !== "assistant") return false;
+  if (message.isMeta) return false;
+  return message.blocks.some((block) => block.type !== "reasoning");
+}
+
+export function getTaskReminderTurnCounts(messages: Message[]): {
+  turnsSinceLastTaskManagement: number;
+  turnsSinceLastReminder: number;
+} {
+  let assistantTurnCount = 0;
+  let turnsSinceLastTaskManagement: number | undefined;
+  let turnsSinceLastReminder: number | undefined;
+
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+
+    // Check blocks for task management tools and reminder markers
+    for (const block of message.blocks) {
+      if (
+        turnsSinceLastTaskManagement === undefined &&
+        block.type === "tool" &&
+        block.name &&
+        TASK_MANAGEMENT_TOOLS.has(block.name)
+      ) {
+        turnsSinceLastTaskManagement = assistantTurnCount;
+      }
+      if (
+        turnsSinceLastReminder === undefined &&
+        block.type === "text" &&
+        block.content.includes(TASK_REMINDER_MARKER)
+      ) {
+        turnsSinceLastReminder = assistantTurnCount;
+      }
+    }
+
+    if (isQualifyingAssistantMessage(message)) {
+      assistantTurnCount++;
+    }
+  }
+
+  return {
+    turnsSinceLastTaskManagement:
+      turnsSinceLastTaskManagement ?? assistantTurnCount,
+    turnsSinceLastReminder: turnsSinceLastReminder ?? assistantTurnCount,
+  };
+}
+
+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";
+
+  if (tasks.length > 0) {
+    text += "\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 {
+  if (
+    turnCounts.turnsSinceLastTaskManagement <
+    TASK_REMINDER_CONFIG.TURNS_SINCE_WRITE
+  ) {
+    return;
+  }
+  if (
+    turnCounts.turnsSinceLastReminder <
+    TASK_REMINDER_CONFIG.TURNS_BETWEEN_REMINDERS
+  ) {
+    return;
+  }
+
+  messages.push({
+    role: "user",
+    content: buildTaskReminderText(tasks),
+  } as ChatCompletionMessageParam);
+}