wave-agent-sdk 1.0.0 → 1.0.1

package/dist/services/session.js

@@ -481,6 +481,70 @@ export async function cleanupEmptyProjectDirectories() {
         // Ignore errors if base directory doesn't exist or can't be accessed
     }
 }
+/**
+ * Clean up "ghost" session files that contain only meta messages
+ * (isMeta: true) — e.g. sessions where a SessionStart hook injected a
+ * system-reminder but no real user/assistant message was ever sent.
+ *
+ * Such sessions are no longer created thanks to lazy materialization in
+ * saveSession(); this one-time sweep removes files that predate that change
+ * so they stop showing up as "0 tokens / No content" entries in the resume
+ * list.
+ *
+ * @returns Promise that resolves to the number of files deleted
+ */
+export async function cleanupMetaOnlySessions() {
+    // Do not perform cleanup operations in test environment
+    if (process.env.NODE_ENV === "test") {
+        return 0;
+    }
+    let deletedCount = 0;
+    try {
+        const projectDirs = await fs.readdir(SESSION_DIR);
+        for (const projectDirName of projectDirs) {
+            const projectPath = join(SESSION_DIR, projectDirName);
+            try {
+                const stat = await fs.stat(projectPath);
+                if (!stat.isDirectory()) {
+                    continue;
+                }
+                const files = await fs.readdir(projectPath);
+                for (const file of files) {
+                    if (!file.endsWith(".jsonl")) {
+                        continue;
+                    }
+                    const filePath = join(projectPath, file);
+                    try {
+                        // Fast path: a file whose last message is not meta contains a
+                        // real message, so it can never be meta-only.
+                        const jsonlHandler = new JsonlHandler();
+                        const lastMessage = await jsonlHandler.getLastMessage(filePath);
+                        if (!lastMessage?.isMeta) {
+                            continue;
+                        }
+                        const messages = await jsonlHandler.read(filePath);
+                        if (messages.length > 0 && messages.every((m) => m.isMeta)) {
+                            await fs.unlink(filePath);
+                            deletedCount++;
+                        }
+                    }
+                    catch {
+                        // Skip corrupted or unreadable files
+                        continue;
+                    }
+                }
+            }
+            catch {
+                // Skip directories we can't access
+                continue;
+            }
+        }
+    }
+    catch {
+        // Ignore errors if base directory doesn't exist or can't be accessed
+    }
+    return deletedCount;
+}
 /**
  * Check if a session exists in JSONL storage (new approach)
  *

package/dist/types/agent.d.ts

@@ -98,6 +98,4 @@ export interface AgentCallbacks extends MessageManagerCallbacks, BackgroundTaskM
     onCommandRunningChange?: (running: boolean) => void;
     onWorkdirChange?: (newCwd: string) => void;
     onQueuedMessagesChange?: (messages: QueuedMessage[]) => void;
-    onGoalStateChange?: (active: boolean, condition?: string, elapsed?: string) => void;
-    onGoalEvaluating?: (evaluating: boolean) => void;
 }

package/dist/types/config.d.ts

@@ -29,4 +29,11 @@ export interface ModelConfig {
     options?: Record<string, unknown>;
     /** Fast model generation params (resolved from models[fastModel].options) */
     fastModelOptions?: Record<string, unknown>;
+    /**
+     * Fast-model-only disable-thinking params passed through verbatim
+     * (e.g. `{ thinking: { type: "disabled" } }`). Applied only in fast-model
+     * scenarios (webFetch content processing, `model: fastModel` subagents),
+     * never in the agent loop. `{}` clears the default.
+     */
+    disableThinkingOptions?: Record<string, unknown>;
 }

package/dist/types/core.d.ts

