wave-agent-sdk 1.0.4 → 1.0.6

package/src/tools/readTool.ts

@@ -1,426 +0,0 @@
-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";
-import { formatLineNumberPrefix } from "../utils/stringUtils.js";
-import { estimateTokens } from "../utils/tokenEstimate.js";
-import {
-  isBinaryDocument,
-  getBinaryDocumentError,
-} from "../utils/fileFormat.js";
-import { convertImageToBase64 } from "../utils/messageOperations.js";
-import { READ_TOOL_NAME } from "../constants/tools.js";
-
-/**
- * Supported image file extensions
- */
-const SUPPORTED_IMAGE_EXTENSIONS = [
-  "png",
-  "jpeg",
-  "jpg",
-  "gif",
-  "webp",
-] as const;
-
-/**
- * Check if a file path represents an image file
- * @param filePath - Path to the file
- * @returns true if the file is a supported image format
- */
-function isImageFile(filePath: string): boolean {
-  const ext = extname(filePath).toLowerCase().substring(1);
-  return (SUPPORTED_IMAGE_EXTENSIONS as readonly string[]).includes(ext);
-}
-
-/**
- * Validate image file size
- * @param filePath - Path to the image file
- * @param maxSizeBytes - Maximum allowed file size in bytes (default: 20MB)
- * @returns Promise<boolean> - true if file size is within limit
- */
-async function validateImageFileSize(
-  filePath: string,
-  maxSizeBytes: number = 20 * 1024 * 1024,
-): Promise<boolean> {
-  try {
-    const stats = await stat(filePath);
-    return stats.size <= maxSizeBytes;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get MIME type for image file based on extension
- * @param filePath - Path to the image file
- * @returns MIME type string
- */
-function getImageMimeType(filePath: string): string {
-  const ext = extname(filePath).toLowerCase().substring(1);
-  switch (ext) {
-    case "png":
-      return "image/png";
-    case "jpg":
-    case "jpeg":
-      return "image/jpeg";
-    case "gif":
-      return "image/gif";
-    case "webp":
-      return "image/webp";
-    default:
-      return "image/png"; // Default fallback
-  }
-}
-
-/**
- * Process an image file and return ToolResult with image data
- * @param filePath - Path to the image file
- * @param context - Tool execution context
- * @returns Promise<ToolResult> with image data
- */
-async function processImageFile(
-  filePath: string,
-  context: ToolContext,
-): Promise<ToolResult> {
-  try {
-    // Resolve path
-    const actualFilePath = filePath.startsWith("/")
-      ? filePath
-      : resolvePath(filePath, context.workdir);
-
-    // Validate file size
-    const isValidSize = await validateImageFileSize(actualFilePath);
-    if (!isValidSize) {
-      const stats = await stat(actualFilePath);
-      const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
-      return {
-        success: false,
-        content: "",
-        error: `Image file exceeds 20MB limit (actual: ${sizeMB}MB)`,
-      };
-    }
-
-    // Convert image to base64
-    const imageDataUrl = convertImageToBase64(actualFilePath);
-    const mimeType = getImageMimeType(actualFilePath);
-
-    // Extract base64 data from data URL (remove data:image/type;base64, prefix)
-    const base64Data = imageDataUrl.split(",")[1] || "";
-
-    return {
-      success: true,
-      content: `Image file processed: ${getDisplayPath(filePath, context.workdir)}\nFormat: ${mimeType}\nSize: Available for AI processing`,
-      shortResult: `Image processed (${mimeType})`,
-      images: [
-        {
-          data: base64Data,
-          mediaType: mimeType,
-        },
-      ],
-      metadata: {
-        type: "image",
-        mimeType,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      content: "",
-      error: `Failed to process image: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-}
-
-/**
- * Read Tool Plugin - Read file content
- */
-export const readTool: ToolPlugin = {
-  name: READ_TOOL_NAME,
-  prompt:
-    () => `Reads a file from the local filesystem. You can access any file directly by using this tool.
-Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
-
-Usage:
-- The file_path parameter must be an absolute path, not a relative path
-- By default, it reads up to 2000 lines starting from the beginning of the file
-- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
-- If the file content exceeds the token limit, use offset and limit parameters to read specific portions of the file, or use Bash with grep/jq to extract specific content
-- Results are returned using cat -n format, with line numbers starting at 1
-- This tool allows Agent to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Agent is a multimodal LLM.
-- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
-- You will regularly be asked to read screenshots. If the user provides a path to a screenshot ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths like /var/folders/123/abc/T/TemporaryItems/NSIRD_screencaptureui_ZfB1tD/Screenshot.png
-- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
-- Binary document formats (PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX) are not supported and will return an error.`,
-  config: {
-    type: "function",
-    function: {
-      name: READ_TOOL_NAME,
-      description: "Read a file from the local filesystem.",
-      parameters: {
-        type: "object",
-        properties: {
-          file_path: {
-            type: "string",
-            description: "The absolute path to the file to read",
-          },
-          offset: {
-            type: "number",
-            description:
-              "The line number to start reading from. Only provide if the file is too large to read at once",
-          },
-          limit: {
-            type: "number",
-            description:
-              "The number of lines to read. Only provide if the file is too large to read at once.",
-          },
-        },
-        required: ["file_path"],
-      },
-    },
-  },
-  execute: async (
-    args: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolResult> => {
-    const filePath = args.file_path as string;
-    const offset = args.offset as number;
-    const limit = args.limit as number;
-
-    if (!filePath || typeof filePath !== "string") {
-      return {
-        success: false,
-        content: "",
-        error: "file_path parameter is required and must be a string",
-      };
-    }
-
-    // Trigger conditional rule loading for this file
-    context.messageManager?.triggerFileRead(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",
-        },
-      };
-    }
-
-    // Check permissions
-    if (context.permissionManager) {
-      const permissionContext = context.permissionManager.createContext(
-        READ_TOOL_NAME,
-        context.permissionMode || "default",
-        context.canUseToolCallback,
-        args,
-      );
-      const decision =
-        await context.permissionManager.checkPermission(permissionContext);
-      if (decision.behavior === "deny") {
-        return {
-          success: false,
-          content: "",
-          error: decision.message || "Permission denied",
-        };
-      }
-    }
-
-    // Check if this is an image file
-    if (isImageFile(filePath)) {
-      return processImageFile(filePath, context);
-    }
-
-    try {
-      // Note: New Read tool requires absolute paths, so we don't use resolvePath
-      // But for compatibility, if it's not an absolute path, we still try to resolve
-      const actualFilePath = filePath.startsWith("/")
-        ? filePath
-        : resolvePath(filePath, context.workdir);
-
-      const stats = await stat(actualFilePath);
-
-      // Deduplication: only dedup if the exact same range was read before
-      if (context.readFileState) {
-        const state = context.readFileState.get(actualFilePath);
-        // Only dedup entries from a prior Read with explicit offset (not Edit/Write entries)
-        if (
-          state &&
-          state.mtime === stats.mtime.getTime() &&
-          state.offset !== undefined
-        ) {
-          const rangeMatch = state.offset === offset && state.limit === limit;
-          if (rangeMatch) {
-            return {
-              success: true,
-              content: `File ${filePath} has not changed since last read. The content from the earlier Read tool_result in this conversation is still current — refer to that instead of re-reading.`,
-              shortResult: "File unchanged",
-              metadata: {
-                type: "file_unchanged",
-              },
-            };
-          }
-        }
-      }
-
-      // Resource Limits — align with Claude Code: 256KB default, bypassed only
-      // when the caller provides an explicit line limit (not offset alone).
-      const maxSizeBytes =
-        context.fileReadingLimits?.maxSizeBytes ?? 0.25 * 1024 * 1024; // Default 256KB
-      if (stats.size > maxSizeBytes && 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,
-          offset, // undefined for full reads
-          limit, // undefined for full reads
-        });
-      }
-
-      // Check if file is empty
-      if (fileContent.length === 0) {
-        logger.warn(`File ${filePath} exists but has empty contents`);
-        return {
-          success: true,
-          content: "System reminder: This file exists but has empty contents.",
-          shortResult: "Empty file",
-          metadata: {
-            type: "text",
-            isEmpty: true,
-          },
-        };
-      }
-
-      const allLines = fileContent.split("\n");
-      const totalLines = allLines.length;
-
-      // Handle offset and limit
-      let startLine = 1;
-      if (typeof offset === "number") {
-        startLine = Math.max(1, offset);
-      }
-
-      let endLine = Math.min(
-        totalLines,
-        startLine + (typeof limit === "number" ? limit : 2000) - 1,
-      );
-
-      // If no offset and limit specified, read entire file (maximum 2000 lines)
-      if (typeof offset !== "number" && typeof limit !== "number") {
-        startLine = 1;
-        endLine = Math.min(totalLines, 2000);
-      }
-
-      // Validate line number range
-      if (startLine > totalLines) {
-        return {
-          success: false,
-          content: "",
-          error: `Start line ${startLine} exceeds total lines ${totalLines}`,
-        };
-      }
-
-      // Extract specified line range
-      const selectedLines = allLines.slice(startLine - 1, endLine);
-
-      // Format output (cat -n format, with line numbers)
-      const formattedContent = selectedLines
-        .map((line, index) => {
-          const lineNumber = startLine + index;
-          return `${formatLineNumberPrefix(lineNumber)}${line}`;
-        })
-        .join("\n");
-
-      // Token-level validation: estimate tokens and reject if over limit
-      const maxTokens = context.fileReadingLimits?.maxTokens ?? 25000; // Default 25000 tokens
-      const ext = extname(actualFilePath).toLowerCase().slice(1);
-      const estimatedTokens = estimateTokens(formattedContent, ext);
-      if (estimatedTokens > maxTokens) {
-        return {
-          success: false,
-          content: "",
-          error: `File content (~${estimatedTokens.toLocaleString()} tokens) exceeds maximum allowed tokens (${maxTokens.toLocaleString()}). Use offset and limit parameters to read specific portions of the file, or use Bash with grep/jq to search within it for specific content.`,
-          metadata: {
-            type: "error_token_limit_exceeded",
-            estimatedTokens,
-            maxTokens,
-          },
-        };
-      }
-
-      // Add file information header
-      let content = `File: ${filePath}\n`;
-      if (startLine > 1 || endLine < totalLines) {
-        content += `Lines ${startLine}-${endLine} of ${totalLines}\n`;
-      } else {
-        content += `Total lines: ${totalLines}\n`;
-      }
-      content += "─".repeat(50) + "\n";
-      content += formattedContent;
-
-      // If only showing partial content, add prompt
-      if (endLine < totalLines) {
-        content += `\n${"─".repeat(50)}\n`;
-        content += `... ${totalLines - endLine} more lines not shown`;
-      }
-
-      return {
-        success: true,
-        content,
-        shortResult: `Read ${selectedLines.length} lines${totalLines > 2000 ? " (truncated)" : ""}`,
-        metadata: {
-          type: "text",
-          totalLines,
-          startLine,
-          endLine,
-          truncated: endLine < totalLines,
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        content: "",
-        error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
-      };
-    }
-  },
-  formatCompactParams: (
-    params: Record<string, unknown>,
-    context: ToolContext,
-  ) => {
-    const filePath = params.file_path as string;
-    const offset = params.offset as number;
-    const limit = params.limit as number;
-
-    let displayPath = getDisplayPath(filePath || "", context.workdir);
-
-    if (typeof offset === "number" || typeof limit === "number") {
-      const offsetStr = typeof offset === "number" ? offset.toString() : "1";
-      const limitStr = typeof limit === "number" ? limit.toString() : "2000";
-      displayPath += ` ${offsetStr}:${limitStr}`;
-    }
-
-    return displayPath;
-  },
-};

package/src/tools/skillTool.ts

@@ -1,248 +0,0 @@
-import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import { SKILL_TOOL_NAME } from "../constants/tools.js";
-import { GENERAL_PURPOSE_SUBAGENT_TYPE } from "../constants/subagents.js";
-import type { SkillMetadata } from "../types/skills.js";
-import { logger } from "../utils/globalLogger.js";
-import {
-  countToolBlocks,
-  formatToolTokenSummary,
-} from "../utils/messageOperations.js";
-
-/**
- * Skill tool plugin for invoking Wave skills
- */
-const SKILL_TOOL_DESCRIPTION =
-  "Execute a skill within the main conversation. When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.";
-
-export const skillTool: ToolPlugin = {
-  name: SKILL_TOOL_NAME,
-  config: {
-    type: "function" as const,
-    function: {
-      name: SKILL_TOOL_NAME,
-      description: SKILL_TOOL_DESCRIPTION,
-      parameters: {
-        type: "object",
-        properties: {
-          skill_name: {
-            type: "string",
-            description: "Name of the skill to invoke",
-          },
-          args: {
-            type: "string",
-            description: "Optional arguments to pass to the skill",
-          },
-        },
-        required: ["skill_name"],
-      },
-    },
-  },
-
-  prompt: (args?: {
-    availableSkills?: SkillMetadata[];
-    isSubagent?: boolean;
-  }) => {
-    let availableSkills = args?.availableSkills?.filter(
-      (skill) => !skill.disableModelInvocation,
-    );
-
-    if (args?.isSubagent) {
-      availableSkills = availableSkills?.filter(
-        (skill) => skill.context !== "fork",
-      );
-    }
-
-    if (!availableSkills || availableSkills.length === 0) {
-      return `${SKILL_TOOL_DESCRIPTION} No skills are currently available.`;
-    }
-
-    const skillList = availableSkills
-      .map(
-        (skill) => `• **${skill.name}** (${skill.type}): ${skill.description}`,
-      )
-      .join("\n");
-
-    return `${SKILL_TOOL_DESCRIPTION} Do not invoke the same skill repeatedly if it has already been called with the same arguments.\n\nAvailable skills:\n${skillList}`;
-  },
-
-  execute: async (
-    args: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolResult> => {
-    try {
-      const skillManager = context.skillManager;
-      if (!skillManager) {
-        return {
-          success: false,
-          content: "",
-          error: "Skill manager not available in tool context",
-        };
-      }
-
-      // Validate arguments
-      const skillName = args.skill_name as string;
-      const skillArgs = args.args as string | undefined;
-
-      if (!skillName || typeof skillName !== "string") {
-        return {
-          success: false,
-          content: "",
-          error: "skill_name parameter is required and must be a string",
-        };
-      }
-
-      const skillMetadata = skillManager.getSkillMetadata(skillName);
-
-      if (skillMetadata?.disableModelInvocation) {
-        return {
-          success: false,
-          content: "",
-          error: `Skill "${skillName}" is not available for model invocation.`,
-        };
-      }
-
-      // Handle fork context
-      if (skillMetadata?.context === "fork") {
-        const subagentManager = context.subagentManager;
-        if (!subagentManager) {
-          return {
-            success: false,
-            content: "",
-            error: "Subagent manager not available in tool context",
-          };
-        }
-
-        const agentType = skillMetadata.agent || GENERAL_PURPOSE_SUBAGENT_TYPE;
-        const configuration = await subagentManager.findSubagent(agentType);
-
-        if (!configuration) {
-          return {
-            success: false,
-            content: "",
-            error: `No subagent found matching "${agentType}" for skill "${skillName}"`,
-          };
-        }
-
-        // Execute the skill to get the content
-        const skillResult = await skillManager.executeSkill({
-          skill_name: skillName,
-          args: skillArgs,
-        });
-
-        logger.debug(`Skill ${skillName} executed, allowedTools:`, {
-          allowedTools: skillResult.allowedTools,
-        });
-
-        // Create subagent instance
-        const instance = await subagentManager.createInstance(
-          configuration,
-          {
-            description: `Skill: ${skillName}`,
-            prompt: skillResult.content,
-            subagent_type: agentType,
-            allowedTools: skillResult.allowedTools,
-            model: skillMetadata.model,
-          },
-          false, // run_in_background
-          () => {
-            // Update shortResult
-            const messages = instance.messageManager.getMessages();
-            const tokens = instance.messageManager.getLatestTotalTokens();
-            const usedTools = instance.usedTools;
-
-            const toolCount = countToolBlocks(messages);
-            const summary = formatToolTokenSummary(toolCount, tokens);
-
-            const getDisplayParam = (t: {
-              name: string;
-              parameters: string;
-              compactParams?: string;
-              stage?: string;
-            }) => {
-              if (
-                (t.stage === "end" || t.stage === "running") &&
-                t.compactParams
-              ) {
-                return t.compactParams;
-              }
-              const flat = t.parameters.replace(/\n/g, "\\n");
-              return flat.length > 30 ? `…${flat.slice(-30)}` : flat;
-            };
-
-            let shortResult = "";
-            if (toolCount > 2) {
-              shortResult += "... ";
-            }
-            shortResult += summary;
-            if (usedTools.length > 0) {
-              shortResult +=
-                "\n" +
-                usedTools
-                  .map((t) => `${t.name} ${getDisplayParam(t)}`)
-                  .join("\n");
-            }
-
-            context.onShortResultUpdate?.(shortResult);
-          },
-        );
-
-        try {
-          const result = await subagentManager.executeAgent(
-            instance,
-            skillResult.content,
-            context.abortSignal,
-            false,
-          );
-
-          // Cleanup subagent instance after agent completion
-          subagentManager.cleanupInstance(instance.subagentId);
-
-          const messages = instance.messageManager.getMessages();
-          const tokens = instance.messageManager.getLatestTotalTokens();
-          const toolCount = countToolBlocks(messages);
-          const summary = formatToolTokenSummary(toolCount, tokens);
-
-          return {
-            success: true,
-            content: result,
-            shortResult: `Invoked skill: ${skillName}${summary ? ` ${summary}` : ""}`,
-          };
-        } catch (error) {
-          return {
-            success: false,
-            content: "",
-            error: `Skill fork failed: ${error instanceof Error ? error.message : String(error)}`,
-          };
-        }
-      }
-
-      // Standard execution
-      const result = await skillManager.executeSkill({
-        skill_name: skillName,
-        args: skillArgs,
-      });
-
-      // Add temporary rules if allowedTools are present
-      if (result.allowedTools && result.allowedTools.length > 0) {
-        context.permissionManager?.addTemporaryRules(result.allowedTools);
-      }
-
-      return {
-        success: true,
-        content: result.content,
-        shortResult: `Invoked skill: ${skillName}`,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        content: "",
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  },
-
-  formatCompactParams: (params: Record<string, unknown>) => {
-    const skillName = params.skill_name as string;
-    return skillName || "unknown-skill";
-  },
-};