wave-agent-sdk 1.0.0 → 1.0.2

package/src/services/aiService.ts

@@ -25,10 +25,8 @@ import * as path from "path";
 
 import {
   WEB_CONTENT_SYSTEM_PROMPT,
-  BTW_SYSTEM_PROMPT,
   type SystemPromptBlock,
 } from "../prompts/index.js";
-import { GOAL_EVALUATION_SYSTEM_PROMPT } from "../constants/goalPrompts.js";
 
 /**
  * Interface for debug data saved during 400 errors
@@ -148,6 +146,18 @@ function getModelConfig(
   return config;
 }
 
+/**
+ * Effective disable-thinking params for a model config. No default: these
+ * params are only sent when the user explicitly configures
+ * `models[X].disableThinkingOptions` (an empty object clears them), so a
+ * gateway that doesn't understand the params is never hit with them.
+ */
+function effectiveDisableThinkingOptions(
+  modelConfig: ModelConfig,
+): Record<string, unknown> | undefined {
+  return modelConfig.disableThinkingOptions;
+}
+
 export interface CallAgentOptions {
   // Resolved configuration
   gatewayConfig: GatewayConfig;
@@ -184,6 +194,10 @@ export interface CallAgentOptions {
     stage?: "start" | "streaming" | "running" | "end";
   }) => void;
   onReasoningUpdate?: (content: string) => void;
