wave-agent-sdk 0.18.7 → 0.19.1

package/src/tools/bashTool.ts

@@ -20,6 +20,25 @@ import {
 
 const BASH_DEFAULT_TIMEOUT_MS = 120000;
 
+/**
+ * Wrap a user command so we can append CWD tracking (`&& pwd -P`) without the
+ * appended part being affected by trailing here-docs, unbalanced quotes, or
+ * multi-line syntax in the user command.
+ *
+ * The command is single-quoted (with embedded single quotes escaped via the
+ * classic `'"'"'` sequence) and run through `eval`. Because the entire user
+ * command becomes a single literal argument to `eval`, any here-doc inside it
+ * only opens/closes during eval's own second parse pass and cannot leak out to
+ * clobber the trailing `&& pwd -P`. Works on sh/dash/bash and Git Bash.
+ */
+function wrapCommandForCwdTracking(
+  command: string,
+  cwdFileForBash: string,
+): string {
+  const escaped = command.replace(/'/g, `'"'"'`);
+  return `eval '${escaped}' && pwd -P >| ${cwdFileForBash}`;
+}
+
 // Commands that should not be auto-backgrounded on timeout (e.g. sleep should just be killed)
 const DISALLOWED_AUTO_BACKGROUND_COMMANDS = ["sleep"];
 
@@ -248,7 +267,10 @@ The working directory persists between commands. Try to maintain your current wo
         `wave_cwd_${Date.now()}_${Math.random().toString(36).substring(2, 11)}.tmp`,
       );
       const tempCwdFileForBash = toPosixPath(tempCwdFile);
-      const wrappedCommand = `${command} && pwd -P >| ${tempCwdFileForBash}`;
+      const wrappedCommand = wrapCommandForCwdTracking(
+        command,
+        tempCwdFileForBash,
+      );
 
       const child: ChildProcess = spawn(wrappedCommand, {
         shell: shellPath || true,

package/src/types/config.ts

@@ -14,11 +14,21 @@ export interface GatewayConfig {
   fetch?: OpenAI["fetch"];
 }
 
+export interface ModelCapabilities {
+  /** Whether the model supports image/vision input. Default: true. */
+  vision?: boolean;
+  /** Whether the model supports prompt caching (ephemeral cache_control markers). Default: false. */
+  promptCaching?: boolean;
+}
+
 export interface ModelConfig {
   model?: string;
   fastModel?: string;
   maxTokens?: number;
   permissionMode?: PermissionMode;
-  fastModelConfig?: Record<string, unknown>;
-  [key: string]: unknown;
+  capabilities?: ModelCapabilities;
+  /** Generation params passed through to the API provider (temperature, thinking, etc.) */
+  options?: Record<string, unknown>;
+  /** Fast model generation params (resolved from models[fastModel].options) */
+  fastModelOptions?: Record<string, unknown>;
 }

package/src/types/hooks.ts

@@ -188,6 +188,7 @@ export interface HookJsonInput {
   user_prompt?: string; // Present for UserPromptSubmit only
   subagent_type?: string; // Present when hook is executed by a subagent
   name?: string; // Present for WorktreeCreate events
+  worktree_path?: string; // Present for WorktreeRemove events
   old_cwd?: string; // Present for CwdChanged events
   new_cwd?: string; // Present for CwdChanged events
   source?: SessionStartSource; // Present for SessionStart events

package/src/types/messaging.ts

@@ -89,7 +89,6 @@ export interface BangBlock {
 export interface CompactBlock {
   type: "compact";
   content: string;
-  sessionId: string;
 }
 
 export interface ReasoningBlock {

package/src/types/skills.ts

@@ -74,6 +74,7 @@ export interface SkillToolArgs {
 export interface SkillManagerOptions {
   personalSkillsPath?: string;
   personalClaudeSkillsPath?: string;
+  personalAgentsSkillsPath?: string;
   scanTimeout?: number;
   workdir?: string;
   watch?: boolean;

package/src/types/telemetry.ts

@@ -58,6 +58,20 @@ export interface LLMRequestMetadata {
   error?: string;
   /** Response included tool calls */
   hasToolCall?: boolean;
+  /** Model text output (recorded when logToolContent is true) */
+  modelOutput?: string;
+}
+
+/** Input context for an LLM request span (content capture gated by logToolContent) */
+export interface LLMRequestInput {
+  /** Scope context */
+  context?: "interaction" | "standalone";
+  /** System prompt string (when available) */
+  systemPrompt?: string;
+  /** Messages array sent to the API */
+  inputMessages?: unknown[];
+  /** Tool schemas JSON string */
+  toolsSchema?: string;
 }
 
 /** Metadata for tool execution spans */
@@ -79,4 +93,6 @@ export type OTelEventName =
   | "user_prompt"
   | "tool_decision"
   | "compaction"
-  | "error";
+  | "error"
+  | "system_prompt"
+  | "tool_schema";

package/src/utils/atomicWrite.ts

@@ -0,0 +1,61 @@
+/**
+ * Atomic file write utilities.
+ *
+ * Writes data to a temporary file first, then renames it to the target path.
+ * This prevents readers from observing a partially-written (truncated) file,
+ * which is critical for config files that may be read concurrently.
+ *
+ * Temp file naming: `${targetPath}.tmp.${process.pid}.${randomUUID()}`
+ * — avoids collisions when multiple processes write the same file.
+ */
+import { writeFileSync, renameSync, unlinkSync, promises as fsp } from "fs";
+import { randomUUID } from "crypto";
+
+function tmpPathFor(targetPath: string): string {
+  return `${targetPath}.tmp.${process.pid}.${randomUUID()}`;
+}
+
+/**
+ * Atomically write `data` to `filePath` (async).
+ *
+ * Writes to a temp file then renames it into place. On any failure the temp
+ * file is removed and the error is re-thrown so callers can handle it.
+ */
+export async function atomicWriteFile(
+  filePath: string,
+  data: string,
+): Promise<void> {
+  const tmpPath = tmpPathFor(filePath);
+  try {
+    await fsp.writeFile(tmpPath, data, "utf-8");
+    await fsp.rename(tmpPath, filePath);
+  } catch (error) {
+    try {
+      await fsp.unlink(tmpPath);
+    } catch {
+      // Ignore cleanup errors — the original error is more important
+    }
+    throw error;
+  }
+}
+
+/**
+ * Atomically write `data` to `filePath` (sync).
+ *
+ * Sync variant for callers that cannot await. Same temp-file-then-rename
+ * strategy as {@link atomicWriteFile}.
+ */
+export function atomicWriteFileSync(filePath: string, data: string): void {
+  const tmpPath = tmpPathFor(filePath);
+  try {
+    writeFileSync(tmpPath, data, "utf-8");
+    renameSync(tmpPath, filePath);
+  } catch (error) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+      // Ignore cleanup errors — the original error is more important
+    }
+    throw error;
+  }
+}

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/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";