wave-agent-sdk 0.0.1 → 0.0.3

package/src/managers/skillManager.ts

@@ -11,7 +11,6 @@ import type {
   SkillInvocationContext,
   Logger,
 } from "../types.js";
-import type { ToolPlugin, ToolResult } from "../tools/types.js";
 import { parseSkillFile, formatSkillError } from "../utils/skillParser.js";
 
 /**
@@ -76,6 +75,13 @@ export class SkillManager {
     }
   }
 
+  /**
+   * Check if the skill manager is initialized
+   */
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
   /**
    * Get all available skills metadata
    */
@@ -233,101 +239,6 @@ export class SkillManager {
     return directories;
   }
 
-  /**
-   * Create a tool plugin for registering with ToolManager
-   */
-  createTool(): ToolPlugin {
-    // Initialize skill manager asynchronously
-    let initializationPromise: Promise<void> | null = null;
-
-    const ensureInitialized = async (): Promise<void> => {
-      if (!initializationPromise) {
-        initializationPromise = this.initialize();
-      }
-      await initializationPromise;
-    };
-
-    const getToolDescription = (): string => {
-      if (!this.initialized) {
-        return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. Skills will be loaded during initialization.";
-      }
-
-      const availableSkills = this.getAvailableSkills();
-
-      if (availableSkills.length === 0) {
-        return "Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific. No skills are currently available.";
-      }
-
-      const skillList = availableSkills
-        .map(
-          (skill) =>
-            `• **${skill.name}** (${skill.type}): ${skill.description}`,
-        )
-        .join("\n");
-
-      return `Invoke a Wave skill by name. Skills are user-defined automation templates that can be personal or project-specific.\n\nAvailable skills:\n${skillList}`;
-    };
-
-    return {
-      name: "skill",
-      config: {
-        type: "function",
-        function: {
-          name: "skill",
-          description: getToolDescription(),
-          parameters: {
-            type: "object",
-            properties: {
-              skill_name: {
-                type: "string",
-                description: "Name of the skill to invoke",
-                enum: this.initialized
-                  ? this.getAvailableSkills().map((skill) => skill.name)
-                  : [],
-              },
-            },
-            required: ["skill_name"],
-          },
-        },
-      },
-      execute: async (args: Record<string, unknown>): Promise<ToolResult> => {
-        try {
-          // Ensure skill manager is initialized
-          await ensureInitialized();
-
-          // Validate arguments
-          const skillName = args.skill_name as string;
-          if (!skillName || typeof skillName !== "string") {
-            return {
-              success: false,
-              content: "",
-              error: "skill_name parameter is required and must be a string",
-            };
-          }
-
-          // Execute the skill
-          const result = await this.executeSkill({ skill_name: skillName });
-
-          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";
-      },
-    };
-  }
-
   /**
    * Execute a skill by name
    */

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(