wave-agent-sdk 0.17.1 → 0.17.3

package/src/managers/aiManager.ts

@@ -76,6 +76,12 @@ export class AIManager {
   private originalWorkdir: string;
   private consecutiveCompactionFailures: number = 0;
   private readonly maxTurns?: number;
+  /** Override tool_choice for this AI manager (e.g. for structured output) */
+  public toolChoiceOverride?:
+    | "auto"
+    | "none"
+    | "required"
+    | { type: "function"; function: { name: string } };
 
   // Service overrides
   constructor(
@@ -613,12 +619,7 @@ export class AIManager {
       if (usedTokens >= POST_COMPACT_TOKEN_BUDGET) break;
     }
 
-    // 2. Working directory
-    contextParts.push(
-      `\n\n[Working Directory]\nCurrent working directory: ${this.getWorkdir()}`,
-    );
-
-    // 3. Plan mode context
+    // 2. Plan mode context
     const currentMode = this.permissionManager?.getCurrentEffectiveMode(
       this.getModelConfig().permissionMode,
     );
@@ -894,6 +895,7 @@ export class AIManager {
           filteredToolPlugins,
           {
             workdir: this.getWorkdir(),
+            originalWorkdir: this.getOriginalWorkdir(),
             memory: combinedMemory,
             language: this.getLanguage(),
             isSubagent: !!this.subagentType,
@@ -902,6 +904,7 @@ export class AIManager {
           },
         ), // Pass custom system prompt
         maxTokens: maxTokens, // Pass max tokens override
+        toolChoice: this.toolChoiceOverride, // Pass tool_choice override
       };
 
       // Add streaming callbacks only if streaming is enabled
@@ -943,35 +946,13 @@ export class AIManager {
         };
       }
 
-      startLLMRequestSpan(model || this.getModelConfig().model);
-      const apiStartTime = Date.now();
-      let ttftMs: number | undefined;
-
-      // If streaming, track TTFT via callback
-      if (this.stream && callAgentOptions.onContentUpdate) {
-        const originalOnContentUpdate = callAgentOptions.onContentUpdate;
-        let firstTokenReceived = false;
-        callAgentOptions.onContentUpdate = (content: string) => {
-          if (!firstTokenReceived) {
-            ttftMs = Date.now() - apiStartTime;
-            firstTokenReceived = true;
-          }
-          originalOnContentUpdate(content);
-        };
-      }
+      startLLMRequestSpan(model || this.getModelConfig().model || "");
 
       const result = await aiService.callAgent(callAgentOptions);
-      const ttltMs = Date.now() - apiStartTime;
 
       // End LLM span with usage data
       endLLMRequestSpan({
-        model: model || this.getModelConfig().model,
-        inputTokens: result.usage?.prompt_tokens,
-        outputTokens: result.usage?.completion_tokens,
-        cacheReadTokens: result.usage?.cache_read_input_tokens,
-        cacheCreationTokens: result.usage?.cache_creation_input_tokens,
-        ttftMs,
-        ttltMs,
+        model: model || this.getModelConfig().model || "",
         success: true,
         hasToolCall: !!(result.tool_calls && result.tool_calls.length > 0),
       });
@@ -1232,7 +1213,7 @@ export class AIManager {
                 (toolResult.error ? `Error: ${toolResult.error}` : "");
               if (jsonRecovered) {
                 toolResultContent +=
-                  "\n\n⚠️ Tool arguments were truncated (likely exceeded max output tokens). Please reduce your output or split into multiple tool calls.";
+                  "\n\nTool arguments were truncated (likely exceeded max output tokens). Please reduce your output or split into multiple tool calls.";
               }
 
               // Update message state - tool execution completed
@@ -1407,7 +1388,7 @@ export class AIManager {
     } catch (error) {
       // End LLM span with error
       endLLMRequestSpan({
-        model: model || this.getModelConfig().model,
+        model: model || this.getModelConfig().model || "",
         success: false,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -1480,23 +1461,85 @@ export class AIManager {
               }
             }
 
-            const shouldContinue = await this.executeStopHooks();
+            // Goal evaluation — supersedes Stop hooks when active
+            const goalManager = this.container.has("GoalManager")
+              ? this.container.get<import("./goalManager.js").GoalManager>(
+                  "GoalManager",
+                )
+              : undefined;
+
+            let goalContinuing = false;
+
+            if (goalManager?.isGoalActive() && !this.subagentType) {
+              // 1. Increment turn count and check circuit breakers
+              goalManager.incrementTurnCount();
+              const circuitBreaker = goalManager.checkCircuitBreakers();
+
+              if (circuitBreaker) {
+                goalManager.clearGoal();
+                logger?.info(`[Goal] ${circuitBreaker}`);
+                this.messageManager.addUserMessage({
+                  content: `<system-reminder>${circuitBreaker}</system-reminder>`,
+                  isMeta: true,
+                });
+                // Fall through to normal Stop hooks on the final turn
+              } else {
+                // 2. Evaluate goal
+                const evaluation = await goalManager.evaluateGoal(
+                  abortController.signal,
+                );
 
-            // If Stop/SubagentStop hooks indicate we should continue (due to blocking errors),
-            // restart the AI conversation cycle
-            if (shouldContinue) {
-              logger?.info(
-                `${this.subagentType ? "SubagentStop" : "Stop"} hooks indicate issues need fixing, continuing conversation...`,
-              );
+                if (evaluation.isMet) {
+                  goalManager.clearGoal();
+                  logger?.info(`[Goal] Goal achieved: ${evaluation.reason}`);
+                  this.messageManager.addUserMessage({
+                    content: `<system-reminder>Goal achieved: ${evaluation.reason}</system-reminder>`,
+                    isMeta: true,
+                  });
+                  // Fall through to normal Stop hooks on the final turn
+                } else {
+                  const goal = goalManager.getGoal()!;
+                  goal.lastReason = evaluation.reason;
+                  logger?.info(`[Goal] Not yet met: ${evaluation.reason}`);
+                  this.messageManager.addUserMessage({
+                    content: `<system-reminder>Goal not yet met: ${evaluation.reason}. Continue working toward: ${goal.condition}</system-reminder>`,
+                    isMeta: true,
+                  });
+                  // Keep loading state active to prevent UI flicker
+                  this.setIsLoading(true);
+                  goalContinuing = true;
+                  await this.sendAIMessage({
+                    recursionDepth: 0,
+                    model,
+                    allowedRules,
+                    maxTokens,
+                  });
+                }
+              }
+            }
 
-              // Restart the conversation to let AI fix the issues
-              // Use recursionDepth = 0 to set loading false again for continuation
-              await this.sendAIMessage({
-                recursionDepth: 0,
-                model,
-                allowedRules,
-                maxTokens,
-              });
+            // Skip Stop hooks when goal evaluator is continuing the conversation
+            if (goalContinuing) {
+              // Goal evaluator supersedes Stop hooks
+            } else {
+              const shouldContinue = await this.executeStopHooks();
+
+              // If Stop/SubagentStop hooks indicate we should continue (due to blocking errors),
+              // restart the AI conversation cycle
+              if (shouldContinue) {
+                logger?.info(
+                  `${this.subagentType ? "SubagentStop" : "Stop"} hooks indicate issues need fixing, continuing conversation...`,
+                );
+
+                // Restart the conversation to let AI fix the issues
+                // Use recursionDepth = 0 to set loading false again for continuation
+                await this.sendAIMessage({
+                  recursionDepth: 0,
+                  model,
+                  allowedRules,
+                  maxTokens,
+                });
+              }
             }
           }
         }
@@ -1688,6 +1731,7 @@ export class AIManager {
         toolInput,
         toolResponse,
         subagentType: this.subagentType, // Include subagent type in hook context
+        planFilePath: this.permissionManager?.getPlanFilePath(),
         env:
           this.container.get<Record<string, string>>("MergedEnv") ||
           (process.env as Record<string, string>),

package/src/managers/backgroundTaskManager.ts

@@ -96,8 +96,14 @@ export class BackgroundTaskManager {
               if (child.pid && !child.killed) {
                 try {
                   process.kill(-child.pid, "SIGKILL");
-                } catch (error) {
-                  logger.error("Failed to force kill process:", error);
+                } catch (error: unknown) {
+                  // ESRCH means the process already exited — not an error
+                  if (
+                    !(error instanceof Error) ||
+                    (error as NodeJS.ErrnoException).code !== "ESRCH"
+                  ) {
+                    logger.error("Failed to force kill process:", error);
+                  }
                 }
               }
             }, 1000);
@@ -267,8 +273,14 @@ export class BackgroundTaskManager {
               if (child.pid && !child.killed) {
                 try {
                   process.kill(-child.pid, "SIGKILL");
-                } catch (error) {
-                  logger.error("Failed to force kill process:", error);
+                } catch (error: unknown) {
+                  // ESRCH means the process already exited — not an error
+                  if (
+                    !(error instanceof Error) ||
+                    (error as NodeJS.ErrnoException).code !== "ESRCH"
+                  ) {
+                    logger.error("Failed to force kill process:", error);
+                  }
                 }
               }
             }, 1000);

package/src/managers/goalManager.ts

@@ -0,0 +1,232 @@
+import { Container } from "../utils/container.js";
+import type { MessageManager } from "./messageManager.js";
+import type { AIManager } from "./aiManager.js";
+import type { Usage } from "../types/index.js";
+import { evaluateGoal as aiEvaluateGoal } from "../services/aiService.js";
+import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
+import { logger } from "../utils/globalLogger.js";
+
+export interface GoalState {
+  condition: string;
+  startedAt: number;
+  turnCount: number;
+  tokenBaseline: number;
+  lastReason?: string;
+  consecutiveEvalFailures: number;
+}
+
+const MAX_GOAL_TURNS = 50;
+const MAX_GOAL_DURATION_MS = 30 * 60 * 1000; // 30 minutes
+const MAX_CONSECUTIVE_EVAL_FAILURES = 3;
+const MAX_CONDITION_LENGTH = 4000;
+
+export class GoalManager {
+  private state: GoalState | null = null;
+  private onGoalStateChange?: (
+    active: boolean,
+    condition?: string,
+    elapsed?: string,
+  ) => void;
+  private onGoalEvaluating?: (evaluating: boolean) => void;
+
+  constructor(private container: Container) {}
+
+  private get messageManager(): MessageManager {
+    return this.container.get<MessageManager>("MessageManager")!;
+  }
+
+  private get aiManager(): AIManager {
+    return this.container.get<AIManager>("AIManager")!;
+  }
+
+  public setOnGoalStateChange(
+    callback: (active: boolean, condition?: string, elapsed?: string) => void,
+  ): void {
+    this.onGoalStateChange = callback;
+  }
+
+  public setOnGoalEvaluating(callback: (evaluating: boolean) => void): void {
+    this.onGoalEvaluating = callback;
+  }
+
+  public setGoal(condition: string): void {
+    if (condition.length > MAX_CONDITION_LENGTH) {
+      throw new Error(
+        `Goal condition exceeds maximum length of ${MAX_CONDITION_LENGTH} characters`,
+      );
+    }
+
+    const totalTokens = this.messageManager.getLatestTotalTokens?.() ?? 0;
+
+    this.state = {
+      condition,
+      startedAt: Date.now(),
+      turnCount: 0,
+      tokenBaseline: totalTokens,
+      consecutiveEvalFailures: 0,
+    };
+
+    this.onGoalStateChange?.(true, condition, "0m");
+    logger?.info(`[Goal] Set goal: ${condition}`);
+  }
+
+  public clearGoal(): void {
+    if (this.state) {
+      logger?.info(`[Goal] Cleared goal: ${this.state.condition}`);
+      this.state = null;
+      this.onGoalStateChange?.(false);
+    }
+  }
+
+  public getGoal(): GoalState | null {
+    return this.state;
+  }
+
+  public isGoalActive(): boolean {
+    return this.state !== null;
+  }
+
+  public incrementTurnCount(): void {
+    if (this.state) {
+      this.state.turnCount++;
+    }
+  }
+
+  public getStatusString(): string {
+    if (!this.state) return "No active goal";
+    const elapsed = this.formatElapsed(Date.now() - this.state.startedAt);
+    let status = `Goal: ${this.state.condition}\nElapsed: ${elapsed}\nTurns: ${this.state.turnCount}`;
+    if (this.state.lastReason) {
+      status += `\nLast evaluation: ${this.state.lastReason}`;
+    }
+    return status;
+  }
+
+  /**
+   * Check circuit breakers. Returns a clear reason if goal should be force-cleared, null otherwise.
+   */
+  public checkCircuitBreakers(): string | null {
+    if (!this.state) return null;
+
+    if (this.state.turnCount >= MAX_GOAL_TURNS) {
+      return `Goal cancelled: maximum turns (${MAX_GOAL_TURNS}) exceeded`;
+    }
+
+    if (Date.now() - this.state.startedAt >= MAX_GOAL_DURATION_MS) {
+      return `Goal cancelled: time limit (${MAX_GOAL_DURATION_MS / 60000} minutes) exceeded`;
+    }
+
+    if (this.state.consecutiveEvalFailures >= MAX_CONSECUTIVE_EVAL_FAILURES) {
+      return `Goal cancelled: ${MAX_CONSECUTIVE_EVAL_FAILURES} consecutive evaluation failures`;
+    }
+
+    return null;
+  }
+
+  /**
+   * Evaluate whether the goal has been met using the fast model.
+   */
+  public async evaluateGoal(abortSignal?: AbortSignal): Promise<{
+    isMet: boolean;
+    reason: string;
+  }> {
+    if (!this.state) {
+      return { isMet: false, reason: "No active goal" };
+    }
+
+    try {
+      const messages = this.messageManager.getMessages();
+      const apiMessages = convertMessagesForAPI(messages);
+      const gatewayConfig = this.aiManager.getGatewayConfig();
+      const modelConfig = this.aiManager.getModelConfig();
+      const fastModel = modelConfig.fastModel || modelConfig.model;
+      if (!fastModel) {
+        return {
+          isMet: false,
+          reason: "No model configured for goal evaluation",
+        };
+      }
+
+      this.onGoalEvaluating?.(true);
+      const result = await aiEvaluateGoal({
+        gatewayConfig,
+        modelConfig,
+        model: fastModel,
+        goalCondition: this.state.condition,
+        messages: apiMessages,
+        abortSignal,
+      });
+
+      // Track evaluation tokens separately
+      if (result.usage) {
+        const usage: Usage = {
+          ...result.usage,
+          operation_type: "goal_evaluation",
+          model: fastModel,
+        };
+        this.messageManager.addUsage(usage);
+      }
+
+      // Reset failure counter on success
+      this.state.consecutiveEvalFailures = 0;
+
+      this.onGoalEvaluating?.(false);
+
+      // Parse the response
+      return this.parseEvaluationResponse(result.content);
+    } catch (error) {
+      this.onGoalEvaluating?.(false);
+      this.state.consecutiveEvalFailures++;
+      logger?.warn(
+        `[Goal] Evaluation failed (${this.state.consecutiveEvalFailures}/${MAX_CONSECUTIVE_EVAL_FAILURES}): ${(error as Error).message}`,
+      );
+      return {
+        isMet: false,
+        reason: `Evaluation failed: ${(error as Error).message}`,
+      };
+    }
+  }
+
+  /**
+   * Parse the evaluation response from the fast model.
+   */
+  private parseEvaluationResponse(content: string): {
+    isMet: boolean;
+    reason: string;
+  } {
+    // Try direct JSON parse
+    try {
+      const parsed = JSON.parse(content);
+      if (typeof parsed.met === "boolean") {
+        return {
+          isMet: parsed.met,
+          reason: parsed.reason || "No reason provided",
+        };
+      }
+    } catch {
+      // Fall through to regex
+    }
+
+    // Try regex extraction
+    const metMatch = content.match(/"met"\s*:\s*(true|false)/);
+    const reasonMatch = content.match(/"reason"\s*:\s*"([^"]*)"/);
+    if (metMatch) {
+      return {
+        isMet: metMatch[1] === "true",
+        reason: reasonMatch?.[1] || "No reason provided",
+      };
+    }
+
+    // Default: not met
+    return { isMet: false, reason: "Could not parse evaluation response" };
+  }
+
+  private formatElapsed(ms: number): string {
+    const minutes = Math.floor(ms / 60000);
+    if (minutes < 1) return "<1m";
+    if (minutes < 60) return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    const remainingMin = minutes % 60;
+    return `${hours}h${remainingMin}m`;
+  }
+}

package/src/managers/messageManager.ts

@@ -62,8 +62,8 @@ export interface MessageManagerCallbacks {
   // Notification callback
   onNotificationMessageAdded?: (params: {
     taskId: string;
-    taskType: "shell" | "agent";
-    status: "completed" | "failed" | "killed";
+    taskType: "shell" | "agent" | "workflow";
+    status: "completed" | "failed" | "killed" | "aborted";
     summary: string;
   }) => void;
 }

package/src/managers/messageQueue.ts

@@ -1,16 +1,42 @@
+export type QueueState = "idle" | "dispatching" | "running";
+
 export interface QueuedMessage {
+  id?: string;
   type?: "message" | "bang";
   content: string;
   images?: Array<{ path: string; mimeType: string }>;
   longTextMap?: Record<string, string>;
+  editable?: boolean; // default true
 }
 
 export class MessageQueue {
   private queue: QueuedMessage[] = [];
+  private nextId = 0;
+  private _state: QueueState = "idle";
   onMessageEnqueued?: () => void;
 
+  get state(): QueueState {
+    return this._state;
+  }
+
+  transitionTo(newState: QueueState): boolean {
+    const valid: Record<QueueState, QueueState[]> = {
+      idle: ["dispatching"],
+      dispatching: ["running", "idle"],
+      running: ["idle"],
+    };
+    if (!valid[this._state].includes(newState)) return false;
+    this._state = newState;
+    return true;
+  }
+
   enqueue(message: QueuedMessage): void {
-    this.queue.push(message);
+    const msg: QueuedMessage = {
+      ...message,
+      id: message.id || `mq-${this.nextId++}`,
+      editable: message.editable ?? true,
+    };
+    this.queue.push(msg);
     this.onMessageEnqueued?.();
   }
 
@@ -20,6 +46,7 @@ export class MessageQueue {
 
   clear(): void {
     this.queue = [];
+    this._state = "idle";
   }
 
   hasPending(): boolean {
@@ -38,4 +65,35 @@ export class MessageQueue {
     this.onMessageEnqueued?.();
     return true;
   }
+
+  removeById(id: string): boolean {
+    const index = this.queue.findIndex((m) => m.id === id);
+    if (index === -1) return false;
+    this.queue.splice(index, 1);
+    this.onMessageEnqueued?.();
+    return true;
+  }
+
+  popLastEditable(): QueuedMessage | null {
+    for (let i = this.queue.length - 1; i >= 0; i--) {
+      if (this.queue[i].editable !== false) {
+        return this.queue.splice(i, 1)[0] ?? null;
+      }
+    }
+    return null;
+  }
+
+  popAllEditable(): QueuedMessage[] {
+    const editable: QueuedMessage[] = [];
+    const remaining: QueuedMessage[] = [];
+    for (const msg of this.queue) {
+      if (msg.editable !== false) {
+        editable.push(msg);
+      } else {
+        remaining.push(msg);
+      }
+    }
+    this.queue = remaining;
+    return editable;
+  }
 }

package/src/managers/pluginManager.ts

@@ -138,7 +138,14 @@ export class PluginManager {
                 continue;
               }
             } catch {
-              // Manifest read failed (marketplace not cloned yet?) — fall through to installPlugin
+              // Manifest read failed — marketplace may not be cloned yet, try to clone/update it
+              try {
+                await marketplaceService.updateMarketplace(marketplaceName);
+              } catch (updateError) {
+                logger?.warn(
+                  `Failed to clone/update marketplace ${marketplaceName}: ${updateError instanceof Error ? updateError.message : String(updateError)}`,
+                );
+              }
             }
 
             logger?.info(`Auto-installing missing plugin: ${pluginId}`);

package/src/managers/skillManager.ts

@@ -34,6 +34,8 @@ export class SkillManager extends EventEmitter {
 
   private skillMetadata = new Map<string, SkillMetadata>();
   private skillContent = new Map<string, Skill>();
+  private pluginSkillMetadata = new Map<string, SkillMetadata>();
+  private pluginSkillContent = new Map<string, Skill>();
   private initialized = false;
   private fileWatcher: FileWatcherService | null = null;
   private watchEnabled: boolean;
@@ -77,7 +79,7 @@ export class SkillManager extends EventEmitter {
    * Refresh skills by re-discovering them
    */
   private async refreshSkills(): Promise<void> {
-    // Clear existing data before discovery
+    // Clear only discovered skills (builtin/personal/project), preserve plugin skills
     this.skillMetadata.clear();
     this.skillContent.clear();
 
@@ -94,6 +96,14 @@ export class SkillManager extends EventEmitter {
       this.skillMetadata.set(name, skill);
     });
 
+    // Restore plugin skills
+    this.pluginSkillMetadata.forEach((metadata, name) => {
+      this.skillMetadata.set(name, metadata);
+    });
+    this.pluginSkillContent.forEach((skill, name) => {
+      this.skillContent.set(name, skill);
+    });
+
     // Log any discovery errors
     if (discovery.errors.length > 0) {
       logger?.warn(`Found ${discovery.errors.length} skill discovery errors`);
@@ -382,7 +392,7 @@ export class SkillManager extends EventEmitter {
     } catch (error) {
       logger?.error(`Failed to execute skill '${skill_name}':`, error);
       return {
-        content: `❌ **Error executing skill**: ${error instanceof Error ? error.message : String(error)}`,
+        content: `**Error executing skill**: ${error instanceof Error ? error.message : String(error)}`,
       };
     }
   }
@@ -404,14 +414,14 @@ export class SkillManager extends EventEmitter {
 
       if (!skill) {
         return {
-          content: `❌ **Skill not found**: "${skill_name}"\n\nAvailable skills:\n${this.formatAvailableSkills()}`,
+          content: `**Skill not found**: "${skill_name}"\n\nAvailable skills:\n${this.formatAvailableSkills()}`,
         };
       }
 
       if (!skill.isValid) {
         const errorMsg = formatSkillError(skill.skillPath, skill.errors);
         return {
-          content: `❌ **Skill validation failed**:\n\n\`\`\`\n${errorMsg}\n\`\`\``,
+          content: `**Skill validation failed**:\n\n\`\`\`\n${errorMsg}\n\`\`\``,
         };
       }
 
@@ -420,7 +430,7 @@ export class SkillManager extends EventEmitter {
     } catch (error) {
       logger?.error(`Failed to prepare skill '${skill_name}':`, error);
       return {
-        content: `❌ **Error preparing skill**: ${error instanceof Error ? error.message : String(error)}`,
+        content: `**Error preparing skill**: ${error instanceof Error ? error.message : String(error)}`,
       };
     }
   }
@@ -429,9 +439,7 @@ export class SkillManager extends EventEmitter {
    * Prepare skill content with arguments but without bash execution
    */
   private prepareSkillContent(skill: Skill, argsString: string): string {
-    const header = `🧠 **${skill.name}** (${skill.type} skill)\n\n`;
-    const description = `*${skill.description}*\n\n`;
-    const skillPath = `📁 Skill location: \`${skill.skillPath}\`\n\n`;
+    const skillPath = `Base directory for this skill: ${skill.skillPath}\n\n`;
 
     // Extract content after frontmatter
     const contentMatch = skill.content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
@@ -451,7 +459,7 @@ export class SkillManager extends EventEmitter {
       );
     }
 
-    return header + description + skillPath + mainContent;
+    return skillPath + mainContent;
   }
 
   /**
@@ -508,6 +516,9 @@ export class SkillManager extends EventEmitter {
 
       this.skillMetadata.set(namespacedName, metadata);
       this.skillContent.set(namespacedName, skill);
+      // Also store in plugin-specific maps so they survive refreshSkills()
+      this.pluginSkillMetadata.set(namespacedName, metadata);
+      this.pluginSkillContent.set(namespacedName, skill);
     }
     logger?.debug(
       `Registered ${skills.length} plugin skills from ${pluginName}. Total skills: ${this.skillMetadata.size}`,