Go back to SDK version 1.0.100 for #37976 for now

The SDK doesn't currently load [Claude Code's
`managed-settings.json`](https://docs.anthropic.com/en/docs/claude-code/settings#settings-files)
- now the adapter does (following [the rules in the
docs](https://docs.anthropic.com/en/docs/claude-code/settings#settings-files)),
but we can remove this once the SDK supports it.

.eslintignore

@@ -0,0 +1,6 @@
+node_modules/
+dist/
+coverage/
+*.min.js
+*.config.js
+.github/

.eslintrc.json

@@ -0,0 +1,33 @@
+{
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 2020,
+    "sourceType": "module",
+    "project": "./tsconfig.json"
+  },
+  "plugins": ["@typescript-eslint"],
+  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended", "prettier"],
+  "env": {
+    "node": true,
+    "es2020": true
+  },
+  "rules": {
+    "@typescript-eslint/explicit-function-return-type": "off",
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      {
+        "argsIgnorePattern": "^_"
+      }
+    ],
+    "no-console": "off",
+    "no-constant-condition": "off",
+    "default-case": "error",
+    "prefer-const": "error",
+    "no-var": "error",
+    "eqeqeq": ["error", "always"],
+    "curly": ["error", "all"]
+  },
+  "ignorePatterns": ["dist", "node_modules", "*.js"]
+}

.github/workflows/ci.yml

@@ -35,6 +35,9 @@ jobs:
       - name: Check formatting
         run: npm run format:check
 
+      - name: Run linter
+        run: npm run lint
+
       - name: Build
         run: npm run build
 

.prettierrc.json

@@ -0,0 +1,4 @@
+{
+  "printWidth": 100,
+  "tabWidth": 2
+}

README.md

@@ -1,3 +1,55 @@
-An ACP-compatible coding agent powered by the Claude Code SDK
+# ACP adapter for Claude Code
 
-This wrapper lets you use the real version of Claude Code from the IDE of your choice.
+[![npm](https://img.shields.io/npm/v/%40zed-industries%2Fclaude-code-acp)](https://www.npmjs.com/package/@zed-industries/claude-code-acp)
+
+Use [Claude Code](https://www.anthropic.com/claude-code) from [ACP-compatible](https://agentclientprotocol.com) clients such as [Zed](https://zed.dev)!
+
+This tool implements an ACP agent by using the official [Claude Code SDK](https://docs.anthropic.com/en/docs/claude-code/sdk/sdk-overview), supporting:
+
+- Context @-mentions
+- Images
+- Tool calls (with permission requests)
+- Following
+- Edit review
+- TODO lists
+- Interactive (and background) terminals
+- Custom [Slash commands](https://docs.anthropic.com/en/docs/claude-code/slash-commands)
+- Client MCP servers
+
+Learn more about the [Agent Client Protocol](https://agentclientprotocol.com/).
+
+## How to use
+
+### Zed
+
+The latest version of Zed can already use this adapter out of the box.
+
+To use Claude Code, open the Agent Panel and click "New Claude Code Thread" from the `+` button menu in the top-right:
+
+https://github.com/user-attachments/assets/ddce66c7-79ac-47a3-ad59-4a6a3ca74903
+
+Read the docs on [External Agent](https://zed.dev/docs/ai/external-agents) support.
+
+### Other clients
+
+- Neovim via [CodeCompanion.nvim](https://codecompanion.olimorris.dev/configuration/adapters#setup-claude-code-via-acp)
+
+[Submit a PR](https://github.com/zed-industries/claude-code-acp/pulls) to add yours!
+
+#### Installation
+
+Install the adapter from `npm`:
+
+```bash
+npm install @zed-industries/claude-code-acp
+```
+
+You can then use `claude-code-acp` as a regular ACP agent:
+
+```
+ANTHROPIC_API_KEY=sk-... claude-code-acp
+```
+
+## License
+
+Apache-2.0

package.json

@@ -6,16 +6,25 @@
   "bin": {
     "claude-code-acp": "./dist/index.js"
   },
-  "version": "0.1.7",
+  "version": "0.4.1",
   "description": "An ACP-compatible coding agent powered by the Claude Code SDK (TypeScript)",
   "main": "dist/index.js",
   "type": "module",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "npm run build && npm run start",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
+    "check": "npm run lint && npm run format:check",
     "test": "vitest",
     "test:integration": "RUN_INTEGRATION_TESTS=true vitest run",
     "test:run": "vitest run",
@@ -34,22 +43,27 @@
   "author": "Zed Industries",
   "license": "Apache-2.0",
   "dependencies": {
-    "@anthropic-ai/claude-code": "1.0.96",
-    "@modelcontextprotocol/sdk": "^1.17.4",
-    "@types/express": "^5.0.3",
-    "@zed-industries/agent-client-protocol": "0.2.0-alpha.4",
-    "express": "^5.1.0",
-    "minimist": "^1.2.8",
-    "uuid": "11.1.0"
+    "@anthropic-ai/claude-code": "1.0.100",
+    "@modelcontextprotocol/sdk": "1.17.5",
+    "@zed-industries/agent-client-protocol": "0.2.0-alpha.8",
+    "diff": "8.0.2",
+    "express": "5.1.0",
+    "minimist": "1.2.8",
+    "uuid": "13.0.0"
   },
   "devDependencies": {
-    "@types/minimist": "^1.2.5",
-    "@types/node": "^24.3.0",
-    "@types/uuid": "^10.0.0",
-    "@vitest/ui": "^3.2.4",
-    "prettier": "^3.6.2",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.4.0",
-    "vitest": "^3.2.4"
+    "@types/express": "5.0.3",
+    "@types/minimist": "1.2.5",
+    "@types/node": "24.3.1",
+    "@types/uuid": "10.0.0",
+    "@typescript-eslint/eslint-plugin": "8.43.0",
+    "@typescript-eslint/parser": "8.43.0",
+    "@vitest/ui": "3.2.4",
+    "eslint": "9.35.0",
+    "eslint-config-prettier": "10.1.8",
+    "prettier": "3.6.2",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.2",
+    "vitest": "3.2.4"
   }
 }

src/acp-agent.ts

@@ -14,6 +14,8 @@ import {
   ReadTextFileRequest,
   ReadTextFileResponse,
   RequestError,
+  SetSessionModeRequest,
+  SetSessionModeResponse,
   TerminalHandle,
   TerminalOutputResponse,
   WriteTextFileRequest,
@@ -22,31 +24,27 @@ import {
 import {
   McpServerConfig,
   Options,
+  PermissionMode,
   Query,
   query,
   SDKAssistantMessage,
   SDKUserMessage,
 } from "@anthropic-ai/claude-code";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
 import { v7 as uuidv7 } from "uuid";
-import {
-  nodeToWebReadable,
-  nodeToWebWritable,
-  Pushable,
-  unreachable,
-} from "./utils.js";
+import { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
 import { SessionNotification } from "@zed-industries/agent-client-protocol";
-import { createMcpServer } from "./mcp-server.js";
+import { createMcpServer, toolNames } from "./mcp-server.js";
 import { AddressInfo } from "node:net";
-import {
-  toolInfoFromToolUse,
-  planEntries,
-  toolUpdateFromToolResult,
-} from "./tools.js";
+import { toolInfoFromToolUse, planEntries, toolUpdateFromToolResult } from "./tools.js";
 
 type Session = {
   query: Query;
   input: Pushable<SDKUserMessage>;
   cancelled: boolean;
+  permissionMode: PermissionMode;
 };
 
 type BackgroundTerminal =
@@ -60,14 +58,18 @@ type BackgroundTerminal =
       pendingOutput: TerminalOutputResponse;
     };
 
+type ToolUseCache = {
+  [key: string]: { type: "tool_use"; id: string; name: string; input: any };
+};
+
 // Implement the ACP Agent interface
 export class ClaudeAcpAgent implements Agent {
   sessions: {
     [key: string]: Session;
   };
   client: AgentSideConnection;
-  toolUseCache: { [key: string]: any };
-  fileContentCache: { [key: string]: any };
+  toolUseCache: ToolUseCache;
+  fileContentCache: { [key: string]: string };
   backgroundTerminals: { [key: string]: BackgroundTerminal } = {};
   clientCapabilities?: ClientCapabilities;
 
@@ -88,45 +90,57 @@ export class ClaudeAcpAgent implements Agent {
           image: true,
           embeddedContext: true,
         },
+        mcpCapabilities: {
+          http: true,
+          sse: true,
+        },
       },
       authMethods: [
         {
           description: "Run `claude /login` in the terminal",
-          name: "Login with Claude CLI",
+          name: "Log in with Claude Code",
           id: "claude-login",
         },
-        {
-          description: "Anthropic API KEY",
-          name: "Use Anthropic API Key",
-          id: "anthropic-api-key",
-        },
       ],
     };
   }
   async newSession(params: NewSessionRequest): Promise<NewSessionResponse> {
-    let sessionId = uuidv7();
-    let input = new Pushable<SDKUserMessage>();
+    if (
+      fs.existsSync(path.resolve(os.homedir(), ".claude.json.backup")) &&
+      !fs.existsSync(path.resolve(os.homedir(), ".claude.json"))
+    ) {
+      throw RequestError.authRequired();
+    }
+
+    const sessionId = uuidv7();
+    const input = new Pushable<SDKUserMessage>();
 
     const mcpServers: Record<string, McpServerConfig> = {};
     if (Array.isArray(params.mcpServers)) {
       for (const server of params.mcpServers) {
-        mcpServers[server.name] = {
-          type: "stdio",
-          command: server.command,
-          args: server.args,
-          env: server.env
-            ? Object.fromEntries(server.env.map((e) => [e.name, e.value]))
-            : undefined,
-        };
+        if ("type" in server) {
+          mcpServers[server.name] = {
+            type: server.type,
+            url: server.url,
+            headers: server.headers
+              ? Object.fromEntries(server.headers.map((e) => [e.name, e.value]))
+              : undefined,
+          };
+        } else {
+          mcpServers[server.name] = {
+            type: "stdio",
+            command: server.command,
+            args: server.args,
+            env: server.env
+              ? Object.fromEntries(server.env.map((e) => [e.name, e.value]))
+              : undefined,
+          };
+        }
       }
     }
 
-    let server = await createMcpServer(
-      this,
-      sessionId,
-      this.clientCapabilities,
-    );
-    let address = server.address() as AddressInfo;
+    const server = await createMcpServer(this, sessionId, this.clientCapabilities);
+    const address = server.address() as AddressInfo;
     mcpServers["acp"] = {
       type: "http",
       url: "http://127.0.0.1:" + address.port + "/mcp",
@@ -135,25 +149,28 @@ export class ClaudeAcpAgent implements Agent {
       },
     };
 
-    let options: Options = {
+    const options: Options = {
       cwd: params.cwd,
       mcpServers,
-      permissionPromptToolName: "mcp__acp__permission",
+      permissionPromptToolName: toolNames.permission,
       stderr: (err) => console.error(err),
+      // note: although not documented by the types, passing an absolute path
+      // here works to find zed's managed node version.
+      executable: process.execPath as any,
     };
 
     const allowedTools = [];
     const disallowedTools = [];
     if (this.clientCapabilities?.fs?.readTextFile) {
-      allowedTools.push("mcp__acp__read");
+      allowedTools.push(toolNames.read);
       disallowedTools.push("Read");
     }
     if (this.clientCapabilities?.fs?.writeTextFile) {
-      allowedTools.push("mcp__acp__write");
+      allowedTools.push(toolNames.write);
       disallowedTools.push("Write", "Edit", "MultiEdit");
     }
     if (this.clientCapabilities?.terminal) {
-      allowedTools.push("mcp__acp__BashOutput", "mcp__acp__KillBash");
+      allowedTools.push(toolNames.bashOutput, toolNames.killBash);
       disallowedTools.push("Bash", "BashOutput", "KillBash");
     }
 
@@ -164,7 +181,7 @@ export class ClaudeAcpAgent implements Agent {
       options.disallowedTools = disallowedTools;
     }
 
-    let q = query({
+    const q = query({
       prompt: input,
       options,
     });
@@ -172,12 +189,46 @@ export class ClaudeAcpAgent implements Agent {
       query: q,
       input: input,
       cancelled: false,
+      permissionMode: "default",
     };
 
-    const availableCommands = await availableSlashCommands(q);
+    getAvailableSlashCommands(q).then((availableCommands) => {
+      this.client.sessionUpdate({
+        sessionId,
+        update: {
+          sessionUpdate: "available_commands_update",
+          availableCommands,
+        },
+      });
+    });
+
     return {
       sessionId,
-      availableCommands,
+      modes: {
+        currentModeId: "default",
+        availableModes: [
+          {
+            id: "default",
+            name: "Always Ask",
+            description: "Prompts for permission on first use of each tool",
+          },
+          {
+            id: "acceptEdits",
+            name: "Accept Edits",
+            description: "Automatically accepts file edit permissions for the session",
+          },
+          {
+            id: "bypassPermissions",
+            name: "Bypass Permissions",
+            description: "Skips all permission prompts",
+          },
+          {
+            id: "plan",
+            name: "Plan Mode",
+            description: "Claude can analyze but not modify files or execute commands",
+          },
+        ],
+      },
     };
   }
 
@@ -196,7 +247,7 @@ export class ClaudeAcpAgent implements Agent {
 
     input.push(promptToClaude(params));
     while (true) {
-      let { value: message, done } = await query.next();
+      const { value: message, done } = await query.next();
       if (done || !message) {
         if (this.sessions[params.sessionId].cancelled) {
           return { stopReason: "cancelled" };
@@ -234,8 +285,8 @@ export class ClaudeAcpAgent implements Agent {
           }
 
           if (
-            message.message.model == "<synthetic>" &&
-            message.message.content.length == 1 &&
+            message.message.model === "<synthetic>" &&
+            message.message.content.length === 1 &&
             message.message.content[0].text.includes("Please run /login")
           ) {
             throw RequestError.authRequired();
@@ -265,29 +316,47 @@ export class ClaudeAcpAgent implements Agent {
     await this.sessions[params.sessionId].query.interrupt();
   }
 
-  async readTextFile(
-    params: ReadTextFileRequest,
-  ): Promise<ReadTextFileResponse> {
-    let response = await this.client.readTextFile(params);
+  async setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse> {
+    if (!this.sessions[params.sessionId]) {
+      throw new Error("Session not found");
+    }
+
+    switch (params.modeId) {
+      case "default":
+      case "acceptEdits":
+      case "plan":
+        this.sessions[params.sessionId].permissionMode = params.modeId;
+        await this.sessions[params.sessionId].query.setPermissionMode(params.modeId);
+        return {};
+      case "bypassPermissions":
+        // For some reason, the SDK doesn't support setting the mode to `bypassPermissions`
+        // so we do it ourselves
+        this.sessions[params.sessionId].permissionMode = "bypassPermissions";
+        await this.sessions[params.sessionId].query.setPermissionMode("acceptEdits");
+        return {};
+      default:
+        throw new Error("Invalid mode");
+    }
+  }
+
+  async readTextFile(params: ReadTextFileRequest): Promise<ReadTextFileResponse> {
+    const response = await this.client.readTextFile(params);
     if (!params.limit && !params.line) {
       this.fileContentCache[params.path] = response.content;
     }
     return response;
   }
 
-  async writeTextFile(
-    params: WriteTextFileRequest,
-  ): Promise<WriteTextFileResponse> {
-    let response = await this.client.writeTextFile(params);
+  async writeTextFile(params: WriteTextFileRequest): Promise<WriteTextFileResponse> {
+    const response = await this.client.writeTextFile(params);
     this.fileContentCache[params.path] = params.content;
     return response;
   }
 }
 
-async function availableSlashCommands(
-  query: Query,
-): Promise<AvailableCommand[]> {
+async function getAvailableSlashCommands(query: Query): Promise<AvailableCommand[]> {
   const UNSUPPORTED_COMMANDS = [
+    "add-dir",
     "agents", // Modal
     "bashes", // Modal
     "bug", // Modal
@@ -305,12 +374,14 @@ async function availableSlashCommands(
     "install-github-app", // Modal
     "login",
     "logout",
+    "memory",
     "mcp",
     "migrate-installer", // Modal
     "model", // Not supported via SDK?
     "output-style", // Modal
     "output-style:new", // Modal
     "permissions", // Modal
+    "privacy-settings",
     "release-notes", // Escape Codes
     "resume",
     "status", // Not supported via SDK?
@@ -319,29 +390,21 @@ async function availableSlashCommands(
     "todos", // Escape Codes
     "vim", // Not needed
   ];
-
   //todo: Do not use `as any` once `supportedCommands` is exposed via the typescript interface
   const commands = await (query as any).supportedCommands();
+
   return commands
-    .map(
-      (command: {
-        name: string;
-        description: string;
-        argumentHint: string;
-      }) => {
-        const input = command.argumentHint
-          ? { hint: command.argumentHint }
-          : null;
-        return {
-          name: command.name,
-          description: command.description || "",
-          input,
-        };
-      },
-    )
+    .map((command: { name: string; description: string; argumentHint: string }) => {
+      const input = command.argumentHint ? { hint: command.argumentHint } : null;
+      return {
+        name: command.name,
+        description: command.description || "",
+        input,
+      };
+    })
     .filter(
       (command: AvailableCommand) =>
-        !UNSUPPORTED_COMMANDS.includes(command.name),
+        !(command.name.match(/\(MCP\)/) || UNSUPPORTED_COMMANDS.includes(command.name)),
     );
 }
 
@@ -440,14 +503,14 @@ function promptToClaude(prompt: PromptRequest): SDKUserMessage {
 export function toAcpNotifications(
   message: SDKAssistantMessage | SDKUserMessage,
   sessionId: string,
-  toolUseCache: { [key: string]: any },
+  toolUseCache: ToolUseCache,
   fileContentCache: { [key: string]: string },
 ): SessionNotification[] {
-  let chunks = message.message.content as ContentChunk[];
-  let output = [];
+  const chunks = message.message.content as ContentChunk[];
+  const output = [];
   // Only handle the first chunk for streaming; extend as needed for batching
   for (const chunk of chunks) {
-    let update: SessionNotification["update"];
+    let update: SessionNotification["update"] | null = null;
     switch (chunk.type) {
       case "text":
         update = {
@@ -464,8 +527,7 @@ export function toAcpNotifications(
           content: {
             type: "image",
             data: chunk.source.type === "base64" ? chunk.source.data : "",
-            mimeType:
-              chunk.source.type === "base64" ? chunk.source.media_type : "",
+            mimeType: chunk.source.type === "base64" ? chunk.source.media_type : "",
             uri: chunk.source.type === "url" ? chunk.source.url : undefined,
           },
         };
@@ -481,7 +543,7 @@ export function toAcpNotifications(
         break;
       case "tool_use":
         toolUseCache[chunk.id] = chunk;
-        if (chunk.name == "TodoWrite") {
+        if (chunk.name === "TodoWrite") {
           update = {
             sessionUpdate: "plan",
             entries: planEntries(chunk.input),
@@ -497,19 +559,32 @@ export function toAcpNotifications(
         }
         break;
 
-      case "tool_result":
-        update = {
-          toolCallId: chunk.tool_use_id,
-          sessionUpdate: "tool_call_update",
-          status: chunk.is_error ? "failed" : "completed",
-          ...toolUpdateFromToolResult(chunk, toolUseCache[chunk.tool_use_id]),
-        };
+      case "tool_result": {
+        const toolUse = toolUseCache[chunk.tool_use_id];
+        if (!toolUse) {
+          console.error(
+            `[claude-code-acp] Got a tool result for tool use that wasn't tracked: ${chunk.tool_use_id}`,
+          );
+          break;
+        }
+
+        if (toolUse.name !== "TodoWrite") {
+          update = {
+            toolCallId: chunk.tool_use_id,
+            sessionUpdate: "tool_call_update",
+            status: chunk.is_error ? "failed" : "completed",
+            ...toolUpdateFromToolResult(chunk, toolUseCache[chunk.tool_use_id]),
+          };
+        }
         break;
+      }
 
       default:
         throw new Error("unhandled chunk type: " + chunk.type);
     }
-    output.push({ sessionId, update });
+    if (update) {
+      output.push({ sessionId, update });
+    }
   }
 
   return output;
@@ -525,7 +600,7 @@ export function runAcp() {
 
 type ContentChunk =
   | { type: "text"; text: string }
-  | { type: "tool_use"; id: string; name: string; input: any } // input is serde_json::Value, so use any or unknown
+  | { type: "tool_use"; id: string; name: string; input: any }
   | {
       type: "tool_result";
       content: string;

src/index.ts

@@ -1,5 +1,24 @@
 #!/usr/bin/env node
 
+// Load managed settings and apply environment variables
+import { loadManagedSettings, applyEnvironmentSettings } from "./utils.js";
+
+const managedSettings = loadManagedSettings();
+if (managedSettings) {
+  applyEnvironmentSettings(managedSettings);
+}
+
+// stdout is used to send messages to the client
+// we redirect everything else to stderr to make sure it doesn't interfere with ACP
+console.log = console.error;
+console.info = console.error;
+console.warn = console.error;
+console.debug = console.error;
+
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("Unhandled Rejection at:", promise, "reason:", reason);
+});
+
 import { runAcp as runAcp } from "./acp-agent.js";
 runAcp();
 

src/mcp-server.ts

@@ -1,15 +1,15 @@
 import express from "express";
-import { randomUUID } from "node:crypto";
+
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z } from "zod";
 import { Server } from "node:http";
 import { ClaudeAcpAgent } from "./acp-agent.js";
-import {
-  ClientCapabilities,
-  TerminalOutputResponse,
-} from "@zed-industries/agent-client-protocol";
-import { tool } from "@anthropic-ai/claude-code";
+import { ClientCapabilities, TerminalOutputResponse } from "@zed-industries/agent-client-protocol";
+import * as diff from "diff";
+
+import { sleep, unreachable } from "./utils.js";
+import { PermissionResult } from "@anthropic-ai/claude-code";
 
 export const SYSTEM_REMINDER = `
 
@@ -17,6 +17,31 @@ export const SYSTEM_REMINDER = `
 Whenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.
 </system-reminder>`;
 
+const unqualifiedToolNames = {
+  read: "read",
+  edit: "edit",
+  write: "write",
+  multiEdit: "multi-edit",
+  bash: "Bash",
+  killBash: "KillBash",
+  bashOutput: "BashOutput",
+  permission: "permission",
+};
+
+const SERVER_PREFIX = "mcp__acp__";
+export const toolNames = {
+  read: SERVER_PREFIX + unqualifiedToolNames.read,
+  edit: SERVER_PREFIX + unqualifiedToolNames.edit,
+  write: SERVER_PREFIX + unqualifiedToolNames.write,
+  multiEdit: SERVER_PREFIX + unqualifiedToolNames.multiEdit,
+  bash: SERVER_PREFIX + unqualifiedToolNames.bash,
+  killBash: SERVER_PREFIX + unqualifiedToolNames.killBash,
+  bashOutput: SERVER_PREFIX + unqualifiedToolNames.bashOutput,
+  permission: SERVER_PREFIX + unqualifiedToolNames.permission,
+};
+
+const editToolNames = [toolNames.edit, toolNames.multiEdit, toolNames.write];
+
 export function createMcpServer(
   agent: ClaudeAcpAgent,
   sessionId: string,
@@ -30,28 +55,21 @@ export function createMcpServer(
 
   if (clientCapabilities?.fs?.readTextFile) {
     server.registerTool(
-      "read",
+      unqualifiedToolNames.read,
       {
         title: "Read",
         description: `Reads the content of the given file in the project.
 
 Never attempt to read a path that hasn't been previously mentioned.
 
-In sessions with mcp__acp__read always use it instead of Read as it contains the most up-to-date contents.`,
+In sessions with ${toolNames.read} always use it instead of Read as it contains the most up-to-date contents.`,
         inputSchema: {
-          abs_path: z
-            .string()
-            .describe("The absolute path to the file to read."),
+          abs_path: z.string().describe("The absolute path to the file to read."),
           offset: z
             .number()
             .optional()
-            .describe(
-              "Which line to start reading from. Omit to start from the beginning.",
-            ),
-          limit: z
-            .number()
-            .optional()
-            .describe("How many lines to read. Omit for the whole file."),
+            .describe("Which line to start reading from. Omit to start from the beginning."),
+          limit: z.number().optional().describe("How many lines to read. Omit for the whole file."),
         },
         annotations: {
           title: "Read file",
@@ -74,7 +92,7 @@ In sessions with mcp__acp__read always use it instead of Read as it contains the
               ],
             };
           }
-          let content = await agent.readTextFile({
+          const content = await agent.readTextFile({
             sessionId,
             path: input.abs_path,
             limit: input.limit,
@@ -105,17 +123,15 @@ In sessions with mcp__acp__read always use it instead of Read as it contains the
 
   if (clientCapabilities?.fs?.writeTextFile) {
     server.registerTool(
-      "write",
+      unqualifiedToolNames.write,
       {
         title: "Write",
         description: `Writes content to the specified file in the project.
 
-In sessions with mcp__acp__write always use it instead of Write as it will
+In sessions with ${toolNames.write} always use it instead of Write as it will
 allow the user to conveniently review changes.`,
         inputSchema: {
-          abs_path: z
-            .string()
-            .describe("The absolute path to the file to write"),
+          abs_path: z.string().describe("The absolute path to the file to write"),
           content: z.string().describe("The full content to write"),
         },
         annotations: {
@@ -139,7 +155,7 @@ allow the user to conveniently review changes.`,
               ],
             };
           }
-          let content = await agent.writeTextFile({
+          await agent.writeTextFile({
             sessionId,
             path: input.abs_path,
             content: input.content,
@@ -162,31 +178,28 @@ allow the user to conveniently review changes.`,
     );
 
     server.registerTool(
-      "edit",
+      unqualifiedToolNames.edit,
       {
         title: "Edit",
         description: `Edit a file.
 
-In sessions with mcp__acp__edit always use it instead of Edit as it will
+In sessions with ${toolNames.edit} always use it instead of Edit as it will
 allow the user to conveniently review changes.
 
 File editing instructions:
-- The \`old_text\` param must match existing file content, including indentation.
-- The \`old_text\` param must come from the actual file, not an outline.
-- The \`old_text\` section must not be empty.
+- The \`old_string\` param must match existing file content, including indentation.
+- The \`old_string\` param must come from the actual file, not an outline.
+- The \`old_string\` section must not be empty.
 - Be minimal with replacements:
   - For unique lines, include only those lines.
   - For non-unique lines, include enough context to identify them.
 - Do not escape quotes, newlines, or other characters.
-- Only edit the specified file.`,
+- Only edit the specified file.
+- If the \`old_string\` value isn't found in the file, the edit won't be applied. The tool will fail and must be retried.`,
         inputSchema: {
-          abs_path: z
-            .string()
-            .describe("The absolute path to the file to read."),
-          old_text: z
-            .string()
-            .describe("The old text to replace (must be unique in the file)"),
-          new_text: z.string().describe("The new text."),
+          abs_path: z.string().describe("The absolute path to the file to read."),
+          old_string: z.string().describe("The old text to replace (must be unique in the file)"),
+          new_string: z.string().describe("The new text."),
         },
         annotations: {
           title: "Edit file",
@@ -197,71 +210,70 @@ File editing instructions:
         },
       },
       async (input) => {
-        try {
-          const session = agent.sessions[sessionId];
-          if (!session) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: "The user has left the building",
-                },
-              ],
-            };
-          }
-
-          let { content } = await agent.readTextFile({
-            sessionId,
-            path: input.abs_path,
-          });
-
-          const { newContent, lineNumbers } = replaceAndCalculateLocation(
-            content,
-            [
-              {
-                oldText: input.old_text,
-                newText: input.new_text,
-                replaceAll: false,
-              },
-            ],
-          );
-
-          await agent.writeTextFile({
-            sessionId,
-            path: input.abs_path,
-            content: newContent,
-          });
-
+        const session = agent.sessions[sessionId];
+        if (!session) {
           return {
             content: [
               {
                 type: "text",
-                text: JSON.stringify({ lineNumbers }),
-              },
-            ],
-          };
-        } catch (error: any) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Editing file failed: " + error.message,
+                text: "The user has left the building",
               },
             ],
           };
         }
+
+        const { content } = await agent.readTextFile({
+          sessionId,
+          path: input.abs_path,
+        });
+
+        const { newContent } = replaceAndCalculateLocation(content, [
+          {
+            oldText: input.old_string,
+            newText: input.new_string,
+            replaceAll: false,
+          },
+        ]);
+
+        const patch = diff.createPatch(input.abs_path, content, newContent);
+
+        await agent.writeTextFile({
+          sessionId,
+          path: input.abs_path,
+          content: newContent,
+        });
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: patch,
+            },
+          ],
+        };
       },
     );
 
     server.registerTool(
-      "multi-edit",
+      unqualifiedToolNames.multiEdit,
       {
         title: "Multi Edit",
-        description: `Edit a file with multiple sequential edits.`,
+        description: `Edit a file with multiple sequential edits.
+
+In sessions with ${toolNames.multiEdit} always use it instead of MultiEdit as it will
+allow the user to conveniently review changes.
+
+File editing instructions:
+- The \`old_string\` param must match existing file content, including indentation.
+- The \`old_string\` param must come from the actual file, not an outline.
+- The \`old_string\` section must not be empty.
+- Be minimal with replacements:
+  - For unique lines, include only those lines.
+  - For non-unique lines, include enough context to identify them, unless you're using \`replace_all\`
+- Do not escape quotes, newlines, or other characters.
+- If any of the provided \`old_string\` values aren't found in the file, no edits will be applied. The tool will fail and must be retried.`,
         inputSchema: {
-          file_path: z
-            .string()
-            .describe("The absolute path to the file to modify"),
+          file_path: z.string().describe("The absolute path to the file to modify"),
           edits: z
             .array(
               z.object({
@@ -270,15 +282,11 @@ File editing instructions:
                 replace_all: z
                   .boolean()
                   .optional()
-                  .describe(
-                    "Replace all occurrences of old_string (default false)",
-                  ),
+                  .describe("Replace all occurrences of old_string (default false)"),
               }),
             )
             .min(1)
-            .describe(
-              "Array of edit operations to perform sequentially on the file",
-            ),
+            .describe("Array of edit operations to perform sequentially on the file"),
         },
         annotations: {
           title: "Multi Edit file",
@@ -301,12 +309,12 @@ File editing instructions:
           };
         }
 
-        let { content } = await agent.readTextFile({
+        const { content } = await agent.readTextFile({
           sessionId,
           path: input.file_path,
         });
 
-        const { newContent, lineNumbers } = replaceAndCalculateLocation(
+        const { newContent } = replaceAndCalculateLocation(
           content,
           input.edits.map((edit) => ({
             oldText: edit.old_string,
@@ -315,6 +323,8 @@ File editing instructions:
           })),
         );
 
+        const patch = diff.createPatch(input.file_path, content, newContent);
+
         await agent.writeTextFile({
           sessionId,
           path: input.file_path,
@@ -325,7 +335,7 @@ File editing instructions:
           content: [
             {
               type: "text",
-              text: JSON.stringify({ lineNumbers }),
+              text: patch,
             },
           ],
         };
@@ -335,14 +345,12 @@ File editing instructions:
 
   if (agent.clientCapabilities?.terminal) {
     server.registerTool(
-      "Bash",
+      unqualifiedToolNames.bash,
       {
         title: "Bash",
         description: "Executes a bash command",
         inputSchema: {
-          command: z
-            .string()
-            .describe("The bash command to execute as a one-liner"),
+          command: z.string().describe("The bash command to execute as a one-liner"),
           timeout_ms: z
             .number()
             .default(2 * 60 * 1000)
@@ -351,7 +359,7 @@ File editing instructions:
             .boolean()
             .default(false)
             .describe(
-              "When set to true, the command is started in the background. The tool returns an `id` that can be used with the `mcp__acp__BashOutput` tool to retrieve the current output, or the `mcp__acp__KillBash` tool to stop it early.",
+              `When set to true, the command is started in the background. The tool returns an \`id\` that can be used with the \`${toolNames.bashOutput}\` tool to retrieve the current output, or the \`${toolNames.killBash}\` tool to stop it early.`,
             ),
         },
       },
@@ -374,10 +382,7 @@ File editing instructions:
           throw new Error("No tool call ID found");
         }
 
-        if (
-          !agent.clientCapabilities?.terminal ||
-          !agent.client.createTerminal
-        ) {
+        if (!agent.clientCapabilities?.terminal || !agent.client.createTerminal) {
           throw new Error("unreachable");
         }
 
@@ -408,13 +413,13 @@ File editing instructions:
         });
 
         const statusPromise = Promise.race([
-          handle.waitForExit().then(() => ({ status: "exited" as const })),
-          abortPromise.then(() => ({ status: "aborted" as const })),
+          handle.waitForExit().then((exitStatus) => ({ status: "exited" as const, exitStatus })),
+          abortPromise.then(() => ({ status: "aborted" as const, exitStatus: null })),
           sleep(input.timeout_ms).then(async () => {
             if (agent.backgroundTerminals[handle.id]?.status === "started") {
               await handle.kill();
             }
-            return { status: "timedOut" as const };
+            return { status: "timedOut" as const, exitStatus: null };
           }),
         ]);
 
@@ -425,7 +430,7 @@ File editing instructions:
             status: "started",
           };
 
-          statusPromise.then(async ({ status }) => {
+          statusPromise.then(async ({ status, exitStatus }) => {
             const bgTerm = agent.backgroundTerminals[handle.id];
 
             if (bgTerm.status !== "started") {
@@ -438,10 +443,8 @@ File editing instructions:
               status,
               pendingOutput: {
                 ...currentOutput,
-                output: stripCommonPrefix(
-                  bgTerm.lastOutput?.output ?? "",
-                  currentOutput.output,
-                ),
+                output: stripCommonPrefix(bgTerm.lastOutput?.output ?? "", currentOutput.output),
+                exitStatus: exitStatus ?? currentOutput.exitStatus,
               },
             };
 
@@ -477,7 +480,7 @@ File editing instructions:
     );
 
     server.registerTool(
-      "BashOutput",
+      unqualifiedToolNames.bashOutput,
       {
         title: "BashOutput",
         description:
@@ -485,9 +488,7 @@ File editing instructions:
         inputSchema: {
           id: z
             .string()
-            .describe(
-              "The id of the background bash command as returned by `mcp__acp__Bash`",
-            ),
+            .describe(`The id of the background bash command as returned by \`${toolNames.bash}\``),
         },
       },
       async (input) => {
@@ -530,16 +531,14 @@ File editing instructions:
     );
 
     server.registerTool(
-      "KillBash",
+      unqualifiedToolNames.killBash,
       {
         title: "KillBash",
         description: "Stops a background command by its id",
         inputSchema: {
           id: z
             .string()
-            .describe(
-              "The id of the background bash command as returned by `mcp__acp__Bash`",
-            ),
+            .describe(`The id of the background bash command as returned by \`${toolNames.bash}\``),
         },
       },
       async (input) => {
@@ -550,17 +549,14 @@ File editing instructions:
         }
 
         switch (bgTerm.status) {
-          case "started":
+          case "started": {
             await bgTerm.handle.kill();
             const currentOutput = await bgTerm.handle.currentOutput();
             agent.backgroundTerminals[bgTerm.handle.id] = {
               status: "killed",
               pendingOutput: {
                 ...currentOutput,
-                output: stripCommonPrefix(
-                  bgTerm.lastOutput?.output ?? "",
-                  currentOutput.output,
-                ),
+                output: stripCommonPrefix(bgTerm.lastOutput?.output ?? "", currentOutput.output),
               },
             };
             await bgTerm.handle.release();
@@ -568,6 +564,7 @@ File editing instructions:
             return {
               content: [{ type: "text", text: "Command killed successfully." }],
             };
+          }
           case "aborted":
             return {
               content: [{ type: "text", text: "Command aborted by user." }],
@@ -585,75 +582,16 @@ File editing instructions:
               content: [{ type: "text", text: "Command killed by timeout." }],
             };
           default: {
-            const unreachable: never = bgTerm;
-            return unreachable;
+            return unreachable(bgTerm);
           }
         }
       },
     );
-
-    function stripCommonPrefix(a: string, b: string): string {
-      let i = 0;
-      while (i < a.length && i < b.length && a[i] === b[i]) i++;
-      return b.slice(i);
-    }
-
-    function sleep(time: number): Promise<void> {
-      return new Promise((resolve) => setTimeout(resolve, time));
-    }
-
-    function toolCommandOutput(
-      status: "started" | "aborted" | "exited" | "killed" | "timedOut",
-      output: TerminalOutputResponse,
-    ): string {
-      const { exitStatus, output: commandOutput, truncated } = output;
-
-      let toolOutput = "";
-
-      switch (status) {
-        case "started": {
-          if (exitStatus?.exitCode == null) {
-            toolOutput += `Interrupted. `;
-          }
-          break;
-        }
-        case "killed":
-          toolOutput += `Killed. `;
-          break;
-        case "timedOut":
-          toolOutput += `Timed out. `;
-          break;
-        case "exited":
-        case "aborted":
-          break;
-        default: {
-          const unreachable: never = status;
-          return unreachable;
-        }
-      }
-
-      if (exitStatus?.exitCode != null && exitStatus.exitCode !== 0) {
-        toolOutput += `Failed with exit code ${exitStatus.exitCode}.`;
-      }
-
-      if (exitStatus?.signal != null) {
-        toolOutput += `Signal \`${exitStatus.signal}\`. `;
-      }
-
-      toolOutput += "Output:\n\n";
-      toolOutput += commandOutput;
-
-      if (truncated) {
-        toolOutput += `\n\nCommand output was too long, so it was truncated to ${commandOutput.length} bytes.`;
-      }
-
-      return toolOutput;
-    }
   }
 
-  let alwaysAllowedTools: { [key: string]: boolean } = {};
+  const alwaysAllowedTools: { [key: string]: boolean } = {};
   server.registerTool(
-    "permission",
+    unqualifiedToolNames.permission,
     {
       title: "Permission Tool",
       description: "Used to request tool permissions",
@@ -664,42 +602,37 @@ File editing instructions:
       },
     },
     async (input) => {
-      const session = agent.sessions[sessionId];
-      if (!session) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                behavior: "deny",
-                message: "Session not found",
-              }),
-            },
-          ],
-        };
-      }
-      if (alwaysAllowedTools[input.tool_name]) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                behavior: "allow",
-                updatedInput: input.input,
-              }),
-            },
-          ],
-        };
-      }
-      let response = await agent.client.requestPermission({
+      const result = await canUseTool(input);
+
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+      };
+    },
+  );
+
+  async function canUseTool(input: {
+    tool_use_id?: string;
+    tool_name: string;
+    input?: any;
+  }): Promise<PermissionResult> {
+    const session = agent.sessions[sessionId];
+    if (!session) {
+      return {
+        behavior: "deny",
+        message: "Session not found",
+      };
+    }
+
+    if (input.tool_name === "ExitPlanMode") {
+      const response = await agent.client.requestPermission({
         options: [
           {
             kind: "allow_always",
-            name: "Always Allow",
-            optionId: "allow_always",
+            name: "Yes, and auto-accept edits",
+            optionId: "acceptEdits",
           },
-          { kind: "allow_once", name: "Allow", optionId: "allow" },
-          { kind: "reject_once", name: "Reject", optionId: "reject" },
+          { kind: "allow_once", name: "Yes, and manually approve edits", optionId: "default" },
+          { kind: "reject_once", name: "No, keep planning", optionId: "plan" },
         ],
         sessionId,
         toolCall: {
@@ -707,50 +640,89 @@ File editing instructions:
           rawInput: input.input,
         },
       });
+
       if (
-        response.outcome?.outcome == "selected" &&
-        (response.outcome.optionId == "allow" ||
-          response.outcome.optionId == "allow_always")
+        response.outcome?.outcome === "selected" &&
+        (response.outcome.optionId === "default" || response.outcome.optionId === "acceptEdits")
       ) {
-        if (response.outcome.optionId == "allow_always") {
-          alwaysAllowedTools[input.tool_name] = true;
-        }
+        session.permissionMode = response.outcome.optionId;
+        await agent.client.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: "current_mode_update",
+            currentModeId: response.outcome.optionId,
+          },
+        });
+
         return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                behavior: "allow",
-                updatedInput: input.input,
-              }),
-            },
+          behavior: "allow",
+          updatedInput: input.input,
+          updatedPermissions: [
+            { type: "setMode", mode: response.outcome.optionId, destination: "session" },
           ],
         };
       } else {
         return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                behavior: "deny",
-                message: "User refused permission to run tool",
-              }),
-            },
-          ],
+          behavior: "deny",
+          message: "User rejected request to exit plan mode.",
         };
       }
-    },
-  );
+    }
+
+    if (
+      session.permissionMode === "bypassPermissions" ||
+      (session.permissionMode === "acceptEdits" && editToolNames.includes(input.tool_name)) ||
+      alwaysAllowedTools[input.tool_name]
+    ) {
+      return {
+        behavior: "allow",
+        updatedInput: input.input,
+      };
+    }
+
+    const response = await agent.client.requestPermission({
+      options: [
+        {
+          kind: "allow_always",
+          name: "Always Allow",
+          optionId: "allow_always",
+        },
+        { kind: "allow_once", name: "Allow", optionId: "allow" },
+        { kind: "reject_once", name: "Reject", optionId: "reject" },
+      ],
+      sessionId,
+      toolCall: {
+        toolCallId: input.tool_use_id!,
+        rawInput: input.input,
+      },
+    });
+    if (
+      response.outcome?.outcome === "selected" &&
+      (response.outcome.optionId === "allow" || response.outcome.optionId === "allow_always")
+    ) {
+      if (response.outcome.optionId === "allow_always") {
+        alwaysAllowedTools[input.tool_name] = true;
+      }
+      return {
+        behavior: "allow",
+        updatedInput: input.input,
+      };
+    } else {
+      return {
+        behavior: "deny",
+        message: "User refused permission to run tool",
+      };
+    }
+  }
 
   const app = express();
   app.use(express.json());
 
   app.post("/mcp", async (req, res) => {
     try {
-      const transport: StreamableHTTPServerTransport =
-        new StreamableHTTPServerTransport({
-          sessionIdGenerator: undefined,
-        });
+      const transport: StreamableHTTPServerTransport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+      });
       res.on("close", () => {
         transport.close();
         server.close();
@@ -763,7 +735,7 @@ File editing instructions:
           jsonrpc: "2.0",
           error: {
             code: -32603,
-            message: "Internal server error",
+            message: `Internal server error: ${error}`,
           },
           id: null,
         });
@@ -782,6 +754,67 @@ File editing instructions:
   });
 }
 
