wave-agent-sdk 0.0.8 → 0.0.10

package/src/utils/cacheControlUtils.ts

@@ -11,8 +11,10 @@ import type {
   ChatCompletionContentPart,
   ChatCompletionContentPartText,
   ChatCompletionFunctionTool,
+  ChatCompletionMessageToolCall,
   CompletionUsage,
 } from "openai/resources";
+import { logger } from "./globalLogger.js";
 
 // ============================================================================
 // Core Types
@@ -62,28 +64,10 @@ export interface ClaudeUsage extends CompletionUsage {
   };
 }
 
-/**
- * Configuration for cache control application
- */
-export interface CacheControlConfig {
-  cacheSystemMessage: boolean;
-  cacheUserMessageCount: number;
-  cacheLastTool: boolean;
-}
-
 // ============================================================================
 // Default Configuration
 // ============================================================================
 
-/**
- * Default cache control configuration
- */
-export const DEFAULT_CACHE_CONTROL_CONFIG: CacheControlConfig = {
-  cacheSystemMessage: true,
-  cacheUserMessageCount: 2,
-  cacheLastTool: true,
-} as const;
-
 // ============================================================================
 // Utility Functions (Basic Structure - to be implemented)
 // ============================================================================
@@ -123,6 +107,30 @@ export function isValidCacheControl(control: unknown): control is CacheControl {
   );
 }
 
