wave-agent-sdk 0.17.9 → 0.17.11

package/builtin/skills/settings/ENV.md

@@ -27,7 +27,7 @@ Wave uses several environment variables to control its core functionality.
 | `WAVE_CUSTOM_HEADERS` | Custom HTTP headers for the AI gateway. Newline-separated `Key: Value` pairs (e.g., `"X-Foo: bar\nAuthorization: Bearer xxx"`). | - |
 | `WAVE_MODEL` | The primary AI model to use for the agent. | `gemini-3-flash` |
 | `WAVE_FAST_MODEL` | The fast AI model to use for quick tasks. | `gemini-2.5-flash` |
-| `WAVE_MAX_INPUT_TOKENS` | Maximum number of input tokens allowed. | `128000` |
+| `WAVE_MAX_INPUT_TOKENS` | Maximum number of input tokens allowed. | `200000` |
 | `WAVE_MAX_OUTPUT_TOKENS` | Maximum number of output tokens allowed. | `16384` |
 | `WAVE_DISABLE_AUTO_MEMORY` | Set to `1` or `true` to disable the auto-memory feature. | `false` |
 | `WAVE_AUTO_MEMORY_FREQUENCY` | Auto memory update frequency. `1` = every turn, `2` = every 2 turns, etc. | `1` |

package/dist/managers/aiManager.d.ts

