wave-agent-sdk 0.19.9 → 1.0.1

package/dist/managers/mcpManager.d.ts

@@ -11,13 +11,21 @@ export interface McpManagerOptions {
     /** Pre-configured MCP servers passed from constructor options */
     mcpServers?: Record<string, McpServerConfig>;
 }
-export declare function expandEnvVars(value: string): string;
+/**
+ * Expand environment variables in a string value.
+ * Supports ${VAR} and ${VAR:-default} patterns.
+ *
+ * @param env - Merged env to resolve against (session snapshot over OS env).
+ *              Defaults to `process.env` for backward compatibility with tests
+ *              and standalone callers.
+ */
+export declare function expandEnvVars(value: string, env?: Record<string, string | undefined>): string;
 /**
  * Walk an MCP config and resolve environment variables in all string fields.
- * Only expands ${VAR} from process.env (skipping WAVE_PLUGIN_ROOT which is
- * handled at spawn time).
+ * Expands ${VAR} against the session env snapshot (over OS env); falls back to
+ * process.env. WAVE_PLUGIN_ROOT is skipped — handled at spawn time.
  */
-export declare function resolveMcpConfig(config: McpConfig): McpConfig;
+export declare function resolveMcpConfig(config: McpConfig, env?: Record<string, string | undefined>): McpConfig;
 export declare class McpManager {
     private container;
     private config;
@@ -30,6 +38,12 @@ export declare class McpManager {
     private reconnectTimers;
     private reconnectAttempts;
     constructor(container: Container, options?: McpManagerOptions);
+    /**
+     * Merged env for this session: OS env overlaid with the per-session settings
+     * snapshot. MCP env-var expansion (${VAR}) resolves against this so multiple
+     * sessions in one `wave --stdio` process don't read each other's settings env.
+     */
+    private get envSnapshot();
     /**
      * Initialize MCP manager with working directory and optionally auto-connect
      */

package/dist/managers/mcpManager.js

@@ -11,7 +11,15 @@ import { logger } from "../utils/globalLogger.js";
  * Supports ${VAR} and ${VAR:-default} patterns.
  */
 const WAVE_TEMPLATE_VARS = ["WAVE_PLUGIN_ROOT", "CLAUDE_PLUGIN_ROOT"];
-export function expandEnvVars(value) {
+/**
+ * Expand environment variables in a string value.
+ * Supports ${VAR} and ${VAR:-default} patterns.
+ *
+ * @param env - Merged env to resolve against (session snapshot over OS env).
+ *              Defaults to `process.env` for backward compatibility with tests
+ *              and standalone callers.
+ */
+export function expandEnvVars(value, env = process.env) {
     return value.replace(/\$\{([^}]+)\}/g, (_match, expr) => {
         const [varName, ...rest] = expr.split(":-");
         const defaultValue = rest.join(":-");
@@ -19,38 +27,38 @@ export function expandEnvVars(value) {
         if (WAVE_TEMPLATE_VARS.includes(varName)) {
             return _match; // return original ${...} string untouched
         }
-        return process.env[varName] ?? defaultValue;
+        return env[varName] ?? process.env[varName] ?? defaultValue;
     });
 }
 /**
  * Walk an MCP config and resolve environment variables in all string fields.
- * Only expands ${VAR} from process.env (skipping WAVE_PLUGIN_ROOT which is
- * handled at spawn time).
+ * Expands ${VAR} against the session env snapshot (over OS env); falls back to
+ * process.env. WAVE_PLUGIN_ROOT is skipped — handled at spawn time.
  */
-export function resolveMcpConfig(config) {
+export function resolveMcpConfig(config, env = process.env) {
     const resolved = { mcpServers: {} };
     for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
         const resolvedServer = { ...serverConfig };
         if (resolvedServer.command) {
-            resolvedServer.command = expandEnvVars(resolvedServer.command);
+            resolvedServer.command = expandEnvVars(resolvedServer.command, env);
         }
         if (resolvedServer.args) {
-            resolvedServer.args = resolvedServer.args.map(expandEnvVars);
+            resolvedServer.args = resolvedServer.args.map((a) => expandEnvVars(a, env));
         }
         if (resolvedServer.env) {
             const resolvedEnv = {};
             for (const [key, val] of Object.entries(resolvedServer.env)) {
-                resolvedEnv[key] = expandEnvVars(val);
+                resolvedEnv[key] = expandEnvVars(val, env);
             }
             resolvedServer.env = resolvedEnv;
         }
         if (resolvedServer.url) {
-            resolvedServer.url = expandEnvVars(resolvedServer.url);
+            resolvedServer.url = expandEnvVars(resolvedServer.url, env);
         }
         if (resolvedServer.headers) {
             const resolvedHeaders = {};
             for (const [key, val] of Object.entries(resolvedServer.headers)) {
-                resolvedHeaders[key] = expandEnvVars(val);
+                resolvedHeaders[key] = expandEnvVars(val, env);
             }
             resolvedServer.headers = resolvedHeaders;
         }
@@ -71,6 +79,16 @@ export class McpManager {
         this.callbacks = options.callbacks || {};
         this.mcpServers = options.mcpServers;
     }
+    /**
+     * Merged env for this session: OS env overlaid with the per-session settings
+     * snapshot. MCP env-var expansion (${VAR}) resolves against this so multiple
+     * sessions in one `wave --stdio` process don't read each other's settings env.
+     */
+    get envSnapshot() {
+        return (this.container
+            .get("ConfigurationService")
+            ?.getMergedEnv?.() ?? process.env);
+    }
     /**
      * Initialize MCP manager with working directory and optionally auto-connect
      */
@@ -125,7 +143,7 @@ export class McpManager {
         try {
             const configContent = await fs.readFile(this.configPath, "utf-8");
             const rawConfig = JSON.parse(configContent);
-            const workspaceConfig = resolveMcpConfig(rawConfig);
+            const workspaceConfig = resolveMcpConfig(rawConfig, this.envSnapshot);
             // Extract original (pre-resolution) URLs for safe display
             const originalUrls = {};
             for (const [name, serverConfig] of Object.entries(rawConfig.mcpServers)) {
@@ -210,28 +228,29 @@ export class McpManager {
         }
         // Capture original URL before any resolution for safe display
         const originalUrl = config.url;
-        // Expand env vars from process.env (e.g. ${TAVILY_API_KEY})
+        // Expand env vars against the session snapshot (over OS env, e.g. ${TAVILY_API_KEY})
+        const env = this.envSnapshot;
         const resolvedConfig = { ...config };
         if (resolvedConfig.command) {
-            resolvedConfig.command = expandEnvVars(resolvedConfig.command);
+            resolvedConfig.command = expandEnvVars(resolvedConfig.command, env);
         }
         if (resolvedConfig.args) {
-            resolvedConfig.args = resolvedConfig.args.map(expandEnvVars);
+            resolvedConfig.args = resolvedConfig.args.map((a) => expandEnvVars(a, env));
         }
         if (resolvedConfig.env) {
             const resolvedEnv = {};
             for (const [key, val] of Object.entries(resolvedConfig.env)) {
-                resolvedEnv[key] = expandEnvVars(val);
+                resolvedEnv[key] = expandEnvVars(val, env);
             }
             resolvedConfig.env = resolvedEnv;
         }
         if (resolvedConfig.url) {
-            resolvedConfig.url = expandEnvVars(resolvedConfig.url);
+            resolvedConfig.url = expandEnvVars(resolvedConfig.url, env);
         }
         if (resolvedConfig.headers) {
             const resolvedHeaders = {};
             for (const [key, val] of Object.entries(resolvedConfig.headers)) {
-                resolvedHeaders[key] = expandEnvVars(val);
+                resolvedHeaders[key] = expandEnvVars(val, env);
             }
             resolvedConfig.headers = resolvedHeaders;
         }
@@ -332,8 +351,11 @@ export class McpManager {
                 if (!server.config.command) {
                     throw new Error(`MCP server ${name} with type "stdio" requires a 'command'`);
                 }
+                // Base env = OS env overlaid with this session's settings snapshot, so
+                // custom env vars from settings.json reach the MCP server subprocess
+                // without polluting other sessions sharing one `wave --stdio` process.
                 const env = {
-                    ...process.env,
+                    ...this.envSnapshot,
                     ...(server.config.env || {}),
                 };
                 // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} and ${CLAUDE_PLUGIN_ROOT}

package/dist/managers/messageManager.d.ts

@@ -5,7 +5,6 @@ import { ChatCompletionMessageFunctionToolCall } from "openai/resources.js";
 import type { MemoryRule } from "../types/memoryRule.js";
 import { Container } from "../utils/container.js";
 export interface MessageManagerCallbacks {
-    onMessagesChange?: (messages: Message[]) => void;
     onSessionIdChange?: (sessionId: string) => void;
     onLatestTotalTokensChange?: (latestTotalTokens: number) => void;
     onUsagesChange?: (usages: Usage[]) => void;
@@ -27,9 +26,9 @@ export interface MessageManagerCallbacks {
     onErrorBlockAdded?: (error: string) => void;
     onCompactBlockAdded?: (content: string) => void;
     onCompactionStateChange?: (isCompacting: boolean) => void;
-    onAddBangMessage?: (command: string) => void;
-    onUpdateBangMessage?: (command: string, output: string) => void;
-    onCompleteBangMessage?: (command: string, exitCode: number) => void;
+    onAddBangMessage?: (command: string, messageId: string) => void;
+    onUpdateBangMessage?: (command: string, output: string, messageId: string) => void;
+    onCompleteBangMessage?: (command: string, exitCode: number, messageId: string) => void;
     onInfoBlockAdded?: (content: string) => void;
     onShowRewind?: () => void;
     onFileHistoryBlockAdded?: (snapshots: import("../types/reversion.js").FileSnapshot[]) => void;
@@ -151,6 +150,12 @@ export declare class MessageManager {
     addBangMessage(command: string): void;
     updateBangMessage(command: string, output: string): void;
     completeBangMessage(command: string, exitCode: number, output?: string): void;
+    /**
+     * Find the message ID of the most recent message containing a bang block
+     * for the given command. Bang callbacks do not carry a block ID, so the
+     * message is located by matching the command against bang blocks.
+     */
+    private findBangMessageId;
     addNotificationMessage(params: Omit<AddNotificationMessageParams, "messages">): void;
     /**
      * Rebuild usage array from messages containing usage metadata
@@ -169,7 +174,6 @@ export declare class MessageManager {
     /**
      * Finalize a streaming block of the given type by setting its stage to "end".
      * Fires the corresponding incremental callback with chunk="" to signal finalization.
-     * Does NOT call onMessagesChange — the caller is responsible for that.
      * Returns true if a block was finalized.
      */
     private finalizeStreamingBlock;

package/dist/managers/messageManager.js

@@ -181,7 +181,6 @@ export class MessageManager {
             this.extractFileReadsFromMessage(messages[messages.length - 1]);
             this.extractSkillInvocationsFromMessage(messages[messages.length - 1]);
         }
-        this.callbacks.onMessagesChange?.([...messages]);
     }
     /**
      * Save current session
@@ -194,6 +193,17 @@ export class MessageManager {
                 // No new messages to save
                 return;
             }
+            // CC-aligned lazy materialization: when the session file has not been
+            // materialized yet (no saved messages) and every unsaved message is a
+            // meta message (isMeta: true, e.g. SessionStart hook context), skip
+            // persistence. Persisting meta-only sessions would create "0 tokens /
+            // No content" ghost entries in the resume list. The meta messages stay
+            // in memory and are flushed together with the first real user/assistant
+            // message (matches CC's pendingEntries buffering).
+            if (this.savedMessageCount === 0 &&
+                unsavedMessages.every((m) => m.isMeta)) {
+                return;
+            }
             // Create session if needed (only when we have messages to save)
             if (this.savedMessageCount === 0) {
                 // This is the first time saving messages, so create the session
@@ -403,7 +413,9 @@ export class MessageManager {
             command,
         });
         this.setMessages(updatedMessages);
-        this.callbacks.onAddBangMessage?.(command);
+        // The bang message is appended as the last message
+        const messageId = this.messages[this.messages.length - 1]?.id ?? "";
+        this.callbacks.onAddBangMessage?.(command, messageId);
     }
     updateBangMessage(command, output) {
         const updatedMessages = updateBangInMessage({
@@ -412,7 +424,8 @@ export class MessageManager {
             output,
         });
         this.setMessages(updatedMessages);
-        this.callbacks.onUpdateBangMessage?.(command, output);
+        const messageId = this.findBangMessageId(command) ?? "";
+        this.callbacks.onUpdateBangMessage?.(command, output, messageId);
     }
     completeBangMessage(command, exitCode, output) {
         const updatedMessages = completeBangInMessage({
@@ -422,7 +435,24 @@ export class MessageManager {
             output,
         });
         this.setMessages(updatedMessages);
-        this.callbacks.onCompleteBangMessage?.(command, exitCode);
+        const messageId = this.findBangMessageId(command) ?? "";
+        this.callbacks.onCompleteBangMessage?.(command, exitCode, messageId);
+    }
+    /**
+     * Find the message ID of the most recent message containing a bang block
+     * for the given command. Bang callbacks do not carry a block ID, so the
+     * message is located by matching the command against bang blocks.
+     */
+    findBangMessageId(command) {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const message = this.messages[i];
+            if (message.role !== "user")
+                continue;
+            const hasBangBlock = message.blocks?.some((block) => block.type === "bang" && block.command === command);
+            if (hasBangBlock)
+                return message.id;
+        }
+        return undefined;
     }
     addNotificationMessage(params) {
         const newMessages = addNotificationMessageToMessages({
@@ -468,7 +498,6 @@ export class MessageManager {
     /**
      * Finalize a streaming block of the given type by setting its stage to "end".
      * Fires the corresponding incremental callback with chunk="" to signal finalization.
-     * Does NOT call onMessagesChange — the caller is responsible for that.
      * Returns true if a block was finalized.
      */
     finalizeStreamingBlock(lastMessage, type) {
@@ -552,7 +581,6 @@ export class MessageManager {
             stage: "streaming",
         });
         // Note: Subagent-specific callbacks are now handled by SubagentManager
-        this.callbacks.onMessagesChange?.([...this.messages]); // Still need to notify of changes
     }
     /**
      * Update the current assistant message reasoning during streaming
@@ -599,7 +627,6 @@ export class MessageManager {
             accumulated: newAccumulatedReasoning,
             stage: "streaming",
         });
-        this.callbacks.onMessagesChange?.([...this.messages]); // Still need to notify of changes
     }
     /**
      * Finalize streaming text/reasoning blocks by setting their stage to "end".
@@ -612,11 +639,8 @@ export class MessageManager {
         const lastMessage = this.messages[this.messages.length - 1];
         if (lastMessage.role !== "assistant")
             return;
-        const textFinalized = this.finalizeStreamingBlock(lastMessage, "text");
-        const reasoningFinalized = this.finalizeStreamingBlock(lastMessage, "reasoning");
-        if (textFinalized || reasoningFinalized) {
-            this.callbacks.onMessagesChange?.([...this.messages]);
-        }
+        this.finalizeStreamingBlock(lastMessage, "text");
+        this.finalizeStreamingBlock(lastMessage, "reasoning");
     }
     /**
      * Finalize any tool blocks still in a non-terminal stage (start/streaming/running)

package/dist/managers/subagentManager.d.ts

@@ -153,4 +153,10 @@ export declare class SubagentManager {
      * Extracted to reuse in both create and restore flows
      */
     private createSubagentCallbacks;
+    /**
+     * 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.
+     */
+    private refreshSubagentState;
 }

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/managers/toolManager.js

@@ -179,6 +179,11 @@ class ToolManager {
             workflowManager: this.container.has("WorkflowManager")
                 ? this.container.get("WorkflowManager")
                 : undefined,
+            sessionEnv: this.container.has("ConfigurationService")
+                ? this.container
+                    .get("ConfigurationService")
+                    ?.getMergedEnv?.()
+                : undefined,
             sessionId: context.sessionId,
             toolCallId: context.toolCallId,
         };

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;

package/dist/prompts/index.js

@@ -285,10 +285,6 @@ 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.`;
 export function buildSystemPrompt(basePrompt, tools, options = {}) {
     // --- Static block (cacheable) ---
     let staticText = basePrompt || DEFAULT_SYSTEM_PROMPT;

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