+/**
+ * Adds cache control to the last tool call in an array
+ * @param toolCalls - Array of tool calls
+ * @returns Tool calls array with cache control on the last tool call
+ */
+function addCacheControlToLastToolCall(
+  toolCalls: ChatCompletionMessageToolCall[],
+): ChatCompletionMessageToolCall[] {
+  if (!toolCalls || toolCalls.length === 0) {
+    return toolCalls;
+  }
+
+  const result = [...toolCalls];
+  const lastIndex = result.length - 1;
+
+  // Add cache control to the last tool call
+  result[lastIndex] = {
+    ...result[lastIndex],
+    cache_control: { type: "ephemeral" },
+  } as ChatCompletionMessageToolCall & { cache_control: CacheControl };
+
+  return result;
+}
+
 /**
  * Adds cache control markers to message content
  * @param content - Original content (string or structured)
@@ -146,7 +154,7 @@ export function addCacheControlToContent(
 
     // Validate array input
     if (!Array.isArray(content)) {
-      console.warn(
+      logger.warn(
         "Invalid content type for cache control transformation:",
         typeof content,
       );
@@ -178,7 +186,7 @@ export function addCacheControlToContent(
 
   // Validate array input
   if (!Array.isArray(content)) {
-    console.warn(
+    logger.warn(
       "Invalid content type for cache control transformation:",
       typeof content,
     );
@@ -216,11 +224,11 @@ export function addCacheControlToLastTool(
   // Validate tools structure
   const validTools = tools.filter((tool) => {
     if (!tool || typeof tool !== "object") {
-      console.warn("Invalid tool structure detected, skipping:", tool);
+      logger.warn("Invalid tool structure detected, skipping:", tool);
       return false;
     }
     if (tool.type !== "function" || !tool.function) {
-      console.warn(
+      logger.warn(
         "Tool is not a function type or missing function property:",
         tool,
       );
@@ -230,7 +238,7 @@ export function addCacheControlToLastTool(
   });
 
   if (validTools.length === 0) {
-    console.warn("No valid tools found for cache control");
+    logger.warn("No valid tools found for cache control");
     return [];
   }
 
@@ -250,20 +258,47 @@ export function addCacheControlToLastTool(
 }
 
 /**
- * Transforms messages for Claude cache control
+ * Finds the latest message index at 20-message intervals (sliding window approach)
+ * @param messages - Array of chat completion messages
+ * @returns Index of the latest interval message (20th, 40th, 60th, etc.) or -1 if none
+ */
+export function findIntervalMessageIndex(
+  messages: ChatCompletionMessageParam[],
+): number {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return -1;
+  }
+
+  const interval = 20; // Hardcoded interval
+  const messageCount = messages.length;
+
+  // Find the largest interval that fits within the message count
+  // Math.floor(messageCount / interval) gives us how many complete intervals we have
+  // Multiply by interval to get the position of the latest interval message
+  const latestIntervalPosition = Math.floor(messageCount / interval) * interval;
+
+  // If no complete intervals exist, return -1
+  if (latestIntervalPosition === 0) {
+    return -1;
+  }
+
+  // Convert from 1-based position to 0-based index
+  return latestIntervalPosition - 1;
+}
+
+/**
+ * Transforms messages for Claude cache control with hardcoded strategy
  * @param messages - Original OpenAI message array
  * @param modelName - Model name for cache detection
- * @param config - Cache control configuration
  * @returns Messages with cache control markers applied
  */
 export function transformMessagesForClaudeCache(
   messages: ChatCompletionMessageParam[],
   modelName: string,
-  config: CacheControlConfig = DEFAULT_CACHE_CONTROL_CONFIG,
 ): ChatCompletionMessageParam[] {
   // Validate inputs
   if (!messages || !Array.isArray(messages)) {
-    console.warn(
+    logger.warn(
       "Invalid messages array provided to transformMessagesForClaudeCache",
     );
     return [];
@@ -278,46 +313,64 @@ export function transformMessagesForClaudeCache(
     return messages;
   }
 
-  // Validate config
-  if (!config || typeof config !== "object") {
-    console.warn("Invalid cache control config, using defaults");
-    config = DEFAULT_CACHE_CONTROL_CONFIG;
+  // 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;
+    }
   }
 
   const result = messages.map((message, index) => {
     // Validate message structure
     if (!message || typeof message !== "object" || !message.role) {
-      console.warn("Invalid message structure at index", index, ":", message);
+      logger.warn("Invalid message structure at index", index, ":", message);
       return message; // Return as-is to avoid breaking the flow
     }
 
-    // System message: cache if enabled in config
-    if (message.role === "system" && config.cacheSystemMessage) {
+    // Last system message: always cached (hardcoded)
+    if (message.role === "system" && index === lastSystemIndex) {
       return {
         ...message,
-        content: addCacheControlToContent(message.content, true),
-      };
+        content: addCacheControlToContent(
+          (message.content as string | ChatCompletionContentPart[]) || "",
+          true,
+        ),
+      } as ChatCompletionMessageParam;
     }
 
-    // User messages: cache last N messages based on config
-    if (message.role === "user" && config.cacheUserMessageCount > 0) {
-      const userMessageIndices: number[] = [];
-      messages.forEach((msg, idx) => {
-        if (msg.role === "user") {
-          userMessageIndices.push(idx);
-        }
-      });
-
-      // Check if this user message is among the last N
-      const isRecentUser = userMessageIndices
-        .slice(-config.cacheUserMessageCount)
-        .includes(index);
-
-      if (isRecentUser) {
+    // Interval-based message caching: cache message at latest interval position (sliding window)
+    if (index === intervalMessageIndex) {
+      // If the message is a tool role, add cache control directly to the message
+      if (message.role === "tool") {
+        return {
+          ...message,
+          cache_control: { type: "ephemeral" },
+        } as ChatCompletionMessageParam;
+      }
+      // If the message has tool calls, cache the last tool call instead of content
+      else if (
+        message.role === "assistant" &&
+        message.tool_calls &&
+        message.tool_calls.length > 0
+      ) {
+        return {
+          ...message,
+          tool_calls: addCacheControlToLastToolCall(message.tool_calls),
+        } as ChatCompletionMessageParam;
+      } else {
+        // For other message types without tool calls, cache the content
         return {
           ...message,
-          content: addCacheControlToContent(message.content, true),
-        };
+          content: addCacheControlToContent(
+            (message.content as string | ChatCompletionContentPart[]) || "",
+            true,
+          ),
+        } as ChatCompletionMessageParam;
       }
     }
 
@@ -420,121 +473,3 @@ export function isValidClaudeUsage(usage: unknown): usage is ClaudeUsage {
 
   return true;
 }
-
-/**
- * Adds cache control to the last N user messages in a conversation
- * This optimizes multi-turn conversations by caching recent user context
- *
- * @param messages - Array of chat completion messages
- * @param maxUserMessagesToCache - Maximum number of recent user messages to cache (default: 2)
- * @returns Modified messages array with cache control on recent user messages
- */
-export function addCacheControlToRecentUserMessages(
-  messages: ChatCompletionMessageParam[],
-  maxUserMessagesToCache: number = 2,
-): ChatCompletionMessageParam[] {
-  // Validate inputs
-  if (!messages || !Array.isArray(messages)) {
-    console.warn(
-      "Invalid messages array provided to addCacheControlToRecentUserMessages",
-    );
-    return [];
-  }
-
-  if (messages.length === 0 || maxUserMessagesToCache <= 0) {
-    return messages;
-  }
-
-  // Validate maxUserMessagesToCache is a reasonable number
-  if (maxUserMessagesToCache > 100) {
-    console.warn(
-      "maxUserMessagesToCache is unusually high:",
-      maxUserMessagesToCache,
-      "limiting to 100",
-    );
-    maxUserMessagesToCache = 100;
-  }
-
-  // Find all user message indices in reverse order (most recent first)
-  const userMessageIndices: number[] = [];
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i];
-
-    // Validate message structure
-    if (!message || typeof message !== "object" || !message.role) {
-      console.warn("Invalid message at index", i, ", skipping");
-      continue;
-    }
-
-    if (message.role === "user") {
-      userMessageIndices.push(i);
-      if (userMessageIndices.length >= maxUserMessagesToCache) {
-        break;
-      }
-    }
-  }
-
-  // If no user messages found, return unchanged
-  if (userMessageIndices.length === 0) {
-    return messages;
-  }
-
-  // Create a copy of messages and modify the identified user messages
-  const modifiedMessages = [...messages];
-
-  for (const index of userMessageIndices) {
-    const message = modifiedMessages[index];
-    if (message.role === "user" && message.content != null) {
-      try {
-        modifiedMessages[index] = {
-          ...message,
-          content: addCacheControlToContent(message.content, true),
-        };
-      } catch (error) {
-        console.warn(
-          "Failed to add cache control to user message at index",
-          index,
-          ":",
-          error,
-        );
-        // Continue with original message if transformation fails
-      }
-    }
-  }
-
-  return modifiedMessages;
-}
-
-/**
- * Helper function to identify user message indices that should be cached
- * Used for testing and validation purposes
- *
- * @param messages - Array of chat completion messages
- * @param maxUserMessagesToCache - Maximum number of recent user messages to identify
- * @returns Array of indices for user messages that should be cached
- */
-export function findRecentUserMessageIndices(
-  messages: ChatCompletionMessageParam[],
-  maxUserMessagesToCache: number = 2,
-): number[] {
-  if (
-    !Array.isArray(messages) ||
-    messages.length === 0 ||
-    maxUserMessagesToCache <= 0
-  ) {
-    return [];
-  }
-
-  const userMessageIndices: number[] = [];
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].role === "user") {
-      userMessageIndices.push(i);
-      if (userMessageIndices.length >= maxUserMessagesToCache) {
-        break;
-      }
-    }
-  }
-
-  // Return indices in original order (not reversed)
-  return userMessageIndices.reverse();
-}