@@ -31,6 +31,8 @@ export declare class AIManager {
     private originalWorkdir;
     private consecutiveCompactionFailures;
     private readonly maxTurns?;
+    /** Tracks file mtime/hash at read time for staleness detection on Edit/Write */
+    private readFileState;
     /** Override tool_choice for this AI manager (e.g. for structured output) */
     toolChoiceOverride?: "auto" | "none" | "required" | {
         type: "function";
@@ -69,11 +71,11 @@ export declare class AIManager {
      */
     private getFilteredToolsConfig;
     /**
-     * Build plan mode system-reminder messages to inject into the API message stream.
-     * These are transient messages not stored in the message history.
-     * This preserves prompt caching by keeping the system prompt constant.
+     * Add plan mode reminder as a persistent meta message to the message manager.
+     * Called before getMessages() so the stored message is included in the API call.
      */
-    private buildPlanModeMessages;
+    private maybeAddPlanModeMessage;
+    private maybeInjectTaskReminderIntoMessages;
     setIsLoading(isLoading: boolean): void;
     abortAIMessage(): void;
     private generateCompactParams;
@@ -108,6 +110,11 @@ export declare class AIManager {
      * @returns Promise<boolean> - true if should continue conversation, false if should stop
      */
     private executeStopHooks;
+    /**
+     * Execute a single tool call: arg parsing, block emission, PreToolUse hooks,
+     * tool execution, PostToolUse hooks, and error handling.
+     */
+    private executeToolCall;
     /**
      * Execute PreToolUse hooks before tool execution
      * Returns true if hooks allow tool execution, false if blocked

package/dist/managers/aiManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aiManager.d.ts","sourceRoot":"","sources":["../../src/managers/aiManager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"aiManager.d.ts","sourceRoot":"","sources":["../../src/managers/aiManager.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,KAAK,EAGN,MAAM,mBAAmB,CAAC;AAkB3B,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAclD,MAAM,WAAW,kBAAkB;IACjC,uBAAuB,CAAC,EAAE,CAAC,YAAY,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1D,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACtC,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,kBAAkB,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,SAAS;IA2BlB,OAAO,CAAC,SAAS;IA1BZ,SAAS,EAAE,OAAO,CAAS;IAClC,OAAO,CAAC,eAAe,CAAgC;IACvD,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,OAAO,CAAC,mBAAmB,CAAgC;IAC3D,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,YAAY,CAAC,CAA2B;IAChD,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,6BAA6B,CAAa;IAClD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAS;IACnC,gFAAgF;IAChF,OAAO,CAAC,aAAa,CAGjB;IACJ,4EAA4E;IACrE,kBAAkB,CAAC,EACtB,MAAM,GACN,MAAM,GACN,UAAU,GACV;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;gBAI3C,SAAS,EAAE,SAAS,EAC5B,OAAO,EAAE,gBAAgB;IAY3B,OAAO,KAAK,WAAW,GAEtB;IAED,OAAO,KAAK,cAAc,GAEzB;IAED,OAAO,KAAK,aAAa,GAIxB;IAED,OAAO,KAAK,WAAW,GAItB;IAED,OAAO,KAAK,qBAAqB,GAEhC;IAED,OAAO,KAAK,WAAW,GAEtB;IAED,OAAO,KAAK,gBAAgB,GAM3B;IAED,OAAO,KAAK,iBAAiB,GAE5B;IAED,OAAO,KAAK,WAAW,GAMtB;IAED,OAAO,KAAK,oBAAoB,GAE/B;IAGM,gBAAgB,IAAI,aAAa;IAIjC,cAAc,IAAI,WAAW;IA6B7B,iBAAiB,IAAI,MAAM;IAI3B,WAAW,IAAI,MAAM,GAAG,SAAS;IAIjC,oBAAoB,IAAI,OAAO;IAI/B,UAAU,IAAI,MAAM;IAIpB,kBAAkB,IAAI,MAAM;IAInC;;;OAGG;IACI,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAKpC,cAAc,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAI/D,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,SAAS,CAAqB;IAEtC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;OAGG;IACH,OAAO,CAAC,uBAAuB;YA+CjB,mCAAmC;IAuB1C,YAAY,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI;IAUtC,cAAc,IAAI,IAAI;IAuB7B,OAAO,CAAC,qBAAqB;YAuBf,6BAA6B;IAsC3C;;;OAGG;IACU,mBAAmB,CAC9B,OAAO,GAAE;QACP,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;KACtB,GACL,OAAO,CAAC,IAAI,CAAC;IAuKhB;;;OAGG;YACW,uBAAuB;IAwH9B,eAAe,IAAI,OAAO;IAI1B,eAAe,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI;IAOnD,OAAO,KAAK,eAAe,GAE1B;IAED,OAAO,KAAK,YAAY,GAEvB;IAEY,aAAa,CACxB,OAAO,GAAE;QACP,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,oEAAoE;QACpE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;KACf,GACL,OAAO,CAAC,IAAI,CAAC;IA2mBhB;;;;OAIG;YACW,gBAAgB;IAkF9B;;;OAGG;YACW,eAAe;IAoM7B;;;OAGG;YACW,sBAAsB;IAsEpC;;OAEG;YACW,uBAAuB;CA2DtC"}

package/dist/managers/aiManager.js

@@ -3,7 +3,7 @@ import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { microcompactMessages } from "../utils/microcompact.js";
 import { parseTaskNotificationXml } from "../utils/notificationXml.js";
 import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
-import * as fs from "node:fs/promises";
+import { getTaskReminderTurnCounts, maybeInjectTaskReminder, TASK_REMINDER_CONFIG, } from "../utils/taskReminder.js";
 import { existsSync } from "node:fs";
 import { buildSystemPrompt } from "../prompts/index.js";
 import { buildPlanModeReminder, buildPlanModeReEntryReminder, buildExitedPlanModeReminder, } from "../prompts/planModeReminders.js";
@@ -19,6 +19,8 @@ export class AIManager {
         this.abortController = null;
         this.toolAbortController = null;
         this.consecutiveCompactionFailures = 0;
+        /** Tracks file mtime/hash at read time for staleness detection on Edit/Write */
+        this.readFileState = new Map();
         this.isCompacting = false;
         this.systemPrompt = options.systemPrompt;
         this.subagentType = options.subagentType; // Store subagent type
@@ -122,50 +124,62 @@ export class AIManager {
         });
     }
     /**
-     * Build plan mode system-reminder messages to inject into the API message stream.
-     * These are transient messages not stored in the message history.
-     * This preserves prompt caching by keeping the system prompt constant.
+     * Add plan mode reminder as a persistent meta message to the message manager.
+     * Called before getMessages() so the stored message is included in the API call.
      */
-    buildPlanModeMessages(currentMode) {
-        const messages = [];
+    maybeAddPlanModeMessage(currentMode) {
         if (!this.permissionManager)
-            return messages;
+            return;
         // Handle exit notification (one-time after leaving plan mode)
         if (this.permissionManager.getNeedsPlanModeExitAttachment()) {
             const planFilePath = this.permissionManager.getPlanFilePath();
             const planExists = planFilePath ? existsSync(planFilePath) : false;
-            messages.push({
-                role: "user",
+            this.messageManager.addUserMessage({
                 content: buildExitedPlanModeReminder(planFilePath, planExists),
+                isMeta: true,
             });
             this.permissionManager.setNeedsPlanModeExitAttachment(false);
         }
         if (currentMode !== "plan")
-            return messages;
+            return;
         const planFilePath = this.permissionManager.getPlanFilePath();
         if (!planFilePath)
-            return messages;
+            return;
         const planExists = existsSync(planFilePath);
         // One-time plan entry reminder
         const planMgr = this.planManager;
         if (planMgr?.isPlanEntryReminderPending()) {
             if (this.permissionManager.hasExitedPlanModeInSession() && planExists) {
                 // Re-entry: use small reminder
-                messages.push({
-                    role: "user",
+                this.messageManager.addUserMessage({
                     content: buildPlanModeReEntryReminder(planFilePath),
+                    isMeta: true,
                 });
             }
             else {
                 // First entry: use full reminder
-                messages.push({
-                    role: "user",
+                this.messageManager.addUserMessage({
                     content: buildPlanModeReminder(planFilePath, planExists, !!this.subagentType),
+                    isMeta: true,
                 });
             }
             planMgr.consumePlanEntryReminder();
         }
-        return messages;
+    }
+    async maybeInjectTaskReminderIntoMessages(messages, toolNames) {
+        // Guard: no task tools available
+        if (!toolNames.has("TaskUpdate"))
+            return;
+        const internalMessages = this.messageManager.getMessages();
+        const turnCounts = getTaskReminderTurnCounts(internalMessages);
+        if (turnCounts.turnsSinceLastTaskManagement <
+            TASK_REMINDER_CONFIG.TURNS_SINCE_WRITE ||
+            turnCounts.turnsSinceLastReminder <
+                TASK_REMINDER_CONFIG.TURNS_BETWEEN_REMINDERS) {
+            return;
+        }
+        const tasks = await this.taskManager.listTasks();
+        maybeInjectTaskReminder(messages, turnCounts, tasks);
     }
     setIsLoading(isLoading) {
         this.isLoading = isLoading;
@@ -299,6 +313,18 @@ export class AIManager {
             const enhancedSummary = await this.buildPostCompactContext(compactResult.content);
             // 7. Execute message reconstruction
             this.messageManager.compactMessagesAndUpdateSession(enhancedSummary, compactUsage);
+            // Re-add plan mode reminder as persistent meta message after compaction
+            const postCompactMode = this.permissionManager?.getCurrentEffectiveMode(this.getModelConfig().permissionMode);
+            if (postCompactMode === "plan") {
+                const planFilePath = this.permissionManager?.getPlanFilePath();
+                if (planFilePath) {
+                    const planExists = existsSync(planFilePath);
+                    this.messageManager.addUserMessage({
+                        content: buildPlanModeReminder(planFilePath, planExists, !!this.subagentType),
+                        isMeta: true,
+                    });
+                }
+            }
             // 8. Track usage
             if (compactUsage && this.callbacks?.onUsageAdded) {
                 this.callbacks.onUsageAdded(compactUsage);
@@ -376,22 +402,6 @@ export class AIManager {
             if (usedTokens >= POST_COMPACT_TOKEN_BUDGET)
                 break;
         }
-        // 2. Plan mode context
-        const currentMode = this.permissionManager?.getCurrentEffectiveMode(this.getModelConfig().permissionMode);
-        if (currentMode === "plan") {
-            const planFilePath = this.permissionManager?.getPlanFilePath();
-            if (planFilePath) {
-                let planExists = false;
-                try {
-                    await fs.access(planFilePath);
-                    planExists = true;
-                }
-                catch {
-                    // Plan file doesn't exist yet
-                }
-                contextParts.push(`\n\n${buildPlanModeReminder(planFilePath, planExists, !!this.subagentType)}`);
-            }
-        }
         // 4. Invoked skills context (with token budget, matching Claude Code)
         const POST_COMPACT_SKILLS_TOKEN_BUDGET = 25000;
         const POST_COMPACT_MAX_TOKENS_PER_SKILL = 5000;
@@ -549,6 +559,10 @@ export class AIManager {
             abortController = this.abortController;
             toolAbortController = this.toolAbortController;
         }
+        // Get current permission mode
+        const currentMode = this.permissionManager?.getCurrentEffectiveMode(this.getModelConfig().permissionMode);
+        // Add plan mode reminder as persistent meta message before getting messages
+        this.maybeAddPlanModeMessage(currentMode);
         // Get recent message history with microcompact applied
         const rawMessages = this.messageManager.getMessages();
         const microcompactedMessages = microcompactMessages(rawMessages, {
@@ -562,19 +576,11 @@ export class AIManager {
             // Track if assistant message has been created
             let assistantMessageCreated = false;
             logger?.debug("modelConfig in sendAIMessage", this.getModelConfig());
-            // Get current permission mode and plan file path
-            const currentMode = this.permissionManager?.getCurrentEffectiveMode(this.getModelConfig().permissionMode);
             const toolsConfig = this.getFilteredToolsConfig();
             const toolNames = new Set(toolsConfig.map((t) => t.function.name));
             const filteredToolPlugins = this.toolManager
                 .getTools()
                 .filter((t) => toolNames.has(t.name));
-            // Inject plan mode system-reminder messages (not system prompt)
-            // This preserves prompt caching by keeping the system prompt constant
-            const planModeMessages = this.buildPlanModeMessages(currentMode);
-            if (planModeMessages.length > 0) {
-                recentMessages.push(...planModeMessages);
-            }
             let autoMemoryOptions;
             if (this.getAutoMemoryEnabled()) {
                 const directory = this.memoryService.getAutoMemoryDirectory(this.getWorkdir());
@@ -603,6 +609,8 @@ export class AIManager {
                 maxTokens: maxTokens, // Pass max tokens override
                 toolChoice: this.toolChoiceOverride, // Pass tool_choice override
             };
+            // Inject task reminder if needed (not persisted, regenerated each turn)
+            await this.maybeInjectTaskReminderIntoMessages(callAgentOptions.messages, toolNames);
             // Add streaming callbacks only if streaming is enabled
             if (this.stream) {
                 callAgentOptions.onContentUpdate = (content) => {
@@ -719,170 +727,34 @@ export class AIManager {
                 }
             }
             if (toolCalls.length > 0) {
-                // Execute all tools in parallel using Promise.all
-                const toolExecutionPromises = toolCalls.map(async (functionToolCall) => {
-                    const toolId = functionToolCall.id || "";
-                    // Check if already interrupted, skip tool execution if so
-                    if (abortController.signal.aborted ||
-                        toolAbortController.signal.aborted) {
-                        return;
-                    }
-                    const toolName = functionToolCall.function?.name || "";
-                    // Safely parse tool parameters, handle tools without parameters
-                    let toolArgs = {};
-                    let jsonRecovered = false;
-                    const argsString = functionToolCall.function?.arguments?.trim();
-                    if (!argsString || argsString === "") {
-                        // Tool without parameters, use empty object
-                        toolArgs = {};
+                // Partition tool calls into batches: consecutive concurrency-safe
+                // tools run in parallel, non-safe tools (Edit, Write, MCP) run one
+                // at a time to prevent read-modify-write races on the same file.
+                const batches = [];
+                for (const call of toolCalls) {
+                    const toolName = call.function?.name || "";
+                    const safe = this.toolManager.isConcurrencySafe(toolName);
+                    const lastBatch = batches[batches.length - 1];
+                    if (lastBatch && lastBatch.safe && safe) {
+                        lastBatch.calls.push(call);
                     }
                     else {
-                        let recoveredArgs = argsString;
-                        try {
-                            toolArgs = JSON.parse(argsString);
-                        }
-                        catch {
-                            // Attempt to recover truncated JSON (e.g., missing closing braces)
-                            recoveredArgs = recoverTruncatedJson(argsString);
-                            try {
-                                toolArgs = JSON.parse(recoveredArgs);
-                                jsonRecovered = true;
-                                logger.warn(`Recovered truncated JSON for tool "${toolName}"`);
-                            }
-                            catch (parseError) {
-                                let errorMessage = `Failed to parse tool arguments`;
-                                if (result.finish_reason === "length") {
-                                    errorMessage +=
-                                        " (output truncated, please reduce your output)";
-                                }
-                                logger?.error(errorMessage, parseError);
-                                this.messageManager.updateToolBlock({
-                                    id: toolId,
-                                    parameters: argsString,
-                                    result: errorMessage,
-                                    success: false,
-                                    error: errorMessage,
-                                    stage: "end",
-                                    name: toolName,
-                                    compactParams: "",
-                                    timestamp: Date.now(),
-                                });
-                                return;
-                            }
-                        }
+                        batches.push({ calls: [call], safe });
                     }
-                    const compactParams = this.generateCompactParams(toolName, toolArgs);
-                    // Emit start stage for non-streaming tool calls
-                    if (!this.stream) {
-                        this.messageManager.updateToolBlock({
-                            id: toolId,
-                            stage: "start",
-                            name: toolName,
-                            compactParams,
-                            parameters: argsString,
-                        });
+                }
+                // Execute batches sequentially; within a safe batch, tools run in parallel
+                for (const batch of batches) {
+                    if (abortController.signal.aborted ||
+                        toolAbortController.signal.aborted) {
+                        break;
                     }
-                    // Emit running stage (tool execution about to start)
-                    this.messageManager.updateToolBlock({
-                        id: toolId,
-                        stage: "running",
-                        name: toolName,
-                        compactParams,
-                        parameters: argsString,
-                        parametersChunk: "",
-                    });
-                    try {
-                        // Execute PreToolUse hooks before tool execution
-                        const shouldExecuteTool = await this.executePreToolUseHooks(toolName, toolArgs, toolId);
-                        // If PreToolUse hooks blocked execution, skip tool execution
-                        if (!shouldExecuteTool) {
-                            logger?.info(`Tool ${toolName} execution blocked by PreToolUse hooks`);
-                            return; // Skip this tool and return from this map function
-                        }
-                        // Create tool execution context
-                        const context = {
-                            abortSignal: toolAbortController.signal,
-                            backgroundTaskManager: this.backgroundTaskManager,
-                            workdir: this.getWorkdir(),
-                            originalWorkdir: this.originalWorkdir,
-                            env: this.container.get("MergedEnv"),
-                            messageId: this.messageManager.getMessages().slice(-1)[0]?.id,
-                            sessionId: this.messageManager.getSessionId(),
-                            toolCallId: toolId,
-                            taskManager: this.taskManager,
-                            onShortResultUpdate: (shortResult) => {
-                                this.messageManager.updateToolBlock({
-                                    id: toolId,
-                                    shortResult,
-                                    stage: "running", // Keep it in running stage while updating shortResult
-                                });
-                            },
-                            onResultUpdate: (result) => {
-                                this.messageManager.updateToolBlock({
-                                    id: toolId,
-                                    result,
-                                    stage: "running", // Keep it in running stage while updating result
-                                });
-                            },
-                            onCwdChange: async (newCwd) => {
-                                const oldCwd = this.getWorkdir();
-                                this.container.register("Workdir", newCwd);
-                                this._onCwdChange?.(newCwd);
-                                if (this.hookManager) {
-                                    const sessionId = this.messageManager.getSessionId();
-                                    const transcriptPath = this.messageManager.getTranscriptPath();
-                                    const env = Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined));
-                                    await this.hookManager.executeCwdChangedHooks(oldCwd, newCwd, sessionId, transcriptPath, env);
-                                }
-                            },
-                        };
-                        // Execute tool
-                        const toolResult = await this.toolManager.execute(functionToolCall.function?.name || "", toolArgs, context);
-                        // Build result content, adding truncation warning if JSON was recovered
-                        let toolResultContent = toolResult.content ||
-                            (toolResult.error ? `Error: ${toolResult.error}` : "");
-                        if (jsonRecovered) {
-                            toolResultContent +=
-                                "\n\nTool arguments were truncated (likely exceeded max output tokens). Please reduce your output or split into multiple tool calls.";
-                        }
-                        // Update message state - tool execution completed
-                        this.messageManager.updateToolBlock({
-                            id: toolId,
-                            parameters: argsString,
-                            result: toolResultContent,
-                            success: toolResult.success,
-                            error: toolResult.error,
-                            stage: "end",
-                            name: toolName,
-                            compactParams,
-                            shortResult: toolResult.shortResult,
-                            isManuallyBackgrounded: toolResult.isManuallyBackgrounded,
-                            startLineNumber: toolResult.startLineNumber,
-                            timestamp: Date.now(),
-                        });
-                        // Execute PostToolUse hooks after successful tool completion
-                        await this.executePostToolUseHooks(toolId, toolName, toolArgs, toolResult);
+                    if (batch.calls.length === 1) {
+                        await this.executeToolCall(batch.calls[0], abortController, toolAbortController, result.finish_reason);
                     }
-                    catch (toolError) {
-                        const errorMessage = toolError instanceof Error
-                            ? toolError.message
-                            : String(toolError);
-                        this.messageManager.updateToolBlock({
-                            id: toolId,
-                            parameters: JSON.stringify(toolArgs, null, 2),
-                            result: `Tool execution failed: ${errorMessage}`,
-                            success: false,
-                            error: errorMessage,
-                            stage: "end",
-                            name: toolName,
-                            compactParams,
-                            isManuallyBackgrounded: false,
-                            timestamp: Date.now(),
-                        });
+                    else {
+                        await Promise.all(batch.calls.map((call) => this.executeToolCall(call, abortController, toolAbortController, result.finish_reason)));
                     }
-                });
-                // Wait for all tools to complete execution in parallel
-                await Promise.all(toolExecutionPromises);
+                }
             }
             // Handle token statistics and message compaction
             await this.handleTokenUsageAndCompaction(result.usage, abortController);
@@ -1172,6 +1044,167 @@ export class AIManager {
             return false;
         }
     }
+    /**
+     * Execute a single tool call: arg parsing, block emission, PreToolUse hooks,
+     * tool execution, PostToolUse hooks, and error handling.
+     */
+    async executeToolCall(functionToolCall, abortController, toolAbortController, finishReason) {
+        const toolId = functionToolCall.id || "";
+        // Check if already interrupted, skip tool execution if so
+        if (abortController.signal.aborted || toolAbortController.signal.aborted) {
+            return;
+        }
+        const toolName = functionToolCall.function?.name || "";
+        // Safely parse tool parameters, handle tools without parameters
+        let toolArgs = {};
+        let jsonRecovered = false;
+        const argsString = functionToolCall.function?.arguments?.trim();
+        if (!argsString || argsString === "") {
+            // Tool without parameters, use empty object
+            toolArgs = {};
+        }
+        else {
+            let recoveredArgs = argsString;
+            try {
+                toolArgs = JSON.parse(argsString);
+            }
+            catch {
+                // Attempt to recover truncated JSON (e.g., missing closing braces)
+                recoveredArgs = recoverTruncatedJson(argsString);
+                try {
+                    toolArgs = JSON.parse(recoveredArgs);
+                    jsonRecovered = true;
+                    logger.warn(`Recovered truncated JSON for tool "${toolName}"`);
+                }
+                catch (parseError) {
+                    let errorMessage = `Failed to parse tool arguments`;
+                    if (finishReason === "length") {
+                        errorMessage += " (output truncated, please reduce your output)";
+                    }
+                    logger?.error(errorMessage, parseError);
+                    this.messageManager.updateToolBlock({
+                        id: toolId,
+                        parameters: argsString,
+                        result: errorMessage,
+                        success: false,
+                        error: errorMessage,
+                        stage: "end",
+                        name: toolName,
+                        compactParams: "",
+                        timestamp: Date.now(),
+                    });
+                    return;
+                }
+            }
+        }
+        const compactParams = this.generateCompactParams(toolName, toolArgs);
+        // Emit start stage for non-streaming tool calls
+        if (!this.stream) {
+            this.messageManager.updateToolBlock({
+                id: toolId,
+                stage: "start",
+                name: toolName,
+                compactParams,
+                parameters: argsString,
+            });
+        }
+        // Emit running stage (tool execution about to start)
+        this.messageManager.updateToolBlock({
+            id: toolId,
+            stage: "running",
+            name: toolName,
+            compactParams,
+            parameters: argsString,
+            parametersChunk: "",
+        });
+        try {
+            // Execute PreToolUse hooks before tool execution
+            const shouldExecuteTool = await this.executePreToolUseHooks(toolName, toolArgs, toolId);
+            // If PreToolUse hooks blocked execution, skip tool execution
+            if (!shouldExecuteTool) {
+                logger?.info(`Tool ${toolName} execution blocked by PreToolUse hooks`);
+                return;
+            }
+            // Create tool execution context
+            const context = {
+                abortSignal: toolAbortController.signal,
+                backgroundTaskManager: this.backgroundTaskManager,
+                workdir: this.getWorkdir(),
+                originalWorkdir: this.originalWorkdir,
+                messageId: this.messageManager.getMessages().slice(-1)[0]?.id,
+                sessionId: this.messageManager.getSessionId(),
+                toolCallId: toolId,
+                taskManager: this.taskManager,
+                readFileState: this.readFileState,
+                onShortResultUpdate: (shortResult) => {
+                    this.messageManager.updateToolBlock({
+                        id: toolId,
+                        shortResult,
+                        stage: "running",
+                    });
+                },
+                onResultUpdate: (result) => {
+                    this.messageManager.updateToolBlock({
+                        id: toolId,
+                        result,
+                        stage: "running",
+                    });
+                },
+                onCwdChange: async (newCwd) => {
+                    const oldCwd = this.getWorkdir();
+                    this.container.register("Workdir", newCwd);
+                    this._onCwdChange?.(newCwd);
+                    if (this.hookManager) {
+                        const sessionId = this.messageManager.getSessionId();
+                        const transcriptPath = this.messageManager.getTranscriptPath();
+                        const env = Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined));
+                        await this.hookManager.executeCwdChangedHooks(oldCwd, newCwd, sessionId, transcriptPath, env);
+                    }
+                },
+            };
+            // Execute tool
+            const toolResult = await this.toolManager.execute(functionToolCall.function?.name || "", toolArgs, context);
+            // Build result content, adding truncation warning if JSON was recovered
+            let toolResultContent = toolResult.content ||
+                (toolResult.error ? `Error: ${toolResult.error}` : "");
+            if (jsonRecovered) {
+                toolResultContent +=
+                    "\n\nTool arguments were truncated (likely exceeded max output tokens). Please reduce your output or split into multiple tool calls.";
+            }
+            // Update message state - tool execution completed
+            this.messageManager.updateToolBlock({
+                id: toolId,
+                parameters: argsString,
+                result: toolResultContent,
+                success: toolResult.success,
+                error: toolResult.error,
+                stage: "end",
+                name: toolName,
+                compactParams,
+                shortResult: toolResult.shortResult,
+                isManuallyBackgrounded: toolResult.isManuallyBackgrounded,
+                startLineNumber: toolResult.startLineNumber,
+                timestamp: Date.now(),
+            });
+            // Execute PostToolUse hooks after successful tool completion
+            await this.executePostToolUseHooks(toolId, toolName, toolArgs, toolResult);
+        }
+        catch (toolError) {
+            const errorMessage = toolError instanceof Error ? toolError.message : String(toolError);
+            this.messageManager.updateToolBlock({
+                id: toolId,
+                parameters: JSON.stringify(toolArgs, null, 2),
+                result: `Tool execution failed: ${errorMessage}`,
+                success: false,
+                error: errorMessage,
+                stage: "end",
+                name: toolName,
+                compactParams,
+                isManuallyBackgrounded: false,
+                timestamp: Date.now(),
+            });
+        }
+    }
     /**
      * Execute PreToolUse hooks before tool execution
      * Returns true if hooks allow tool execution, false if blocked
@@ -1243,8 +1276,7 @@ export class AIManager {
                 toolResponse,
                 subagentType: this.subagentType, // Include subagent type in hook context
                 planFilePath: this.permissionManager?.getPlanFilePath(),
-                env: this.container.get("MergedEnv") ||
-                    process.env,
+                env: Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined)), // Include environment variables
             };
             const results = await this.hookManager.executeHooks("PostToolUse", context);
             // Process hook results to handle exit codes and update tool results

package/dist/managers/backgroundTaskManager.js

@@ -39,7 +39,7 @@ export class BackgroundTaskManager {
             stdio: "pipe",
             detached: true,
             cwd: this.workdir,
-            env: this.container.get("MergedEnv") || {
+            env: {
                 ...process.env,
             },
         });

package/dist/managers/bangManager.js

@@ -25,7 +25,7 @@ export class BangManager {
                 shell: true,
                 stdio: "pipe",
                 cwd: this.workdir,
-                env: this.container.get("MergedEnv") || {
+                env: {
                     ...process.env,
                 },
             });

package/dist/managers/hookManager.js

@@ -718,8 +718,7 @@ export class HookManager {
             transcriptPath,
             cwd: this.workdir,
             endSource: source,
-            env: this.container.get("MergedEnv") ||
-                process.env,
+            env: Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined)),
         };
         const results = await this.executeHooks("SessionEnd", context);
         // Process results but never block shutdown
@@ -768,8 +767,7 @@ export class HookManager {
             transcriptPath,
             cwd: this.workdir,
             compactSummary,
-            env: this.container.get("MergedEnv") ||
-                process.env,
+            env: Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined)),
         };
         const results = await this.executeHooks("PostCompact", context);
         if (results.length > 0) {