wave-agent-sdk 1.0.0 → 1.0.2

package/dist/agent.d.ts

@@ -19,7 +19,6 @@ export declare class Agent {
     private pluginManager;
     private skillManager;
     private cronManager;
-    private goalManager;
     private hookManager;
     private reversionManager;
     private messageQueue;
@@ -92,10 +91,6 @@ export declare class Agent {
     get isCommandRunning(): boolean;
     /** Get queued user-facing messages (excludes background notifications) */
     get queuedMessages(): QueuedMessage[];
-    /** Get goal status string */
-    get goalStatus(): string;
-    /** Check if a goal is active */
-    get isGoalActive(): boolean;
     /**
      * Remove a queued message by index
      * @param index - The index of the message to remove
@@ -231,19 +226,6 @@ export declare class Agent {
      * @param customInstructions - Optional custom instructions for compaction
      */
     compact(customInstructions?: string): Promise<void>;
-    /**
-     * Set an autonomous goal for the session
-     * @param condition - The goal condition to achieve
-     */
-    setGoal(condition: string): Promise<void>;
-    /**
-     * Clear the current autonomous goal
-     */
-    clearGoal(): Promise<void>;
-    /**
-     * Show the current goal status
-     */
-    showGoalStatus(): Promise<void>;
     /** Unified interrupt method, interrupts both AI messages and command execution */
     abortMessage(): void;
     /** Interrupt bash command execution */
@@ -275,11 +257,18 @@ export declare class Agent {
      */
     triggerShowRewind(): void;
     /**
-     * Ask a side question without tool use
+     * Ask a side question without interrupting the main agent.
+     *
+     * Runs a single-turn fork of the conversation that reuses the main loop's
+     * system prompt, tools, and memory injection (prompt-cache friendly) and
+     * never executes tools. The abort signal lets the UI cancel a pending
+     * question (loading dismiss); aborts propagate as thrown errors.
+     *
      * @param question - The side question to ask
+     * @param abortSignal - Optional signal to abort the pending request
      * @returns Promise that resolves to the AI's answer
      */
-    askBtw(question: string): Promise<string>;
+    askBtw(question: string, abortSignal?: AbortSignal, onContent?: (content: string) => void, onReasoning?: (content: string) => void): Promise<string>;
     /**
      * Send a message to the AI agent with optional images
      *

package/dist/agent.js

@@ -1,8 +1,5 @@
 import { LspManager } from "./managers/lspManager.js";
 import { configValidator } from "./utils/configValidator.js";
-import { btw } from "./services/aiService.js";
-import { convertMessagesForAPI } from "./utils/convertMessagesForAPI.js";
-import { supportsVision } from "./utils/modelCapabilities.js";
 import { parseTaskNotificationXml } from "./utils/notificationXml.js";
 import { InitializationService } from "./services/initializationService.js";
 import { InteractionService } from "./services/interactionService.js";
@@ -114,7 +111,6 @@ export class Agent {
         this.pluginManager = this.container.get("PluginManager");
         this.bangManager = this.container.get("BangManager");
         this.cronManager = this.container.get("CronManager");
-        this.goalManager = this.container.get("GoalManager");
         this.messageQueue = this.container.get("MessageQueue");
         // Wire up CWD change callback from AIManager to sync Agent's workdir
         this.aiManager.setOnCwdChange((newCwd) => {
@@ -141,14 +137,6 @@ export class Agent {
         if (options.permissionMode) {
             this.setPermissionMode(options.permissionMode);
         }
-        // Wire up goal state change callback
-        this.goalManager.setOnGoalStateChange((active, condition, elapsed) => {
-            this.options.callbacks?.onGoalStateChange?.(active, condition, elapsed);
-        });
-        // Wire up goal evaluating callback
-        this.goalManager.setOnGoalEvaluating((evaluating) => {
-            this.options.callbacks?.onGoalEvaluating?.(evaluating);
-        });
     }
     // Public getter methods
     get sessionId() {
@@ -219,14 +207,6 @@ export class Agent {
             .getQueue()
             .filter((m) => m.type !== "notification");
     }
-    /** Get goal status string */
-    get goalStatus() {
-        return this.goalManager.getStatusString();
-    }
-    /** Check if a goal is active */
-    get isGoalActive() {
-        return this.goalManager.isGoalActive();
-    }
     /**
      * Remove a queued message by index
      * @param index - The index of the message to remove
@@ -523,9 +503,14 @@ export class Agent {
         await this.messageManager.saveSession();
     }
     async clearMessages() {
+        // Aligned with webview (ChatApp handleClearChat): /clear is ignored
+        // while the agent is running, instead of aborting the AI mid-turn
+        // (which used to inject a late "Request was aborted" error into the
+        // newly cleared session).
+        if (this.aiManager.isLoading) {
+            return;
+        }
         this.aiManager.abortAIMessage();
-        // Clear any active goal
-        this.goalManager.clearGoal();
         // Capture old session info before clearing
         const oldSessionId = this.messageManager.getSessionId();
         const transcriptPath = this.messageManager.getTranscriptPath();
@@ -568,74 +553,17 @@ export class Agent {
      * @param customInstructions - Optional custom instructions for compaction
      */
     async compact(customInstructions) {
+        // Aligned with webview: /compact is ignored while the agent is running,
+        // instead of aborting the AI mid-turn before compacting.
+        if (this.aiManager.isLoading) {
+            return;
+        }
         this.aiManager.abortAIMessage();
         await this.aiManager.compactConversation({
             customInstructions,
         });
         await this.messageManager.saveSession();
     }
-    /**
-     * Set an autonomous goal for the session
-     * @param condition - The goal condition to achieve
-     */
-    async setGoal(condition) {
-        // Check plan mode
-        if (this.getPermissionMode() === "plan") {
-            this.messageManager.addUserMessage({
-                content: "<system-reminder>Cannot set a goal in plan mode. Exit plan mode first.</system-reminder>",
-                isMeta: true,
-            });
-            return;
-        }
-        this.goalManager.setGoal(condition);
-        this.messageManager.addUserMessage({
-            content: `<system-reminder>Goal set: ${condition}. The agent will work autonomously until this goal is achieved.</system-reminder>`,
-            isMeta: true,
-        });
-        // Add the goal as a user directive to start working
-        this.messageManager.addUserMessage({
-            content: condition,
-        });
-        this.aiManager.sendAIMessage();
-        await this.messageManager.saveSession();
-    }
-    /**
-     * Clear the current autonomous goal
-     */
-    async clearGoal() {
-        if (this.goalManager.isGoalActive()) {
-            this.goalManager.clearGoal();
-            this.messageManager.addUserMessage({
-                content: "<system-reminder>Goal cleared.</system-reminder>",
-                isMeta: true,
-            });
-        }
-        else {
-            this.messageManager.addUserMessage({
-                content: "<system-reminder>No active goal to clear.</system-reminder>",
-                isMeta: true,
-            });
-        }
-        await this.messageManager.saveSession();
-    }
-    /**
-     * Show the current goal status
-     */
-    async showGoalStatus() {
-        if (this.goalManager.isGoalActive()) {
-            this.messageManager.addUserMessage({
-                content: `<system-reminder>${this.goalManager.getStatusString()}</system-reminder>`,
-                isMeta: true,
-            });
-        }
-        else {
-            this.messageManager.addUserMessage({
-                content: "<system-reminder>No active goal. Use /goal <condition> to set one.</system-reminder>",
-                isMeta: true,
-            });
-        }
-        await this.messageManager.saveSession();
-    }
     /** Unified interrupt method, interrupts both AI messages and command execution */
     abortMessage() {
         // Guard: prevent tryDispatch (triggered by abortAIMessage → setIsLoading(false))
@@ -757,6 +685,17 @@ export class Agent {
         this.subagentManager.cleanup();
         // Cleanup forked agent manager
         await this.forkedAgentManager.cleanup();
+        // Drain an in-flight auto-memory extraction fork so the process doesn't
+        // exit mid-extraction
+        try {
+            const autoMemoryService = this.container.get("AutoMemoryService");
+            if (autoMemoryService) {
+                await autoMemoryService.drain();
+            }
+        }
+        catch (error) {
+            this.logger?.warn(`Auto-memory extraction drain failed: ${error.message}`);
+        }
         // Cleanup skill manager
         await this.skillManager.destroy();
         // Cleanup live configuration reload
@@ -777,21 +716,20 @@ export class Agent {
         this.messageManager.triggerShowRewind();
     }
     /**
-     * Ask a side question without tool use
+     * Ask a side question without interrupting the main agent.
+     *
+     * Runs a single-turn fork of the conversation that reuses the main loop's
+     * system prompt, tools, and memory injection (prompt-cache friendly) and
+     * never executes tools. The abort signal lets the UI cancel a pending
+     * question (loading dismiss); aborts propagate as thrown errors.
+     *
      * @param question - The side question to ask
+     * @param abortSignal - Optional signal to abort the pending request
      * @returns Promise that resolves to the AI's answer
      */
-    async askBtw(question) {
-        const messages = convertMessagesForAPI(this.messageManager.getMessages(), {
-            supportsVision: supportsVision(this.getModelConfig().capabilities),
-        });
-        const result = await btw({
-            gatewayConfig: this.getGatewayConfig(),
-            modelConfig: this.getModelConfig(),
-            messages,
-            question,
-        });
-        return result.content;
+    async askBtw(question, abortSignal, onContent, onReasoning) {
+        const result = await this.aiManager.runBtwFork(question, abortSignal, onContent, onReasoning);
+        return result.content ?? result.error ?? "No response received";
     }
     /**
      * Send a message to the AI agent with optional images
@@ -821,7 +759,7 @@ export class Agent {
      */
     async sendMessage(content, images) {
         // If the agent is busy, enqueue the message — unless it's an immediate
-        // slash command (e.g., /goal clear, /clear, /compact) that should execute
+        // slash command (e.g., /clear, /compact) that should execute
         // right away even while AI is processing
         if (this.aiManager.isLoading || this.isCommandRunning) {
             const trimmed = content.trim();

package/dist/managers/aiManager.d.ts

@@ -1,6 +1,15 @@
-import type { GatewayConfig, ModelConfig, Usage } from "../types/index.js";
+import type { GatewayConfig, ModelConfig, Usage, Message } from "../types/index.js";
 import { Container } from "../utils/container.js";
 import type { WorktreeSession } from "../utils/worktreeSession.js";
+/** Result of a fork-path agent loop (compaction or auto-memory extraction). */
+interface ForkLoopResult {
+    content?: string;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
 export interface AIManagerCallbacks {
     onCompactionStateChange?: (isCompacting: boolean) => void;
     onUsageAdded?: (usage: Usage) => void;
@@ -119,15 +128,60 @@ export declare class AIManager {
     private buildMainSystemPrompt;
     private resolveFilteredTools;
     /**
-     * Fork-path compaction: run a bounded agent loop over a copy of the
-     * conversation using the same system prompt, tools, model, and generation
-     * params as the main loop, so the forked request prefix matches exactly
-     * and the prompt cache is reused. Tool calls are denied locally (the model
-     * is told to summarize, not act) and their rejections are fed back for
-     * another turn. Returns undefined content when the model never produces
-     * text; the caller treats that as a compaction failure.
+     * Fork-path loop: run a bounded agent loop over a copy of the conversation
+     * using the same system prompt, tools, model, and generation params as the
+     * main loop, so the forked request prefix matches exactly and the prompt
+     * cache is reused. A `canUseTool` gate decides whether each tool call
+     * executes locally (with a stripped context) or is denied and fed back to
+     * the model for another turn. Returns undefined content when the model never
+     * produces text; the caller treats that as a failure.
+     */
+    private runForkLoop;
+    /**
+     * Fork-path compaction: deny all tool calls locally (the model is told to
+     * summarize, not act) and feed the rejections back for another turn.
      */
     private runCompactFork;
+    /**
+     * Auto-memory extraction via the perfect fork: the extraction prompt is run
+     * against the same request prefix as the main conversation (same system
+     * prompt, tools, model, and message history) so the prompt cache is reused.
+     * Gate-approved tools execute locally in a stripped context; everything else
+     * is denied. Usage is reported with operation_type "agent" so extraction
+     * token costs stay visible in session accounting.
+     */
+    runAutoMemoryFork(messages: Message[], prompt: string, options: {
+        canUseTool: (name: string, args: Record<string, unknown>) => boolean;
+        deniedToolMessage?: string;
+        maxTurns?: number;
+    }, abortSignal?: AbortSignal): Promise<ForkLoopResult>;
+    /**
+     * Parse a fork tool call's JSON arguments, recovering truncated JSON the
+     * same way the main loop does. Unparseable arguments fall back to `{}` and
+     * are rejected by the gate or the tool's own parameter validation.
+     */
+    private parseForkToolArgs;
+    /**
+     * Execute a single tool call inside a fork with a stripped context: no
+     * permission manager (never prompts the user), no message manager (no
+     * conditional-rule triggering), no messageId (no file-history snapshots),
+     * and no background task manager (commands run in the foreground). Only
+     * gate-approved tool names reach this path.
+     */
+    private executeForkTool;
+    /**
+     * Fork-path side question ("/btw"): run a single-turn fork of the
+     * conversation using the same system prompt, tools, model, and generation
+     * params as the main loop, so the forked request prefix matches exactly and
+     * the prompt cache is reused. The in-progress assistant message (if any) is
+     * stripped so the fork starts from the last completed request prefix. Tools
+     * are never executed — the wrapped question instructs the model to answer
+     * directly; an attempted tool call is surfaced as an error string.
+     */
+    runBtwFork(question: string, abortSignal?: AbortSignal, onContent?: (content: string) => void, onReasoning?: (content: string) => void): Promise<{
+        content?: string;
+        error?: string;
+    }>;
     /**
      * Build post-compact context restoration content.
      * Restores file reads, working directory, plan mode, skills, and background tasks.
@@ -166,3 +220,4 @@ export declare class AIManager {
      */
     private executePostToolUseHooks;
 }
+export {};