wave-agent-sdk 1.0.0 → 1.0.2

package/dist/managers/subagentManager.js

@@ -538,18 +538,21 @@ export class SubagentManager {
     createSubagentCallbacks(subagentId) {
         return {
             onUserMessageAdded: (params) => {
+                this.refreshSubagentState(subagentId);
                 // Forward user message events to parent via SubagentManager callbacks
                 if (this.callbacks?.onSubagentUserMessageAdded) {
                     this.callbacks.onSubagentUserMessageAdded(subagentId, params);
                 }
             },
             onAssistantMessageAdded: (messageId) => {
+                this.refreshSubagentState(subagentId);
                 // Forward assistant message events to parent via SubagentManager callbacks
                 if (this.callbacks?.onSubagentAssistantMessageAdded) {
                     this.callbacks.onSubagentAssistantMessageAdded(subagentId, messageId);
                 }
             },
             onAssistantContentUpdated: (params) => {
+                this.refreshSubagentState(subagentId);
                 // Forward assistant content updates to parent via SubagentManager callbacks
                 if (this.callbacks?.onSubagentAssistantContentUpdated) {
                     this.callbacks.onSubagentAssistantContentUpdated({
@@ -559,6 +562,7 @@ export class SubagentManager {
                 }
             },
             onAssistantReasoningUpdated: (params) => {
+                this.refreshSubagentState(subagentId);
                 // Forward assistant reasoning updates to parent via SubagentManager callbacks
                 if (this.callbacks?.onSubagentAssistantReasoningUpdated) {
                     this.callbacks.onSubagentAssistantReasoningUpdated({
@@ -568,6 +572,7 @@ export class SubagentManager {
                 }
             },
             onToolBlockUpdated: (params) => {
+                this.refreshSubagentState(subagentId);
                 const instance = this.instances.get(subagentId);
                 if (instance) {
                     // Log tool execution to file only when finalized
@@ -582,28 +587,6 @@ export class SubagentManager {
                     this.callbacks.onSubagentToolBlockUpdated(subagentId, params);
                 }
             },
-            // These callbacks will be handled by the parent agent
-            onMessagesChange: (messages) => {
-                const instance = this.instances.get(subagentId);
-                if (instance) {
-                    instance.messages = messages;
-                    // Compute usedTools from messages (last 2 tool blocks)
-                    const toolBlocks = messages.flatMap((m) => m.blocks?.filter((b) => b.type === "tool") ?? []);
-                    const last2 = toolBlocks.slice(-2);
-                    instance.usedTools = last2.map((tb) => ({
-                        name: tb.name ?? "",
-                        parameters: tb.parameters ?? "",
-                        compactParams: tb.compactParams,
-                        stage: tb.stage,
-                    }));
-                    // Trigger the onUpdate callback if provided
-                    instance.onUpdate?.();
-                    // Forward subagent message changes to parent via callbacks
-                    if (this.callbacks?.onSubagentMessagesChange) {
-                        this.callbacks.onSubagentMessagesChange(subagentId, messages);
-                    }
-                }
-            },
             onLatestTotalTokensChange: (tokens) => {
                 const instance = this.instances.get(subagentId);
                 if (instance) {
@@ -616,6 +599,7 @@ export class SubagentManager {
                 }
             },
             onErrorBlockAdded: (error) => {
+                this.refreshSubagentState(subagentId);
                 const instance = this.instances.get(subagentId);
                 if (instance?.logStream) {
                     instance.logStream.write(`[${new Date().toISOString()}] Error: ${error}\n`);
@@ -623,4 +607,31 @@ export class SubagentManager {
             },
         };
     }
+    /**
+     * Pull the latest messages from the subagent instance's MessageManager and
+     * refresh the instance's cached messages, usedTools, onUpdate and the
+     * onSubagentMessagesChange forwarding. Triggered by incremental callbacks.
+     */
+    refreshSubagentState(subagentId) {
+        const instance = this.instances.get(subagentId);
+        if (!instance)
+            return;
+        const messages = instance.messageManager.getMessages();
+        instance.messages = messages;
+        // Compute usedTools from messages (last 2 tool blocks)
+        const toolBlocks = messages.flatMap((m) => m.blocks?.filter((b) => b.type === "tool") ?? []);
+        const last2 = toolBlocks.slice(-2);
+        instance.usedTools = last2.map((tb) => ({
+            name: tb.name ?? "",
+            parameters: tb.parameters ?? "",
+            compactParams: tb.compactParams,
+            stage: tb.stage,
+        }));
+        // Trigger the onUpdate callback if provided
+        instance.onUpdate?.();
+        // Forward subagent message changes to parent via callbacks
+        if (this.callbacks?.onSubagentMessagesChange) {
+            this.callbacks.onSubagentMessagesChange(subagentId, messages);
+        }
+    }
 }

package/dist/prompts/index.d.ts

@@ -34,7 +34,6 @@ export declare function getCompactPrompt(customInstructions?: string): string;
  */
 export declare function formatCompactSummary(summary: string): string;
 export declare const WEB_CONTENT_SYSTEM_PROMPT = "You are a helpful assistant that extracts information from web content. The content is provided in Markdown format.";
-export declare const BTW_SYSTEM_PROMPT = "You are a helpful assistant. Answer the user's side question based on the conversation history. \nDo NOT say things like \"Let me try...\", \"I'll now...\", \"Let me check...\", or promise to take any action. \nIf you don't know the answer, say so - do not offer to look it up or investigate. \nSimply answer the question with the information you have.";
 export declare function buildSystemPrompt(basePrompt: string | undefined, tools: ToolPlugin[], options?: {
     workdir?: string;
     originalWorkdir?: string;
@@ -46,4 +45,3 @@ export declare function buildSystemPrompt(basePrompt: string | undefined, tools:
         content: string;
     };
 }): SystemPromptBlock[];
-export declare function enhanceSystemPromptWithEnvDetails(existingSystemPrompt: string, workdir: string, originalWorkdir?: string, worktreeSession?: WorktreeSession | null): string;

package/dist/prompts/index.js

@@ -285,10 +285,43 @@ export function formatCompactSummary(summary) {
     return formattedSummary.trim();
 }
 export const WEB_CONTENT_SYSTEM_PROMPT = `You are a helpful assistant that extracts information from web content. The content is provided in Markdown format.`;
-export const BTW_SYSTEM_PROMPT = `You are a helpful assistant. Answer the user's side question based on the conversation history. 
-Do NOT say things like "Let me try...", "I'll now...", "Let me check...", or promise to take any action. 
-If you don't know the answer, say so - do not offer to look it up or investigate. 
-Simply answer the question with the information you have.`;
+/**
+ * Notes block prepended to the subagent env section, aligned with Claude
+ * Code's enhanceSystemPromptWithEnvDetails().
+ */
+const SUBAGENT_ENV_NOTES = `Notes:
+- Agent threads always have their cwd reset between bash calls, as a result please only use absolute file paths.
+- In your final response, share file paths (always absolute, never relative) that are relevant to the task. Include code snippets only when the exact text is load-bearing (e.g., a bug you found, a function signature the caller asked for) — do not recap code you merely read.
+- For clear communication with the user the assistant MUST avoid using emojis.
+- Do not use a colon before tool calls. Text like "Let me read the file:" followed by a read tool call should just be "Let me read the file." with a period.`;
+/**
+ * Shell info line, aligned with Claude Code's getShellInfoLine(). On win32 an
+ * extra Unix-syntax hint is appended.
+ */
+function getShellInfoLine() {
+    const shell = process.env.SHELL || "unknown";
+    const shellName = shell.includes("zsh")
+        ? "zsh"
+        : shell.includes("bash")
+            ? "bash"
+            : shell;
+    if (os.platform() === "win32") {
+        return `Shell: ${shellName} (use Unix shell syntax, not Windows — e.g., /dev/null not NUL, forward slashes in paths)`;
+    }
+    return `Shell: ${shellName}`;
+}
+/**
+ * OS Version value, aligned with Claude Code's getUnameSR(). os.type() and
+ * os.release() wrap uname(3) on POSIX, producing output byte-identical to
+ * `uname -sr`. Windows has no uname(3); os.type() returns "Windows_NT" there,
+ * but os.version() gives the friendlier "Windows 11 Pro", so use that instead.
+ */
+function getUnameSR() {
+    if (os.platform() === "win32") {
+        return `${os.version()} ${os.release()}`;
+    }
+    return `${os.type()} ${os.release()}`;
+}
 export function buildSystemPrompt(basePrompt, tools, options = {}) {
     // --- Static block (cacheable) ---
     let staticText = basePrompt || DEFAULT_SYSTEM_PROMPT;
@@ -309,27 +342,49 @@ export function buildSystemPrompt(basePrompt, tools, options = {}) {
     if (options.workdir) {
         const isGitRepo = isGitRepository(options.workdir);
         const platform = os.platform();
-        const osVersion = `${os.type()} ${os.release()}`;
-        const today = new Date().toISOString().split("T")[0];
-        const shell = process.env.SHELL || "unknown";
-        const shellName = shell.includes("zsh")
-            ? "zsh"
-            : shell.includes("bash")
-                ? "bash"
-                : shell;
+        const shellInfo = getShellInfoLine();
+        const osVersion = getUnameSR();
+        const primaryWorkdir = options.originalWorkdir ?? options.workdir;
         const worktreeSession = options.worktreeSession;
-        dynamicText += `
+        if (options.isSubagent) {
+            // Subagent env section, aligned with Claude Code's computeEnvInfo() +
+            // enhanceSystemPromptWithEnvDetails() (without the model description and
+            // knowledge cutoff lines, which Wave does not use).
+            dynamicText += `
+
+${SUBAGENT_ENV_NOTES}
 
 Here is useful information about the environment you are running in:
 <env>
-Primary working directory: ${options.originalWorkdir ?? options.workdir}${worktreeSession ? `\nThis is a git worktree — an isolated copy of the repository. Run all commands from this directory. Do NOT \`cd\` to the original repository root at ${worktreeSession.originalCwd}.` : ""}
+Working directory: ${primaryWorkdir}
 Is directory a git repo: ${isGitRepo}
 Platform: ${platform}
-Shell: ${shellName}
+${shellInfo}
 OS Version: ${osVersion}
-Today's date: ${today}
 </env>
 `;
+        }
+        else {
+            // Main agent env section, aligned with Claude Code's
+            // computeSimpleEnvInfo() (without the model description, knowledge
+            // cutoff, and marketing lines, which Wave does not use).
+            const envItems = [
+                `Primary working directory: ${primaryWorkdir}`,
+                worktreeSession
+                    ? `This is a git worktree — an isolated copy of the repository. Run all commands from this directory. Do NOT \`cd\` to the original repository root.`
+                    : null,
+                `Is a git repository: ${isGitRepo}`,
+                `Platform: ${platform}`,
+                shellInfo,
+                `OS Version: ${osVersion}`,
+            ].filter((item) => item !== null);
+            const envBlock = [
+                `# Environment`,
+                `You have been invoked in the following environment: `,
+                ...envItems.map((item) => ` - ${item}`),
+            ].join("\n");
+            dynamicText += `\n\n${envBlock}`;
+        }
     }
     if (options.autoMemory) {
         dynamicText += `\n\n${buildAutoMemoryPrompt(options.autoMemory.directory)}`;
@@ -342,34 +397,3 @@ Today's date: ${today}
     }
     return blocks;
 }
-export function enhanceSystemPromptWithEnvDetails(existingSystemPrompt, workdir, originalWorkdir, worktreeSession) {
-    const isGitRepo = isGitRepository(workdir);
-    const platform = os.platform();
-    const osVersion = `${os.type()} ${os.release()}`;
-    const today = new Date().toISOString().split("T")[0];
-    const shell = process.env.SHELL || "unknown";
-    const shellName = shell.includes("zsh")
-        ? "zsh"
-        : shell.includes("bash")
-            ? "bash"
-            : shell;
-    const notes = `Notes:
-- Agent threads always have their cwd reset between bash calls, as a result please only use absolute file paths.${worktreeSession ? `\n- You are in a git worktree at ${worktreeSession.worktreePath} (branch: ${worktreeSession.worktreeBranch}). Absolute paths from prior context may refer to the original repo at ${worktreeSession.originalCwd}; translate them to your worktree. Do NOT edit files outside this worktree.` : ""}
-- In your final response, share file paths (always absolute, never relative) that are relevant to the task. Include code snippets only when the exact text is load-bearing (e.g., a bug you found, a function signature the caller asked for) — do not recap code you merely read.
-- For clear communication with the user the assistant MUST avoid using emojis.
-- Do not use a colon before tool calls. Text like "Let me read the file:" followed by a read tool call should just be "Let me read the file." with a period.`;
-    return `${existingSystemPrompt}
-
-${notes}
-
-Here is useful information about the environment you are running in:
-<env>
-Primary working directory: ${originalWorkdir ?? workdir}${worktreeSession ? `\nThis is a git worktree — an isolated copy of the repository. Run all commands from this directory. Do NOT \`cd\` to the original repository root at ${worktreeSession.originalCwd}.` : ""}
-Is directory a git repo: ${isGitRepo}
-Platform: ${platform}
-Shell: ${shellName}
-OS Version: ${osVersion}
-Today's date: ${today}
-</env>
-`;
-}

package/dist/services/aiService.d.ts

@@ -34,6 +34,7 @@ export interface CallAgentOptions {
         stage?: "start" | "streaming" | "running" | "end";
     }) => void;
     onReasoningUpdate?: (content: string) => void;
+    disableThinkingOptions?: Record<string, unknown>;
 }
 export interface CallAgentResult {
     content?: string;
@@ -62,37 +63,3 @@ export interface ProcessWebContentResult {
     };
 }
 export declare function processWebContent(options: ProcessWebContentOptions): Promise<ProcessWebContentResult>;
-export interface BtwOptions {
-    gatewayConfig: GatewayConfig;
-    modelConfig: ModelConfig;
-    messages: ChatCompletionMessageParam[];
-    question: string;
-    abortSignal?: AbortSignal;
-    model?: string;
-}
-export interface BtwResult {
-    content: string;
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-}
-export declare function btw(options: BtwOptions): Promise<BtwResult>;
-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 declare function evaluateGoal(options: EvaluateGoalOptions): Promise<EvaluateGoalResult>;

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