wave-code 0.10.0 → 0.10.2

package/dist/acp/agent.d.ts

@@ -1,14 +1,28 @@
-import type { Agent as AcpAgent, AgentSideConnection, InitializeResponse, NewSessionRequest, NewSessionResponse, LoadSessionRequest, LoadSessionResponse, PromptRequest, PromptResponse, CancelNotification, AuthenticateResponse } from "@agentclientprotocol/sdk";
+import { type Agent as AcpAgent, type AgentSideConnection, type InitializeResponse, type NewSessionRequest, type NewSessionResponse, type LoadSessionRequest, type LoadSessionResponse, type ListSessionsRequest, type ListSessionsResponse, type PromptRequest, type PromptResponse, type CancelNotification, type AuthenticateResponse, type SetSessionModeRequest, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse } from "@agentclientprotocol/sdk";
 export declare class WaveAcpAgent implements AcpAgent {
     private agents;
     private connection;
     constructor(connection: AgentSideConnection);
+    private getSessionModeState;
+    private getSessionConfigOptions;
+    private cleanupAllAgents;
     initialize(): Promise<InitializeResponse>;
     authenticate(): Promise<AuthenticateResponse | void>;
+    private createAgent;
     newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
     loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse>;
+    listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse>;
+    unstable_closeSession(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    extMethod(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    setSessionMode(params: SetSessionModeRequest): Promise<void>;
+    setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
     prompt(params: PromptRequest): Promise<PromptResponse>;
     cancel(params: CancelNotification): Promise<void>;
+    private handlePermissionRequest;
+    private getToolContentAsync;
+    private getToolContent;
+    private getToolLocations;
+    private getToolKind;
     private createCallbacks;
 }
 //# sourceMappingURL=agent.d.ts.map

package/dist/acp/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/acp/agent.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,KAAK,IAAI,QAAQ,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EAIrB,MAAM,0BAA0B,CAAC;AAElC,qBAAa,YAAa,YAAW,QAAQ;IAC3C,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,UAAU,CAAsB;gBAE5B,UAAU,EAAE,mBAAmB;IAIrC,UAAU,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAczC,YAAY,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAIpD,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAsClE,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAmCrE,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAuDtD,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IASvD,OAAO,CAAC,eAAe;CAuFxB"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/acp/agent.ts"],"names":[],"mappings":"AAeA,OAAO,EACL,KAAK,KAAK,IAAI,QAAQ,EACtB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAUzB,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,KAAK,8BAA8B,EAEpC,MAAM,0BAA0B,CAAC;AAElC,qBAAa,YAAa,YAAW,QAAQ;IAC3C,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,UAAU,CAAsB;gBAE5B,UAAU,EAAE,mBAAmB;IAI3C,OAAO,CAAC,mBAAmB;IA4B3B,OAAO,CAAC,uBAAuB;YAkBjB,gBAAgB;IASxB,UAAU,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAoBzC,YAAY,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;YAI5C,WAAW;IAiEnB,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAalE,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAWrE,YAAY,CAChB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,oBAAoB,CAAC;IAuB1B,qBAAqB,CACzB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAc7B,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAO7B,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAS5D,sBAAsB,CAC1B,MAAM,EAAE,6BAA6B,GACpC,OAAO,CAAC,8BAA8B,CAAC;IAgBpC,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAiDtD,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;YASzC,uBAAuB;YAgHvB,mBAAmB;IA6EjC,OAAO,CAAC,cAAc;IAqCtB,OAAO,CAAC,gBAAgB;IAmCxB,OAAO,CAAC,WAAW;IAmBnB,OAAO,CAAC,eAAe;CAgMxB"}

package/dist/acp/agent.js