package/src/utils/constants.ts

@@ -24,24 +24,9 @@ export const ERROR_LOG_DIRECTORY = path.join(DATA_DIRECTORY, "error-logs");
 /**
  * User-level memory file path
  */
-export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "user-memory.md");
+export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
 
 /**
  * AI related constants
  */
 export const DEFAULT_TOKEN_LIMIT = 96000; // Default token limit
-
-/**
- * @deprecated These constants are now legacy. Use ModelConfig through Agent constructor instead.
- * They are maintained for backward compatibility with existing code that might still reference them,
- * but the actual AI services now use configuration injection.
- */
-export const FAST_MODEL_ID = process.env.AIGW_FAST_MODEL || "gemini-2.5-flash";
-
-/**
- * @deprecated These constants are now legacy. Use ModelConfig through Agent constructor instead.
- * They are maintained for backward compatibility with existing code that might still reference them,
- * but the actual AI services now use configuration injection.
- */
-export const AGENT_MODEL_ID =
-  process.env.AIGW_MODEL || "claude-sonnet-4-20250514";

package/src/utils/convertMessagesForAPI.ts

@@ -30,7 +30,8 @@ function safeToolArguments(args: string): string {
 }
 
 /**
- * Convert message format to API call format, stopping when a compressed message is encountered
+ * Convert message format to API call format, stopping when a compressed message is encountered.
+ * Messages with no meaningful content or tool calls are filtered out.
  * @param messages Message list
  * @returns Converted API message format list
  */