+function stripCommonPrefix(a: string, b: string): string {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) {
+    i++;
+  }
+  return b.slice(i);
+}
+
+function toolCommandOutput(
+  status: "started" | "aborted" | "exited" | "killed" | "timedOut",
+  output: TerminalOutputResponse,
+): string {
+  const { exitStatus, output: commandOutput, truncated } = output;
+
+  let toolOutput = "";
+
+  switch (status) {
+    case "started":
+    case "exited": {
+      if (exitStatus && (exitStatus.exitCode ?? null) === null) {
+        toolOutput += `Interrupted by the user. `;
+      }
+      break;
+    }
+    case "killed":
+      toolOutput += `Killed. `;
+      break;
+    case "timedOut":
+      toolOutput += `Timed out. `;
+      break;
+    case "aborted":
+      break;
+    default: {
+      const unreachable: never = status;
+      return unreachable;
+    }
+  }
+
+  if (exitStatus) {
+    if (typeof exitStatus.exitCode === "number") {
+      toolOutput += `Exited with code ${exitStatus.exitCode}.`;
+    }
+
+    if (typeof exitStatus.signal === "string") {
+      toolOutput += `Signal \`${exitStatus.signal}\`. `;
+    }
+
+    toolOutput += "Final output:\n\n";
+  } else {
+    toolOutput += "New output:\n\n";
+  }
+
+  toolOutput += commandOutput;
+
+  if (truncated) {
+    toolOutput += `\n\nCommand output was too long, so it was truncated to ${commandOutput.length} bytes.`;
+  }
+
+  return toolOutput;
+}
+
 /**
  * Replace text in a file and calculate the line numbers where the edits occurred.
  *
@@ -808,7 +841,7 @@ export function replaceAndCalculateLocation(
   for (const edit of edits) {
     // Skip empty oldText
     if (edit.oldText === "") {
-      continue;
+      throw new Error(`The provided \`old_string\` is empty.\n\nNo edits were applied.`);
     }
 
     if (edit.replaceAll) {
@@ -819,7 +852,14 @@ export function replaceAndCalculateLocation(
 
       while (true) {
         const index = currentContent.indexOf(edit.oldText, searchIndex);
-        if (index === -1) break;
+        if (index === -1) {
+          if (searchIndex === 0) {
+            throw new Error(
+              `The provided \`old_string\` does not appear in the file: "${edit.oldText}".\n\nNo edits were applied.`,
+            );
+          }
+          break;
+        }
 
         // Add content before the match
         parts.push(currentContent.substring(lastIndex, index));
@@ -839,7 +879,11 @@ export function replaceAndCalculateLocation(
     } else {
       // Replace first occurrence only
       const index = currentContent.indexOf(edit.oldText);
-      if (index !== -1) {
+      if (index === -1) {
+        throw new Error(
+          `The provided \`old_string\` does not appear in the file: "${edit.oldText}".\n\nNo edits were applied.`,
+        );
+      } else {
         const marker = `${markerPrefix}${markerCounter++}__`;
         markers.push(marker);
         currentContent =

src/tests/acp-agent.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeAll, afterAll } from "vitest";
 import { spawn, spawnSync } from "child_process";
 import {
   Agent,
+  AvailableCommand,
   Client,
   ClientSideConnection,
   NewSessionResponse,
@@ -14,185 +15,183 @@ import {
   WriteTextFileResponse,
 } from "@zed-industries/agent-client-protocol";
 import { nodeToWebWritable, nodeToWebReadable } from "../utils.js";
-import {
-  markdownEscape,
-  toolInfoFromToolUse,
-  toolUpdateFromToolResult,
-} from "../tools.js";
+import { markdownEscape, toolInfoFromToolUse, toolUpdateFromToolResult } from "../tools.js";
 import { toAcpNotifications } from "../acp-agent.js";
 import { SDKAssistantMessage } from "@anthropic-ai/claude-code";
 
-describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)(
-  "ACP subprocess integration",
-  () => {
-    let child: ReturnType<typeof spawn>;
+describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("ACP subprocess integration", () => {
+  let child: ReturnType<typeof spawn>;
 
-    beforeAll(async () => {
-      let valid = spawnSync("tsc", { stdio: "inherit" });
-      if (valid.status) {
-        throw new Error("failed to compile");
-      }
-      // Start the subprocess
-      child = spawn("npm", ["run", "--silent", "dev"], {
-        stdio: ["pipe", "pipe", "inherit"],
-        env: process.env,
-      });
-      child.on("error", (error) => {
-        console.error("Error starting subprocess:", error);
-      });
-      child.on("exit", (exit) => {
-        console.error("Exited with", exit);
-      });
+  beforeAll(async () => {
+    const valid = spawnSync("tsc", { stdio: "inherit" });
+    if (valid.status) {
+      throw new Error("failed to compile");
+    }
+    // Start the subprocess
+    child = spawn("npm", ["run", "--silent", "dev"], {
+      stdio: ["pipe", "pipe", "inherit"],
+      env: process.env,
     });
-
-    afterAll(() => {
-      child.kill();
+    child.on("error", (error) => {
+      console.error("Error starting subprocess:", error);
     });
+    child.on("exit", (exit) => {
+      console.error("Exited with", exit);
+    });
+  });
 
-    class TestClient implements Client {
-      agent: Agent;
-      files: Map<string, string> = new Map();
-      receivedText: string = "";
+  afterAll(() => {
+    child.kill();
+  });
 
-      constructor(agent: Agent) {
-        this.agent = agent;
-      }
+  class TestClient implements Client {
+    agent: Agent;
+    files: Map<string, string> = new Map();
+    receivedText: string = "";
+    resolveAvailableCommands: (commands: AvailableCommand[]) => void;
+    availableCommandsPromise: Promise<AvailableCommand[]>;
 
-      takeReceivedText() {
-        const text = this.receivedText;
-        this.receivedText = "";
-        return text;
-      }
+    constructor(agent: Agent) {
+      this.agent = agent;
+      this.resolveAvailableCommands = () => {};
+      this.availableCommandsPromise = new Promise((resolve) => {
+        this.resolveAvailableCommands = resolve;
+      });
+    }
 
-      async requestPermission(
-        params: RequestPermissionRequest,
-      ): Promise<RequestPermissionResponse> {
-        const optionId = params.options.find(
-          (p) => p.kind === "allow_once",
-        )!.optionId;
+    takeReceivedText() {
+      const text = this.receivedText;
+      this.receivedText = "";
+      return text;
+    }
 
-        return { outcome: { outcome: "selected", optionId } };
-      }
+    async requestPermission(params: RequestPermissionRequest): Promise<RequestPermissionResponse> {
+      const optionId = params.options.find((p) => p.kind === "allow_once")!.optionId;
 
-      async sessionUpdate(params: SessionNotification): Promise<void> {
-        console.error("RECEIVED", JSON.stringify(params, null, 4));
+      return { outcome: { outcome: "selected", optionId } };
+    }
 
-        if (
-          params.update.sessionUpdate === "agent_message_chunk" &&
-          params.update.content.type === "text"
-        ) {
-          this.receivedText += params.update.content.text;
+    async sessionUpdate(params: SessionNotification): Promise<void> {
+      console.error("RECEIVED", JSON.stringify(params, null, 4));
+
+      switch (params.update.sessionUpdate) {
+        case "agent_message_chunk": {
+          if (params.update.content.type === "text") {
+            this.receivedText += params.update.content.text;
+          }
+          break;
         }
-      }
-
-      async writeTextFile(
-        params: WriteTextFileRequest,
-      ): Promise<WriteTextFileResponse> {
-        this.files.set(params.path, params.content);
-        return null;
-      }
-
-      async readTextFile(
-        params: ReadTextFileRequest,
-      ): Promise<ReadTextFileResponse> {
-        const content = this.files.get(params.path) ?? "";
-        return {
-          content,
-        };
+        case "available_commands_update":
+          this.resolveAvailableCommands(params.update.availableCommands);
+          break;
+        default:
+          break;
       }
     }
 
-    async function setupTestSession(cwd: string): Promise<{
-      client: TestClient;
-      connection: ClientSideConnection;
-      newSessionResponse: NewSessionResponse;
-    }> {
-      let client;
-      const connection = new ClientSideConnection(
-        (agent) => {
-          client = new TestClient(agent);
-          return client;
-        },
-        nodeToWebWritable(child.stdin!),
-        nodeToWebReadable(child.stdout!),
-      );
-
-      await connection.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {
-          fs: {
-            readTextFile: true,
-            writeTextFile: true,
-          },
-        },
-      });
-
-      const newSessionResponse = await connection.newSession({
-        cwd,
-        mcpServers: [],
-      });
-
-      return { client: client!, connection, newSessionResponse };
+    async writeTextFile(params: WriteTextFileRequest): Promise<WriteTextFileResponse> {
+      this.files.set(params.path, params.content);
+      return null;
     }
 
-    it("should connect to the ACP subprocess", async () => {
-      const { client, connection, newSessionResponse } =
-        await setupTestSession("./");
+    async readTextFile(params: ReadTextFileRequest): Promise<ReadTextFileResponse> {
+      const content = this.files.get(params.path) ?? "";
+      return {
+        content,
+      };
+    }
+  }
 
-      await connection.prompt({
-        prompt: [
-          {
-            type: "text",
-            text: "Hello",
-          },
-        ],
-        sessionId: newSessionResponse.sessionId,
-      });
+  async function setupTestSession(cwd: string): Promise<{
+    client: TestClient;
+    connection: ClientSideConnection;
+    newSessionResponse: NewSessionResponse;
+  }> {
+    let client;
+    const connection = new ClientSideConnection(
+      (agent) => {
+        client = new TestClient(agent);
+        return client;
+      },
+      nodeToWebWritable(child.stdin!),
+      nodeToWebReadable(child.stdout!),
+    );
 
-      expect(client.takeReceivedText()).not.toEqual("");
-    }, 30000);
+    await connection.initialize({
+      protocolVersion: 1,
+      clientCapabilities: {
+        fs: {
+          readTextFile: true,
+          writeTextFile: true,
+        },
+      },
+    });
 
-    it("should include available commands", async () => {
-      const { client, connection, newSessionResponse } =
-        await setupTestSession(__dirname);
+    const newSessionResponse = await connection.newSession({
+      cwd,
+      mcpServers: [],
+    });
 
-      expect(newSessionResponse.availableCommands).toContainEqual({
-        name: "quick-math",
-        description: "10 * 3 = 30 (project)",
-        input: null,
-      });
-      expect(newSessionResponse.availableCommands).toContainEqual({
-        name: "say-hello",
-        description: "Say hello (project)",
-        input: { hint: "[name]" },
-      });
+    return { client: client!, connection, newSessionResponse };
+  }
 
-      await connection.prompt({
-        prompt: [
-          {
-            type: "text",
-            text: "/quick-math",
-          },
-        ],
-        sessionId: newSessionResponse.sessionId,
-      });
+  it("should connect to the ACP subprocess", async () => {
+    const { client, connection, newSessionResponse } = await setupTestSession("./");
 
-      expect(client.takeReceivedText()).toContain("30");
+    await connection.prompt({
+      prompt: [
+        {
+          type: "text",
+          text: "Hello",
+        },
+      ],
+      sessionId: newSessionResponse.sessionId,
+    });
 
-      await connection.prompt({
-        prompt: [
-          {
-            type: "text",
-            text: "/say-hello GPT-5",
-          },
-        ],
-        sessionId: newSessionResponse.sessionId,
-      });
+    expect(client.takeReceivedText()).not.toEqual("");
+  }, 30000);
 
-      expect(client.takeReceivedText()).toContain("Hello GPT-5");
-    }, 30000);
-  },
-);
+  it("should include available commands", async () => {
+    const { client, connection, newSessionResponse } = await setupTestSession(__dirname);
+
+    const commands = await client.availableCommandsPromise;
+
+    expect(commands).toContainEqual({
+      name: "quick-math",
+      description: "10 * 3 = 30 (project)",
+      input: null,
+    });
+    expect(commands).toContainEqual({
+      name: "say-hello",
+      description: "Say hello (project)",
+      input: { hint: "[name]" },
+    });
+
+    await connection.prompt({
+      prompt: [
+        {
+          type: "text",
+          text: "/quick-math",
+        },
+      ],
+      sessionId: newSessionResponse.sessionId,
+    });
+
+    expect(client.takeReceivedText()).toContain("30");
+
+    await connection.prompt({
+      prompt: [
+        {
+          type: "text",
+          text: "/say-hello GPT-5",
+        },
+      ],
+      sessionId: newSessionResponse.sessionId,
+    });
+
+    expect(client.takeReceivedText()).toContain("Hello GPT-5");
+  }, 30000);
+});
 
 describe("tool conversions", () => {
   it("should handle Bash nicely", () => {
@@ -233,7 +232,7 @@ describe("tool conversions", () => {
 
     expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
       kind: "search",
-      title: "Find */**.ts",
+      title: "Find `*/**.ts`",
       content: [],
       locations: [],
     });
