wave-agent-sdk 0.14.2 → 0.14.4

package/src/managers/subagentManager.ts

@@ -187,10 +187,57 @@ export class SubagentManager {
    * Find subagent by exact name match
    */
   async findSubagent(name: string) {
+    // Check cached configurations first (includes plugin agents)
+    if (this.cachedConfigurations !== null) {
+      const cached = this.cachedConfigurations.find(
+        (config) => config.name === name,
+      );
+      if (cached) return cached;
+    }
+    // Fall back to filesystem scan for non-plugin agents
     const { findSubagentByName } = await import("../utils/subagentParser.js");
     return findSubagentByName(name, this.workdir);
   }
 
+  /**
+   * Register plugin agents into the cached configurations.
+   * Names each agent as `pluginName:agentName` to avoid collisions.
+   */
+  registerPluginAgents(
+    pluginName: string,
+    agents: SubagentConfiguration[],
+  ): void {
+    if (this.cachedConfigurations === null) {
+      // Should not happen if initialization order is correct
+      this.cachedConfigurations = [];
+    }
+
+    // Remove any previously registered agents for this plugin (by name prefix)
+    this.cachedConfigurations = this.cachedConfigurations.filter(
+      (config) => !config.name.startsWith(`${pluginName}:`),
+    );
+
+    for (const agent of agents) {
+      const namespacedName = `${pluginName}:${agent.name}`;
+      const namespacedAgent: SubagentConfiguration = {
+        ...agent,
+        name: namespacedName,
+        // Safety net: substitute any remaining ${WAVE_PLUGIN_ROOT} placeholders
+        systemPrompt: agent.systemPrompt.replace(
+          /\$\{WAVE_PLUGIN_ROOT\}/g,
+          agent.pluginRoot ?? "",
+        ),
+      };
+      this.cachedConfigurations!.push(namespacedAgent);
+    }
+
+    // Re-sort by priority then name
+    this.cachedConfigurations!.sort((a, b) => {
+      if (a.priority !== b.priority) return a.priority - b.priority;
+      return a.name.localeCompare(b.name);
+    });
+  }
+
   /**
    * Create a new subagent instance with isolated managers
    */
@@ -204,6 +251,7 @@ export class SubagentManager {
       model?: string;
       stream?: boolean;
       permissionModeOverride?: PermissionMode;
+      maxTurns?: number;
     },
     runInBackground?: boolean,
     onUpdate?: () => void,
@@ -309,6 +357,7 @@ export class SubagentManager {
       subagentType: parameters.subagent_type, // Pass subagent type for hook context
       modelOverride: parameters.model || configuration.model, // Pass model override
       stream: parameters.stream ?? this.stream, // Pass streaming mode flag
+      maxTurns: parameters.maxTurns, // Pass maxTurns limit
       callbacks: {
         onUsageAdded: this.onUsageAdded,
       },

package/src/services/autoMemoryService.ts

@@ -164,6 +164,7 @@ export class AutoMemoryService {
         ],
         model: "fastModel", // Use fast model for background tasks to reduce latency and cost
         permissionModeOverride: "dontAsk", // Auto-deny out-of-scope writes without prompting user
+        maxTurns: 5, // Limit turns to prevent verification rabbit-holes
       },
       `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`,
     );

package/src/services/pluginLoader.ts

@@ -10,7 +10,12 @@ import {
 } from "../types/index.js";
 import { scanCommandsDirectory } from "../utils/customCommands.js";
 import { parseSkillFile } from "../utils/skillParser.js";
+import {
+  parseAgentFile,
+  type SubagentConfiguration,
+} from "../utils/subagentParser.js";
 import { resolveMcpConfig } from "../managers/mcpManager.js";