@@ -61,7 +62,7 @@ export function convertMessagesForAPI(
       break;
     }
 
-    // Skip empty assistant messages
+    // Skip empty assistant messages (no blocks or all blocks are empty)
     if (message.role === "assistant" && message.blocks.length === 0) {
       continue;
     }
@@ -128,12 +129,17 @@ export function convertMessagesForAPI(
       let content = "";
       let tool_calls: ChatCompletionMessageToolCall[] | undefined = undefined;
 
-      // Construct content from text blocks
+      // Construct content from text blocks - filter out empty content
       const textBlocks = message.blocks.filter(
-        (block) => block.type === "text",
+        (block) =>
+          block.type === "text" &&
+          block.content &&
+          block.content.trim().length > 0,
       );
       if (textBlocks.length > 0) {
-        content = textBlocks.map((block) => block.content || "").join("\n");
+        content = textBlocks
+          .map((block) => (block.type === "text" ? block.content : ""))
+          .join("\n");
       }
 
       // Construct tool calls from tool blocks
@@ -158,13 +164,16 @@ export function convertMessagesForAPI(
         }
       }
 
-      // Construct assistant message - only add if there is content or tool calls
-      if (content || tool_calls) {
+      // Construct assistant message - only add if there is meaningful content or tool calls
+      const hasContent = content && content.trim().length > 0;
+      const hasToolCalls = tool_calls && tool_calls.length > 0;
+
+      if (hasContent || hasToolCalls) {
         const assistantMessage: ChatCompletionMessageParam = {
           role: "assistant",
-          content,
+          content: hasContent ? content : undefined,
           tool_calls,
-          ...(message.metadata ? { ...message.metadata } : {}),
+          ...(message.additionalFields ? { ...message.additionalFields } : {}),
         };
 
         recentMessages.unshift(assistantMessage);
@@ -174,8 +183,12 @@ export function convertMessagesForAPI(
       const contentParts: ChatCompletionContentPart[] = [];
 
       message.blocks.forEach((block) => {
-        // Add text content
-        if (block.type === "text" && block.content) {
+        // Add text content - only if it has meaningful content
+        if (
+          block.type === "text" &&
+          block.content &&
+          block.content.trim().length > 0
+        ) {
           contentParts.push({
             type: "text",
             text: block.customCommandContent || block.content,
@@ -217,11 +230,22 @@ export function convertMessagesForAPI(
         }
       });
 
+      // Only add user message if there is meaningful content
       if (contentParts.length > 0) {
-        recentMessages.unshift({
-          role: "user",
-          content: contentParts,
+        // Filter out empty text parts
+        const meaningfulParts = contentParts.filter((part) => {
+          if (part.type === "text") {
+            return part.text && part.text.trim().length > 0;
+          }
+          return true; // Keep image parts
         });
+
+        if (meaningfulParts.length > 0) {
+          recentMessages.unshift({
+            role: "user",
+            content: meaningfulParts,
+          });
+        }
       }
     }
   }

package/src/utils/fileSearch.ts

@@ -0,0 +1,107 @@
+import { globIterate, type Path } from "glob";
+import { getGlobIgnorePatterns } from "./fileFilter.js";
+import type { FileItem } from "../types/fileSearch.js";
+
+/**
+ * Convert Path objects to FileItem objects
+ */
+export const convertPathsToFileItems = (paths: Path[]): FileItem[] => {
+  return paths.map((pathObj) => ({
+    path: pathObj.relative(),
+    type: pathObj.isDirectory() ? "directory" : "file",
+  }));
+};
+
+/**
+ * Search files and directories using glob patterns
+ */
+export const searchFiles = async (
+  query: string,
+  options?: {
+    maxResults?: number;
+    workingDirectory?: string;
+  },
+): Promise<FileItem[]> => {
+  const { maxResults = 10, workingDirectory = process.cwd() } = options || {};
+
+  try {
+    const globOptions: import("glob").GlobOptionsWithFileTypesTrue = {
+      ignore: getGlobIgnorePatterns(workingDirectory),
+      maxDepth: 10,
+      nocase: true, // Case insensitive
+      dot: true, // Include hidden files and directories
+      cwd: workingDirectory, // Specify search root directory
+      withFileTypes: true, // Get Path objects instead of strings
+    };
+
+    // Build glob patterns based on query
+    let patterns: string[] = [];
+
+    if (!query.trim()) {
+      // When query is empty, show some common file types and directories
+      patterns = [
+        "**/*.{ts,tsx,js,jsx,json,py,java}", // Combine common file extensions
+        "*/", // First level directories
+      ];
+    } else {
+      // Build multiple glob patterns to support more flexible search
+      patterns = [
+        // Match files with filenames containing query
+        `**/*${query}*`,
+        // Match files with query in path (match directory names)
+        `**/${query}*/**/*`,
+        // Match directory names containing query
+        `**/*${query}*/`,
+        // Match directories containing query in path
+        `**/${query}*/`,
+      ];
+    }
+
+    // Collect results until we reach maxResults
+    const collectedPaths: Path[] = [];
+    const seenPaths = new Set<string>();
+
+    // Process each pattern sequentially
+    for (const pattern of patterns) {
+      if (collectedPaths.length >= maxResults) {
+        break;
+      }
+
+      // Use globIterate to get results one by one
+      const iterator = globIterate(pattern, globOptions) as AsyncGenerator<
+        Path,
+        void,
+        void
+      >;
+
+      for await (const pathObj of iterator) {
+        if (collectedPaths.length >= maxResults) {
+          // Stop the iterator when we have enough results
+          break;
+        }
+
+        const relativePath = pathObj.relative();
+        if (!seenPaths.has(relativePath)) {
+          seenPaths.add(relativePath);
+          collectedPaths.push(pathObj);
+        }
+      }
+    }
+
+    // Sort collected paths: directories first, then files
+    collectedPaths.sort((a, b) => {
+      const aIsDir = a.isDirectory();
+      const bIsDir = b.isDirectory();
+      if (aIsDir && !bIsDir) return -1;
+      if (!aIsDir && bIsDir) return 1;
+      return a.relative().localeCompare(b.relative());
+    });
+
+    // Convert to FileItems
+    const fileItems = convertPathsToFileItems(collectedPaths);
+    return fileItems;
+  } catch (error) {
+    console.error("Glob search error:", error);
+    return [];
+  }
+};