wave-agent-sdk 0.18.6 → 0.19.0

package/src/utils/cacheControlUtils.ts

@@ -13,6 +13,8 @@ import type {
   CompletionUsage,
 } from "openai/resources";
 import { logger } from "./globalLogger.js";
+import { supportsPromptCaching } from "./modelCapabilities.js";
+import type { ModelCapabilities } from "../types/config.js";
 
 // ============================================================================
 // Core Types
@@ -73,41 +75,6 @@ export interface ClaudeUsage extends CompletionUsage {
 // Utility Functions (Basic Structure - to be implemented)
 // ============================================================================
 
-/**
- * Determines if a model supports prompt caching
- * @param modelName - Model identifier
- * @returns True if model name matches the cache pattern (default: contains 'claude')
- */
-export function supportsPromptCaching(modelName: string): boolean {
-  // Handle null, undefined, and non-string inputs
-  if (!modelName || typeof modelName !== "string") {
-    return false;
-  }
-
-  // Handle empty strings and whitespace-only strings
-  const trimmed = modelName.trim();
-  if (trimmed.length === 0) {
-    return false;
-  }
-
-  const cachePattern = process.env.WAVE_PROMPT_CACHE_REGEX || "claude";
-  try {
-    const regex = new RegExp(cachePattern, "i");
-    return regex.test(trimmed);
-  } catch {
-    // If regex is invalid, fall back to simple includes check with default
-    return trimmed.toLowerCase().includes("claude");
-  }
-}
-
-/**
- * Determines if a model supports cache control
- * @param modelName - Model identifier
- * @returns True if model name contains 'claude' (case-insensitive)
- * @deprecated Use supportsPromptCaching instead
- */
-export const isClaudeModel = supportsPromptCaching;
-
 /**
  * Validates cache control structure
  * @param control - Object to validate
@@ -254,12 +221,12 @@ export function countContentBlocks(
  * Tools are marked separately via addCacheControlToLastTool (called by aiService).
  *
  * @param messages - Original OpenAI message array
- * @param modelName - Model name for cache detection
+ * @param capabilities - Declarative model capabilities for cache detection
  * @returns Messages with cache control markers applied
  */
 export function transformMessagesForExplicitCache(
   messages: ChatCompletionMessageParam[],
-  modelName: string,
+  capabilities?: ModelCapabilities,
 ): ChatCompletionMessageParam[] {
   // Validate inputs
   if (!messages || !Array.isArray(messages)) {
@@ -274,7 +241,7 @@ export function transformMessagesForExplicitCache(
   }
 
   // Only apply cache control for models that support prompt caching
-  if (!supportsPromptCaching(modelName)) {
+  if (!supportsPromptCaching(capabilities)) {
     return messages;
   }
 

package/src/utils/containerSetup.ts

@@ -205,7 +205,11 @@ export function setupAgentContainer(
 
   const rootSessionId = messageManager.getRootSessionId();
 
-  container.register("ReversionService", new ReversionService(rootSessionId));
+  const reversionService = new ReversionService(rootSessionId);
+  container.register("ReversionService", reversionService);
+  reversionService.cleanupOldSessions(30).catch((error) => {
+    logger.error("Failed to cleanup old file history:", error);
+  });
   const reversionManager = new ReversionManager(container);
   container.register("ReversionManager", reversionManager);
 

package/src/utils/convertMessagesForAPI.ts

@@ -39,15 +39,26 @@ function safeToolArguments(args: string): string {
   }
 }
 
+/**
+ * Options for converting messages to API format.
+ */
+export interface ConvertMessagesOptions {
+  /** When false, images are stripped and replaced with text placeholders. */
+  supportsVision?: boolean;
+}
+
 /**
  * Convert message format to API call format, stopping when a compacted message is encountered.
  * Messages with no meaningful content or tool calls are filtered out.
  * @param messages Message list
+ * @param options Optional conversion options (e.g. supportsVision)
  * @returns Converted API message format list
  */
 export function convertMessagesForAPI(
   messages: Message[],
+  options?: ConvertMessagesOptions,
 ): ChatCompletionMessageParam[] {
+  const supportsVision = options?.supportsVision !== false;
   const recentMessages: ChatCompletionMessageParam[] = [];
 
   const startIndex = messages.length - 1;
@@ -86,53 +97,64 @@ export function convertMessagesForAPI(
       const completedToolIds = new Set<string>(); // Record completed tool IDs
 
       if (toolBlocks.length > 0) {
+        // Collect image user messages to place after all tool messages
+        const imageUserMessages: ChatCompletionMessageParam[] = [];
+
         toolBlocks.forEach((toolBlock) => {
           // Only add completed tool blocks (i.e., stage is 'end')
           if (toolBlock.id && toolBlock.stage === "end") {
             completedToolIds.add(toolBlock.id);
 
-            // Check for image data
+            // Always add a proper tool message to satisfy tool_call_id pairing
+            recentMessages.unshift({
+              tool_call_id: toolBlock.id,
+              role: "tool",
+              content: stripAnsiColors(toolBlock.result || ""),
+            });
+
+            // If there are images, also prepare a user message with image content
             if (toolBlock.images && toolBlock.images.length > 0) {
-              // If there is an image, create a user message instead of a tool message
-              const contentParts: ChatCompletionContentPart[] = [];
+              if (supportsVision) {
+                const contentParts: ChatCompletionContentPart[] = [];
 
-              // Add tool result as text
-              const toolResultText = `Tool result for ${toolBlock.name || "unknown tool"}:\n${stripAnsiColors(toolBlock.result || "")}`;
-              contentParts.push({
-                type: "text",
-                text: toolResultText,
-              });
+                toolBlock.images.forEach((image) => {
+                  const imageUrl = image.data.startsWith("data:")
+                    ? image.data
+                    : `data:${image.mediaType || "image/png"};base64,${image.data}`;
 
-              // Add image
-              toolBlock.images.forEach((image) => {
-                const imageUrl = image.data.startsWith("data:")
-                  ? image.data
-                  : `data:${image.mediaType || "image/png"};base64,${image.data}`;
-
-                contentParts.push({
-                  type: "image_url",
-                  image_url: {
-                    url: imageUrl,
-                    detail: "auto",
-                  },
+                  contentParts.push({
+                    type: "image_url",
+                    image_url: {
+                      url: imageUrl,
+                      detail: "auto",
+                    },
+                  });
                 });
-              });
 
-              // Add user message
-              recentMessages.unshift({
-                role: "user",
-                content: contentParts,
-              });
-            } else {
-              // Normal tool message
-              recentMessages.unshift({
-                tool_call_id: toolBlock.id,
-                role: "tool",
-                content: stripAnsiColors(toolBlock.result || ""),
-              });
+                imageUserMessages.push({
+                  role: "user",
+                  content: contentParts,
+                });
+              } else {
+                // Non-vision model: replace images with a text placeholder
+                imageUserMessages.push({
+                  role: "user",
+                  content:
+                    "[Tool returned an image, but the current model does not support image recognition]",
+                });
+              }
             }
           }
         });
+
+        // Insert image user messages after all tool messages but before the
+        // assistant message (which will be unshifted next). Since tool messages
+        // were unshifted to the front, we splice images right after them.
+        if (imageUserMessages.length > 0) {
+          // Tool messages are at indices 0..N-1, existing messages start at N
+          const toolMsgCount = completedToolIds.size;
+          recentMessages.splice(toolMsgCount, 0, ...imageUserMessages);
+        }
       }
 
       // Construct the content of the assistant message
@@ -227,32 +249,40 @@ export function convertMessagesForAPI(
           block.imageUrls &&
           block.imageUrls.length > 0
         ) {
-          block.imageUrls.forEach((imageUrl: string) => {
-            // Check if it's already base64, convert if not
-            let finalImageUrl = imageUrl;
-            if (!imageUrl.startsWith("data:image/")) {
-              // If it's a file path, it needs to be converted to base64
-              try {
-                finalImageUrl = convertImageToBase64(imageUrl);
-              } catch (error) {
-                logger.error(
-                  "Failed to convert image path to base64:",
-                  imageUrl,
-                  error,
-                );
-                // Skip this image, do not add to content
-                return;
+          if (!supportsVision) {
+            // Non-vision model: replace images with a text placeholder
+            contentParts.push({
+              type: "text",
+              text: "[User shared an image, but the current model does not support image recognition]",
+            });
+          } else {
+            block.imageUrls.forEach((imageUrl: string) => {
+              // Check if it's already base64, convert if not
+              let finalImageUrl = imageUrl;
+              if (!imageUrl.startsWith("data:image/")) {
+                // If it's a file path, it needs to be converted to base64
+                try {
+                  finalImageUrl = convertImageToBase64(imageUrl);
+                } catch (error) {
+                  logger.error(
+                    "Failed to convert image path to base64:",
+                    imageUrl,
+                    error,
+                  );
+                  // Skip this image, do not add to content
+                  return;
+                }
               }
-            }
 
-            contentParts.push({
-              type: "image_url",
-              image_url: {
-                url: finalImageUrl,
-                detail: "auto",
-              },
+              contentParts.push({
+                type: "image_url",
+                image_url: {
+                  url: finalImageUrl,
+                  detail: "auto",
+                },
+              });
             });
-          });
+          }
         }
 
         // If there is a tool block in user message, add its result

package/src/utils/fileUtils.ts

@@ -1,8 +1,6 @@
 import fs from "node:fs/promises";
 import { createReadStream } from "node:fs";
 import path from "node:path";
-import { execSync } from "node:child_process";
-import { homedir } from "node:os";
 import { glob } from "glob";
 
 /**
@@ -156,50 +154,6 @@ export async function getLastLine(
   }
 }
 
-/**
- * Ensures that a pattern is present in the global git ignore file.
- *
- * @param {string} pattern - The pattern to add to global git ignore.
- */
-export async function ensureGlobalGitIgnore(pattern: string): Promise<void> {
-  try {
-    let globalIgnorePath: string;
-    try {
-      globalIgnorePath = execSync("git config --get core.excludesfile", {
-        encoding: "utf8",
-      }).trim();
-    } catch {
-      // If not set, use default paths
-      const xdgConfigHome =
-        process.env.XDG_CONFIG_HOME || path.join(homedir(), ".config");
-      globalIgnorePath = path.join(xdgConfigHome, "git", "ignore");
-    }
-
-    if (!globalIgnorePath) return;
-
-    // Ensure directory exists
-    await fs.mkdir(path.dirname(globalIgnorePath), { recursive: true });
-
-    let content = "";
-    try {
-      content = await fs.readFile(globalIgnorePath, "utf8");
-    } catch {
-      // File doesn't exist
-    }
-
-    const lines = content.split("\n").map((line) => line.trim());
-    if (!lines.includes(pattern)) {
-      const newContent =
-        content.endsWith("\n") || content === ""
-          ? `${content}${pattern}\n`
-          : `${content}\n${pattern}\n`;
-      await fs.writeFile(globalIgnorePath, newContent, "utf8");
-    }
-  } catch {
-    // Ignore errors
-  }
-}
-
 /**
  * Simple Levenshtein distance implementation
  */

package/src/utils/gitUtils.ts

@@ -222,6 +222,60 @@ export function getDefaultRemoteBranch(cwd: string): string {
   return "main";
 }
 
+/**
+ * Module-level set tracking git dirs already processed in this process,
+ * to avoid redundant I/O.
+ */
+const excludedGitDirs = new Set<string>();
+
+/**
+ * Ensure that Wave runtime files are excluded from git status by writing
+ * patterns to `.git/info/exclude` (per-repo, not global).
+ *
+ * Idempotent: if the marker `# wave-runtime` is already present in the
+ * exclude file, it skips writing. A module-level Set provides additional
+ * per-process dedup to avoid redundant file reads.
+ *
+ * @param cwd Working directory to start searching from
+ */
+export function ensureWaveRuntimeFilesExcluded(cwd: string): void {
+  try {
+    const gitDir = resolveGitDir(cwd);
+    if (!gitDir) return;
+
+    if (excludedGitDirs.has(gitDir)) return;
+
+    const excludePath = path.join(gitDir, "info", "exclude");
+    let content = "";
+    try {
+      content = fsSync.readFileSync(excludePath, "utf8");
+    } catch {
+      // File doesn't exist yet
+    }
+
+    const marker = "# wave-runtime";
+    if (content.includes(marker)) {
+      excludedGitDirs.add(gitDir);
+      return;
+    }
+
+    const block = [
+      marker,
+      "**/.wave/scheduled_tasks.lock",
+      "**/.wave/scheduled_tasks.json",
+      "**/.wave/worktrees/",
+      "**/.wave/settings.local.json",
+      "",
+    ].join("\n");
+
+    fsSync.mkdirSync(path.join(gitDir, "info"), { recursive: true });
+    fsSync.appendFileSync(excludePath, block);
+    excludedGitDirs.add(gitDir);
+  } catch {
+    // Best-effort: ignore all errors
+  }
+}
+
 /**
  * Check if there are uncommitted changes in the working directory
  * @param cwd Working directory

package/src/utils/groupMessagesByApiRound.ts

@@ -1,4 +1,5 @@
 import type { Message } from "../types/index.js";
+import { estimateTokens as estimateStrTokens } from "./tokenEstimate.js";
 
 export interface ApiRound {
   messages: Message[];
@@ -95,26 +96,26 @@ export function getLastApiRounds(
 }
 
 /**
- * Roughly estimate token count from character count (~4 chars per token).
+ * Estimate token count from message blocks using CJK-aware estimation.
  */
 function estimateTokens(messages: Message[]): number {
-  let chars = 0;
+  let combined = "";
   for (const msg of messages) {
     for (const block of msg.blocks) {
       if ("content" in block && typeof block.content === "string") {
-        chars += block.content.length;
+        combined += block.content;
       }
       if (
         block.type === "tool" &&
         block.parameters &&
         typeof block.parameters === "string"
       ) {
-        chars += block.parameters.length;
+        combined += block.parameters;
       }
       if (block.type === "tool" && block.result) {
-        chars += block.result.length;
+        combined += block.result;
       }
     }
   }
-  return Math.ceil(chars / 4);
+  return estimateStrTokens(combined);
 }

package/src/utils/mcpUtils.ts

@@ -132,6 +132,7 @@ export function findToolServer(
 ): McpServerStatus | undefined {
   return servers.find(
     (s) =>
-      s.status === "connected" && s.tools?.some((t) => t.name === toolName),
+      (s.status === "connected" || s.status === "reconnecting") &&
+      s.tools?.some((t) => t.name === toolName),
   );
 }

package/src/utils/modelCapabilities.ts

@@ -0,0 +1,30 @@
+/**
+ * Model Capability Detection
+ *
+ * Pure declarative capability accessors. Capabilities are configured per-model
+ * via the `capabilities` field in `ModelConfig` (settings.json), not via regex
+ * or environment variables.
+ */
+
+import type { ModelCapabilities } from "../types/config.js";
+
+/**
+ * Determines if a model supports prompt caching.
+ * @param capabilities - Declarative model capabilities
+ * @returns True if promptCaching is explicitly enabled (default: false)
+ */
+export function supportsPromptCaching(
+  capabilities?: ModelCapabilities,
+): boolean {
+  return capabilities?.promptCaching ?? false;
+}
+
+/**
+ * Determines if a model supports image/vision recognition.
+ * Opt-out semantics: by default all models are assumed to support vision.
+ * @param capabilities - Declarative model capabilities
+ * @returns True unless vision is explicitly disabled (default: true)
+ */
+export function supportsVision(capabilities?: ModelCapabilities): boolean {
+  return capabilities?.vision ?? true;
+}

package/src/utils/skillParser.ts

@@ -57,7 +57,9 @@ export function parseSkillFile(
       skillPath.includes("/.wave/skills") ||
       skillPath.includes("\\.wave\\skills") ||
       skillPath.includes("/.claude/skills") ||
-      skillPath.includes("\\.claude\\skills")
+      skillPath.includes("\\.claude\\skills") ||
+      skillPath.includes("/.agents/skills") ||
+      skillPath.includes("\\.agents\\skills")
         ? "project"
         : "personal";
 

package/src/utils/tokenEstimate.ts

@@ -0,0 +1,34 @@
+/**
+ * CJK-aware token estimation without external dependencies.
+ *
+ * The naive `length / 4` heuristic under-estimates CJK text by ~4x because
+ * each Chinese/Japanese/Korean character is typically 1-2 tokens, not 0.25.
+ * This function separates CJK characters from other text and applies
+ * different ratios:
+ *
+ * - CJK characters: 1 char ≈ 1 token
+ * - Other characters: 4 chars ≈ 1 token (2 for JSON/JSONL/JSONC)
+ *
+ * The estimate intentionally leans high for CJK (safe direction for limit
+ * checks — better to reject than to let oversized content through).
+ */
+
+// CJK Unified Ideographs + Extension A + Hiragana + Katakana + Hangul Syllables
+const CJK_REGEX =
+  /[\u4e00-\u9fff\u3400-\u4dbf\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g;
+
+/**
+ * Estimate token count for a string, with CJK-awareness.
+ *
+ * @param content - The text content to estimate
+ * @param ext - File extension (without dot), e.g. "ts", "json". JSON/JSONL/JSONC
+ *              files use a tighter ratio (2 chars/token) for non-CJK text.
+ * @returns Estimated token count
+ */
+export function estimateTokens(content: string, ext?: string): number {
+  const cjkCount = (content.match(CJK_REGEX) || []).length;
+  const otherCount = content.length - cjkCount;
+  const bytesPerToken =
+    ext === "json" || ext === "jsonl" || ext === "jsonc" ? 2 : 4;
+  return Math.ceil(cjkCount + otherCount / bytesPerToken);
+}

package/src/utils/worktreeUtils.ts

@@ -6,7 +6,11 @@
 import { execFileSync } from "node:child_process";
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { getGitMainRepoRoot, getDefaultRemoteBranch } from "./gitUtils.js";
+import {
+  getGitMainRepoRoot,
+  getDefaultRemoteBranch,
+  ensureWaveRuntimeFilesExcluded,
+} from "./gitUtils.js";
 import { logger } from "./globalLogger.js";
 
 export interface WorktreeInfo {
@@ -105,6 +109,9 @@ export function createWorktree(name: string, cwd: string): WorktreeInfo {
   const branchName = `worktree-${name}`;
   const baseBranch = getDefaultRemoteBranch(cwd);
 
+  // Ensure Wave runtime files are git-excluded in this repo
+  ensureWaveRuntimeFilesExcluded(cwd);
+
   // Ensure parent directory exists
   const parentDir = path.dirname(worktreePath);
   if (!fs.existsSync(parentDir)) {