+import { logger } from "../utils/globalLogger.js";
 
 export class PluginLoader {
   /**
@@ -165,6 +170,38 @@ export class PluginLoader {
     }
   }
 
+  /**
+   * Load agent configurations from a plugin's agents directory
+   */
+  static async loadAgents(
+    pluginPath: string,
+  ): Promise<SubagentConfiguration[]> {
+    const agentsPath = path.join(pluginPath, "agents");
+    const agents: SubagentConfiguration[] = [];
+
+    try {
+      const entries = await fs.readdir(agentsPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+          const agentFilePath = path.join(agentsPath, entry.name);
+          try {
+            const config = parseAgentFile(agentFilePath, "plugin", pluginPath);
+            agents.push(config);
+          } catch (parseError) {
+            // Log error but continue with other files
+            logger?.warn(
+              `Warning: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+            );
+          }
+        }
+      }
+    } catch {
+      // agents directory might not exist
+    }
+
+    return agents;
+  }
+
   /**
    * Validate the plugin manifest structure
    */

package/src/types/plugins.ts

@@ -3,6 +3,7 @@ import { Skill } from "./skills.js";
 import { LspConfig } from "./lsp.js";
 import { McpConfig } from "./mcp.js";
 import { PartialHookConfiguration } from "./configuration.js";
+import { SubagentConfiguration } from "../utils/subagentParser.js";
 
 /**
  * Plugin manifest structure (.wave-plugin/plugin.json)
@@ -31,6 +32,7 @@ export interface Plugin extends PluginManifest {
   path: string;
   commands: CustomSlashCommand[];
   skills: Skill[];
+  agents: SubagentConfiguration[];
   lspConfig?: LspConfig;
   mcpConfig?: McpConfig;
   hooksConfig?: PartialHookConfiguration;

package/src/utils/constants.ts

@@ -29,5 +29,5 @@ export const USER_MEMORY_FILE = path.join(DATA_DIRECTORY, "AGENTS.md");
 /**
  * AI related constants
  */
-export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 96000; // Default token limit
-export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 8192; // Default output token limit
+export const DEFAULT_WAVE_MAX_INPUT_TOKENS = 128000; // Default token limit
+export const DEFAULT_WAVE_MAX_OUTPUT_TOKENS = 16384; // Default output token limit

package/src/utils/convertMessagesForAPI.ts

@@ -2,7 +2,7 @@ import type { Message } from "../types/index.js";
 import { convertImageToBase64 } from "./messageOperations.js";
 import { taskNotificationToXml } from "./notificationXml.js";
 import { ChatCompletionMessageToolCall } from "openai/resources";
-import { stripAnsiColors } from "./stringUtils.js";
+import { recoverTruncatedJson, stripAnsiColors } from "./stringUtils.js";
 import {
   ChatCompletionContentPart,
   ChatCompletionMessageParam,
@@ -10,7 +10,8 @@ import {
 import { logger } from "./globalLogger.js";
 
 /**
- * Safely handle tool call parameters, ensuring a legal JSON string is returned
+ * Safely handle tool call parameters, ensuring a legal JSON string is returned.
+ * Attempts to recover truncated JSON (e.g., missing closing braces).
  * @param args Tool call parameters
  * @returns Legal JSON string
  */
@@ -23,12 +24,18 @@ function safeToolArguments(args: string): string {
     // Try to parse as JSON to validate format
     JSON.parse(args);
     return args;
-  } catch (error) {
-    logger.error(`Invalid tool arguments: ${args}`, error);
-    // If not valid JSON, return a fallback empty object with the original string as a comment or property
-    return JSON.stringify({
-      invalid_arguments: args,
-    });
+  } catch {
+    // Attempt to recover truncated JSON
+    const recovered = recoverTruncatedJson(args);
+    try {
+      JSON.parse(recovered);
+      return recovered;
+    } catch {
+      // Truly malformed JSON — return sanitized fallback
+      return JSON.stringify({
+        invalid_arguments: args,
+      });
+    }
   }
 }
 
@@ -145,6 +152,20 @@ export function convertMessagesForAPI(
           .join("\n");
       }
 
+      // Extract reasoning content from reasoning blocks
+      const reasoningBlocks = message.blocks.filter(
+        (block) =>
+          block.type === "reasoning" &&
+          block.content &&
+          block.content.trim().length > 0,
+      );
+      let reasoning_content: string | undefined;
+      if (reasoningBlocks.length > 0) {
+        reasoning_content = reasoningBlocks
+          .map((block) => (block.type === "reasoning" ? block.content : ""))
+          .join("\n");
+      }
+
       // Construct tool calls from tool blocks
       if (toolBlocks.length > 0) {
         tool_calls = toolBlocks
@@ -176,8 +197,9 @@ export function convertMessagesForAPI(
           role: "assistant",
           content: hasContent ? content : undefined,
           tool_calls,
+          ...(reasoning_content ? { reasoning_content } : {}),
           ...(message.additionalFields ? { ...message.additionalFields } : {}),
-        };
+        } as ChatCompletionMessageParam;
 
         recentMessages.unshift(assistantMessage);
       }

package/src/utils/stringUtils.ts

@@ -92,6 +92,49 @@ export function formatLineNumberPrefix(lineNumber: number): string {
   return `${lineNumber.toString().padStart(6)}\t`;
 }
 
+/**
+ * Attempt to recover truncated JSON (e.g., missing closing braces due to max tokens).
+ * Tracks brace depth and only recovers if there are unclosed `{` braces.
+ * Will NOT recover if there are unclosed `[` brackets (can't guess the content).
+ * @param jsonStr Potentially truncated JSON string
+ * @returns Recovered JSON string, or the original if unrecoverable
+ */
+export function recoverTruncatedJson(jsonStr: string): string {
+  let braceDepth = 0;
+  let bracketDepth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (const ch of jsonStr) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (!inString) {
+      if (ch === "{") braceDepth++;
+      if (ch === "}") braceDepth--;
+      if (ch === "[") bracketDepth++;
+      if (ch === "]") bracketDepth--;
+    }
+  }
+
+  // Build recovery suffix
+  let suffix = "";
+  if (inString) suffix += '"'; // Close unclosed string
+  if (braceDepth > 0 && bracketDepth === 0) {
+    suffix += "}".repeat(braceDepth);
+  }
+  return suffix ? jsonStr + suffix : jsonStr;
+}
+
 /**
  * Efficiently get the last N lines of a string without splitting the whole string.
  */

package/src/utils/subagentParser.ts

@@ -10,8 +10,10 @@ export interface SubagentConfiguration {
   model?: string;
   systemPrompt: string;
   filePath: string;
-  scope: "project" | "user" | "builtin";
+  scope: "project" | "user" | "builtin" | "plugin";
   priority: number;
+  /** Plugin root directory path, set when scope is "plugin" */
+  pluginRoot?: string;
 }
 
 interface SubagentFrontmatter {
@@ -119,11 +121,12 @@ function validateConfiguration(
 }
 
 /**
- * Parse a single subagent markdown file
+ * Parse a single subagent markdown file with optional pluginRoot support
  */
 function parseSubagentFile(
   filePath: string,
-  scope: "project" | "user" | "builtin",
+  scope: "project" | "user" | "builtin" | "plugin",
+  pluginRoot?: string,
 ): SubagentConfiguration {
   try {
     const content = readFileSync(filePath, "utf-8");
@@ -143,16 +146,28 @@ function parseSubagentFile(
     let priority = 1;
     if (scope === "user") priority = 2;
     if (scope === "builtin") priority = 3;
+    if (scope === "plugin") priority = 2; // Same priority as user-level
+
+    let systemPrompt = body;
+
+    // Substitute ${WAVE_PLUGIN_ROOT} for plugin scope at parse time
+    if (scope === "plugin" && pluginRoot) {
+      systemPrompt = systemPrompt.replace(
+        /\$\{WAVE_PLUGIN_ROOT\}/g,
+        pluginRoot,
+      );
+    }
 
     return {
       name: frontmatter.name!,
       description: frontmatter.description!,
       tools: frontmatter.tools,
       model: frontmatter.model,
-      systemPrompt: body,
+      systemPrompt,
       filePath,
       scope,
       priority,
+      pluginRoot: scope === "plugin" ? pluginRoot : undefined,
     };
   } catch (error) {
     throw new Error(
@@ -161,6 +176,18 @@ function parseSubagentFile(
   }
 }
 
+/**
+ * Parse a plugin agent markdown file.
+ * Exposed as a public API for PluginLoader to use.
+ */
+export function parseAgentFile(
+  filePath: string,
+  scope: "plugin",
+  pluginRoot: string,
+): SubagentConfiguration {
+  return parseSubagentFile(filePath, scope, pluginRoot);
+}
+
 /**
  * Scan directory for subagent files
  */