@@ -1,12 +1,67 @@
-import { Agent as WaveAgent } from "wave-agent-sdk";
+import { Agent as WaveAgent, listSessions as listWaveSessions, listAllSessions as listAllWaveSessions, deleteSession as deleteWaveSession, truncateContent, } from "wave-agent-sdk";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { logger } from "../utils/logger.js";
+import { AGENT_METHODS, } from "@agentclientprotocol/sdk";
 export class WaveAcpAgent {
     constructor(connection) {
         this.agents = new Map();
         this.connection = connection;
     }
+    getSessionModeState(agent) {
+        return {
+            currentModeId: agent.getPermissionMode(),
+            availableModes: [
+                {
+                    id: "default",
+                    name: "Default",
+                    description: "Ask for permission for restricted tools",
+                },
+                {
+                    id: "acceptEdits",
+                    name: "Accept Edits",
+                    description: "Automatically accept file edits",
+                },
+                {
+                    id: "plan",
+                    name: "Plan",
+                    description: "Plan mode for complex tasks",
+                },
+                {
+                    id: "bypassPermissions",
+                    name: "Bypass Permissions",
+                    description: "Automatically accept all tool calls",
+                },
+            ],
+        };
+    }
+    getSessionConfigOptions(agent) {
+        return [
+            {
+                id: "permission_mode",
+                name: "Permission Mode",
+                type: "select",
+                category: "mode",
+                currentValue: agent.getPermissionMode(),
+                options: [
+                    { value: "default", name: "Default" },
+                    { value: "acceptEdits", name: "Accept Edits" },
+                    { value: "plan", name: "Plan" },
+                    { value: "bypassPermissions", name: "Bypass Permissions" },
+                ],
+            },
+        ];
+    }
+    async cleanupAllAgents() {
+        logger.info("Cleaning up all active agents due to connection closure");
+        const destroyPromises = Array.from(this.agents.values()).map((agent) => agent.destroy());
+        await Promise.all(destroyPromises);
+        this.agents.clear();
+    }
     async initialize() {
         logger.info("Initializing WaveAcpAgent");
+        // Setup cleanup on connection closure
+        this.connection.closed.then(() => this.cleanupAllAgents());
         return {
             protocolVersion: 1,
             agentInfo: {
@@ -15,18 +70,29 @@ export class WaveAcpAgent {
             },
             agentCapabilities: {
                 loadSession: true,
+                sessionCapabilities: {
+                    list: {},
+                    close: {},
+                },
             },
         };
     }
     async authenticate() {
         // No authentication required for now
     }
-    async newSession(params) {
-        const { cwd } = params;
-        logger.info(`Creating new session in ${cwd}`);
+    async createAgent(sessionId, cwd) {
         const callbacks = {};
+        const agentRef = {};
         const agent = await WaveAgent.create({
             workdir: cwd,
+            restoreSessionId: sessionId,
+            stream: false,
+            canUseTool: (context) => {
+                if (!agentRef.instance) {
+                    throw new Error("Agent instance not yet initialized");
+                }
+                return this.handlePermissionRequest(agentRef.instance.sessionId, context);
+            },
             callbacks: {
                 onAssistantContentUpdated: (chunk) => callbacks.onAssistantContentUpdated?.(chunk, ""),
                 onAssistantReasoningUpdated: (chunk) => callbacks.onAssistantReasoningUpdated?.(chunk, ""),
@@ -34,46 +100,113 @@ export class WaveAcpAgent {
                     const cb = callbacks.onToolBlockUpdated;
                     cb?.(params);
                 },
-                onTasksChange: (tasks) => {
-                    const cb = callbacks.onTasksChange;
-                    cb?.(tasks);
-                },
+                onTasksChange: (tasks) => callbacks.onTasksChange?.(tasks),
+                onPermissionModeChange: (mode) => callbacks.onPermissionModeChange?.(mode),
             },
         });
-        const sessionId = agent.sessionId;
-        logger.info(`New session created: ${sessionId}`);
-        this.agents.set(sessionId, agent);
+        agentRef.instance = agent;
+        const actualSessionId = agent.sessionId;
+        this.agents.set(actualSessionId, agent);
         // Update the callbacks object with the correct sessionId
-        Object.assign(callbacks, this.createCallbacks(sessionId));
+        Object.assign(callbacks, this.createCallbacks(actualSessionId));
+        // Send initial available commands after agent creation
+        // Use setImmediate to ensure the client receives the session response before the update
+        setImmediate(() => {
+            this.connection.sessionUpdate({
+                sessionId: actualSessionId,
+                update: {
+                    sessionUpdate: "available_commands_update",
+                    availableCommands: agent.getSlashCommands().map((cmd) => ({
+                        name: cmd.name,
+                        description: cmd.description,
+                        input: {
+                            hint: "Enter arguments...",
+                        },
+                    })),
+                },
+            });
+        });
+        return agent;
+    }
+    async newSession(params) {
+        const { cwd } = params;
+        logger.info(`Creating new session in ${cwd}`);
+        const agent = await this.createAgent(undefined, cwd);
+        logger.info(`New session created with ID: ${agent.sessionId}`);
         return {
-            sessionId: sessionId,
+            sessionId: agent.sessionId,
+            modes: this.getSessionModeState(agent),
+            configOptions: this.getSessionConfigOptions(agent),
         };
     }
     async loadSession(params) {
-        const { sessionId } = params;
-        logger.info(`Loading session: ${sessionId}`);
-        const callbacks = {};
-        const agent = await WaveAgent.create({
-            restoreSessionId: sessionId,
-            callbacks: {
-                onAssistantContentUpdated: (chunk) => callbacks.onAssistantContentUpdated?.(chunk, ""),
-                onAssistantReasoningUpdated: (chunk) => callbacks.onAssistantReasoningUpdated?.(chunk, ""),
-                onToolBlockUpdated: (params) => {
-                    const cb = callbacks.onToolBlockUpdated;
-                    cb?.(params);
-                },
-                onTasksChange: (tasks) => {
-                    const cb = callbacks.onTasksChange;
-                    cb?.(tasks);
-                },
-            },
-        });
-        this.agents.set(sessionId, agent);
-        logger.info(`Session loaded: ${sessionId}`);
-        // Update the callbacks object with the correct sessionId
-        Object.assign(callbacks, this.createCallbacks(sessionId));
+        const { sessionId, cwd } = params;
+        logger.info(`Loading session: ${sessionId} in ${cwd}`);
+        const agent = await this.createAgent(sessionId, cwd);
+        return {
+            modes: this.getSessionModeState(agent),
+            configOptions: this.getSessionConfigOptions(agent),
+        };
+    }
+    async listSessions(params) {
+        const { cwd } = params;
+        logger.info(`listSessions called with params: ${JSON.stringify(params)}`);
+        let waveSessions;
+        if (!cwd) {
+            logger.info("listSessions called without cwd, listing all sessions");
+            waveSessions = await listAllWaveSessions();
+        }
+        else {
+            logger.info(`Listing sessions for ${cwd}`);
+            waveSessions = await listWaveSessions(cwd);
+        }
+        logger.info(`Found ${waveSessions.length} sessions`);
+        const sessions = waveSessions.map((meta) => ({
+            sessionId: meta.id,
+            cwd: meta.workdir,
+            title: meta.firstMessage ? truncateContent(meta.firstMessage) : undefined,
+            updatedAt: meta.lastActiveAt.toISOString(),
+        }));
+        return { sessions };
+    }
+    async unstable_closeSession(params) {
+        const sessionId = params.sessionId;
+        logger.info(`Stopping session ${sessionId}`);
+        const agent = this.agents.get(sessionId);
+        if (agent) {
+            const workdir = agent.workingDirectory;
+            await agent.destroy();
+            this.agents.delete(sessionId);
+            // Delete the session file so it doesn't show up in listSessions
+            await deleteWaveSession(sessionId, workdir);
+        }
         return {};
     }
+    async extMethod(method, params) {
+        if (method === AGENT_METHODS.session_close) {
+            return this.unstable_closeSession(params);
+        }
+        throw new Error(`Method ${method} not implemented`);
+    }
+    async setSessionMode(params) {
+        const { sessionId, modeId } = params;
+        const agent = this.agents.get(sessionId);
+        if (!agent)
+            throw new Error(`Session ${sessionId} not found`);
+        agent.setPermissionMode(modeId);
+    }
+    async setSessionConfigOption(params) {
+        const { sessionId, configId, value } = params;
+        const agent = this.agents.get(sessionId);
+        if (!agent)
+            throw new Error(`Session ${sessionId} not found`);
+        if (configId === "permission_mode") {
+            agent.setPermissionMode(value);
+        }
+        return {
+            configOptions: this.getSessionConfigOptions(agent),
+        };
+    }
     async prompt(params) {
         const { sessionId, prompt } = params;
         logger.info(`Received prompt for session ${sessionId}`);
@@ -99,8 +232,6 @@ export class WaveAcpAgent {
         try {
             logger.info(`Sending message to agent: ${textContent.substring(0, 50)}...`);
             await agent.sendMessage(textContent, images.length > 0 ? images : undefined);
-            // Force save session so it can be loaded later
-            await agent.messageManager.saveSession();
             logger.info(`Message sent successfully for session ${sessionId}`);
             return {
                 stopReason: "end_turn",
@@ -125,7 +256,243 @@ export class WaveAcpAgent {
             agent.abortMessage();
         }
     }
+    async handlePermissionRequest(sessionId, context) {
+        logger.info(`Handling permission request for ${context.toolName} in session ${sessionId}`);
+        const agent = this.agents.get(sessionId);
+        const workdir = agent?.workingDirectory || process.cwd();
+        const toolCallId = context.toolCallId ||
+            "perm-" + Math.random().toString(36).substring(2, 9);
+        let effectiveName = context.toolName;
+        let effectiveCompactParams = undefined;
+        if (agent?.messages && context.toolCallId) {
+            const toolBlock = agent.messages
+                .flatMap((m) => m.blocks)
+                .find((b) => b.type === "tool" && b.id === context.toolCallId);
+            if (toolBlock) {
+                effectiveName = toolBlock.name || effectiveName;
+                effectiveCompactParams =
+                    toolBlock.compactParams || effectiveCompactParams;
+            }
+        }
+        const displayTitle = effectiveName && effectiveCompactParams
+            ? `${effectiveName}: ${effectiveCompactParams}`
+            : effectiveName || "Tool Call";
+        const options = [
+            {
+                optionId: "allow_once",
+                name: "Allow Once",
+                kind: "allow_once",
+            },
+            {
+                optionId: "allow_always",
+                name: "Allow Always",
+                kind: "allow_always",
+            },
+            {
+                optionId: "reject_once",
+                name: "Reject Once",
+                kind: "reject_once",
+            },
+        ];
+        const content = context.toolName
+            ? await this.getToolContentAsync(context.toolName, context.toolInput, workdir)
+            : undefined;
+        const locations = context.toolName
+            ? this.getToolLocations(context.toolName, context.toolInput)
+            : undefined;
+        const kind = context.toolName
+            ? this.getToolKind(context.toolName)
+            : undefined;
+        try {
+            const response = await this.connection.requestPermission({
+                sessionId: sessionId,
+                toolCall: {
+                    toolCallId,
+                    title: displayTitle,
+                    status: "pending",
+                    rawInput: context.toolInput,
+                    content,
+                    locations,
+                    kind,
+                },
+                options,
+            });
+            if (response.outcome.outcome === "cancelled") {
+                return { behavior: "deny", message: "Cancelled by user" };
+            }
+            const selectedOptionId = response.outcome.optionId;
+            logger.info(`User selected permission option: ${selectedOptionId}`);
+            switch (selectedOptionId) {
+                case "allow_always":
+                    return {
+                        behavior: "allow",
+                        newPermissionRule: `${context.toolName}(*)`,
+                    };
+                case "allow_once":
+                    return { behavior: "allow" };
+                case "reject_once":
+                    return { behavior: "deny", message: "Rejected by user" };
+                default:
+                    return { behavior: "deny", message: "Unknown option selected" };
+            }
+        }
+        catch (error) {
+            logger.error("Error requesting permission via ACP:", error);
+            return {
+                behavior: "deny",
+                message: `Error requesting permission: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async getToolContentAsync(name, parameters, workdir) {
+        if (!parameters)
+            return undefined;
+        if (name === "Write") {
+            let oldText = null;
+            try {
+                const filePath = (parameters.file_path ||
+                    parameters.filePath);
+                const fullPath = path.isAbsolute(filePath)
+                    ? filePath
+                    : path.join(workdir, filePath);
+                oldText = await fs.readFile(fullPath, "utf-8");
+            }
+            catch {
+                // File might not exist, which is fine for Write
+            }
+            return [
+                {
+                    type: "diff",
+                    path: (parameters.file_path || parameters.filePath),
+                    oldText,
+                    newText: parameters.content,
+                },
+            ];
+        }
+        if (name === "Edit") {
+            let oldText = null;
+            let newText = null;
+            try {
+                const filePath = (parameters.file_path ||
+                    parameters.filePath);
+                const fullPath = path.isAbsolute(filePath)
+                    ? filePath
+                    : path.join(workdir, filePath);
+                oldText = await fs.readFile(fullPath, "utf-8");
+                if (oldText) {
+                    if (parameters.replace_all) {
+                        newText = oldText
+                            .split(parameters.old_string)
+                            .join(parameters.new_string);
+                    }
+                    else {
+                        newText = oldText.replace(parameters.old_string, parameters.new_string);
+                    }
+                }
+            }
+            catch {
+                logger.error("Failed to read file for Edit diff");
+            }
+            if (oldText && newText) {
+                return [
+                    {
+                        type: "diff",
+                        path: (parameters.file_path || parameters.filePath),
+                        oldText,
+                        newText,
+                    },
+                ];
+            }
+            // Fallback to snippets if file reading fails
+            return [
+                {
+                    type: "diff",
+                    path: (parameters.file_path || parameters.filePath),
+                    oldText: parameters.old_string,
+                    newText: parameters.new_string,
+                },
+            ];
+        }
+        return this.getToolContent(name, parameters, undefined);
+    }
+    getToolContent(name, parameters, shortResult) {
+        const contents = [];
+        if (parameters) {
+            if (name === "Write") {
+                contents.push({
+                    type: "diff",
+                    path: (parameters.file_path || parameters.filePath),
+                    oldText: null,
+                    newText: parameters.content,
+                });
+            }
+            else if (name === "Edit") {
+                contents.push({
+                    type: "diff",
+                    path: (parameters.file_path || parameters.filePath),
+                    oldText: parameters.old_string,
+                    newText: parameters.new_string,
+                });
+            }
+        }
+        if (shortResult) {
+            contents.push({
+                type: "content",
+                content: {
+                    type: "text",
+                    text: shortResult,
+                },
+            });
+        }
+        return contents.length > 0 ? contents : undefined;
+    }
+    getToolLocations(name, parameters, extraStartLineNumber) {
+        if (!parameters)
+            return undefined;
+        if (name === "Write" ||
+            name === "Edit" ||
+            name === "Read" ||
+            name === "LSP") {
+            const filePath = (parameters.file_path || parameters.filePath);
+            let line = extraStartLineNumber ??
+                parameters.startLineNumber ??
+                parameters.line ??
+                parameters.offset;
+            if (name === "Write" && line === undefined) {
+                line = 1;
+            }
+            if (filePath) {
+                return [
+                    {
+                        path: filePath,
+                        line: line,
+                    },
+                ];
+            }
+        }
+        return undefined;
+    }
+    getToolKind(name) {
+        switch (name) {
+            case "Read":
+            case "Glob":
+            case "Grep":
+            case "LSP":
+                return "read";
+            case "Write":
+            case "Edit":
+                return "edit";
+            case "Bash":
+                return "execute";
+            case "Agent":
+                return "other";
+            default:
+                return "other";
+        }
+    }
     createCallbacks(sessionId) {
+        const getAgent = () => this.agents.get(sessionId);
+        const toolStates = new Map();
         return {
             onAssistantContentUpdated: (chunk) => {
                 this.connection.sessionUpdate({
@@ -152,15 +519,59 @@ export class WaveAcpAgent {
                 });
             },
             onToolBlockUpdated: (params) => {
-                const { id, name, stage, success, error, result } = params;
+                const { id, name, stage, success, error, result, parameters, compactParams, shortResult, startLineNumber, } = params;
+                let state = toolStates.get(id);
+                if (!state) {
+                    state = {};
+                    toolStates.set(id, state);
+                }
+                if (name)
+                    state.name = name;
+                if (compactParams)
+                    state.compactParams = compactParams;
+                if (shortResult)
+                    state.shortResult = shortResult;
+                if (startLineNumber !== undefined)
+                    state.startLineNumber = startLineNumber;
+                const effectiveName = state.name || name;
+                const effectiveCompactParams = state.compactParams || compactParams;
+                const effectiveShortResult = state.shortResult || shortResult;
+                const effectiveStartLineNumber = state.startLineNumber !== undefined
+                    ? state.startLineNumber
+                    : startLineNumber;
+                const displayTitle = effectiveName && effectiveCompactParams
+                    ? `${effectiveName}: ${effectiveCompactParams}`
+                    : effectiveName || "Tool Call";
+                let parsedParameters = undefined;
+                if (parameters) {
+                    try {
+                        parsedParameters = JSON.parse(parameters);
+                    }
+                    catch {
+                        // Ignore parse errors during streaming
+                    }
+                }
+                const content = effectiveName && (parsedParameters || effectiveShortResult)
+                    ? this.getToolContent(effectiveName, parsedParameters, effectiveShortResult)
+                    : undefined;
+                const locations = effectiveName && parsedParameters
+                    ? this.getToolLocations(effectiveName, parsedParameters, effectiveStartLineNumber)
+                    : undefined;
+                const kind = effectiveName
+                    ? this.getToolKind(effectiveName)
+                    : undefined;
                 if (stage === "start") {
                     this.connection.sessionUpdate({
                         sessionId: sessionId,
                         update: {
                             sessionUpdate: "tool_call",
                             toolCallId: id,
-                            title: name || "Tool Call",
+                            title: displayTitle,
                             status: "pending",
+                            content,
+                            locations,
+                            kind,
+                            rawInput: parsedParameters,
                         },
                     });
                     return;
@@ -182,10 +593,17 @@ export class WaveAcpAgent {
                         sessionUpdate: "tool_call_update",
                         toolCallId: id,
                         status,
-                        title: name || "Tool Call",
+                        title: displayTitle,
                         rawOutput: result || error,
+                        content,
+                        locations,
+                        kind,
+                        rawInput: parsedParameters,
                     },
                 });
+                if (stage === "end") {
+                    toolStates.delete(id);
+                }
             },
             onTasksChange: (tasks) => {
                 this.connection.sessionUpdate({
@@ -204,6 +622,25 @@ export class WaveAcpAgent {
                     },
                 });
             },
+            onPermissionModeChange: (mode) => {
+                this.connection.sessionUpdate({
+                    sessionId: sessionId,
+                    update: {
+                        sessionUpdate: "current_mode_update",
+                        currentModeId: mode,
+                    },
+                });
+                const agent = getAgent();
+                if (agent) {
+                    this.connection.sessionUpdate({
+                        sessionId: sessionId,
+                        update: {
+                            sessionUpdate: "config_option_update",
+                            configOptions: this.getSessionConfigOptions(agent),
+                        },
+                    });
+                }
+            },
         };
     }
 }

package/dist/components/ChatInterface.js

@@ -39,7 +39,7 @@ export const ChatInterface = () => {
         }
         const terminalHeight = stdout?.rows || 24;
         const totalHeight = detailsHeight + selectorHeight + dynamicBlocksHeight;
-        if (totalHeight > terminalHeight) {
+        if (totalHeight > terminalHeight - 3) {
             setIsConfirmationTooTall(true);
         }
     }, [

package/dist/components/DiffDisplay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DiffDisplay.d.ts","sourceRoot":"","sources":["../../src/components/DiffDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAMvC,UAAU,gBAAgB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CA0VlD,CAAC"}
+{"version":3,"file":"DiffDisplay.d.ts","sourceRoot":"","sources":["../../src/components/DiffDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAYvC,UAAU,gBAAgB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CA6WlD,CAAC"}