wave-agent-sdk 0.0.2 → 0.0.3

package/src/managers/subagentManager.ts

@@ -0,0 +1,368 @@
+import { randomUUID } from "crypto";
+import type { SubagentConfiguration } from "../utils/subagentParser.js";
+import type { Message, Logger, GatewayConfig, ModelConfig } from "../types.js";
+import { AIManager } from "./aiManager.js";
+import {
+  MessageManager,
+  type MessageManagerCallbacks,
+} from "./messageManager.js";
+import { ToolManager } from "./toolManager.js";
+
+export interface SubagentInstance {
+  subagentId: string;
+  configuration: SubagentConfiguration;
+  aiManager: AIManager;
+  messageManager: MessageManager;
+  toolManager: ToolManager;
+  status: "initializing" | "active" | "completed" | "error" | "aborted";
+  taskDescription: string;
+  messages: Message[];
+}
+
+export interface SubagentManagerOptions {
+  workdir: string;
+  parentToolManager: ToolManager;
+  parentMessageManager: MessageManager;
+  logger?: Logger;
+  gatewayConfig: GatewayConfig;
+  modelConfig: ModelConfig;
+  tokenLimit: number;
+}
+
+export class SubagentManager {
+  private instances = new Map<string, SubagentInstance>();
+  private cachedConfigurations: SubagentConfiguration[] | null = null;
+
+  private workdir: string;
+  private parentToolManager: ToolManager;
+  private parentMessageManager: MessageManager;
+  private logger?: Logger;
+  private gatewayConfig: GatewayConfig;
+  private modelConfig: ModelConfig;
+  private tokenLimit: number;
+
+  constructor(options: SubagentManagerOptions) {
+    this.workdir = options.workdir;
+    this.parentToolManager = options.parentToolManager;
+    this.parentMessageManager = options.parentMessageManager;
+    this.logger = options.logger;
+    this.gatewayConfig = options.gatewayConfig;
+    this.modelConfig = options.modelConfig;
+    this.tokenLimit = options.tokenLimit;
+  }
+
+  /**
+   * Initialize the SubagentManager by loading and caching configurations
+   */
+  async initialize(): Promise<void> {
+    await this.loadConfigurations();
+  }
+
+  /**
+   * Load all available subagent configurations and cache them
+   */
+  async loadConfigurations(): Promise<SubagentConfiguration[]> {
+    if (this.cachedConfigurations === null) {
+      const { loadSubagentConfigurations } = await import(
+        "../utils/subagentParser.js"
+      );
+      this.cachedConfigurations = await loadSubagentConfigurations(
+        this.workdir,
+      );
+    }
+    return this.cachedConfigurations;
+  }
+
+  /**
+   * Get cached configurations synchronously (must call loadConfigurations first)
+   */
+  getConfigurations(): SubagentConfiguration[] {
+    if (this.cachedConfigurations === null) {
+      throw new Error(
+        "SubagentManager not initialized. Call loadConfigurations() first.",
+      );
+    }
+    return this.cachedConfigurations;
+  }
+
+  /**
+   * Find subagent by exact name match
+   */
+  async findSubagent(name: string) {
+    const { findSubagentByName } = await import("../utils/subagentParser.js");
+    return findSubagentByName(name, this.workdir);
+  }
+
+  /**
+   * Create a new subagent instance with isolated managers
+   */
+  async createInstance(
+    configuration: SubagentConfiguration,
+    taskDescription: string,
+  ): Promise<SubagentInstance> {
+    if (
+      !this.parentToolManager ||
+      !this.gatewayConfig ||
+      !this.modelConfig ||
+      !this.tokenLimit
+    ) {
+      throw new Error(
+        "SubagentManager not properly initialized - call initialize() first",
+      );
+    }
+
+    const subagentId = randomUUID();
+
+    // Create isolated MessageManager for the subagent
+    const subagentCallbacks: MessageManagerCallbacks = {
+      // These callbacks will be handled by the parent agent
+      onMessagesChange: (messages: Message[]) => {
+        const instance = this.instances.get(subagentId);
+        if (instance) {
+          instance.messages = messages;
+          // Update parent's subagent block with latest messages
+          this.parentMessageManager.updateSubagentBlock(subagentId, {
+            messages: messages,
+          });
+        }
+      },
+    };
+
+    const messageManager = new MessageManager({
+      callbacks: subagentCallbacks,
+      workdir: this.workdir,
+      logger: this.logger,
+    });
+
+    // Use the parent tool manager directly - tool restrictions will be handled by allowedTools parameter
+    const toolManager = this.parentToolManager;
+
+    // Determine model to use
+    const modelToUse =
+      configuration.model && configuration.model !== "inherit"
+        ? configuration.model
+        : this.modelConfig.agentModel;
+
+    // Create isolated AIManager for the subagent
+    const aiManager = new AIManager({
+      messageManager,
+      toolManager,
+      logger: this.logger,
+      workdir: this.workdir,
+      systemPrompt: configuration.systemPrompt,
+      gatewayConfig: this.gatewayConfig,
+      modelConfig: {
+        ...this.modelConfig,
+        agentModel: modelToUse,
+      },
+      tokenLimit: this.tokenLimit,
+    });
+
+    const instance: SubagentInstance = {
+      subagentId,
+      configuration,
+      aiManager,
+      messageManager,
+      toolManager,
+      status: "initializing",
+      taskDescription,
+      messages: [],
+    };
+
+    this.instances.set(subagentId, instance);
+
+    // Create subagent block in parent message manager
+    this.parentMessageManager.addSubagentBlock(
+      subagentId,
+      configuration.name,
+      "active",
+      [],
+    );
+
+    return instance;
+  }
+
+  /**
+   * Execute task using subagent instance
+   *
+   * IMPORTANT: This method automatically filters out the Task tool from allowedTools
+   * to prevent subagents from spawning other subagents (infinite recursion protection)
+   */
+  async executeTask(
+    instance: SubagentInstance,
+    prompt: string,
+  ): Promise<string> {
+    try {
+      // Set status to active and update parent
+      this.updateInstanceStatus(instance.subagentId, "active");
+      this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+        status: "active",
+      });
+
+      // Add the user's prompt as a message
+      instance.messageManager.addUserMessage(prompt);
+
+      // Create allowed tools list - always exclude Task tool to prevent subagent recursion
+      let allowedTools = instance.configuration.tools;
+
+      // Always filter out the Task tool to prevent subagents from creating sub-subagents
+      if (allowedTools) {
+        allowedTools = allowedTools.filter((tool) => tool !== "Task");
+      } else {
+        // If no tools specified, get all tools except Task
+        const allTools = instance.toolManager.list().map((tool) => tool.name);
+        allowedTools = allTools.filter((tool) => tool !== "Task");
+      }
+
+      // Execute the AI request with tool restrictions
+      await instance.aiManager.sendAIMessage({
+        allowedTools,
+        model:
+          instance.configuration.model !== "inherit"
+            ? instance.configuration.model
+            : undefined,
+      });
+
+      // Get the latest messages to extract the response
+      const messages = instance.messageManager.getMessages();
+      const lastAssistantMessage = messages
+        .filter((msg) => msg.role === "assistant")
+        .pop();
+
+      if (!lastAssistantMessage) {
+        throw new Error("No response from subagent");
+      }
+
+      // Extract text content from the last assistant message
+      const textBlocks = lastAssistantMessage.blocks.filter(
+        (block) => block.type === "text",
+      );
+      const response = textBlocks.map((block) => block.content).join("\n");
+
+      // Update status to completed and update parent with final messages
+      this.updateInstanceStatus(instance.subagentId, "completed");
+      this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+        status: "completed",
+        messages: messages,
+      });
+
+      return response || "Task completed with no text response";
+    } catch (error) {
+      this.updateInstanceStatus(instance.subagentId, "error");
+      this.parentMessageManager.updateSubagentBlock(instance.subagentId, {
+        status: "error",
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Get instance by subagent ID
+   */
+  getInstance(subagentId: string): SubagentInstance | null {
+    return this.instances.get(subagentId) || null;
+  }
+
+  /**
+   * Update instance status
+   */
+  updateInstanceStatus(
+    subagentId: string,
+    status: SubagentInstance["status"],
+  ): void {
+    const instance = this.instances.get(subagentId);
+    if (instance) {
+      instance.status = status;
+    }
+  }
+
+  /**
+   * Add message to instance
+   */
+  addMessageToInstance(subagentId: string, message: Message): void {
+    const instance = this.instances.get(subagentId);
+    if (instance) {
+      instance.messages.push(message);
+    }
+  }
+
+  /**
+   * Abort a running subagent instance
+   */
+  abortInstance(subagentId: string): boolean {
+    const instance = this.instances.get(subagentId);
+    if (!instance) {
+      return false;
+    }
+
+    // Only abort active or initializing instances
+    if (instance.status !== "active" && instance.status !== "initializing") {
+      return false;
+    }
+
+    try {
+      // Abort the AI manager operations
+      instance.aiManager.abortAIMessage();
+
+      // Update status
+      this.updateInstanceStatus(subagentId, "aborted");
+      this.parentMessageManager.updateSubagentBlock(subagentId, {
+        status: "aborted",
+        messages: instance.messages,
+      });
+
+      this.logger?.info(`Aborted subagent instance: ${subagentId}`);
+      return true;
+    } catch (error) {
+      this.logger?.error(
+        `Failed to abort subagent instance ${subagentId}:`,
+        error,
+      );
+      return false;
+    }
+  }
+
+  /**
+   * Abort all active subagent instances
+   */
+  abortAllInstances(): void {
+    const activeInstances = this.getActiveInstances();
+    for (const instance of activeInstances) {
+      this.abortInstance(instance.subagentId);
+    }
+  }
+
+  /**
+   * Clean up completed, errored, or aborted instances
+   */
+  cleanupInstance(subagentId: string): void {
+    const instance = this.instances.get(subagentId);
+    if (
+      instance &&
+      (instance.status === "completed" ||
+        instance.status === "error" ||
+        instance.status === "aborted")
+    ) {
+      this.instances.delete(subagentId);
+    }
+  }
+
+  /**
+   * Get all active instances
+   */
+  getActiveInstances(): SubagentInstance[] {
+    return Array.from(this.instances.values()).filter(
+      (instance) =>
+        instance.status === "active" || instance.status === "initializing",
+    );
+  }
+
+  /**
+   * Clean up all instances (for session end)
+   */
+  cleanup(): void {
+    // Abort all active instances before cleanup
+    this.abortAllInstances();
+    this.instances.clear();
+  }
+}

package/src/managers/toolManager.ts

@@ -9,10 +9,14 @@ import { globTool } from "../tools/globTool.js";
 import { grepTool } from "../tools/grepTool.js";
 import { lsTool } from "../tools/lsTool.js";
 import { readTool } from "../tools/readTool.js";
-import { SkillManager } from "./skillManager.js";
+import { todoWriteTool } from "../tools/todoWriteTool.js";
+import { createTaskTool } from "../tools/taskTool.js";
+import { createSkillTool } from "../tools/skillTool.js";
 import { McpManager } from "./mcpManager.js";
 import { ChatCompletionFunctionTool } from "openai/resources.js";
 import type { Logger } from "../types.js";
+import type { SubagentManager } from "./subagentManager.js";
+import type { SkillManager } from "./skillManager.js";
 
 export interface ToolManagerOptions {
   mcpManager: McpManager;
@@ -30,12 +34,42 @@ class ToolManager {
   constructor(options: ToolManagerOptions) {
     this.mcpManager = options.mcpManager;
     this.logger = options.logger;
+  }
 
-    // Initialize built-in tools
-    this.initializeBuiltInTools();
+  /**
+   * Register a new tool
+   */
+  public register(tool: ToolPlugin): void {
+    this.tools.set(tool.name, tool);
   }
 
-  private initializeBuiltInTools(): void {
+  /**
+   * Initialize built-in tools. Can be called with dependencies for tools that require them.
+   *
+   * This method can be called multiple times safely. When called without dependencies,
+   * it registers basic tools (Bash, Read, Write, TodoWrite, etc.). When called with
+   * dependencies, it also registers tools that require managers (Task, Skill).
+   *
+   * @param deps Optional dependencies for advanced tools
+   * @param deps.subagentManager SubagentManager instance for Task tool
+   * @param deps.skillManager SkillManager instance for Skill tool
+   *
+   * @example
+   * ```typescript
+   * // Initialize basic tools only
+   * toolManager.initializeBuiltInTools();
+   *
+   * // Initialize all tools including those requiring dependencies
+   * toolManager.initializeBuiltInTools({
+   *   subagentManager: mySubagentManager,
+   *   skillManager: mySkillManager
+   * });
+   * ```
+   */
+  public initializeBuiltInTools(deps?: {
+    subagentManager?: SubagentManager;
+    skillManager?: SkillManager;
+  }): void {
     const builtInTools = [
       bashTool,
       bashOutputTool,
@@ -48,12 +82,23 @@ class ToolManager {
       grepTool,
       lsTool,
       readTool,
-      new SkillManager({ logger: this.logger }).createTool(),
+      todoWriteTool,
     ];
 
     for (const tool of builtInTools) {
       this.tools.set(tool.name, tool);
     }
+
+    // Register tools that require dependencies
+    if (deps?.subagentManager) {
+      const taskTool = createTaskTool(deps.subagentManager);
+      this.tools.set(taskTool.name, taskTool);
+    }
+
+    if (deps?.skillManager) {
+      const skillTool = createSkillTool(deps.skillManager);
+      this.tools.set(skillTool.name, skillTool);
+    }
   }
 
   async execute(

package/src/services/aiService.ts

@@ -6,6 +6,31 @@ import {
   ChatCompletionFunctionTool,
 } from "openai/resources.js";
 import type { GatewayConfig, ModelConfig } from "../types.js";
+import * as os from "os";
+import * as fs from "fs";
+import * as path from "path";
+
+/**
+ * Check if a directory is a git repository
+ * @param dirPath Directory path to check
+ * @returns "Yes" if it's a git repo, "No" otherwise
+ */
+function isGitRepository(dirPath: string): string {
+  try {
+    // Check if .git directory exists in current directory or any parent directory
+    let currentPath = path.resolve(dirPath);
+    while (currentPath !== path.dirname(currentPath)) {
+      const gitPath = path.join(currentPath, ".git");
+      if (fs.existsSync(gitPath)) {
+        return "Yes";
+      }
+      currentPath = path.dirname(currentPath);
+    }
+    return "No";
+  } catch {
+    return "No";
+  }
+}
 
 /**
  * OpenAI model configuration type, based on OpenAI parameters but excluding messages
@@ -89,23 +114,26 @@ export async function callAgent(
     });
 
     // Build system prompt content
-    let systemContent: string;
-
-    if (systemPrompt) {
-      // Use custom system prompt if provided
-      systemContent = systemPrompt;
-    } else {
-      // Use default system prompt
-      systemContent = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
-
-## Current Working Directory
-${workdir}
+    let systemContent =
+      systemPrompt ||
+      `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.`;
+
+    // Always add environment information
+    systemContent += `
+
+Here is useful information about the environment you are running in:
+<env>
+Working directory: ${workdir}
+Is directory a git repo: ${isGitRepository(workdir)}
+Platform: ${os.platform()}
+OS Version: ${os.type()} ${os.release()}
+Today's date: ${new Date().toISOString().split("T")[0]}
+</env>
 `;
 
-      // If there is memory content, add it to the system prompt
-      if (memory && memory.trim()) {
-        systemContent += `\n\n## Memory Context\n\nThe following is important context and memory from previous interactions:\n\n${memory}`;
-      }
+    // If there is memory content, add it to the system prompt
+    if (memory && memory.trim()) {
+      systemContent += `\n## Memory Context\n\nThe following is important context and memory from previous interactions:\n\n${memory}`;
     }
 
     // Add system prompt

package/src/tools/grepTool.ts

@@ -71,7 +71,7 @@ export const grepTool: ToolPlugin = {
           head_limit: {
             type: "number",
             description:
-              'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). When unspecified, shows all results from ripgrep.',
+              'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults to 100 to prevent excessive token usage.',
           },
           multiline: {
             type: "boolean",
@@ -209,12 +209,15 @@ export const grepTool: ToolPlugin = {
         };
       }
 
-      // Apply head_limit
+      // Apply head_limit with default fallback
       let finalOutput = output;
       let lines = output.split("\n");
 
-      if (headLimit && headLimit > 0 && lines.length > headLimit) {
-        lines = lines.slice(0, headLimit);
+      // Set default head_limit if not specified to prevent excessive token usage
+      const effectiveHeadLimit = headLimit || 100;
+
+      if (lines.length > effectiveHeadLimit) {
+        lines = lines.slice(0, effectiveHeadLimit);
         finalOutput = lines.join("\n");
       }
 
@@ -230,8 +233,8 @@ export const grepTool: ToolPlugin = {
         shortResult = `Found ${totalLines} matching line${totalLines === 1 ? "" : "s"}`;
       }
 
-      if (headLimit && totalLines > headLimit) {
-        shortResult += ` (showing first ${headLimit})`;
+      if (effectiveHeadLimit && totalLines > effectiveHeadLimit) {
+        shortResult += ` (showing first ${effectiveHeadLimit})`;
       }
 
       return {

package/src/tools/readTool.ts

@@ -1,6 +1,10 @@
 import { readFile } from "fs/promises";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
+import {
+  isBinaryDocument,
+  getBinaryDocumentError,
+} from "../utils/fileFormat.js";
 
 /**
  * Read Tool Plugin - Read file content
@@ -12,7 +16,7 @@ export const readTool: ToolPlugin = {
     function: {
       name: "Read",
       description:
-        "Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume 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.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- 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\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.\n- This tool can read PDF files (.pdf). PDFs are processed page by page, extracting both text and visual content for analysis.\n- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.\n- 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.\n- 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\n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.",
+        "Reads a file from the local filesystem. You can access any file directly by using this tool.\nAssume 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.\n\nUsage:\n- The file_path parameter must be an absolute path, not a relative path\n- By default, it reads up to 2000 lines starting from the beginning of the file\n- 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\n- Any lines longer than 2000 characters will be truncated\n- Results are returned using cat -n format, with line numbers starting at 1\n- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.\n- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.\n- 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.\n- 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\n- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.\n- Binary document formats (PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX) are not supported and will return an error.",
       parameters: {
         type: "object",
         properties: {
@@ -51,6 +55,15 @@ export const readTool: ToolPlugin = {
       };
     }
 
+    // Check for binary document formats
+    if (isBinaryDocument(filePath)) {
+      return {
+        success: false,
+        content: "",
+        error: getBinaryDocumentError(filePath),
+      };
+    }
+
     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
@@ -71,8 +84,19 @@ export const readTool: ToolPlugin = {
         };
       }
 
-      const lines = fileContent.split("\n");
+      // Check content size limit (100KB)
+      const MAX_CONTENT_SIZE = 100 * 1024; // 100KB
+      let contentToProcess = fileContent;
+      let contentTruncated = false;
+
+      if (fileContent.length > MAX_CONTENT_SIZE) {
+        contentToProcess = fileContent.substring(0, MAX_CONTENT_SIZE);
+        contentTruncated = true;
+      }
+
+      const lines = contentToProcess.split("\n");
       const totalLines = lines.length;
+      const originalTotalLines = fileContent.split("\n").length;
 
       // Handle offset and limit
       let startLine = 1;
@@ -117,7 +141,10 @@ export const readTool: ToolPlugin = {
 
       // Add file information header
       let content = `File: ${filePath}\n`;
-      if (startLine > 1 || endLine < totalLines) {
+      if (contentTruncated) {
+        content += `Content truncated at ${MAX_CONTENT_SIZE} bytes\n`;
+        content += `Lines ${startLine}-${endLine} of ${totalLines} (original file: ${originalTotalLines} lines)\n`;
+      } else if (startLine > 1 || endLine < totalLines) {
         content += `Lines ${startLine}-${endLine} of ${totalLines}\n`;
       } else {
         content += `Total lines: ${totalLines}\n`;
@@ -126,15 +153,22 @@ export const readTool: ToolPlugin = {
       content += formattedContent;
 
       // If only showing partial content, add prompt
-      if (endLine < totalLines) {
+      if (endLine < totalLines || contentTruncated) {
         content += `\n${"─".repeat(50)}\n`;
-        content += `... ${totalLines - endLine} more lines not shown`;
+        if (contentTruncated) {
+          content += `... content truncated due to size limit (${MAX_CONTENT_SIZE} bytes)`;
+          if (endLine < totalLines) {
+            content += ` and ${totalLines - endLine} more lines not shown`;
+          }
+        } else {
+          content += `... ${totalLines - endLine} more lines not shown`;
+        }
       }
 
       return {
         success: true,
         content,
-        shortResult: `Read ${selectedLines.length} lines${totalLines > 2000 ? " (truncated)" : ""}`,
+        shortResult: `Read ${selectedLines.length} lines${totalLines > 2000 || contentTruncated ? " (truncated)" : ""}`,
       };
     } catch (error) {
       return {