wave-agent-sdk 0.19.9 → 1.0.1

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;
+    });
   }
 }