wave-code 0.10.0 → 0.10.1

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":"AAaA,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;IA8CnB,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA8BlE,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA4BrE,YAAY,CAChB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,oBAAoB,CAAC;IAmB1B,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;YAsGvB,mBAAmB;IA2EjC,OAAO,CAAC,cAAc;IA4BtB,OAAO,CAAC,gBAAgB;IAgBxB,OAAO,CAAC,WAAW;IAmBnB,OAAO,CAAC,eAAe;CAsIxB"}

package/dist/acp/agent.js

@@ -1,12 +1,67 @@
-import { Agent as WaveAgent } from "wave-agent-sdk";
+import { Agent as WaveAgent, listSessions as listWaveSessions, deleteSession as deleteWaveSession, } 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,28 @@ 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,
+            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 +99,124 @@ 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));
+        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}`);
+        // Send initial available commands after agent creation
+        setImmediate(() => {
+            this.connection.sessionUpdate({
+                sessionId: agent.sessionId,
+                update: {
+                    sessionUpdate: "available_commands_update",
+                    availableCommands: agent.getSlashCommands().map((cmd) => ({
+                        name: cmd.name,
+                        description: cmd.description,
+                        input: {
+                            hint: "Enter arguments...",
+                        },
+                    })),
+                },
+            });
+        });
         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);
+        const { sessionId, cwd } = params;
+        logger.info(`Loading session: ${sessionId} in ${cwd}`);
+        const agent = await this.createAgent(sessionId, cwd);
+        // Send initial available commands after agent creation
+        setImmediate(() => {
+            this.connection.sessionUpdate({
+                sessionId: agent.sessionId,
+                update: {
+                    sessionUpdate: "available_commands_update",
+                    availableCommands: agent.getSlashCommands().map((cmd) => ({
+                        name: cmd.name,
+                        description: cmd.description,
+                        input: {
+                            hint: "Enter arguments...",
+                        },
+                    })),
                 },
-            },
+            });
         });
-        this.agents.set(sessionId, agent);
-        logger.info(`Session loaded: ${sessionId}`);
-        // Update the callbacks object with the correct sessionId
-        Object.assign(callbacks, this.createCallbacks(sessionId));
+        return {
+            modes: this.getSessionModeState(agent),
+            configOptions: this.getSessionConfigOptions(agent),
+        };
+    }
+    async listSessions(params) {
+        const { cwd } = params;
+        logger.info(`listSessions called with params: ${JSON.stringify(params)}`);
+        if (!cwd) {
+            logger.warn("listSessions called without cwd, returning empty list");
+            return { sessions: [] };
+        }
+        logger.info(`Listing sessions for ${cwd}`);
+        const waveSessions = await listWaveSessions(cwd);
+        logger.info(`Found ${waveSessions.length} sessions for ${cwd}`);
+        const sessions = waveSessions.map((meta) => ({
+            sessionId: meta.id,
+            cwd: meta.workdir,
+            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 +242,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 +266,217 @@ 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);
+        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",
+            },
+            {
+                optionId: "reject_always",
+                name: "Reject Always",
+                kind: "reject_always",
+            },
+        ];
+        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: `Permission for ${context.toolName}`,
+                    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_once":
+                    return { behavior: "allow" };
+                case "allow_always":
+                    return {
+                        behavior: "allow",
+                        newPermissionRule: `${context.toolName}(*)`,
+                    };
+                case "reject_once":
+                    return { behavior: "deny", message: "Rejected by user" };
+                case "reject_always":
+                    return {
+                        behavior: "deny",
+                        message: "Rejected by user",
+                        newPermissionRule: `!${context.toolName}(*)`,
+                    };
+                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;
+                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,
+                    oldText,
+                    newText: parameters.content,
+                },
+            ];
+        }
+        if (name === "Edit") {
+            let oldText = null;
+            let newText = null;
+            try {
+                const filePath = parameters.file_path;
+                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,
+                        oldText,
+                        newText,
+                    },
+                ];
+            }
+            // Fallback to snippets if file reading fails
+            return [
+                {
+                    type: "diff",
+                    path: parameters.file_path,
+                    oldText: parameters.old_string,
+                    newText: parameters.new_string,
+                },
+            ];
+        }
+        return this.getToolContent(name, parameters);
+    }
+    getToolContent(name, parameters) {
+        if (!parameters)
+            return undefined;
+        if (name === "Write") {
+            return [
+                {
+                    type: "diff",
+                    path: parameters.file_path,
+                    oldText: null,
+                    newText: parameters.content,
+                },
+            ];
+        }
+        if (name === "Edit") {
+            return [
+                {
+                    type: "diff",
+                    path: parameters.file_path,
+                    oldText: parameters.old_string,
+                    newText: parameters.new_string,
+                },
+            ];
+        }
+        return undefined;
+    }
+    getToolLocations(name, parameters) {
+        if (!parameters)
+            return undefined;
+        if (name === "Write" || name === "Edit" || name === "Read") {
+            return [
+                {
+                    path: parameters.file_path,
+                    line: parameters.offset,
+                },
+            ];
+        }
+        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);
         return {
             onAssistantContentUpdated: (chunk) => {
                 this.connection.sessionUpdate({
@@ -152,7 +503,23 @@ export class WaveAcpAgent {
                 });
             },
             onToolBlockUpdated: (params) => {
-                const { id, name, stage, success, error, result } = params;
+                const { id, name, stage, success, error, result, parameters } = params;
+                let parsedParameters = undefined;
+                if (parameters) {
+                    try {
+                        parsedParameters = JSON.parse(parameters);
+                    }
+                    catch {
+                        // Ignore parse errors during streaming
+                    }
+                }
+                const content = name && parsedParameters
+                    ? this.getToolContent(name, parsedParameters)
+                    : undefined;
+                const locations = name && parsedParameters
+                    ? this.getToolLocations(name, parsedParameters)
+                    : undefined;
+                const kind = name ? this.getToolKind(name) : undefined;
                 if (stage === "start") {
                     this.connection.sessionUpdate({
                         sessionId: sessionId,
@@ -161,6 +528,10 @@ export class WaveAcpAgent {
                             toolCallId: id,
                             title: name || "Tool Call",
                             status: "pending",
+                            content,
+                            locations,
+                            kind,
+                            rawInput: parsedParameters,
                         },
                     });
                     return;
@@ -184,6 +555,10 @@ export class WaveAcpAgent {
                         status,
                         title: name || "Tool Call",
                         rawOutput: result || error,
+                        content,
+                        locations,
+                        kind,
+                        rawInput: parsedParameters,
                     },
                 });
             },
@@ -204,6 +579,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/contexts/useChat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useChat.d.ts","sourceRoot":"","sources":["../../src/contexts/useChat.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"useChat.d.ts","sourceRoot":"","sources":["../../src/contexts/useChat.tsx"],"names":[],"mappings":"AAAA,OAAO,KAON,MAAM,OAAO,CAAC;AAGf,OAAO,KAAK,EACV,OAAO,EACP,eAAe,EACf,cAAc,EACd,IAAI,EACJ,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACf,MAAM,gBAAgB,CAAC;AAUxB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,aAAa,EAAE,OAAO,CAAC;IAEvB,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,oBAAoB,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACjD,cAAc,EAAE,KAAK,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACpD,CAAC,CAAC;IAEH,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,CACX,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,KAC/C,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,IAAI,CAAC;IAE1B,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,gBAAgB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3D,mBAAmB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9D,eAAe,EAAE,cAAc,EAAE,CAAC;IAElC,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,uBAAuB,EAAE,CACvB,MAAM,EAAE,MAAM,KACX;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC/D,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IAEhD,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IAEhD,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;IAC5C,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7C,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;IAElD,qBAAqB,EAAE,OAAO,CAAC;IAC/B,cAAc,CAAC,EAAE;QACf,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAChC,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC,CAAC;IACF,gBAAgB,EAAE,CAChB,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,eAAe,CAAC,EAAE,MAAM,EACxB,oBAAoB,CAAC,EAAE,OAAO,KAC3B,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACjC,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,0BAA0B,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACnE,wBAAwB,EAAE,MAAM,IAAI,CAAC;IAErC,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAElC,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,oBAAoB,EAAE,MAAM,OAAO,CAAC;QAClC,QAAQ,EAAE,OAAO,EAAE,CAAC;QACpB,UAAU,EAAE,MAAM,EAAE,CAAC;KACtB,CAAC,CAAC;IACH,qBAAqB,EAAE,MAAM,CAAC;IAC9B,wBAAwB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvE,gBAAgB,EAAE,MAAM,OAAO,gBAAgB,EAAE,aAAa,CAAC;IAC/D,cAAc,EAAE,MAAM,OAAO,gBAAgB,EAAE,WAAW,CAAC;IAC3D,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAID,eAAO,MAAM,OAAO,uBAMnB,CAAC;AAEF,MAAM,WAAW,iBAAkB,SAAQ,YAAY;IACrD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAsiBpD,CAAC"}

package/dist/contexts/useChat.js

@@ -113,9 +113,6 @@ export const ChatProvider = ({ children, bypassPermissions, pluginDirs, tools, w
                 onPermissionModeChange: (mode) => {
                     setPermissionModeState(mode);
                 },
-                onSlashCommandsChange: (commands) => {
-                    setSlashCommands([...commands]);
-                },
             };
             try {
                 // Create the permission callback inside the try block to access showConfirmation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -39,9 +39,9 @@
     "react": "^19.2.4",
     "react-dom": "19.2.4",
     "yargs": "^17.7.2",
-    "@agentclientprotocol/sdk": "0.15.0",
+    "@agentclientprotocol/sdk": "0.16.1",
     "zod": "^3.23.8",
-    "wave-agent-sdk": "0.10.0"
+    "wave-agent-sdk": "0.10.1"
   },
   "devDependencies": {
     "@types/react": "^19.1.8",

package/src/acp/agent.ts

@@ -1,20 +1,43 @@
-import { Agent as WaveAgent, AgentOptions } from "wave-agent-sdk";
+import {
+  Agent as WaveAgent,
+  AgentOptions,
+  PermissionDecision,
+  ToolPermissionContext,
+  AgentToolBlockUpdateParams,
+  Task,
+  listSessions as listWaveSessions,
+  deleteSession as deleteWaveSession,
+} from "wave-agent-sdk";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { logger } from "../utils/logger.js";
-import type {
-  Agent as AcpAgent,
-  AgentSideConnection,
-  InitializeResponse,
-  NewSessionRequest,
-  NewSessionResponse,
-  LoadSessionRequest,
-  LoadSessionResponse,
-  PromptRequest,
-  PromptResponse,
-  CancelNotification,
-  AuthenticateResponse,
-  SessionId as AcpSessionId,
-  ToolCallStatus,
-  StopReason,
+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 SessionId as AcpSessionId,
+  type ToolCallStatus,
+  type StopReason,
+  type PermissionOption,
+  type SessionInfo,
+  type ToolCallContent,
+  type ToolCallLocation,
+  type ToolKind,
+  type SessionConfigOption,
+  type SetSessionModeRequest,
+  type SetSessionConfigOptionRequest,
+  type SetSessionConfigOptionResponse,
+  AGENT_METHODS,
 } from "@agentclientprotocol/sdk";
 
 export class WaveAcpAgent implements AcpAgent {
@@ -25,8 +48,65 @@ export class WaveAcpAgent implements AcpAgent {
     this.connection = connection;
   }
 
+  private getSessionModeState(agent: WaveAgent) {
+    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",
+        },
+      ],
+    };
+  }
+
+  private getSessionConfigOptions(agent: WaveAgent): SessionConfigOption[] {
+    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" },
+        ],
+      },
+    ];
+  }
+
+  private 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(): Promise<InitializeResponse> {
     logger.info("Initializing WaveAcpAgent");
+    // Setup cleanup on connection closure
+    this.connection.closed.then(() => this.cleanupAllAgents());
     return {
       protocolVersion: 1,
       agentInfo: {
@@ -35,6 +115,10 @@ export class WaveAcpAgent implements AcpAgent {
       },
       agentCapabilities: {
         loadSession: true,
+        sessionCapabilities: {
+          list: {},
+          close: {},
+        },
       },
     };
   }
@@ -43,12 +127,25 @@ export class WaveAcpAgent implements AcpAgent {
     // No authentication required for now
   }
 
-  async newSession(params: NewSessionRequest): Promise<NewSessionResponse> {
-    const { cwd } = params;
-    logger.info(`Creating new session in ${cwd}`);
+  private async createAgent(
+    sessionId: string | undefined,
+    cwd: string,
+  ): Promise<WaveAgent> {
     const callbacks: AgentOptions["callbacks"] = {};
+    const agentRef: { instance?: WaveAgent } = {};
+
     const agent = await WaveAgent.create({
       workdir: cwd,
+      restoreSessionId: sessionId,
+      canUseTool: (context) => {
+        if (!agentRef.instance) {
+          throw new Error("Agent instance not yet initialized");
+        }
+        return this.handlePermissionRequest(
+          agentRef.instance.sessionId,
+          context,
+        );
+      },
       callbacks: {
         onAssistantContentUpdated: (chunk: string) =>
           callbacks.onAssistantContentUpdated?.(chunk, ""),
@@ -60,62 +157,154 @@ export class WaveAcpAgent implements AcpAgent {
             | undefined;
           cb?.(params);
         },
-        onTasksChange: (tasks: unknown[]) => {
-          const cb = callbacks.onTasksChange as
-            | ((tasks: unknown[]) => void)
-            | undefined;
-          cb?.(tasks);
-        },
+        onTasksChange: (tasks) => callbacks.onTasksChange?.(tasks as Task[]),
+        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));
+
+    return agent;
+  }
+
+  async newSession(params: NewSessionRequest): Promise<NewSessionResponse> {
+    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}`);
+
+    // Send initial available commands after agent creation
+    setImmediate(() => {
+      this.connection.sessionUpdate({
+        sessionId: agent.sessionId as AcpSessionId,
+        update: {
+          sessionUpdate: "available_commands_update",
+          availableCommands: agent.getSlashCommands().map((cmd) => ({
+            name: cmd.name,
+            description: cmd.description,
+            input: {
+              hint: "Enter arguments...",
+            },
+          })),
+        },
+      });
+    });
 
     return {
-      sessionId: sessionId as AcpSessionId,
+      sessionId: agent.sessionId as AcpSessionId,
+      modes: this.getSessionModeState(agent),
+      configOptions: this.getSessionConfigOptions(agent),
     };
   }
 
   async loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse> {
-    const { sessionId } = params;
-    logger.info(`Loading session: ${sessionId}`);
-    const callbacks: AgentOptions["callbacks"] = {};
-    const agent = await WaveAgent.create({
-      restoreSessionId: sessionId,
-      callbacks: {
-        onAssistantContentUpdated: (chunk: string) =>
-          callbacks.onAssistantContentUpdated?.(chunk, ""),
-        onAssistantReasoningUpdated: (chunk: string) =>
-          callbacks.onAssistantReasoningUpdated?.(chunk, ""),
-        onToolBlockUpdated: (params: unknown) => {
-          const cb = callbacks.onToolBlockUpdated as
-            | ((params: unknown) => void)
-            | undefined;
-          cb?.(params);
-        },
-        onTasksChange: (tasks: unknown[]) => {
-          const cb = callbacks.onTasksChange as
-            | ((tasks: unknown[]) => void)
-            | undefined;
-          cb?.(tasks);
+    const { sessionId, cwd } = params;
+    logger.info(`Loading session: ${sessionId} in ${cwd}`);
+    const agent = await this.createAgent(sessionId, cwd);
+
+    // Send initial available commands after agent creation
+    setImmediate(() => {
+      this.connection.sessionUpdate({
+        sessionId: agent.sessionId as AcpSessionId,
+        update: {
+          sessionUpdate: "available_commands_update",
+          availableCommands: agent.getSlashCommands().map((cmd) => ({
+            name: cmd.name,
+            description: cmd.description,
+            input: {
+              hint: "Enter arguments...",
+            },
+          })),
         },
-      },
+      });
     });
 
-    this.agents.set(sessionId, agent);
-    logger.info(`Session loaded: ${sessionId}`);
+    return {
+      modes: this.getSessionModeState(agent),
+      configOptions: this.getSessionConfigOptions(agent),
+    };
+  }
+
+  async listSessions(
+    params: ListSessionsRequest,
+  ): Promise<ListSessionsResponse> {
+    const { cwd } = params;
+    logger.info(`listSessions called with params: ${JSON.stringify(params)}`);
+    if (!cwd) {
+      logger.warn("listSessions called without cwd, returning empty list");
+      return { sessions: [] };
+    }
 
-    // Update the callbacks object with the correct sessionId
-    Object.assign(callbacks, this.createCallbacks(sessionId));
+    logger.info(`Listing sessions for ${cwd}`);
+    const waveSessions = await listWaveSessions(cwd);
+    logger.info(`Found ${waveSessions.length} sessions for ${cwd}`);
+    const sessions: SessionInfo[] = waveSessions.map((meta) => ({
+      sessionId: meta.id as AcpSessionId,
+      cwd: meta.workdir,
+      updatedAt: meta.lastActiveAt.toISOString(),
+    }));
+    return { sessions };
+  }
 
+  async unstable_closeSession(
+    params: Record<string, unknown>,
+  ): Promise<Record<string, unknown>> {
+    const sessionId = params.sessionId as string;
+    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: string,
+    params: Record<string, unknown>,
+  ): Promise<Record<string, unknown>> {
+    if (method === AGENT_METHODS.session_close) {
+      return this.unstable_closeSession(params);
+    }
+    throw new Error(`Method ${method} not implemented`);
+  }
+
+  async setSessionMode(params: SetSessionModeRequest): Promise<void> {
+    const { sessionId, modeId } = params;
+    const agent = this.agents.get(sessionId);
+    if (!agent) throw new Error(`Session ${sessionId} not found`);
+    agent.setPermissionMode(
+      modeId as "default" | "acceptEdits" | "plan" | "bypassPermissions",
+    );
+  }
+
+  async setSessionConfigOption(
+    params: SetSessionConfigOptionRequest,
+  ): Promise<SetSessionConfigOptionResponse> {
+    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 as "default" | "acceptEdits" | "plan" | "bypassPermissions",
+      );
+    }
+
+    return {
+      configOptions: this.getSessionConfigOptions(agent),
+    };
+  }
+
   async prompt(params: PromptRequest): Promise<PromptResponse> {
     const { sessionId, prompt } = params;
     logger.info(`Received prompt for session ${sessionId}`);
@@ -149,12 +338,6 @@ export class WaveAcpAgent implements AcpAgent {
         textContent,
         images.length > 0 ? images : undefined,
       );
-      // Force save session so it can be loaded later
-      await (
-        agent as unknown as {
-          messageManager: { saveSession: () => Promise<void> };
-        }
-      ).messageManager.saveSession();
       logger.info(`Message sent successfully for session ${sessionId}`);
       return {
         stopReason: "end_turn" as StopReason,
@@ -180,7 +363,248 @@ export class WaveAcpAgent implements AcpAgent {
     }
   }
 
+  private async handlePermissionRequest(
+    sessionId: string,
+    context: ToolPermissionContext,
+  ): Promise<PermissionDecision> {
+    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);
+
+    const options: PermissionOption[] = [
+      {
+        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",
+      },
+      {
+        optionId: "reject_always",
+        name: "Reject Always",
+        kind: "reject_always",
+      },
+    ];
+
+    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 as AcpSessionId,
+        toolCall: {
+          toolCallId,
+          title: `Permission for ${context.toolName}`,
+          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_once":
+          return { behavior: "allow" };
+        case "allow_always":
+          return {
+            behavior: "allow",
+            newPermissionRule: `${context.toolName}(*)`,
+          };
+        case "reject_once":
+          return { behavior: "deny", message: "Rejected by user" };
+        case "reject_always":
+          return {
+            behavior: "deny",
+            message: "Rejected by user",
+            newPermissionRule: `!${context.toolName}(*)`,
+          };
+        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)}`,
+      };
+    }
+  }
+
+  private async getToolContentAsync(
+    name: string,
+    parameters: Record<string, unknown> | undefined,
+    workdir: string,
+  ): Promise<ToolCallContent[] | undefined> {
+    if (!parameters) return undefined;
+    if (name === "Write") {
+      let oldText: string | null = null;
+      try {
+        const filePath = parameters.file_path as string;
+        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 as string,
+          oldText,
+          newText: parameters.content as string,
+        },
+      ];
+    }
+    if (name === "Edit") {
+      let oldText: string | null = null;
+      let newText: string | null = null;
+      try {
+        const filePath = parameters.file_path as string;
+        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 as string)
+              .join(parameters.new_string as string);
+          } else {
+            newText = oldText.replace(
+              parameters.old_string as string,
+              parameters.new_string as string,
+            );
+          }
+        }
+      } catch {
+        logger.error("Failed to read file for Edit diff");
+      }
+
+      if (oldText && newText) {
+        return [
+          {
+            type: "diff",
+            path: parameters.file_path as string,
+            oldText,
+            newText,
+          },
+        ];
+      }
+
+      // Fallback to snippets if file reading fails
+      return [
+        {
+          type: "diff",
+          path: parameters.file_path as string,
+          oldText: parameters.old_string as string,
+          newText: parameters.new_string as string,
+        },
+      ];
+    }
+    return this.getToolContent(name, parameters);
+  }
+
+  private getToolContent(
+    name: string,
+    parameters: Record<string, unknown> | undefined,
+  ): ToolCallContent[] | undefined {
+    if (!parameters) return undefined;
+    if (name === "Write") {
+      return [
+        {
+          type: "diff",
+          path: parameters.file_path as string,
+          oldText: null,
+          newText: parameters.content as string,
+        },
+      ];
+    }
+    if (name === "Edit") {
+      return [
+        {
+          type: "diff",
+          path: parameters.file_path as string,
+          oldText: parameters.old_string as string,
+          newText: parameters.new_string as string,
+        },
+      ];
+    }
+    return undefined;
+  }
+
+  private getToolLocations(
+    name: string,
+    parameters: Record<string, unknown> | undefined,
+  ): ToolCallLocation[] | undefined {
+    if (!parameters) return undefined;
+    if (name === "Write" || name === "Edit" || name === "Read") {
+      return [
+        {
+          path: parameters.file_path as string,
+          line: parameters.offset as number,
+        },
+      ];
+    }
+    return undefined;
+  }
+
+  private getToolKind(name: string): ToolKind {
+    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";
+    }
+  }
+
   private createCallbacks(sessionId: string): AgentOptions["callbacks"] {
+    const getAgent = () => this.agents.get(sessionId);
     return {
       onAssistantContentUpdated: (chunk: string) => {
         this.connection.sessionUpdate({
@@ -206,8 +630,27 @@ export class WaveAcpAgent implements AcpAgent {
           },
         });
       },
-      onToolBlockUpdated: (params) => {
-        const { id, name, stage, success, error, result } = params;
+      onToolBlockUpdated: (params: AgentToolBlockUpdateParams) => {
+        const { id, name, stage, success, error, result, parameters } = params;
+
+        let parsedParameters: Record<string, unknown> | undefined = undefined;
+        if (parameters) {
+          try {
+            parsedParameters = JSON.parse(parameters);
+          } catch {
+            // Ignore parse errors during streaming
+          }
+        }
+
+        const content =
+          name && parsedParameters
+            ? this.getToolContent(name, parsedParameters)
+            : undefined;
+        const locations =
+          name && parsedParameters
+            ? this.getToolLocations(name, parsedParameters)
+            : undefined;
+        const kind = name ? this.getToolKind(name) : undefined;
 
         if (stage === "start") {
           this.connection.sessionUpdate({
@@ -217,6 +660,10 @@ export class WaveAcpAgent implements AcpAgent {
               toolCallId: id,
               title: name || "Tool Call",
               status: "pending",
+              content,
+              locations,
+              kind,
+              rawInput: parsedParameters,
             },
           });
           return;
@@ -244,6 +691,10 @@ export class WaveAcpAgent implements AcpAgent {
             status,
             title: name || "Tool Call",
             rawOutput: result || error,
+            content,
+            locations,
+            kind,
+            rawInput: parsedParameters,
           },
         });
       },
@@ -265,6 +716,25 @@ export class WaveAcpAgent implements AcpAgent {
           },
         });
       },
+      onPermissionModeChange: (mode) => {
+        this.connection.sessionUpdate({
+          sessionId: sessionId as AcpSessionId,
+          update: {
+            sessionUpdate: "current_mode_update",
+            currentModeId: mode,
+          },
+        });
+        const agent = getAgent();
+        if (agent) {
+          this.connection.sessionUpdate({
+            sessionId: sessionId as AcpSessionId,
+            update: {
+              sessionUpdate: "config_option_update",
+              configOptions: this.getSessionConfigOptions(agent),
+            },
+          });
+        }
+      },
     };
   }
 }

package/src/components/ChatInterface.tsx

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

package/src/contexts/useChat.tsx

@@ -295,9 +295,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         onPermissionModeChange: (mode) => {
           setPermissionModeState(mode);
         },
-        onSlashCommandsChange: (commands) => {
-          setSlashCommands([...commands]);
-        },
       };
 
       try {