wave-agent-sdk 0.17.9 → 0.17.10

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) {