wave-agent-sdk 0.19.9 → 1.0.1

package/dist/services/aiService.js

@@ -7,8 +7,7 @@ import { supportsPromptCaching } from "../utils/modelCapabilities.js";
 import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
-import { WEB_CONTENT_SYSTEM_PROMPT, BTW_SYSTEM_PROMPT, } from "../prompts/index.js";
-import { GOAL_EVALUATION_SYSTEM_PROMPT } from "../constants/goalPrompts.js";
+import { WEB_CONTENT_SYSTEM_PROMPT, } from "../prompts/index.js";
 // Global rate limiter state for 1 QPS
 let nextAllowedTime = 0;
 const MIN_INTERVAL = 1000; // 1 second for 1 QPS
@@ -66,6 +65,15 @@ function getModelConfig(modelName, baseConfig = {}) {
     }
     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) {
+    return modelConfig.disableThinkingOptions;
+}
 function validateModelConfig(modelConfig) {
     if (!modelConfig.model) {
         throw new ConfigurationError(CONFIG_ERRORS.MISSING_MODEL, "model", {
@@ -81,7 +89,7 @@ function validateModelConfig(modelConfig) {
     }
 }
 export async function callAgent(options) {
-    const { gatewayConfig, modelConfig, messages, abortSignal, workdir, tools, model, systemPrompt, onContentUpdate, onToolUpdate, onReasoningUpdate, } = options;
+    const { gatewayConfig, modelConfig, messages, abortSignal, workdir, tools, model, systemPrompt, onContentUpdate, onToolUpdate, onReasoningUpdate, disableThinkingOptions, } = options;
     // Validate model config at call time
     validateModelConfig(modelConfig);
     // Apply global 1 QPS rate limit
@@ -147,6 +155,7 @@ export async function callAgent(options) {
         const openaiModelConfig = getModelConfig(model || modelConfig.model, {
             max_tokens: resolvedMaxTokens,
             ...(modelConfig.options || {}),
+            ...(disableThinkingOptions ?? {}),
         });
         // Determine if streaming is needed
         const isStreaming = options.stream === true ||
@@ -509,10 +518,16 @@ export async function processWebContent(options) {
     const activeExtraParams = options.model
         ? 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 {
         const response = await openai.chat.completions.create({
@@ -555,130 +570,3 @@ export async function processWebContent(options) {
         throw error;
     }
 }
-export async function btw(options) {
-    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.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 async function evaluateGoal(options) {
-    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");
-            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.name === "AbortError") {
-            logger.info("Goal evaluation was aborted");
-            throw new Error("Goal evaluation was aborted");
-        }
-        logger.error("Goal evaluation failed:", error);
-        throw error;
-    }
-}

package/dist/services/autoMemoryService.d.ts

@@ -7,9 +7,11 @@ export declare class AutoMemoryService {
     private container;
     private lastMemoryMessageId;
     private turnsSinceLastExtraction;
+    private extractionInProgress;
+    private pendingExtraction;
     constructor(container: Container);
     private get messageManager();
-    private get forkedAgentManager();
+    private get aiManager();
     private get memoryService();
     private get configurationService();
     /**
@@ -17,7 +19,30 @@ export declare class AutoMemoryService {
      */
     onTurnEnd(workdir: string): Promise<void>;
     /**
-     * Initialize and execute the background extraction subagent.
+     * 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.
+     */
+    drain(): Promise<void>;
+    /**
+     * 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 runExtraction;
+    /**
+     * 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;
+    /**
+     * 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;
 }

package/dist/services/autoMemoryService.js

@@ -3,6 +3,14 @@ import * as fs from "node:fs/promises";
 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";
+/**
+ * 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.
@@ -12,12 +20,14 @@ export class AutoMemoryService {
         this.container = container;
         this.lastMemoryMessageId = null;
         this.turnsSinceLastExtraction = 0;
+        this.extractionInProgress = false;
+        this.pendingExtraction = null;
     }
     get messageManager() {
         return this.container.get("MessageManager");
     }
-    get forkedAgentManager() {
-        return this.container.get("ForkedAgentManager");
+    get aiManager() {
+        return this.container.get("AIManager");
     }
     get memoryService() {
         return this.container.get("MemoryService");
@@ -54,7 +64,12 @@ export class AutoMemoryService {
         const recentMessages = messages.slice(startIndex);
         const hasManualMemoryWrite = recentMessages.some((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;
@@ -77,20 +92,51 @@ export class AutoMemoryService {
             this.turnsSinceLastExtraction = 0;
             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() {
+        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.
      */
-    async runExtraction(workdir, messages) {
+    async runExtraction(workdir, messages, newMessageCount) {
         const memoryDir = this.memoryService.getAutoMemoryDirectory(workdir);
         // Ensure memory directory exists before starting
         await this.memoryService.ensureAutoMemoryDirectory(workdir);
@@ -106,30 +152,72 @@ export class AutoMemoryService {
         catch {
             // 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", messages, {
-            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
+        await this.aiManager.runAutoMemoryFork(messages, `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`, {
             maxTurns: 5, // Limit turns to prevent verification rabbit-holes
-        }, `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`);
-        logger.debug("Auto-memory extraction started in background.");
+            canUseTool: (name, args) => this.isAllowedForkTool(name, args, memoryDir, workdir),
+            deniedToolMessage: DENIED_TOOL_MESSAGE,
+        });
+        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.
+     */
+    isAllowedForkTool(name, args, memoryDir, workdir) {
+        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.
+     */
+    isReadOnlyBashCommand(command) {
+        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/dist/services/configurationService.d.ts

@@ -18,10 +18,23 @@ export declare class ConfigurationService {
     private currentConfiguration;
     private options;
     private _configuredEnvKeys;
+    private envSnapshot;
     /**
      * Set agent options for configuration resolution
      */
     setOptions(options: AgentOptions): void;
+    /**
+     * Returns a copy of the per-session environment snapshot (settings.json `env`).
+     * Priority over OS env; does NOT include OS env. For subprocess spawning use
+     * {@link getMergedEnv} instead.
+     */
+    getEnvSnapshot(): Record<string, string>;
+    /**
+     * Returns OS env merged with the session snapshot (snapshot wins). Use this
+     * when spawning user-facing subprocesses (bash, hooks, bang, background, MCP)
+     * so they inherit both OS env and the session's settings env.
+     */
+    getMergedEnv(): Record<string, string>;
     /**
      * Load and merge configuration with comprehensive validation
      */
@@ -35,8 +48,14 @@ export declare class ConfigurationService {
      */
     validateConfigurationFile(filePath: string): ValidationResult;
     /**
-     * Set environment variables from configuration
-     * This replaces direct process.env modification
+     * Store environment variables from configuration into the per-session
+     * snapshot (NOT process.env). Settings `env` shadows OS env for this session
+     * only — multiple sessions in one stdio process stay isolated.
+     *
+     * Exception: `WAVE_SERVER_URL` is also mirrored to `process.env` because the
+     * process-level singletons (AuthService, remoteSettingsService background
+     * fetch) need to read it and don't hold a per-session snapshot. Same value
+     * across sessions ⇒ no cross-pollution. See docs/specs/core/agent-config.md.
      */
     setEnvironmentVars(env: Record<string, string>): void;
     /**