+
+  // Disable-thinking params for fast-model subagent calls (merged into the
+  // request; never used in the agent loop).
+  disableThinkingOptions?: Record<string, unknown>;
 }
 
 export interface CallAgentResult {
@@ -238,6 +252,7 @@ export async function callAgent(
     onContentUpdate,
     onToolUpdate,
     onReasoningUpdate,
+    disableThinkingOptions,
   } = options;
 
   // Validate model config at call time
@@ -321,6 +336,7 @@ export async function callAgent(
     const openaiModelConfig = getModelConfig(model || modelConfig.model, {
       max_tokens: resolvedMaxTokens,
       ...(modelConfig.options || {}),
+      ...(disableThinkingOptions ?? {}),
     });
 
     // Determine if streaming is needed
@@ -842,10 +858,17 @@ export async function processWebContent(
     ? modelConfig.fastModelOptions || {}
     : modelConfig.options || {};
 
+  // Disable-thinking params only apply to the fast-model override path;
+  // the agent-model path is untouched.
+  const disableThinking = options.model
+    ? effectiveDisableThinkingOptions(modelConfig)
+    : undefined;
+
   const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
     temperature: 0.1,
     max_tokens: 4096,
     ...activeExtraParams,
+    ...(disableThinking || {}),
   });
 
   try {
@@ -894,204 +917,3 @@ export async function processWebContent(
   }
 }
 
-export interface BtwOptions {
-  // Resolved configuration
-  gatewayConfig: GatewayConfig;
-  modelConfig: ModelConfig;
-
-  // Parameters
-  messages: ChatCompletionMessageParam[];
-  question: string;
-  abortSignal?: AbortSignal;
-  model?: string;
-}
-
-export interface BtwResult {
-  content: string;
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-}
-
-export async function btw(options: BtwOptions): Promise<BtwResult> {
-  const { gatewayConfig, modelConfig, messages, question, abortSignal } =
-    options;
-
-  // Validate model config at call time
-  validateModelConfig(modelConfig);
-
-  // Apply global 1 QPS rate limit
-  if (
-    process.env.NODE_ENV !== "test" ||
-    modelConfig.model === "rate-limit-test"
-  ) {
-    await acquireSlot(abortSignal);
-  }
-
-  // Create OpenAI client with injected configuration
-  const openai = new OpenAIClient({
-    apiKey: gatewayConfig.apiKey,
-    baseURL: gatewayConfig.baseURL,
-    defaultHeaders: gatewayConfig.defaultHeaders,
-    fetchOptions: gatewayConfig.fetchOptions,
-    fetch: gatewayConfig.fetch,
-  });
-
-  const openaiModelConfig = getModelConfig(options.model || modelConfig.model, {
-    temperature: 0.1,
-    max_tokens: 4096,
-    ...(modelConfig.options || {}),
-  });
-
-  try {
-    const response = await openai.chat.completions.create(
-      {
-        ...openaiModelConfig,
-        messages: [
-          {
-            role: "system",
-            content: BTW_SYSTEM_PROMPT,
-          },
-          ...messages,
-          {
-            role: "user",
-            content: question,
-          },
-        ],
-      },
-      {
-        signal: abortSignal,
-      },
-    );
-
-    const result = response.choices[0]?.message?.content?.trim();
-    if (!result) {
-      throw new Error(
-        "Failed to process side question: Empty response from AI",
-      );
-    }
-    const usage = response.usage
-      ? {
-          prompt_tokens: response.usage.prompt_tokens,
-          completion_tokens: response.usage.completion_tokens,
-          total_tokens: response.usage.total_tokens,
-        }
-      : undefined;
-
-    return {
-      content: result,
-      usage,
-    };
-  } catch (error) {
-    if ((error as Error).name === "AbortError") {
-      logger.info("Side question request was aborted");
-      throw new Error("Side question request was aborted");
-    }
-    logger.error("Failed to process side question:", error);
-    throw error;
-  }
-}
-
-export interface EvaluateGoalOptions {
-  gatewayConfig: GatewayConfig;
-  modelConfig: ModelConfig;
-  model: string;
-  goalCondition: string;
-  messages: ChatCompletionMessageParam[];
-  abortSignal?: AbortSignal;
-}
-
-export interface EvaluateGoalResult {
-  content: string;
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-}
-
-export async function evaluateGoal(
-  options: EvaluateGoalOptions,
-): Promise<EvaluateGoalResult> {
-  const {
-    gatewayConfig,
-    modelConfig,
-    model,
-    goalCondition,
-    messages,
-    abortSignal,
-  } = options;
-
-  // Create OpenAI client with injected configuration (no rate limiter — bypasses 1 QPS)
-  const openai = new OpenAIClient({
-    apiKey: gatewayConfig.apiKey,
-    baseURL: gatewayConfig.baseURL,
-    defaultHeaders: gatewayConfig.defaultHeaders,
-    fetchOptions: gatewayConfig.fetchOptions,
-    fetch: gatewayConfig.fetch,
-  });
-
-  const openaiModelConfig = getModelConfig(model, {
-    temperature: 0,
-    max_tokens: 200,
-    ...(modelConfig.fastModelOptions || {}),
-  });
-
-  // Strip images from messages to reduce token usage (same as compact)
-  const cleanedMessages = messages.map((msg) => {
-    if (Array.isArray(msg.content)) {
-      const textParts = msg.content.filter(
-        (part) => part.type === "text",
-      ) as import("openai/resources.js").ChatCompletionContentPartText[];
-      const text = textParts.map((p) => p.text).join("\n");
-      return { ...msg, content: text || "(empty message)" };
-    }
-    return msg;
-  });
-
-  try {
-    const response = await openai.chat.completions.create(
-      {
-        ...openaiModelConfig,
-        messages: [
-          {
-            role: "system",
-            content: GOAL_EVALUATION_SYSTEM_PROMPT,
-          },
-          ...cleanedMessages,
-          {
-            role: "user",
-            content: `Goal condition: ${goalCondition}\n\nHas this goal been achieved based on the conversation above?`,
-          },
-        ],
-      },
-      {
-        signal: abortSignal,
-      },
-    );
-
-    const result = response.choices[0]?.message?.content?.trim();
-    if (!result) {
-      throw new Error("Goal evaluation returned empty response");
-    }
-
-    const usage = response.usage
-      ? {
-          prompt_tokens: response.usage.prompt_tokens,
-          completion_tokens: response.usage.completion_tokens,
-          total_tokens: response.usage.total_tokens,
-        }
-      : undefined;
-
-    return { content: result, usage };
-  } catch (error) {
-    if ((error as Error).name === "AbortError") {
-      logger.info("Goal evaluation was aborted");
-      throw new Error("Goal evaluation was aborted");
-    }
-    logger.error("Goal evaluation failed:", error);
-    throw error;
-  }
-}

package/src/services/autoMemoryService.ts

@@ -2,14 +2,32 @@ import * as path from "node:path";
 import * as fs from "node:fs/promises";
 import { Container } from "../utils/container.js";
 import { MessageManager } from "../managers/messageManager.js";
-import { ForkedAgentManager } from "../managers/forkedAgentManager.js";
+import { AIManager } from "../managers/aiManager.js";
 import { MemoryService } from "./memory.js";
 import { ConfigurationService } from "./configurationService.js";
 import { logger } from "../utils/globalLogger.js";
 import { isPathInside } from "../utils/pathSafety.js";
 import { buildAutoMemoryExtractionPrompt } from "../prompts/autoMemoryExtraction.js";
+import {
+  READ_ONLY_COMMANDS,
+  splitBashCommand,
+  hasWriteRedirections,
+  hasCommandSubstitution,
+  hasProcessSubstitution,
+  hasSedInPlace,
+  isDangerousFind,
+} from "../utils/bashParser.js";
 import type { Message } from "../types/index.js";
 
+/**
+ * Message fed back to the extraction fork when the model requests a tool
+ * outside the allowed set (Bash rm, MCP tools, Agent, out-of-dir writes...).
+ */
+const DENIED_TOOL_MESSAGE =
+  "This tool call was denied during auto-memory extraction. Available tools: " +
+  "Read, Grep, Glob, read-only Bash commands, and Write/Edit inside the " +
+  "memory directory only.";
+
 /**
  * Service responsible for managing the auto-memory background agent lifecycle.
  * Extracts and updates persistent project-level memory from conversation history.
@@ -17,6 +35,8 @@ import type { Message } from "../types/index.js";
 export class AutoMemoryService {
   private lastMemoryMessageId: string | null = null;
   private turnsSinceLastExtraction: number = 0;
+  private extractionInProgress: boolean = false;
+  private pendingExtraction: Promise<void> | null = null;
 
   constructor(private container: Container) {}
 
@@ -24,8 +44,8 @@ export class AutoMemoryService {
     return this.container.get<MessageManager>("MessageManager")!;
   }
 
-  private get forkedAgentManager(): ForkedAgentManager {
-    return this.container.get<ForkedAgentManager>("ForkedAgentManager")!;
+  private get aiManager(): AIManager {
+    return this.container.get<AIManager>("AIManager")!;
   }
 
   private get memoryService(): MemoryService {
@@ -71,7 +91,14 @@ export class AutoMemoryService {
       (m) =>
         m.role === "assistant" &&
         m.blocks.some((b) => {
-          if (b.type === "tool" && (b.name === "Write" || b.name === "Edit")) {
+          if (
+            b.type === "tool" &&
+            (b.name === "Write" || b.name === "Edit") &&
+            // Only a successful manual write counts as a manual update. A
+            // denied/failed write didn't touch memory, so the extraction fork
+            // must still run or the information is lost.
+            b.success !== false
+          ) {
             try {
               const params = b.parameters ? JSON.parse(b.parameters) : null;
               const filePath = params?.file_path || params?.path;
@@ -98,22 +125,61 @@ export class AutoMemoryService {
       return;
     }
 
-    // 3. Trigger background extraction using a forked subagent
-    try {
-      await this.runExtraction(workdir, messages);
-      this.lastMemoryMessageId = messages[messages.length - 1].id || null;
-      this.turnsSinceLastExtraction = 0;
-    } catch (error) {
-      logger.error("Auto-memory extraction failed to trigger:", error);
+    // 3. Concurrency guard: if an extraction is already in flight, skip this
+    // turn. turnsSinceLastExtraction is intentionally NOT reset so the next
+    // eligible turn retriggers the extraction.
+    if (this.extractionInProgress) {
+      logger.debug(
+        "Skipping auto-memory extraction: another extraction is still in progress.",
+      );
+      return;
     }
+
+    // 4. Trigger the perfect-fork extraction fire-and-forget. The message
+    // snapshot and new-message count are computed now; lastMemoryMessageId
+    // advances at trigger time so the next extraction starts from a later
+    // window even while this one runs.
+    const lastExtractedIndex = this.lastMemoryMessageId
+      ? messages.findIndex((m) => m.id === this.lastMemoryMessageId)
+      : -1;
+    const newMessageCount =
+      lastExtractedIndex === -1
+        ? messages.length
+        : messages.length - 1 - lastExtractedIndex;
+
+    this.turnsSinceLastExtraction = 0;
+    this.lastMemoryMessageId = messages[messages.length - 1].id || null;
+    this.extractionInProgress = true;
+    const extraction = this.runExtraction(workdir, messages, newMessageCount)
+      .catch((error) => {
+        logger.error("Auto-memory extraction failed:", error);
+      })
+      .finally(() => {
+        this.extractionInProgress = false;
+        this.pendingExtraction = null;
+      });
+    this.pendingExtraction = extraction;
+  }
+
+  /**
+   * Wait for an in-flight extraction to settle. Called from Agent.dispose so
+   * the process doesn't exit while the extraction fork is mid-flight.
+   */
+  async drain(): Promise<void> {
+    await this.pendingExtraction;
   }
 
   /**
-   * Initialize and execute the background extraction subagent.
+   * Initialize and execute the extraction in a perfect fork: same system
+   * prompt, tools, model, and message prefix as the main conversation, so the
+   * prompt cache is reused. A tool gate confines the fork to read-only
+   * inspection and memory-directory writes. Runs in-process; callers treat it
+   * as fire-and-forget.
    */
   private async runExtraction(
     workdir: string,
     messages: Message[],
+    newMessageCount: number,
   ): Promise<void> {
     const memoryDir = this.memoryService.getAutoMemoryDirectory(workdir);
 
@@ -132,43 +198,83 @@ export class AutoMemoryService {
       // Ignore if directory doesn't exist yet
     }
 
-    // Calculate how many new messages to analyze
-    let newMessageCount = messages.length;
-    if (this.lastMemoryMessageId) {
-      const lastIndex = messages.findIndex(
-        (m) => m.id === this.lastMemoryMessageId,
-      );
-      if (lastIndex !== -1) {
-        newMessageCount = messages.length - 1 - lastIndex;
-      }
-    }
-
     const prompt = buildAutoMemoryExtractionPrompt(
       newMessageCount,
       existingMemoriesManifest,
     );
 
-    // Execute the forked agent in background (fire-and-forget, decoupled from BackgroundTaskManager)
-    await this.forkedAgentManager.forkAndExecute(
-      "general-purpose",
+    await this.aiManager.runAutoMemoryFork(
       messages,
+      `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`,
       {
-        description: "Auto-memory extraction background agent",
-        allowedTools: [
-          "Read",
-          "Glob",
-          "Grep",
-          `Write(${memoryDir}/**/*)`,
-          `Edit(${memoryDir}/**/*)`,
-          `Bash(rm ${memoryDir}/**/*)`,
-        ],
-        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
+        canUseTool: (name, args) =>
+          this.isAllowedForkTool(name, args, memoryDir, workdir),
+        deniedToolMessage: DENIED_TOOL_MESSAGE,
       },
-      `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`,
     );
 
-    logger.debug("Auto-memory extraction started in background.");
+    logger.debug("Auto-memory extraction completed.");
+  }
+
+  /**
+   * Tool gate for the extraction fork: Read/Grep/Glob are always allowed;
+   * Write/Edit only when the target path is inside the memory directory; Bash
+   * only for read-only commands (aligned with the permission manager's
+   * read-only bash classification). Everything else — Bash rm, MCP tools,
+   * Agent, out-of-dir writes — is denied.
+   */
+  private isAllowedForkTool(
+    name: string,
+    args: Record<string, unknown>,
+    memoryDir: string,
+    workdir: string,
+  ): boolean {
+    if (name === "Read" || name === "Grep" || name === "Glob") {
+      return true;
+    }
+
+    if (name === "Write" || name === "Edit") {
+      const filePath = args.file_path ?? args.path;
+      if (typeof filePath !== "string" || !filePath) return false;
+      const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.resolve(workdir, filePath);
+      return isPathInside(absolutePath, memoryDir);
+    }
+
+    if (name === "Bash") {
+      const command = typeof args.command === "string" ? args.command : "";
+      return this.isReadOnlyBashCommand(command);
+    }
+
+    return false;
+  }
+
+  /**
+   * A bash command is read-only when every part is a READ_ONLY_COMMANDS entry
+   * without write redirections, command/process substitution, sed -i, or
+   * dangerous find flags. Mirrors PermissionManager.isAutoAllowedPart.
+   */
+  private isReadOnlyBashCommand(command: string): boolean {
+    if (!command.trim()) return false;
+    if (hasWriteRedirections(command)) return false;
+    if (hasCommandSubstitution(command)) return false;
+    if (hasProcessSubstitution(command)) return false;
+    if (hasSedInPlace(command)) return false;
+
+    const parts = splitBashCommand(command);
+    if (parts.length === 0) return false;
+
+    return parts.every((part) => {
+      const trimmed = part.trim();
+      if (!trimmed) return true;
+      const commandMatch = trimmed.match(/^(\w+)(\s+.*)?$/);
+      if (!commandMatch) return false;
+      const cmd = commandMatch[1];
+      if (!READ_ONLY_COMMANDS.includes(cmd)) return false;
+      if (cmd === "find" && isDangerousFind(part)) return false;
+      return true;
+    });
   }
 }

package/src/services/configurationService.ts

@@ -619,16 +619,31 @@ export class ConfigurationService {
       baseConfig.fastModelOptions = fastModelSource.options;
     }
 
+    // Resolve fast-model disable-thinking params from models[fastModel].disableThinkingOptions
+    const fastModelDisableThinking =
+      fastModelSource && fastModelSource.disableThinkingOptions
+        ? fastModelSource.disableThinkingOptions
+        : undefined;
+    if (fastModelDisableThinking) {
+      baseConfig.disableThinkingOptions = fastModelDisableThinking;
+    }
+
     // Merge model-specific settings from configuration
     const modelSpecificConfig =
       resolvedAgentModel &&
       this.currentConfiguration?.models?.[resolvedAgentModel];
 
     if (modelSpecificConfig) {
-      return {
+      const resolved: ModelConfig = {
         ...baseConfig,
         ...modelSpecificConfig,
       };
+      // Re-apply after the spread so the agent model's own
+      // disableThinkingOptions cannot clobber the fast-model value.
+      if (fastModelDisableThinking) {
+        resolved.disableThinkingOptions = fastModelDisableThinking;
+      }
+      return resolved;
     }
 
     return baseConfig;

package/src/services/session.ts

@@ -612,6 +612,74 @@ export async function cleanupEmptyProjectDirectories(): Promise<void> {
   }
 }
 
+/**
+ * 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(): Promise<number> {
+  // 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/src/types/agent.ts

@@ -119,10 +119,4 @@ export interface AgentCallbacks
   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/src/types/config.ts

@@ -33,4 +33,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/src/types/core.ts

@@ -25,7 +25,7 @@ export interface Usage {
   completion_tokens: number; // Tokens generated in completions
   total_tokens: number; // Sum of prompt + completion tokens
   model?: string; // Model used for the operation (e.g., "gpt-4", "gpt-3.5-turbo")
-  operation_type?: "agent" | "compact" | "goal_evaluation"; // Type of operation that generated usage
+  operation_type?: "agent" | "compact"; // Type of operation that generated usage
 
   // Cache-related tokens (Claude top-level + OpenAI prompt_tokens_details)
   cache_read_input_tokens?: number; // Tokens read from cache (Claude) or cached_tokens (OpenAI prompt_tokens_details)