@@ -279,8 +278,7 @@ describe("tool conversions", () => {
 
     expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
       kind: "search",
-      title:
-        "List the `/Users/test/github/claude-code-acp` directory's contents",
+      title: "List the `/Users/test/github/claude-code-acp` directory's contents",
       content: [],
       locations: [],
     });
@@ -309,7 +307,7 @@ describe("tool conversions", () => {
       id: "toolu_01ABC123XYZ789",
       name: "Write",
       input: {
-        abs_path: "/Users/test/project/example.txt",
+        file_path: "/Users/test/project/example.txt",
         content: "Hello, World!\nThis is test content.",
       },
     };
@@ -361,7 +359,7 @@ describe("tool conversions", () => {
       id: "toolu_01MNO456PQR789",
       name: "Read",
       input: {
-        abs_path: "/Users/test/project/readme.md",
+        file_path: "/Users/test/project/readme.md",
       },
     };
 
@@ -494,7 +492,7 @@ describe("tool conversions", () => {
   });
 
   it("should handle KillBash entries", () => {
-    let tool_use = {
+    const tool_use = {
       type: "tool_use",
       id: "toolu_01PhLms5fuvmdjy2bb6dfUKT",
       name: "KillBash",
@@ -511,7 +509,7 @@ describe("tool conversions", () => {
   });
 
   it("should handle BashOutput entries", () => {
-    let tool_use = {
+    const tool_use = {
       type: "tool_use",
       id: "toolu_01SJUWPtj1QspgANgtpqGPuN",
       name: "BashOutput",
@@ -568,8 +566,7 @@ describe("tool conversions", () => {
                   activeForm: "Adding concurrent access tests",
                 },
                 {
-                  content:
-                    "Add tests for Each function with various data types",
+                  content: "Add tests for Each function with various data types",
                   status: "pending",
                   activeForm: "Adding Each function tests",
                 },
@@ -657,36 +654,6 @@ describe("tool conversions", () => {
     ]);
   });
 
-  it("should extract locations from edit tool results", () => {
-    const toolUse = {
-      type: "tool_use",
-      id: "toolu_01ABC123",
-      name: "edit",
-      input: {
-        abs_path: "/Users/test/project/example.txt",
-        old_text: "old content",
-        new_text: "new content",
-      },
-    };
-
-    const toolResult = {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ lineNumbers: [5, 10, 15] }),
-        },
-      ],
-    };
-
-    const update = toolUpdateFromToolResult(toolResult, toolUse);
-
-    expect(update.locations).toEqual([
-      { path: "/Users/test/project/example.txt", line: 5 },
-      { path: "/Users/test/project/example.txt", line: 10 },
-      { path: "/Users/test/project/example.txt", line: 15 },
-    ]);
-  });
-
   it("should show full diff for multi edit tool", () => {
     const toolUse = {
       type: "tool_use",
@@ -708,7 +675,7 @@ describe("tool conversions", () => {
         ],
       },
     };
-    let fileCache: { [key: string]: string } = {
+    const fileCache: { [key: string]: string } = {
       "/Users/test/project/config.json": JSON.stringify(
         {
           version: 1,
@@ -724,14 +691,14 @@ describe("tool conversions", () => {
       content: [
         {
           newText: `{
-    \"version\": 2,
-    \"filler\": \"filler\",
-    \"enabled\": true
+    "version": 2,
+    "filler": "filler",
+    "enabled": true
 }`,
           oldText: `{
-    \"version\": 1,
-    \"filler\": \"filler\",
-    \"enabled\": false
+    "version": 1,
+    "filler": "filler",
+    "enabled": false
 }`,
           path: "/Users/test/project/config.json",
           type: "diff",
@@ -741,116 +708,26 @@ describe("tool conversions", () => {
       locations: [
         {
           path: "/Users/test/project/config.json",
+          line: 1,
+        },
+        {
+          path: "/Users/test/project/config.json",
+          line: 3,
         },
       ],
       title: "Edit /Users/test/project/config.json",
     });
   });
 
-  it("should extract locations from multi-edit tool results", () => {
-    const toolUse = {
-      type: "tool_use",
-      id: "toolu_01DEF456",
-      name: "multi-edit",
-      input: {
-        file_path: "/Users/test/project/config.json",
-        edits: [
-          {
-            old_string: "version: 1.0",
-            new_string: "version: 2.0",
-            replace_all: false,
-          },
-          {
-            old_string: "enabled: false",
-            new_string: "enabled: true",
-            replace_all: true,
-          },
-        ],
-      },
-    };
-
-    const toolResult = {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ lineNumbers: [2, 8, 12, 20] }),
-        },
-      ],
-    };
-
-    const update = toolUpdateFromToolResult(toolResult, toolUse);
-
-    expect(update.locations).toEqual([
-      { path: "/Users/test/project/config.json", line: 2 },
-      { path: "/Users/test/project/config.json", line: 8 },
-      { path: "/Users/test/project/config.json", line: 12 },
-      { path: "/Users/test/project/config.json", line: 20 },
-    ]);
-  });
-
-  it("should handle mcp__acp__edit tool results", () => {
-    const toolUse = {
-      type: "tool_use",
-      id: "toolu_01GHI789",
-      name: "mcp__acp__edit",
-      input: {
-        abs_path: "/Users/test/project/main.py",
-        old_text: "def hello():",
-        new_text: "def hello_world():",
-      },
-    };
-
-    const toolResult = {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ lineNumbers: [42] }),
-        },
-      ],
-    };
-
-    const update = toolUpdateFromToolResult(toolResult, toolUse);
-
-    expect(update.locations).toEqual([
-      { path: "/Users/test/project/main.py", line: 42 },
-    ]);
-  });
-
-  it("should handle empty locations from edit tools", () => {
-    const toolUse = {
-      type: "tool_use",
-      id: "toolu_01JKL012",
-      name: "edit",
-      input: {
-        abs_path: "/Users/test/project/notfound.txt",
-        old_text: "nonexistent",
-        new_text: "replacement",
-      },
-    };
-
-    const toolResult = {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ lineNumbers: [] }),
-        },
-      ],
-    };
-
-    const update = toolUpdateFromToolResult(toolResult, toolUse);
-
-    expect(update.locations).toEqual([]);
-  });
-
-  it("should handle malformed tool results gracefully", () => {
+  it("should return empty update for successful edit result", () => {
     const toolUse = {
       type: "tool_use",
       id: "toolu_01MNO345",
-      name: "edit",
+      name: "mcp__acp__edit",
       input: {
         abs_path: "/Users/test/project/test.txt",
-        old_text: "old",
-        new_text: "new",
+        old_string: "old",
+        new_string: "new",
       },
     };
 
@@ -861,6 +738,9 @@ describe("tool conversions", () => {
           text: "not valid json",
         },
       ],
+      tool_use_id: "test",
+      is_error: false,
+      type: "tool_result" as const,
     };
 
     const update = toolUpdateFromToolResult(toolResult, toolUse);
@@ -868,6 +748,40 @@ describe("tool conversions", () => {
     // Should return empty object when parsing fails
     expect(update).toEqual({});
   });
+
+  it("should return content update for edit failure", () => {
+    const toolUse = {
+      type: "tool_use",
+      id: "toolu_01MNO345",
+      name: "mcp__acp__edit",
+      input: {
+        abs_path: "/Users/test/project/test.txt",
+        old_string: "old",
+        new_string: "new",
+      },
+    };
+
+    const toolResult = {
+      content: [
+        {
+          type: "text",
+          text: "Failed to find `old_string`",
+        },
+      ],
+      tool_use_id: "test",
+      is_error: true,
+      type: "tool_result" as const,
+    };
+
+    const update = toolUpdateFromToolResult(toolResult, toolUse);
+
+    // Should return empty object when parsing fails
+    expect(update).toEqual({
+      content: [
+        { content: { type: "text", text: "Failed to find `old_string`" }, type: "content" },
+      ],
+    });
+  });
 });
 
 describe("escape markdown", () => {
@@ -878,8 +792,6 @@ describe("escape markdown", () => {
 
     text = "for example:\n```markdown\nHello *world*!\n```\n";
     escaped = markdownEscape(text);
-    expect(escaped).toEqual(
-      "````\nfor example:\n```markdown\nHello *world*!\n```\n````",
-    );
+    expect(escaped).toEqual("````\nfor example:\n```markdown\nHello *world*!\n```\n````");
   });
 });

src/tests/replace-and-calculate-location.test.ts

@@ -4,13 +4,9 @@ import { replaceAndCalculateLocation } from "../mcp-server.js";
 describe("replaceAndCalculateLocation", () => {
   it("should replace first occurrence and return correct line number", () => {
     const content = "line 1\nline 2 with text\nline 3 with text\nline 4";
-    const result = replaceAndCalculateLocation(content, [
-      { oldText: "text", newText: "replaced" },
-    ]);
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
 
-    expect(result.newContent).toBe(
-      "line 1\nline 2 with replaced\nline 3 with text\nline 4",
-    );
+    expect(result.newContent).toBe("line 1\nline 2 with replaced\nline 3 with text\nline 4");
     expect(result.lineNumbers).toEqual([1]); // Line 2 (0-based indexing)
   });
 
@@ -20,20 +16,15 @@ describe("replaceAndCalculateLocation", () => {
       { oldText: "text", newText: "replaced", replaceAll: true },
     ]);
 
-    expect(result.newContent).toBe(
-      "line 1\nline 2 with replaced\nline 3 with replaced\nline 4",
-    );
+    expect(result.newContent).toBe("line 1\nline 2 with replaced\nline 3 with replaced\nline 4");
     expect(result.lineNumbers).toEqual([1, 2]); // Lines 2 and 3 (0-based)
   });
 
   it("should return empty line numbers array when no match found", () => {
     const content = "line 1\nline 2\nline 3";
-    const result = replaceAndCalculateLocation(content, [
-      { oldText: "notfound", newText: "replaced" },
-    ]);
-
-    expect(result.newContent).toBe(content);
-    expect(result.lineNumbers).toEqual([]);
+    expect(() => {
+      replaceAndCalculateLocation(content, [{ oldText: "notfound", newText: "replaced" }]);
+    }).toThrow('The provided `old_string` does not appear in the file: "notfound"');
   });
 
   it("should handle Windows line endings (CRLF)", () => {
@@ -54,9 +45,7 @@ describe("replaceAndCalculateLocation", () => {
       { oldText: "text", newText: "replaced", replaceAll: true },
     ]);
 
-    expect(result.newContent).toBe(
-      "line 1\rline 2 with replaced\rline 3 with replaced\rline 4",
-    );
+    expect(result.newContent).toBe("line 1\rline 2 with replaced\rline 3 with replaced\rline 4");
     expect(result.lineNumbers).toEqual([1, 2]);
   });
 
@@ -66,17 +55,13 @@ describe("replaceAndCalculateLocation", () => {
       { oldText: "text", newText: "replaced", replaceAll: true },
     ]);
 
-    expect(result.newContent).toBe(
-      "line 1\nline 2 with replaced\r\nline 3 with replaced\rline 4",
-    );
+    expect(result.newContent).toBe("line 1\nline 2 with replaced\r\nline 3 with replaced\rline 4");
     expect(result.lineNumbers).toEqual([1, 2]);
   });
 
   it("should handle text at the beginning of file", () => {
     const content = "text at start\nline 2\nline 3";
-    const result = replaceAndCalculateLocation(content, [
-      { oldText: "text", newText: "replaced" },
-    ]);
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
 
     expect(result.newContent).toBe("replaced at start\nline 2\nline 3");
     expect(result.lineNumbers).toEqual([0]); // First line (0-based)
@@ -84,9 +69,7 @@ describe("replaceAndCalculateLocation", () => {
 
   it("should handle text at the end of file", () => {
     const content = "line 1\nline 2\nlast line with text";
-    const result = replaceAndCalculateLocation(content, [
-      { oldText: "text", newText: "replaced" },
-    ]);
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
 
     expect(result.newContent).toBe("line 1\nline 2\nlast line with replaced");
     expect(result.lineNumbers).toEqual([2]); // Last line (0-based)
@@ -98,53 +81,41 @@ describe("replaceAndCalculateLocation", () => {
       { oldText: "text", newText: "replaced", replaceAll: true },
     ]);
 
-    expect(result.newContent).toBe(
-      "line 1\nreplaced replaced replaced\nline 3",
-    );
+    expect(result.newContent).toBe("line 1\nreplaced replaced replaced\nline 3");
     expect(result.lineNumbers).toEqual([1]); // All on line 2 (0-based), deduplicated
   });
 
   it("should handle empty file content", () => {
-    const content = "";
-    const result = replaceAndCalculateLocation(content, [
-      { oldText: "text", newText: "replaced" },
-    ]);
-
-    expect(result.newContent).toBe("");
-    expect(result.lineNumbers).toEqual([]);
+    expect(() => {
+      replaceAndCalculateLocation("", [{ oldText: "text", newText: "replaced" }]);
+    }).toThrowError(
+      'The provided `old_string` does not appear in the file: "text".\n\nNo edits were applied.',
+    );
   });
 
   it("should handle empty search text", () => {
     // Test with replaceAll false (default)
     const content1 = "line 1\nline 2\nline 3";
-    const result1 = replaceAndCalculateLocation(content1, [
-      { oldText: "", newText: "replaced" },
-    ]);
-    expect(result1.newContent).toBe(content1);
-    expect(result1.lineNumbers).toEqual([]);
+    expect(() => {
+      replaceAndCalculateLocation(content1, [{ oldText: "", newText: "replaced" }]);
+    }).toThrowError("The provided `old_string` is empty.\n\nNo edits were applied.");
 
     // Test with replaceAll true on single line
     const content2 = "abc";
-    const result2 = replaceAndCalculateLocation(content2, [
-      { oldText: "", newText: "X", replaceAll: true },
-    ]);
-    expect(result2.newContent).toBe(content2);
-    expect(result2.lineNumbers).toEqual([]);
+    expect(() => {
+      replaceAndCalculateLocation(content2, [{ oldText: "", newText: "X", replaceAll: true }]);
+    }).toThrowError("The provided `old_string` is empty.\n\nNo edits were applied.");
 
     // Test with replaceAll true on multiline content
     const content3 = "ab\ncd";
-    const result3 = replaceAndCalculateLocation(content3, [
-      { oldText: "", newText: "X", replaceAll: true },
-    ]);
-    expect(result3.newContent).toBe(content3);
-    expect(result3.lineNumbers).toEqual([]);
+    expect(() => {
+      replaceAndCalculateLocation(content3, [{ oldText: "", newText: "X", replaceAll: true }]);
+    }).toThrowError("The provided `old_string` is empty.\n\nNo edits were applied.");
   });
 
   it("should handle single line content", () => {
     const content = "single line with text here";
-    const result = replaceAndCalculateLocation(content, [
-      { oldText: "text", newText: "replaced" },
-    ]);
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
 
     expect(result.newContent).toBe("single line with replaced here");
     expect(result.lineNumbers).toEqual([0]); // Line 1 (0-based)
@@ -183,9 +154,7 @@ describe("replaceAndCalculateLocation", () => {
   it("should handle very long lines", () => {
     const longLine = "a".repeat(10000) + "text" + "b".repeat(10000);
     const content = `line 1\n${longLine}\nline 3`;
-    const result = replaceAndCalculateLocation(content, [
-      { oldText: "text", newText: "replaced" },
-    ]);
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
 
     expect(result.newContent).toBe(
       `line 1\n${"a".repeat(10000)}replaced${"b".repeat(10000)}\nline 3`,
@@ -198,9 +167,7 @@ describe("replaceAndCalculateLocation", () => {
     lines[500] = "line with text";
     const content = lines.join("\n");
 
-    const result = replaceAndCalculateLocation(content, [
-      { oldText: "text", newText: "replaced" },
-    ]);
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
 
     expect(result.lineNumbers).toEqual([500]);
     expect(result.newContent).includes("line with replaced");
@@ -224,9 +191,7 @@ describe("replaceAndCalculateLocation", () => {
     const result1 = replaceAndCalculateLocation(content, [
       { oldText: "short", newText: "very very long text" },
     ]);
-    expect(result1.newContent).toBe(
-      "very very long text\nmedium line\nlong line here",
-    );
+    expect(result1.newContent).toBe("very very long text\nmedium line\nlong line here");
     expect(result1.lineNumbers).toEqual([0]);
 
     // Replacing with shorter text
@@ -260,9 +225,7 @@ describe("replaceAndCalculateLocation", () => {
 
   it("should handle replacement at exact end of line", () => {
     const content = "line ends with text\nnext line";
-    const result = replaceAndCalculateLocation(content, [
-      { oldText: "text", newText: "replaced" },
-    ]);
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
 
     expect(result.newContent).toBe("line ends with replaced\nnext line");
     expect(result.lineNumbers).toEqual([0]);
@@ -302,9 +265,7 @@ describe("replaceAndCalculateLocation", () => {
     // - All "foo" occurrences (lines 1, 3, 5 in original)
     // - First "bar" occurrence (line 1 after first edit)
     // - "line 3" (line 2 after previous edits)
-    expect(result.newContent).toBe(
-      "line 1\nFOO BAR\nLINE THREE\nFOO baz\nline 5\nbar FOO\nline 7",
-    );
+    expect(result.newContent).toBe("line 1\nFOO BAR\nLINE THREE\nFOO baz\nline 5\nbar FOO\nline 7");
 
     // Line numbers reflect position in final content, deduplicated and sorted
     expect(result.lineNumbers).toEqual([
@@ -326,9 +287,7 @@ describe("replaceAndCalculateLocation", () => {
     // First edit replaces first "hello" only
     // Second edit replaces all "world" in the modified content
     // Third edit replaces remaining "hello"s in the modified content
-    expect(result.newContent).toBe(
-      "hi earth\ngreetings greetings\nearth greetings earth",
-    );
+    expect(result.newContent).toBe("hi earth\ngreetings greetings\nearth greetings earth");
 
     // Line numbers reflect position in final content, deduplicated and sorted
     expect(result.lineNumbers).toEqual([
@@ -340,17 +299,14 @@ describe("replaceAndCalculateLocation", () => {
 
   it("should handle complex scenarios with marker-like text", () => {
     // Test that our marker approach doesn't get confused by similar text
-    const content =
-      "line 1\n__MARKER__text\nline 3\n__REPLACE_MARKER_abc__\nline 5";
+    const content = "line 1\n__MARKER__text\nline 3\n__REPLACE_MARKER_abc__\nline 5";
     const result = replaceAndCalculateLocation(content, [
       { oldText: "__MARKER__", newText: "REPLACED", replaceAll: true },
       { oldText: "text", newText: "content" },
       { oldText: "__REPLACE_MARKER_abc__", newText: "DONE" },
     ]);
 
-    expect(result.newContent).toBe(
-      "line 1\nREPLACEDcontent\nline 3\nDONE\nline 5",
-    );
+    expect(result.newContent).toBe("line 1\nREPLACEDcontent\nline 3\nDONE\nline 5");
 
     // Line numbers should be correct even with marker-like text
     expect(result.lineNumbers).toEqual([

src/tools.ts

@@ -1,13 +1,10 @@
-import { ContentBlock } from "@modelcontextprotocol/sdk/types.js";
 import {
-  Client,
   PlanEntry,
   ToolCallContent,
   ToolCallLocation,
   ToolKind,
 } from "@zed-industries/agent-client-protocol";
-import { replaceAndCalculateLocation, SYSTEM_REMINDER } from "./mcp-server.js";
-import { tool } from "@anthropic-ai/claude-code";
+import { replaceAndCalculateLocation, SYSTEM_REMINDER, toolNames } from "./mcp-server.js";
 
 interface ToolInfo {
   title: string;
@@ -47,9 +44,7 @@ export function toolInfoFromToolUse(
 
     case "NotebookRead":
       return {
-        title: input?.notebook_path
-          ? `Read Notebook ${input.notebook_path}`
-          : "Read Notebook",
+        title: input?.notebook_path ? `Read Notebook ${input.notebook_path}` : "Read Notebook",
         kind: "read",
         content: [],
         locations: input?.notebook_path ? [{ path: input.notebook_path }] : [],
@@ -57,9 +52,7 @@ export function toolInfoFromToolUse(
 
     case "NotebookEdit":
       return {
-        title: input?.notebook_path
-          ? `Edit Notebook ${input.notebook_path}`
-          : "Edit Notebook",
+        title: input?.notebook_path ? `Edit Notebook ${input.notebook_path}` : "Edit Notebook",
         kind: "edit",
         content:
           input && input.new_source
@@ -74,11 +67,9 @@ export function toolInfoFromToolUse(
       };
 
     case "Bash":
-    case "mcp__acp__Bash":
+    case toolNames.bash:
       return {
-        title: input?.command
-          ? "`" + input.command.replaceAll("`", "\\`") + "`"
-          : "Terminal",
+        title: input?.command ? "`" + input.command.replaceAll("`", "\\`") + "`" : "Terminal",
         kind: "execute",
         content:
           input && input.description
@@ -92,7 +83,7 @@ export function toolInfoFromToolUse(
       };
 
     case "BashOutput":
-    case "mcp__acp__BashOutput":
+    case toolNames.bashOutput:
       return {
         title: "Tail Logs",
         kind: "execute",
@@ -100,22 +91,18 @@ export function toolInfoFromToolUse(
       };
 
     case "KillBash":
-    case "mcp__acp__KillBash":
+    case toolNames.killBash:
       return {
         title: "Kill Process",
         kind: "execute",
         content: [],
       };
 
-    case "mcp__acp__read": {
+    case toolNames.read: {
       let limit = "";
       if (input.limit) {
         limit =
-          " (" +
-          ((input.offset ?? 0) + 1) +
-          " - " +
-          ((input.offset ?? 0) + input.limit) +
-          ")";
+          " (" + ((input.offset ?? 0) + 1) + " - " + ((input.offset ?? 0) + input.limit) + ")";
       } else if (input.offset) {
         limit = " (from line " + (input.offset + 1) + ")";
       }
@@ -137,7 +124,7 @@ export function toolInfoFromToolUse(
         title: "Read File",
         kind: "read",
         content: [],
-        locations: [{ path: input.abs_path, line: input.offset ?? 0 }],
+        locations: [{ path: input.file_path, line: input.offset ?? 0 }],
       };
 
     case "LS":
@@ -148,47 +135,55 @@ export function toolInfoFromToolUse(
         locations: [],
       };
 
-    case "mcp__acp__edit":
-    case "Edit":
-      let oldText = input.old_text || null;
-      let newText = input.new_text;
+    case toolNames.edit:
+    case "Edit": {
+      const path = input?.abs_path ?? input?.file_path;
+      let oldText = input.old_string ?? null;
+      let newText = input.new_string ?? "";
+      let affectedLines: number[] = [];
 
-      if (input?.abs_path && input.old_text) {
+      if (path && oldText) {
         try {
-          let oldContent = cachedFileContent[input.abs_path] || "";
-          let newContent = replaceAndCalculateLocation(oldContent, [
+          const oldContent = cachedFileContent[path] || "";
+          const newContent = replaceAndCalculateLocation(oldContent, [
             {
-              oldText: input.old_text,
-              newText: input.new_text,
+              oldText,
+              newText,
               replaceAll: false,
             },
           ]);
           oldText = oldContent;
           newText = newContent.newContent;
+          affectedLines = newContent.lineNumbers;
         } catch (e) {
           console.error(e);
         }
       }
       return {
-        title: input?.abs_path ? `Edit ${input.abs_path}` : "Edit",
+        title: path ? `Edit \`${path}\`` : "Edit",
         kind: "edit",
         content:
-          input && input.abs_path
+          input && path
             ? [
                 {
                   type: "diff",
-                  path: input.abs_path,
+                  path,
                   oldText,
                   newText,
                 },
               ]
             : [],
-        locations: input?.abs_path ? [{ path: input.abs_path }] : [],
+        locations: path
+          ? affectedLines.length > 0
+            ? affectedLines.map((line) => ({ line, path }))
+            : [{ path }]
+          : [],
       };
+    }
 
-    case "mcp__acp__multi-edit":
-    case "MultiEdit":
-      let multiInput = input as {
+    case toolNames.multiEdit:
+    case "MultiEdit": {
+      const multiInput = input as {
         file_path: string;
         edits: {
           old_string: string;
@@ -196,18 +191,15 @@ export function toolInfoFromToolUse(
           replace_all?: boolean;
         }[];
       };
-      let oldTextMulti = multiInput.edits
-        .map((edit: any) => edit.old_string)
-        .join("\n");
-      let newTextMulti = multiInput.edits
-        .map((edit: any) => edit.new_string)
-        .join("\n");
+      let oldTextMulti = multiInput.edits.map((edit: any) => edit.old_string).join("\n");
+      let newTextMulti = multiInput.edits.map((edit: any) => edit.new_string).join("\n");
+      let affectedLines: number[] = [];
       try {
         if (multiInput.edits && multiInput.file_path) {
-          let oldContent =
+          const oldContent =
             cachedFileContent[multiInput.file_path] ||
             multiInput.edits.map((edit: any) => edit.oldText).join("\n");
-          let newContent = replaceAndCalculateLocation(
+          const newContent = replaceAndCalculateLocation(
             oldContent,
             multiInput.edits.map((edit) => ({
               oldText: edit.old_string,
@@ -217,6 +209,7 @@ export function toolInfoFromToolUse(
           );
           oldTextMulti = oldContent;
           newTextMulti = newContent.newContent;
+          affectedLines = newContent.lineNumbers;
         }
       } catch (e) {
         console.error(e);
@@ -234,10 +227,14 @@ export function toolInfoFromToolUse(
             newText: newTextMulti,
           },
         ],
-        locations: input?.file_path ? [{ path: input.file_path }] : [],
+        locations: input?.file_path
+          ? affectedLines.length > 0
+            ? affectedLines.map((line) => ({ line, path: input.file_path }))
+            : [{ path: input.file_path }]
+          : [],
       };
-
-    case "mcp__acp__write":
+    }
+    case toolNames.write: {
       let content: ToolCallContent[] = [];
       if (input && input.abs_path) {
         content = [
@@ -262,32 +259,33 @@ export function toolInfoFromToolUse(
         content,
         locations: input?.abs_path ? [{ path: input.abs_path }] : [],
       };
+    }
 
     case "Write":
       return {
-        title: input?.abs_path ? `Write ${input.abs_path}` : "Write",
+        title: input?.file_path ? `Write ${input.file_path}` : "Write",
         kind: "edit",
         content:
-          input && input.abs_path
+          input && input.file_path
             ? [
                 {
                   type: "diff",
-                  path: input.abs_path,
+                  path: input.file_path,
                   oldText: null,
                   newText: input.content,
                 },
               ]
             : [],
-        locations: input?.abs_path ? [{ path: input.abs_path }] : [],
+        locations: input?.file_path ? [{ path: input.file_path }] : [],
       };
 
     case "Glob": {
       let label = "Find";
       if (input.path) {
-        label += ` ${input.path}`;
+        label += ` \`${input.path}\``;
       }
       if (input.pattern) {
-        label += ` ${input.pattern}`;
+        label += ` \`${input.pattern}\``;
       }
       return {
         title: label,
@@ -326,6 +324,7 @@ export function toolInfoFromToolUse(
             label += " -c";
             break;
           case "Content":
+          default:
             break;
         }
       }
@@ -401,10 +400,10 @@ export function toolInfoFromToolUse(
         content: [],
       };
 
-    case "exit_plan_mode":
+    case "ExitPlanMode":
       return {
-        title: "Exit Plan Mode",
-        kind: "think",
+        title: "Ready to code?",
+        kind: "switch_mode",
         content:
           input && input.plan
             ? [{ type: "content", content: { type: "text", text: input.plan } }]
@@ -435,94 +434,41 @@ export function toolInfoFromToolUse(
   }
 }
 
+type ToolResult = {
+  type: "tool_result";
+  content: any;
+  tool_use_id: string;
+  is_error: boolean;
+};
+
 export function toolUpdateFromToolResult(
-  toolResult: any,
+  toolResult: ToolResult,
   toolUse: any | undefined,
 ): ToolUpdate {
   switch (toolUse?.name) {
-    case "mcp__acp__edit":
-    case "edit":
-    case "Edit": {
-      // Parse the line numbers from the tool result
-      if (toolResult.content && toolResult.content.length > 0) {
-        try {
-          const firstContent = toolResult.content[0];
-          const data = JSON.parse(firstContent.text || firstContent);
-          if (data.lineNumbers && Array.isArray(data.lineNumbers)) {
-            const locations: ToolCallLocation[] = data.lineNumbers.map(
-              (line: number) => ({
-                path: toolUse?.input?.abs_path || toolUse?.input?.file_path,
-                line: line,
-              }),
-            );
-            return { locations };
-          }
-        } catch (e) {
-          // If parsing fails, return empty object
-          return {};
-        }
-      }
-      return {};
-    }
-    case "mcp__acp__multi-edit":
-    case "multi-edit":
-    case "MultiEdit": {
-      // Parse the line numbers from the tool result
-      if (toolResult.content && toolResult.content.length > 0) {
-        try {
-          const firstContent = toolResult.content[0];
-          const data = JSON.parse(firstContent.text || firstContent);
-          if (data.lineNumbers && Array.isArray(data.lineNumbers)) {
-            const locations: ToolCallLocation[] = data.lineNumbers.map(
-              (line: number) => ({
-                path: toolUse?.input?.file_path || toolUse?.input?.abs_path,
-                line: line,
-              }),
-            );
-            return { locations };
-          }
-        } catch (e) {
-          // If parsing fails, return empty object
-          return {};
-        }
-      }
-      return {};
-    }
-
-    case "mcp__acp__write":
-    case "Write":
-      return {};
-
     case "Read":
-    case "mcp__acp__read":
+    case toolNames.read:
       if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
         return {
           content: toolResult.content.map((content: any) => ({
             type: "content",
             content:
-              content.type == "text"
+              content.type === "text"
                 ? {
                     type: "text",
-                    text: markdownEscape(
-                      content.text.replace(SYSTEM_REMINDER, ""),
-                    ),
+                    text: markdownEscape(content.text.replace(SYSTEM_REMINDER, "")),
                   }
                 : content,
           })),
         };
-      } else if (
-        typeof toolResult.content === "string" &&
-        toolResult.content.length > 0
-      ) {
+      } else if (typeof toolResult.content === "string" && toolResult.content.length > 0) {
         return {
           content: [
             {
               type: "content",
               content: {
                 type: "text",
-                text: markdownEscape(
-                  toolResult.content.replace(SYSTEM_REMINDER, ""),
-                ),
+                text: markdownEscape(toolResult.content.replace(SYSTEM_REMINDER, "")),
               },
             },
           ],
@@ -530,9 +476,25 @@ export function toolUpdateFromToolResult(
       }
       return {};
 
-    case "mcp__acp__Bash":
-      // The bash tool already embeds a terminal
+    case toolNames.bash:
+    case "edit":
+    case "Edit":
+    case toolNames.edit:
+    case toolNames.multiEdit:
+    case "multi-edit":
+    case "MultiEdit":
+    case toolNames.write:
+    case "Write": {
+      if (toolResult.is_error && toolResult.content?.length > 0) {
+        // Only return errors
+        return toAcpContentUpdate(toolResult.content);
+      }
       return {};
+    }
+
+    case "ExitPlanMode": {
+      return { title: "Exited Plan Mode" };
+    }
 
     case "Task":
     case "NotebookEdit":
@@ -549,34 +511,35 @@ export function toolUpdateFromToolResult(
     case "WebSearch":
     case "Other":
     default: {
-      if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
-        return {
-          content: toolResult.content.map((content: any) => ({
-            type: "content",
-            content,
-          })),
-        };
-      } else if (
-        typeof toolResult.content === "string" &&
-        toolResult.content.length > 0
-      ) {
-        return {
-          content: [
-            {
-              type: "content",
-              content: {
-                type: "text",
-                text: toolResult.content,
-              },
-            },
-          ],
-        };
-      }
-      return {};
+      return toAcpContentUpdate(toolResult.content);
     }
   }
 }
 
+function toAcpContentUpdate(content: any): { content?: ToolCallContent[] } {
+  if (Array.isArray(content) && content.length > 0) {
+    return {
+      content: content.map((content: any) => ({
+        type: "content",
+        content,
+      })),
+    };
+  } else if (typeof content === "string" && content.length > 0) {
+    return {
+      content: [
+        {
+          type: "content",
+          content: {
+            type: "text",
+            text: content,
+          },
+        },
+      ],
+    };
+  }
+  return {};
+}
+
 type ClaudePlanEntry = {
   content: string;
   status: "pending" | "in_progress" | "completed";
@@ -593,7 +556,7 @@ export function planEntries(input: { todos: ClaudePlanEntry[] }): PlanEntry[] {
 
 export function markdownEscape(text: string): string {
   let escape = "```";
-  for (let [m] of text.matchAll(/^```+/gm)) {
+  for (const [m] of text.matchAll(/^```+/gm)) {
     while (m.length >= escape.length) {
       escape += "`";
     }

src/utils.ts

@@ -2,6 +2,8 @@
 
 import { Readable, Writable } from "node:stream";
 import { WritableStream, ReadableStream } from "node:stream/web";
+import { readFileSync } from "node:fs";
+import { platform } from "node:os";
 
 // Useful for bridging push-based and async-iterator-based code.
 export class Pushable<T> implements AsyncIterable<T> {
@@ -45,24 +47,23 @@ export class Pushable<T> implements AsyncIterable<T> {
 }
 
 // Helper to convert Node.js streams to Web Streams
-export function nodeToWebWritable(
-  nodeStream: Writable,
-): WritableStream<Uint8Array> {
+export function nodeToWebWritable(nodeStream: Writable): WritableStream<Uint8Array> {
   return new WritableStream<Uint8Array>({
     write(chunk) {
       return new Promise<void>((resolve, reject) => {
         nodeStream.write(Buffer.from(chunk), (err) => {
-          if (err) reject(err);
-          else resolve();
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
         });
       });
     },
   });
 }
 
-export function nodeToWebReadable(
-  nodeStream: Readable,
-): ReadableStream<Uint8Array> {
+export function nodeToWebReadable(nodeStream: Readable): ReadableStream<Uint8Array> {
   return new ReadableStream<Uint8Array>({
     start(controller) {
       nodeStream.on("data", (chunk: Buffer) => {
@@ -77,3 +78,47 @@ export function nodeToWebReadable(
 export function unreachable(value: never): never {
   throw new Error(`Unexpected case: ${value}`);
 }
+
+export function sleep(time: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, time));
+}
+
+interface ManagedSettings {
+  permissions?: {
+    allow?: string[];
+    deny?: string[];
+  };
+  env?: Record<string, string>;
+}
+
+// Following the rules in https://docs.anthropic.com/en/docs/claude-code/settings#settings-files
+// This can be removed once the SDK supports it natively.
+function getManagedSettingsPath(): string {
+  const os = platform();
+  switch (os) {
+    case "darwin":
+      return "/Library/Application Support/ClaudeCode/managed-settings.json";
+    case "linux": // including WSL
+      return "/etc/claude-code/managed-settings.json";
+    case "win32":
+      return "C:\\ProgramData\\ClaudeCode\\managed-settings.json";
+    default:
+      return "/etc/claude-code/managed-settings.json";
+  }
+}
+
+export function loadManagedSettings(): ManagedSettings | null {
+  try {
+    return JSON.parse(readFileSync(getManagedSettingsPath(), "utf8")) as ManagedSettings;
+  } catch {
+    return null;
+  }
+}
+
+export function applyEnvironmentSettings(settings: ManagedSettings): void {
+  if (settings.env) {
+    for (const [key, value] of Object.entries(settings.env)) {
+      process.env[key] = value;
+    }
+  }
+}