wave-agent-sdk 0.11.6 → 0.11.7

package/src/services/aiService.ts

@@ -22,7 +22,11 @@ import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
 
-import { COMPRESS_MESSAGES_SYSTEM_PROMPT } from "../prompts/index.js";
+import {
+  COMPRESS_MESSAGES_SYSTEM_PROMPT,
+  WEB_CONTENT_SYSTEM_PROMPT,
+  BTW_SYSTEM_PROMPT,
+} from "../prompts/index.js";
 
 /**
  * Interface for debug data saved during 400 errors
@@ -829,3 +833,195 @@ export async function compressMessages(
     throw error;
   }
 }
+
+export interface ProcessWebContentOptions {
+  // Resolved configuration
+  gatewayConfig: GatewayConfig;
+  modelConfig: ModelConfig;
+
+  // Parameters
+  content: string;
+  prompt: string;
+  abortSignal?: AbortSignal;
+  model?: string;
+}
+
+export interface ProcessWebContentResult {
+  content: string;
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export async function processWebContent(
+  options: ProcessWebContentOptions,
+): Promise<ProcessWebContentResult> {
+  const { gatewayConfig, modelConfig, content, prompt, abortSignal } = options;
+
+  // Apply global 1 QPS rate limit
+  if (
+    process.env.NODE_ENV !== "test" ||
+    modelConfig.model === "rate-limit-test"
+  ) {
+    await acquireSlot(abortSignal);
+  }
+
+  // Create OpenAI client with injected configuration
+  const openai = new OpenAIClient({
+    apiKey: gatewayConfig.apiKey,
+    baseURL: gatewayConfig.baseURL,
+    defaultHeaders: gatewayConfig.defaultHeaders,
+    fetchOptions: gatewayConfig.fetchOptions,
+    fetch: gatewayConfig.fetch,
+  });
+
+  // Get model configuration - use injected agent model
+  const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
+    temperature: 0.1,
+    max_tokens: 4096,
+  });
+
+  try {
+    const response = await openai.chat.completions.create(
+      {
+        ...openaiModelConfig,
+        messages: [
+          {
+            role: "system",
+            content: WEB_CONTENT_SYSTEM_PROMPT,
+          },
+          {
+            role: "user",
+            content: `Web Content:\n\n${content}\n\nUser Prompt: ${prompt}`,
+          },
+        ],
+      },
+      {
+        signal: abortSignal,
+      },
+    );
+
+    const result = response.choices[0]?.message?.content?.trim();
+    if (!result) {
+      throw new Error("Failed to process web content: Empty response from AI");
+    }
+    const usage = response.usage
+      ? {
+          prompt_tokens: response.usage.prompt_tokens,
+          completion_tokens: response.usage.completion_tokens,
+          total_tokens: response.usage.total_tokens,
+        }
+      : undefined;
+
+    return {
+      content: result,
+      usage,
+    };
+  } catch (error) {
+    if ((error as Error).name === "AbortError") {
+      logger.info("Web content processing request was aborted");
+      throw new Error("Web content processing request was aborted");
+    }
+    logger.error("Failed to process web content:", error);
+    throw error;
+  }
+}
+
+export interface BtwOptions {
+  // Resolved configuration
+  gatewayConfig: GatewayConfig;
+  modelConfig: ModelConfig;
+
+  // Parameters
+  messages: ChatCompletionMessageParam[];
+  question: string;
+  abortSignal?: AbortSignal;
+  model?: string;
+}
+
+export interface BtwResult {
+  content: string;
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export async function btw(options: BtwOptions): Promise<BtwResult> {
+  const { gatewayConfig, modelConfig, messages, question, abortSignal } =
+    options;
+
+  // Apply global 1 QPS rate limit
+  if (
+    process.env.NODE_ENV !== "test" ||
+    modelConfig.model === "rate-limit-test"
+  ) {
+    await acquireSlot(abortSignal);
+  }
+
+  // Create OpenAI client with injected configuration
+  const openai = new OpenAIClient({
+    apiKey: gatewayConfig.apiKey,
+    baseURL: gatewayConfig.baseURL,
+    defaultHeaders: gatewayConfig.defaultHeaders,
+    fetchOptions: gatewayConfig.fetchOptions,
+    fetch: gatewayConfig.fetch,
+  });
+
+  // Get model configuration - use injected agent model
+  const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
+    temperature: 0.1,
+    max_tokens: 4096,
+  });
+
+  try {
+    const response = await openai.chat.completions.create(
+      {
+        ...openaiModelConfig,
+        messages: [
+          {
+            role: "system",
+            content: BTW_SYSTEM_PROMPT,
+          },
+          ...messages,
+          {
+            role: "user",
+            content: question,
+          },
+        ],
+      },
+      {
+        signal: abortSignal,
+      },
+    );
+
+    const result = response.choices[0]?.message?.content?.trim();
+    if (!result) {
+      throw new Error(
+        "Failed to process side question: Empty response from AI",
+      );
+    }
+    const usage = response.usage
+      ? {
+          prompt_tokens: response.usage.prompt_tokens,
+          completion_tokens: response.usage.completion_tokens,
+          total_tokens: response.usage.total_tokens,
+        }
+      : undefined;
+
+    return {
+      content: result,
+      usage,
+    };
+  } catch (error) {
+    if ((error as Error).name === "AbortError") {
+      logger.info("Side question request was aborted");
+      throw new Error("Side question request was aborted");
+    }
+    logger.error("Failed to process side question:", error);
+    throw error;
+  }
+}

package/src/services/initializationService.ts

@@ -78,8 +78,11 @@ export class InitializationService {
       resolveAndValidateConfig,
     } = context;
 
+    const startTime = performance.now();
+
     // Initialize managers first
     try {
+      const phaseStart = performance.now();
       // Initialize SkillManager
       await skillManager.initialize();
 
@@ -100,6 +103,9 @@ export class InitializationService {
       slashCommandManager.registerSkillCommands(
         skillManager.getAvailableSkills(),
       );
+      logger?.debug(
+        `Initialization Phase [Managers and Tools] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
+      );
     } catch (error) {
       logger?.error("Failed to initialize managers and tools:", error);
       // Don't throw error to prevent app startup failure
@@ -107,10 +113,14 @@ export class InitializationService {
 
     // Initialize MCP servers with auto-connect
     try {
+      const phaseStart = performance.now();
       await mcpManager.initialize(workdir, true);
       if (lspManager instanceof LspManager) {
         await lspManager.initialize(workdir);
       }
+      logger?.debug(
+        `Initialization Phase [MCP and LSP] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
+      );
     } catch (error) {
       logger?.error("Failed to initialize MCP servers:", error);
       // Don't throw error to prevent app startup failure
@@ -118,6 +128,7 @@ export class InitializationService {
 
     // Initialize hooks configuration
     try {
+      const phaseStart = performance.now();
       // Load hooks configuration using ConfigurationService
       const configResult =
         await configurationService.loadMergedConfiguration(workdir);
@@ -158,6 +169,9 @@ export class InitializationService {
           }
         }
       }
+      logger?.debug(
+        `Initialization Phase [Hooks Configuration] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
+      );
     } catch (error) {
       logger?.error("Failed to initialize hooks system:", error);
       // Don't throw error to prevent app startup failure
@@ -196,6 +210,7 @@ export class InitializationService {
 
     // Initialize auto-memory directory
     try {
+      const phaseStart = performance.now();
       if (configurationService.resolveAutoMemoryEnabled()) {
         const memoryService =
           container.get<import("./memory.js").MemoryService>("MemoryService");
@@ -209,6 +224,9 @@ export class InitializationService {
           }
         }
       }
+      logger?.debug(
+        `Initialization Phase [Auto-memory Initialization] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
+      );
     } catch (error) {
       logger?.error("Failed to initialize auto-memory directory:", error);
     }
@@ -218,14 +236,22 @@ export class InitializationService {
 
     // Discover modular memory rules
     try {
+      const phaseStart = performance.now();
       await memoryRuleManager.discoverRules();
+      logger?.debug(
+        `Initialization Phase [Memory Rules Discovery] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
+      );
     } catch (error) {
       logger?.error("Failed to discover memory rules:", error);
     }
 
     // Initialize live configuration reload
     try {
+      const phaseStart = performance.now();
       await liveConfigManager.initialize();
+      logger?.debug(
+        `Initialization Phase [Live Config Initialization] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
+      );
     } catch (error) {
       logger?.error("Failed to initialize live configuration reload:", error);
       // Don't throw error to prevent app startup failure - continue without live reload
@@ -233,6 +259,7 @@ export class InitializationService {
 
     // Load memory files during initialization
     try {
+      const phaseStart = performance.now();
       const memoryService = container.get<MemoryService>("MemoryService");
       if (!memoryService) {
         throw new Error("MemoryService not found in container");
@@ -256,6 +283,9 @@ export class InitializationService {
         logger?.warn("Failed to load user memory file:", error);
         setUserMemory("");
       }
+      logger?.debug(
+        `Initialization Phase [Memory Files Loading] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
+      );
     } catch (error) {
       // Ensure memory is always initialized even if loading fails
       setProjectMemory("");
@@ -265,6 +295,7 @@ export class InitializationService {
     }
 
     // Handle session restoration or set provided messages
+    const sessionPhaseStart = performance.now();
     if (options?.messages) {
       // If messages are provided, use them directly (useful for testing)
       messageManager.setMessages(options.messages);
@@ -293,5 +324,12 @@ export class InitializationService {
         agentOptions.callbacks?.onTasksChange?.(tasks);
       }
     }
+    logger?.debug(
+      `Initialization Phase [Session Restoration] took ${(performance.now() - sessionPhaseStart).toFixed(2)}ms`,
+    );
+
+    logger?.debug(
+      `Total Initialization took ${(performance.now() - startTime).toFixed(2)}ms`,
+    );
   }
 }

package/src/tools/agentTool.ts

@@ -36,7 +36,7 @@ export const agentTool: ToolPlugin = {
           run_in_background: {
             type: "boolean",
             description:
-              "Set to true to run this command in the background. Use TaskOutput to read the output later.",
+              "Set to true to run this command in the background. Use Read to read the output later.",
           },
         },
         required: ["description", "prompt", "subagent_type"],
@@ -154,7 +154,7 @@ When using the Agent tool, you must specify a subagent_type parameter to select
           if (run_in_background || isBackgrounded) return;
 
           const messages = instance.messageManager.getMessages();
-          const tokens = instance.messageManager.getlatestTotalTokens();
+          const tokens = instance.messageManager.getLatestTotalTokens();
           const lastTools = instance.lastTools;
 
           const toolCount = countToolBlocks(messages);
@@ -224,7 +224,7 @@ When using the Agent tool, you must specify a subagent_type parameter to select
             subagentManager.cleanupInstance(instance.subagentId);
 
             const messages = instance.messageManager.getMessages();
-            const tokens = instance.messageManager.getlatestTotalTokens();
+            const tokens = instance.messageManager.getLatestTotalTokens();
             const toolCount = countToolBlocks(messages);
             const summary = formatToolTokenSummary(toolCount, tokens);
 

package/src/tools/bashTool.ts

@@ -7,7 +7,6 @@ import { stripAnsiColors } from "../utils/stringUtils.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import {
   BASH_TOOL_NAME,
-  TASK_OUTPUT_TOOL_NAME,
   GLOB_TOOL_NAME,
   GREP_TOOL_NAME,
   READ_TOOL_NAME,
@@ -87,7 +86,7 @@ export const bashTool: ToolPlugin = {
           },
           run_in_background: {
             type: "boolean",
-            description: `Set to true to run this command in the background. Use ${TASK_OUTPUT_TOOL_NAME} to read the output later.`,
+            description: `Set to true to run this command in the background. Use ${READ_TOOL_NAME} to read the output later.`,
           },
         },
         required: ["command"],
@@ -120,7 +119,7 @@ Usage notes:
   - You can specify an optional timeout in milliseconds (up to ${BASH_DEFAULT_TIMEOUT_MS}ms / ${BASH_DEFAULT_TIMEOUT_MS / 60000} minutes). If not specified, commands will timeout after ${BASH_DEFAULT_TIMEOUT_MS}ms (${BASH_DEFAULT_TIMEOUT_MS / 60000} minutes).
   - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
   - If the output exceeds ${MAX_OUTPUT_LENGTH} characters, output will be truncated and the full output will be persisted to a temporary file.
-  - You can use the \`run_in_background\` parameter to run the command in the background, which allows you to continue working while the command runs. You can monitor the output using the ${BASH_TOOL_NAME} tool as it becomes available. You do not need to use '&' at the end of the command when using this parameter.
+  - You can use the \`run_in_background\` parameter to run the command in the background, which allows you to continue working while the command runs. You can monitor the output using the ${READ_TOOL_NAME} tool as it becomes available. You do not need to use '&' at the end of the command when using this parameter.
   - Avoid using ${BASH_TOOL_NAME} with the \`find\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or when these commands are truly necessary for the task. Instead, always prefer using the dedicated tools for these commands:
     - File search: Use ${GLOB_TOOL_NAME} (NOT find or ls)
     - Content search: Use ${GREP_TOOL_NAME}
@@ -226,7 +225,7 @@ Usage notes:
       const outputPath = task?.outputPath;
       return {
         success: true,
-        content: `Command started in background with ID: ${taskId}.${outputPath ? ` Real-time output: ${outputPath}` : ` Use TaskOutput tool with task_id="${taskId}" to monitor output.`}`,
+        content: `Command started in background with ID: ${taskId}.${outputPath ? ` Real-time output: ${outputPath}` : ` Use ${READ_TOOL_NAME} tool with task_id="${taskId}" to monitor output.`}`,
         shortResult: `Background process ${taskId} started`,
       };
     }

package/src/tools/editTool.ts

@@ -106,6 +106,9 @@ Usage:
       };
     }
 
+    // Touch file to track it in context
+    context.messageManager?.touchFile(filePath);
+
     try {
       const resolvedPath = resolvePath(filePath, context.workdir);
 

package/src/tools/globTool.ts

@@ -32,6 +32,10 @@ export const globTool: ToolPlugin = {
             description:
               'The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.',
           },
+          limit: {
+            type: "number",
+            description: "Maximum number of files to return. Defaults to 100.",
+          },
         },
         required: ["pattern"],
       },
@@ -50,6 +54,8 @@ export const globTool: ToolPlugin = {
   ): Promise<ToolResult> => {
     const pattern = args.pattern as string;
     const searchPath = args.path as string;
+    const limit = (args.limit as number) || MAX_GLOB_RESULTS;
+    const startTime = Date.now();
 
     if (!pattern || typeof pattern !== "string") {
       return {
@@ -113,22 +119,29 @@ export const globTool: ToolPlugin = {
         .map((item) => item.path);
 
       const totalCount = sortedFiles.length;
-      const finalFiles = sortedFiles.slice(0, MAX_GLOB_RESULTS);
+      const finalFiles = sortedFiles.slice(0, limit);
 
       // Format output
       const output = finalFiles
         .map((file, index) => `${index + 1}. ${file}`)
         .join("\n");
 
-      const isTruncated = totalCount > MAX_GLOB_RESULTS;
+      const isTruncated = totalCount > limit;
       const shortResult = isTruncated
-        ? `Found ${totalCount} files (showing first ${MAX_GLOB_RESULTS})`
+        ? `Found ${totalCount} files (showing first ${limit})`
         : `Found ${totalCount} file${totalCount === 1 ? "" : "s"}`;
 
+      const durationMs = Date.now() - startTime;
+
       return {
         success: true,
         content: output,
         shortResult,
+        metadata: {
+          durationMs,
+          numFiles: totalCount,
+          truncated: isTruncated,
+        },
       };
     } catch (error) {
       return {

package/src/tools/grepTool.ts

@@ -81,6 +81,15 @@ export const grepTool: ToolPlugin = {
             description:
               "Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false.",
           },
+          offset: {
+            type: "number",
+            description: "The number of matches to skip.",
+          },
+          context: {
+            type: "number",
+            description:
+              'Alias for -C. Number of lines to show before and after each match. Requires output_mode: "content", ignored otherwise.',
+          },
         },
         required: ["pattern"],
       },
@@ -113,6 +122,8 @@ export const grepTool: ToolPlugin = {
     const fileType = args.type as string;
     const headLimit = args.head_limit as number;
     const multiline = args.multiline as boolean;
+    const offset = args.offset as number;
+    const contextArg = args.context as number;
 
     if (!pattern || typeof pattern !== "string") {
       return {
@@ -165,8 +176,9 @@ export const grepTool: ToolPlugin = {
 
       // Context lines (only effective in content mode)
       if (outputMode === "content") {
-        if (contextAround) {
-          rgArgs.push("-C", contextAround.toString());
+        const effectiveContext = contextArg ?? contextAround;
+        if (effectiveContext) {
+          rgArgs.push("-C", effectiveContext.toString());
         } else {
           if (contextBefore) {
             rgArgs.push("-B", contextBefore.toString());
@@ -215,41 +227,57 @@ export const grepTool: ToolPlugin = {
           content:
             "No matches found. Suggestion: specify the 'path' field to search in ignored or other directories (e.g., 'node_modules'), as the default search path is the current working directory and respects .gitignore.",
           shortResult: "No matches found",
+          metadata: {
+            numMatches: 0,
+          },
         };
       }
 
-      // Apply head_limit with default fallback
-      let finalOutput = output;
       let lines = output.split("\n");
+      const totalMatches = lines.length;
 
-      // Set default head_limit if not specified to prevent excessive token usage
-      const effectiveHeadLimit = headLimit || 0;
+      // Apply offset
+      const effectiveOffset = offset || 0;
+      if (effectiveOffset > 0) {
+        lines = lines.slice(effectiveOffset);
+      }
 
+      // Apply head_limit
+      const effectiveHeadLimit = headLimit || 0;
+      let truncated = false;
       if (effectiveHeadLimit > 0 && lines.length > effectiveHeadLimit) {
         lines = lines.slice(0, effectiveHeadLimit);
-        finalOutput = lines.join("\n");
+        truncated = true;
       }
 
+      const finalOutput = lines.join("\n");
+
       // Generate short result
       let shortResult: string;
-      const totalLines = output.split("\n").length;
+      const numMatches = lines.length;
 
       if (outputMode === "files_with_matches") {
-        shortResult = `Found ${totalLines} file${totalLines === 1 ? "" : "s"}`;
+        shortResult = `Found ${numMatches} file${numMatches === 1 ? "" : "s"}`;
       } else if (outputMode === "count") {
-        shortResult = `Match counts for ${totalLines} file${totalLines === 1 ? "" : "s"}`;
+        shortResult = `Match counts for ${numMatches} file${numMatches === 1 ? "" : "s"}`;
       } else {
-        shortResult = `Found ${totalLines} matching line${totalLines === 1 ? "" : "s"}`;
+        shortResult = `Found ${numMatches} matching line${numMatches === 1 ? "" : "s"}`;
       }
 
-      if (effectiveHeadLimit && totalLines > effectiveHeadLimit) {
-        shortResult += ` (showing first ${effectiveHeadLimit})`;
+      if (effectiveOffset > 0 || truncated) {
+        shortResult += ` (showing ${numMatches} of ${totalMatches})`;
       }
 
       return {
         success: true,
         content: finalOutput,
         shortResult,
+        metadata: {
+          numMatches: totalMatches,
+          truncated,
+          appliedLimit: effectiveHeadLimit,
+          appliedOffset: effectiveOffset,
+        },
       };
     } catch (error) {
       return {

package/src/tools/readTool.ts

@@ -1,5 +1,6 @@
 import { readFile, stat } from "fs/promises";
 import { extname } from "path";
+import { createHash } from "crypto";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
@@ -117,6 +118,10 @@ async function processImageFile(
           mediaType: mimeType,
         },
       ],
+      metadata: {
+        type: "image",
+        mimeType,
+      },
     };
   } catch (error) {
     return {
@@ -190,12 +195,19 @@ Usage:
       };
     }
 
+    // Touch file to track it in context
+    context.messageManager?.touchFile(filePath);
+
     // Check for binary document formats
     if (isBinaryDocument(filePath)) {
+      const isPdf = filePath.toLowerCase().endsWith(".pdf");
       return {
         success: false,
         content: "",
         error: getBinaryDocumentError(filePath),
+        metadata: {
+          type: isPdf ? "pdf" : "binary",
+        },
       };
     }
 
@@ -230,8 +242,54 @@ Usage:
         ? filePath
         : resolvePath(filePath, context.workdir);
 
+      const stats = await stat(actualFilePath);
+
+      // Deduplication
+      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",
+            },
+          };
+        }
+      }
+
+      // Resource Limits
+      const maxSizeBytes =
+        context.fileReadingLimits?.maxSizeBytes ?? 1024 * 1024; // Default 1MB
+      if (
+        stats.size > maxSizeBytes &&
+        typeof offset !== "number" &&
+        typeof limit !== "number"
+      ) {
+        return {
+          success: false,
+          content: "",
+          error: `File size (${(stats.size / 1024).toFixed(2)}KB) exceeds limit (${(maxSizeBytes / 1024).toFixed(2)}KB). Please use offset and limit to read a portion of the file.`,
+          metadata: {
+            type: "error_limit_exceeded",
+            size: stats.size,
+            limit: maxSizeBytes,
+          },
+        };
+      }
+
       const fileContent = await readFile(actualFilePath, "utf-8");
 
+      // Update readFileState
+      if (context.readFileState) {
+        const hash = createHash("sha256").update(fileContent).digest("hex");
+        context.readFileState.set(actualFilePath, {
+          mtime: stats.mtime.getTime(),
+          hash,
+        });
+      }
+
       // Check if file is empty
       if (fileContent.length === 0) {
         logger.warn(`File ${filePath} exists but has empty contents`);
@@ -240,6 +298,10 @@ Usage:
           content:
             "⚠️ System reminder: This file exists but has empty contents.",
           shortResult: "Empty file",
+          metadata: {
+            type: "text",
+            isEmpty: true,
+          },
         };
       }
 
@@ -306,6 +368,13 @@ Usage:
         success: true,
         content,
         shortResult: `Read ${selectedLines.length} lines${totalLines > 2000 ? " (truncated)" : ""}`,
+        metadata: {
+          type: "text",
+          totalLines,
+          startLine,
+          endLine,
+          truncated: endLine < totalLines,
+        },
       };
     } catch (error) {
       return {