@@ -22,7 +22,7 @@ export interface Usage {
     completion_tokens: number;
     total_tokens: number;
     model?: string;
-    operation_type?: "agent" | "compact" | "goal_evaluation";
+    operation_type?: "agent" | "compact";
     cache_read_input_tokens?: number;
     cache_creation_input_tokens?: number;
     cache_creation?: {

package/dist/utils/containerSetup.js

@@ -16,7 +16,6 @@ import { SlashCommandManager } from "../managers/slashCommandManager.js";
 import { PluginManager } from "../managers/pluginManager.js";
 import { BangManager } from "../managers/bangManager.js";
 import { CronManager } from "../managers/cronManager.js";
-import { GoalManager } from "../managers/goalManager.js";
 import { WorkflowManager } from "../managers/workflowManager.js";
 import { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
 import { ReversionManager } from "../managers/reversionManager.js";
@@ -24,6 +23,7 @@ import { SubagentManager } from "../managers/subagentManager.js";
 import { ForkedAgentManager } from "../managers/forkedAgentManager.js";
 import { LiveConfigManager } from "../managers/liveConfigManager.js";
 import { ReversionService } from "../services/reversionService.js";
+import { cleanupMetaOnlySessions } from "../services/session.js";
 import { MemoryService } from "../services/memory.js";
 import { AutoMemoryService } from "../services/autoMemoryService.js";
 import { USER_MEMORY_FILE } from "./constants.js";
@@ -144,6 +144,17 @@ export function setupAgentContainer(setupOptions) {
     reversionService.cleanupOldSessions(30).catch((error) => {
         logger.error("Failed to cleanup old file history:", error);
     });
+    // Remove pre-existing meta-only session files (SessionStart hook context
+    // with no real messages) that were persisted before lazy materialization.
+    cleanupMetaOnlySessions()
+        .then((count) => {
+        if (count > 0) {
+            logger.debug(`Removed ${count} meta-only session file(s)`);
+        }
+    })
+        .catch((error) => {
+        logger.error("Failed to cleanup meta-only session files:", error);
+    });
     const reversionManager = new ReversionManager(container);
     container.register("ReversionManager", reversionManager);
     const canUseToolWithPermissionRequest = options.canUseTool
@@ -255,8 +266,6 @@ export function setupAgentContainer(setupOptions) {
     const cronManager = new CronManager(container, messageManager.getSessionId());
     container.register("CronManager", cronManager);
     cronManager.start();
-    const goalManager = new GoalManager(container);
-    container.register("GoalManager", goalManager);
     const workflowManager = new WorkflowManager(container);
     container.register("WorkflowManager", workflowManager);
     return container;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",

package/src/agent.ts

@@ -8,7 +8,6 @@ import { McpManager } from "./managers/mcpManager.js";
 import { LspManager } from "./managers/lspManager.js";
 import { BangManager } from "./managers/bangManager.js";
 import { CronManager } from "./managers/cronManager.js";
-import { GoalManager } from "./managers/goalManager.js";
 import { BackgroundTaskManager } from "./managers/backgroundTaskManager.js";
 import { MessageQueue, type QueuedMessage } from "./managers/messageQueue.js";
 import { SlashCommandManager } from "./managers/slashCommandManager.js";
@@ -38,9 +37,6 @@ import { LiveConfigManager } from "./managers/liveConfigManager.js";
 import { configValidator } from "./utils/configValidator.js";
 import { SkillManager } from "./managers/skillManager.js";
 import { TaskManager } from "./services/taskManager.js";
-import { btw } from "./services/aiService.js";
-import { convertMessagesForAPI } from "./utils/convertMessagesForAPI.js";
-import { supportsVision } from "./utils/modelCapabilities.js";
 import type { WorktreeSession } from "./utils/worktreeSession.js";
 import { parseTaskNotificationXml } from "./utils/notificationXml.js";
 import { InitializationService } from "./services/initializationService.js";
@@ -73,7 +69,6 @@ export class Agent {
   private pluginManager: PluginManager; // Add plugin manager instance
   private skillManager: SkillManager; // Add skill manager instance
   private cronManager: CronManager; // Add cron manager instance
-  private goalManager: GoalManager; // Add goal manager instance
   private hookManager: HookManager; // Add hooks manager instance
   private reversionManager: ReversionManager;
   private messageQueue: MessageQueue; // Unified queue for messages, bang commands, and notifications
@@ -208,7 +203,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
@@ -238,16 +232,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
@@ -340,16 +324,6 @@ export class Agent {
       .filter((m) => m.type !== "notification");
   }
 
-  /** Get goal status string */
-  public get goalStatus(): string {
-    return this.goalManager.getStatusString();
-  }
-
-  /** Check if a goal is active */
-  public get isGoalActive(): boolean {
-    return this.goalManager.isGoalActive();
-  }
-
   /**
    * Remove a queued message by index
    * @param index - The index of the message to remove
@@ -709,9 +683,6 @@ export class Agent {
   public async clearMessages(): Promise<void> {
     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();
@@ -781,75 +752,6 @@ export class Agent {
     await this.messageManager.saveSession();
   }
 
-  /**
-   * Set an autonomous goal for the session
-   * @param condition - The goal condition to achieve
-   */
-  public async setGoal(condition: string): Promise<void> {
-    // 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
-   */
-  public async clearGoal(): Promise<void> {
-    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
-   */
-  public async showGoalStatus(): Promise<void> {
-    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 */
   public abortMessage(): void {
     // Guard: prevent tryDispatch (triggered by abortAIMessage → setIsLoading(false))
@@ -994,6 +896,21 @@ 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<
+          import("./services/autoMemoryService.js").AutoMemoryService
+        >("AutoMemoryService");
+      if (autoMemoryService) {
+        await autoMemoryService.drain();
+      }
+    } catch (error) {
+      this.logger?.warn(
+        `Auto-memory extraction drain failed: ${(error as Error).message}`,
+      );
+    }
     // Cleanup skill manager
     await this.skillManager.destroy();
     // Cleanup live configuration reload
@@ -1018,21 +935,30 @@ export class Agent {
   }
 
   /**
-   * 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
    */
-  public async askBtw(question: string): Promise<string> {
-    const messages = convertMessagesForAPI(this.messageManager.getMessages(), {
-      supportsVision: supportsVision(this.getModelConfig().capabilities),
-    });
-    const result = await btw({
-      gatewayConfig: this.getGatewayConfig(),
-      modelConfig: this.getModelConfig(),
-      messages,
+  public async askBtw(
+    question: string,
+    abortSignal?: AbortSignal,
+    onContent?: (content: string) => void,
+    onReasoning?: (content: string) => void,
+  ): Promise<string> {
+    const result = await this.aiManager.runBtwFork(
       question,
-    });
-    return result.content;
+      abortSignal,
+      onContent,
+      onReasoning,
+    );
+    return result.content ?? result.error ?? "No response received";
   }
 
   /**
@@ -1066,7 +992,7 @@ export class Agent {
     images?: Array<{ path: string; mimeType: string }>,
   ): Promise<void> {
     // 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();