wave-agent-sdk 0.7.2 → 0.8.1

package/src/managers/slashCommandManager.ts

@@ -12,15 +12,13 @@ import {
 } from "../utils/commandArgumentParser.js";
 import { Container } from "../utils/container.js";
 import {
-  BashCommandResult,
   parseBashCommands,
   replaceBashCommandsWithOutput,
+  executeBashCommands,
 } from "../utils/markdownParser.js";
-import { exec } from "child_process";
-import { promisify } from "util";
 import { INIT_PROMPT } from "../prompts/index.js";
-
-const execAsync = promisify(exec);
+import type { SkillManager } from "./skillManager.js";
+import type { SkillMetadata } from "../types/skills.js";
 
 import { logger } from "../utils/globalLogger.js";
 
@@ -31,6 +29,7 @@ export interface SlashCommandManagerOptions {
 export class SlashCommandManager {
   private commands = new Map<string, SlashCommand>();
   private customCommands = new Map<string, CustomSlashCommand>();
+  private skillCommandIds = new Set<string>();
   private workdir: string;
 
   constructor(
@@ -61,25 +60,11 @@ export class SlashCommandManager {
     return this.container.get<TaskManager>("TaskManager")!;
   }
 
-  private initializeBuiltinCommands(): void {
-    // Register built-in clear command
-    this.registerCommand({
-      id: "clear",
-      name: "clear",
-      description: "Clear the chat session and terminal",
-      handler: () => {
-        // Clear chat messages
-        this.messageManager.clearMessages();
-
-        // Reset task list if WAVE_TASK_LIST_ID is not set
-        if (!process.env.WAVE_TASK_LIST_ID) {
-          const newTaskListId = this.messageManager.getRootSessionId();
-          this.taskManager.setTaskListId(newTaskListId);
-          this.taskManager.emit("tasksChange", newTaskListId);
-        }
-      },
-    });
+  private get skillManager(): SkillManager {
+    return this.container.get<SkillManager>("SkillManager")!;
+  }
 
+  private initializeBuiltinCommands(): void {
     // Register built-in init command
     this.registerCommand({
       id: "init",
@@ -132,15 +117,10 @@ export class SlashCommandManager {
             }
 
             if (args) {
-              if (hasParameterPlaceholders(processedContent)) {
-                processedContent = substituteCommandParameters(
-                  processedContent,
-                  args,
-                );
-              } else {
-                // If no placeholders, append arguments to the content
-                processedContent = `${processedContent.trim()} ${args}`;
-              }
+              processedContent = substituteCommandParameters(
+                processedContent,
+                args,
+              );
             }
 
             await this.executeCustomCommandInMainAgent(
@@ -159,6 +139,66 @@ export class SlashCommandManager {
     }
   }
 
+  /**
+   * Register skills as slash commands
+   */
+  public registerSkillCommands(skills: SkillMetadata[]): void {
+    // Clear existing skill commands
+    for (const commandId of this.skillCommandIds) {
+      this.unregisterCommand(commandId);
+    }
+    this.skillCommandIds.clear();
+
+    for (const skill of skills) {
+      if (skill.userInvocable === false) {
+        continue;
+      }
+      const commandId = skill.name;
+      this.skillCommandIds.add(commandId);
+
+      this.registerCommand({
+        id: commandId,
+        name: skill.name,
+        description: `Skill: ${skill.description}`,
+        handler: async (args?: string) => {
+          try {
+            const result = await this.skillManager.executeSkill({
+              skill_name: skill.name,
+              args,
+            });
+
+            // Add user message with skill content
+            const originalInput = args
+              ? `/${skill.name} ${args}`
+              : `/${skill.name}`;
+            this.messageManager.addUserMessage({
+              content: originalInput,
+              customCommandContent: result.content,
+            });
+
+            // Trigger AI response
+            await this.aiManager.sendAIMessage({
+              model: skill.model,
+              allowedRules: result.allowedTools,
+            });
+          } catch (error) {
+            logger?.error(
+              `Failed to execute skill command '${skill.name}':`,
+              error,
+            );
+            this.messageManager.addErrorBlock(
+              `Failed to execute skill command '${skill.name}': ${
+                error instanceof Error ? error.message : String(error)
+              }`,
+            );
+          }
+        },
+      });
+    }
+
+    logger?.debug(`Registered ${skills.length} skill commands`);
+  }
+
   /**
    * Register commands from a plugin with namespacing
    */
@@ -195,15 +235,10 @@ export class SlashCommandManager {
           }
 
           if (args) {
-            if (hasParameterPlaceholders(processedContent)) {
-              processedContent = substituteCommandParameters(
-                processedContent,
-                args,
-              );
-            } else {
-              // If no placeholders, append arguments to the content
-              processedContent = `${processedContent.trim()} ${args}`;
-            }
+            processedContent = substituteCommandParameters(
+              processedContent,
+              args,
+            );
           }
 
           await this.executeCustomCommandInMainAgent(
@@ -343,40 +378,15 @@ export class SlashCommandManager {
       const { commands, processedContent } = parseBashCommands(content);
 
       // Execute bash commands if any
-      const bashResults: BashCommandResult[] = [];
-      for (const command of commands) {
-        try {
-          const { stdout, stderr } = await execAsync(command, {
-            cwd: this.workdir,
-            timeout: 30000, // 30 second timeout
-          });
-          bashResults.push({
-            command,
-            output: stdout || stderr || "",
-            exitCode: 0,
-          });
-        } catch (error) {
-          const execError = error as {
-            stdout?: string;
-            stderr?: string;
-            message?: string;
-            code?: number;
-          };
-          bashResults.push({
-            command,
-            output:
-              execError.stdout || execError.stderr || execError.message || "",
-            exitCode: execError.code || 1,
-          });
-        }
+      let finalContent = processedContent;
+      if (commands.length > 0) {
+        const bashResults = await executeBashCommands(commands, this.workdir);
+        finalContent = replaceBashCommandsWithOutput(
+          processedContent,
+          bashResults,
+        );
       }
 
-      // Replace bash command placeholders with their outputs
-      const finalContent =
-        bashResults.length > 0
-          ? replaceBashCommandsWithOutput(processedContent, bashResults)
-          : processedContent;
-
       // Add custom command message to show the command being executed
       const originalInput = args
         ? `/${commandName} ${args}`

package/src/managers/subagentManager.ts

@@ -14,12 +14,14 @@ import {
   createAbortPromise,
 } from "../utils/abortUtils.js";
 import { BackgroundTaskManager } from "./backgroundTaskManager.js";
+import { logger } from "../utils/globalLogger.js";
 import {
   UserMessageParams,
   type AgentToolBlockUpdateParams,
 } from "../utils/messageOperations.js";
 
 import { Container } from "../utils/container.js";
+import type { PermissionManager } from "./permissionManager.js";
 
 export interface SubagentManagerCallbacks {
   // Granular subagent message callbacks (015-subagent-message-callbacks)
@@ -67,8 +69,10 @@ export interface SubagentInstance {
   lastTools: string[]; // Track last two tool names
   subagentType: string; // Store the subagent type for hook context
   description: string; // Store the AI-generated description
+  allowedTools?: string[]; // Optional permission rules (e.g. git:*)
   backgroundTaskId?: string; // ID of the background task if transitioned
   onUpdate?: () => void; // Optional callback for real-time updates
+  model?: string; // Optional model override
 }
 
 export interface SubagentManagerOptions {
@@ -159,6 +163,8 @@ export class SubagentManager {
       description: string;
       prompt: string;
       subagent_type: string;
+      allowedTools?: string[];
+      model?: string;
     },
     runInBackground?: boolean,
     onUpdate?: () => void,
@@ -176,6 +182,31 @@ export class SubagentManager {
     // Create a child container for the subagent to isolate its managers
     const subagentContainer = this.container.createChild();
 
+    // Create isolated PermissionManager for the subagent
+    const { PermissionManager } = await import("./permissionManager.js");
+    const parentPermissionManager =
+      this.container.get<PermissionManager>("PermissionManager");
+    const subagentPermissionManager = new PermissionManager(subagentContainer, {
+      workdir: this.workdir,
+      configuredDefaultMode:
+        parentPermissionManager?.getConfiguredDefaultMode(),
+      allowedRules: parentPermissionManager?.getAllowedRules(),
+      deniedRules: parentPermissionManager?.getDeniedRules(),
+      additionalDirectories:
+        parentPermissionManager?.getAdditionalDirectories(),
+      planFilePath: parentPermissionManager?.getPlanFilePath(),
+    });
+    subagentContainer.register("PermissionManager", subagentPermissionManager);
+
+    // Add temporary permission rules if provided
+    if (parameters.allowedTools) {
+      logger.debug(
+        `Adding ${parameters.allowedTools.length} temporary permission rules to subagent ${subagentId}`,
+        { rules: parameters.allowedTools },
+      );
+      subagentPermissionManager.addTemporaryRules(parameters.allowedTools);
+    }
+
     // Create isolated MessageManager for the subagent
     const subagentCallbacks = this.createSubagentCallbacks(subagentId);
 
@@ -187,8 +218,13 @@ export class SubagentManager {
     });
     subagentContainer.register("MessageManager", messageManager);
 
-    // Use the parent tool manager directly - tool restrictions will be handled by allowedTools parameter
-    const toolManager = parentToolManager;
+    // Create isolated ToolManager for the subagent to ensure it uses the subagent's PermissionManager
+    const toolManager = new ToolManager({
+      container: subagentContainer,
+      tools: configuration.tools,
+    });
+    toolManager.initializeBuiltInTools();
+    subagentContainer.register("ToolManager", toolManager);
 
     // Create isolated AIManager for the subagent
     const aiManager = new AIManager(subagentContainer, {
@@ -201,9 +237,12 @@ export class SubagentManager {
         const parentModelConfig = this.getModelConfig();
         let modelToUse: string;
 
-        if (!configuration.model || configuration.model === "inherit") {
-          // Use parent's agentModel for "inherit" or undefined
-          modelToUse = parentModelConfig.agentModel;
+        if (parameters.model) {
+          // Use model override from parameters if provided
+          modelToUse = parameters.model;
+        } else if (!configuration.model || configuration.model === "inherit") {
+          // Use parent's model for "inherit" or undefined
+          modelToUse = parentModelConfig.model;
         } else if (configuration.model === "fastModel") {
           // Use parent's fastModel for special "fastModel" value
           modelToUse = parentModelConfig.fastModel;
@@ -214,7 +253,7 @@ export class SubagentManager {
 
         return {
           ...parentModelConfig,
-          agentModel: modelToUse,
+          model: modelToUse,
         };
       },
       getMaxInputTokens: this.getMaxInputTokens,
@@ -237,6 +276,8 @@ export class SubagentManager {
       lastTools: [], // Initialize lastTools
       subagentType: parameters.subagent_type, // Store the subagent type
       description: parameters.description, // Store the AI-generated description
+      allowedTools: parameters.allowedTools, // Store optional permission rules
+      model: parameters.model, // Store optional model override
       onUpdate,
     };
 
@@ -392,23 +433,26 @@ export class SubagentManager {
       // Add the user's prompt as a message
       instance.messageManager.addUserMessage({ content: prompt });
 
-      // Create allowed tools list - always exclude Task tool to prevent subagent recursion
-      let allowedTools = instance.configuration.tools;
+      // Create enabled tools list - always exclude Task tool to prevent subagent recursion
+      // Use instance.configuration.tools if provided, otherwise fallback to all tools
+      let enabledTools = instance.configuration.tools;
 
       // Always filter out the Task tool to prevent subagents from creating sub-subagents
-      if (allowedTools) {
-        allowedTools = allowedTools.filter((tool) => tool !== "Task");
+      if (enabledTools) {
+        enabledTools = enabledTools.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");
+        enabledTools = allTools.filter((tool) => tool !== "Task");
       }
 
       // Execute the AI request with tool restrictions
       // The AIManager will handle abort signals through its own abort controllers
       // Resolve model name for sendAIMessage
       let resolvedModel: string | undefined;
-      if (
+      if (instance.model) {
+        resolvedModel = instance.model;
+      } else if (
         instance.configuration.model &&
         instance.configuration.model !== "inherit"
       ) {
@@ -424,7 +468,7 @@ export class SubagentManager {
       // For "inherit" or undefined, resolvedModel remains undefined (uses AIManager default)
 
       const executeAI = instance.aiManager.sendAIMessage({
-        tools: allowedTools,
+        tools: enabledTools,
         model: resolvedModel,
       });
 

package/src/managers/toolManager.ts

@@ -37,6 +37,9 @@ import { Container } from "../utils/container.js";
 
 import { logger } from "../utils/globalLogger.js";
 
+import type { SubagentConfiguration } from "../utils/subagentParser.js";
+import type { SkillMetadata } from "../types/skills.js";
+
 export interface ToolManagerOptions {
   container: Container;
   /** Optional list of tool names to enable */
@@ -244,7 +247,11 @@ class ToolManager {
     return [...builtInTools, ...mcpTools];
   }
 
-  getToolsConfig(): ChatCompletionFunctionTool[] {
+  getToolsConfig(options?: {
+    availableSubagents?: SubagentConfiguration[];
+    availableSkills?: SkillMetadata[];
+    workdir?: string;
+  }): ChatCompletionFunctionTool[] {
     const effectivePermissionMode = this.getPermissionMode();
     const builtInToolsConfig = Array.from(this.toolsRegistry.values())
       .filter((tool) => {
@@ -258,7 +265,20 @@ class ToolManager {
         }
         return true;
       })
-      .map((tool) => tool.config);
+      .map((tool) => {
+        // Create a copy of the tool config to avoid modifying the original
+        const config = {
+          ...tool.config,
+          function: {
+            ...tool.config.function,
+          },
+        };
+        // Override description with prompt if available
+        if (tool.prompt) {
+          config.function.description = tool.prompt(options);
+        }
+        return config;
+      });
     const mcpToolsConfig = this.mcpManager.getMcpToolsConfig();
     return [...builtInToolsConfig, ...mcpToolsConfig];
   }

package/src/prompts/index.ts

@@ -288,9 +288,6 @@ Any promises made to the user
 Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.
 Wrap your summary in <summary></summary> tags.`;
 
-import type { SubagentConfiguration } from "../utils/subagentParser.js";
-import type { SkillMetadata } from "../types/skills.js";
-
 export function buildSystemPrompt(
   basePrompt: string | undefined,
   tools: ToolPlugin[],
@@ -303,8 +300,6 @@ export function buildSystemPrompt(
       planFilePath: string;
       planExists: boolean;
     };
-    availableSubagents?: SubagentConfiguration[];
-    availableSkills?: SkillMetadata[];
   } = {},
 ): string {
   let prompt = basePrompt || DEFAULT_SYSTEM_PROMPT;
@@ -312,16 +307,6 @@ export function buildSystemPrompt(
     prompt += `\n\n${TOOL_POLICY}`;
   }
 
-  for (const tool of tools) {
-    if (tool.prompt) {
-      prompt += tool.prompt({
-        availableSubagents: options.availableSubagents,
-        availableSkills: options.availableSkills,
-        workdir: options.workdir,
-      });
-    }
-  }
-
   if (options.language) {
     prompt += `\n\n# Language\nAlways respond in ${options.language}. Technical terms (e.g., code, tool names, file paths) should remain in their original language or English where appropriate.`;
   }

package/src/services/aiService.ts

@@ -132,9 +132,9 @@ function getModelConfig(
   };
 
   // Configuration rules for specific models
-  if (modelName.includes("gpt-5-codex")) {
-    // gpt-5-codex model sets temperature to undefined
-    config.temperature = undefined;
+  if (modelName.includes("gpt-5")) {
+    // gpt-5 models should not have temperature field
+    delete config.temperature;
   }
 
   return config;
@@ -203,7 +203,7 @@ export async function callAgent(
   // Apply global 1 QPS rate limit
   if (
     process.env.NODE_ENV !== "test" ||
-    modelConfig.agentModel === "rate-limit-test"
+    modelConfig.model === "rate-limit-test"
   ) {
     await acquireSlot(abortSignal);
   }
@@ -239,7 +239,7 @@ export async function callAgent(
     openaiMessages = [systemMessage, ...messages];
 
     // Apply cache control for Claude models
-    const currentModel = model || modelConfig.agentModel;
+    const currentModel = model || modelConfig.model;
     const resolvedMaxTokens = options.maxTokens ?? modelConfig.maxTokens;
 
     processedTools = tools;
@@ -257,7 +257,7 @@ export async function callAgent(
     }
 
     // Get model configuration - use injected modelConfig with optional override
-    const openaiModelConfig = getModelConfig(model || modelConfig.agentModel, {
+    const openaiModelConfig = getModelConfig(model || modelConfig.model, {
       temperature: 0,
       max_tokens: resolvedMaxTokens,
     });
@@ -421,7 +421,7 @@ export async function callAgent(
         const debugData: DebugData = {
           originalMessages: messages,
           timestamp: new Date().toISOString(),
-          model: model || modelConfig.agentModel,
+          model: model || modelConfig.model,
           workdir,
           sessionId: options.sessionId,
           gatewayConfig: {
@@ -760,7 +760,7 @@ export async function compressMessages(
   // Apply global 1 QPS rate limit
   if (
     process.env.NODE_ENV !== "test" ||
-    modelConfig.agentModel === "rate-limit-test"
+    modelConfig.model === "rate-limit-test"
   ) {
     await acquireSlot(abortSignal);
   }
@@ -775,13 +775,10 @@ export async function compressMessages(
   });
 
   // Get model configuration - use injected agent model
-  const openaiModelConfig = getModelConfig(
-    options.model || modelConfig.agentModel,
-    {
-      temperature: 0.1,
-      max_tokens: 2048,
-    },
-  );
+  const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
+    temperature: 0.1,
+    max_tokens: 2048,
+  });
 
   try {
     const response = await openai.chat.completions.create(

package/src/services/configurationService.ts

@@ -444,13 +444,13 @@ export class ConfigurationService {
   /**
    * Resolves model configuration with fallbacks
    * Resolution priority: options > env (from settings.json) > process.env > default
-   * @param agentModel - Agent model from constructor (optional)
+   * @param model - Agent model from constructor (optional)
    * @param fastModel - Fast model from constructor (optional)
    * @param maxTokens - Max output tokens from constructor (optional)
    * @returns Resolved model configuration with defaults
    */
   resolveModelConfig(
-    agentModel?: string,
+    model?: string,
     fastModel?: string,
     maxTokens?: number,
     permissionMode?: PermissionMode,
@@ -460,7 +460,7 @@ export class ConfigurationService {
     const DEFAULT_FAST_MODEL = "gemini-2.5-flash";
 
     // Resolve agent model: constructor > env (settings.json) > process.env > default
-    let resolvedAgentModel = agentModel || this.env.WAVE_MODEL;
+    let resolvedAgentModel = model || this.env.WAVE_MODEL;
 
     if (!resolvedAgentModel && this.currentConfiguration?.env?.WAVE_MODEL) {
       resolvedAgentModel = this.currentConfiguration.env.WAVE_MODEL;
@@ -481,7 +481,7 @@ export class ConfigurationService {
     const resolvedMaxTokens = this.resolveMaxOutputTokens(maxTokens);
 
     return {
-      agentModel: resolvedAgentModel,
+      model: resolvedAgentModel,
       fastModel: resolvedFastModel,
       maxTokens: resolvedMaxTokens,
       permissionMode,

package/src/services/hook.ts

@@ -83,6 +83,13 @@ async function buildHookJsonInput(
     }
   }
 
+  // Add name field for WorktreeCreate events
+  if (context.event === "WorktreeCreate") {
+    if (context.worktreeName !== undefined) {
+      jsonInput.name = context.worktreeName;
+    }
+  }
+
   return jsonInput;
 }