0.1.11

.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/publish.yml

@@ -6,7 +6,6 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
-    environment: release # Optional: for enhanced security
     permissions:
       contents: read
       id-token: write
@@ -17,8 +16,8 @@ jobs:
         with:
           node-version: "lts/*"
           registry-url: "https://registry.npmjs.org"
-      - name: Update npm
-        run: npm install -g npm@latest
       - run: npm ci
-      - run: npm run build
-      - run: npm publish
+        # Add back provenance once repo is public
+      - run: npm publish # --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

CHANGELOG.md

@@ -1,20 +0,0 @@
-# Changelog
-
-## v0.4.3
-
-- Move ACP tools over MCP from an "http" MCP server to an "sdk" one so more tool calls can stay in-memory.
-- Update to @anthropic-ai/claude-code@v1.0.119
-- Update to @zed-industries/agent-client-protocol@v0.4.0
-
-## v0.4.2
-
-- Fix missing package.json metadata
-
-## v0.4.1
-
-- Add support for /compact command [ecfd36a](https://github.com/zed-industries/claude-code-acp/commit/ecfd36afa6c4e31f12e1daf9b8a2bdc12dda1794)
-- Add default limits to read tool [7bd1638](https://github.com/zed-industries/claude-code-acp/commit/7bd163818bb959b11fd2c933eff73ad83c57abb8)
-- Better rendering of Tool errors [491efe3](https://github.com/zed-industries/claude-code-acp/commit/491efe32e8547075842e448d873fc01b2ffabf3a)
-- Load managed-settings.json [f691024](https://github.com/zed-industries/claude-code-acp/commit/f691024350362858e00b97248ac68e356d2331c2)
-- Update to @anthropic-ai/claude-code@v1.0.113
-- Update to @zed-industries/agent-client-protocol@v0.3.1

README.md

@@ -1,14 +1,12 @@
 # ACP adapter for Claude Code
 
-[![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)
+- Tool calls
 - Following
 - Edit review
 - TODO lists
@@ -28,27 +26,24 @@ To use Claude Code, open the Agent Panel and click "New Claude Code Thread" from
 
 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.
+[Read the docs](https://zed.dev/docs/ai/external-agents) on External Agent support.
 
 ### Other clients
 
-- Neovim via [CodeCompanion.nvim](https://codecompanion.olimorris.dev/configuration/adapters#setup-claude-code-via-acp)
-- [marimo notebook](https://github.com/marimo-team/marimo)
-
-[Submit a PR](https://github.com/zed-industries/claude-code-acp/pulls) to add yours!
+Setup instructions for other clients are coming soon. Feel free to [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
+$ 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
+$ ANTHROPIC_API_KEY=sk-... claude-code-acp
 ```
 
 ## License

eslint.config.js

@@ -1,48 +0,0 @@
-import js from "@eslint/js";
-import tseslint from "@typescript-eslint/eslint-plugin";
-import tsparser from "@typescript-eslint/parser";
-import prettierConfig from "eslint-config-prettier";
-import globals from "globals";
-
-export default [
-  {
-    ignores: ["node_modules/", "dist/", "coverage/", "*.min.js", "*.config.js", ".github/"],
-  },
-  js.configs.recommended,
-  {
-    files: ["src/**/*.ts"],
-    languageOptions: {
-      ecmaVersion: 2020,
-      sourceType: "module",
-      parser: tsparser,
-      parserOptions: {
-        project: "./tsconfig.json",
-      },
-      globals: {
-        ...globals.node,
-      },
-    },
-    plugins: {
-      "@typescript-eslint": tseslint,
-    },
-    rules: {
-      ...tseslint.configs.recommended.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"],
-    },
-  },
-  prettierConfig,
-];

package.json

@@ -6,7 +6,7 @@
   "bin": {
     "claude-code-acp": "./dist/index.js"
   },
-  "version": "0.4.3",
+  "version": "0.1.11",
   "description": "An ACP-compatible coding agent powered by the Claude Code SDK (TypeScript)",
   "main": "dist/index.js",
   "type": "module",
@@ -40,39 +40,29 @@
     "sdk",
     "code"
   ],
-  "homepage": "https://github.com/zed-industries/claude-code-acp#readme",
-  "bugs": {
-    "url": "https://github.com/zed-industries/claude-code-acp/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/zed-industries/claude-code-acp.git"
-  },
   "author": "Zed Industries",
   "license": "Apache-2.0",
   "dependencies": {
-    "@anthropic-ai/claude-code": "1.0.119",
-    "@modelcontextprotocol/sdk": "1.18.1",
-    "@zed-industries/agent-client-protocol": "0.4.0",
-    "diff": "8.0.2",
-    "express": "5.1.0",
-    "minimist": "1.2.8",
-    "uuid": "13.0.0"
+    "@anthropic-ai/claude-code": "^1.0.100",
+    "@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"
   },
   "devDependencies": {
-    "@types/express": "5.0.3",
-    "@types/minimist": "1.2.5",
-    "@types/node": "24.5.2",
-    "@types/uuid": "10.0.0",
-    "@typescript-eslint/eslint-plugin": "8.44.0",
-    "@typescript-eslint/parser": "8.44.0",
-    "@vitest/ui": "3.2.4",
-    "eslint": "9.35.0",
-    "eslint-config-prettier": "10.1.8",
-    "globals": "16.4.0",
-    "prettier": "3.6.2",
-    "ts-node": "10.9.2",
-    "typescript": "5.9.2",
-    "vitest": "3.2.4"
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^24.3.0",
+    "@types/uuid": "^10.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.42.0",
+    "@typescript-eslint/parser": "^8.42.0",
+    "@vitest/ui": "^3.2.4",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.6.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.0",
+    "vitest": "^3.2.4"
   }
 }

src/acp-agent.ts

@@ -7,7 +7,6 @@ import {
   ClientCapabilities,
   InitializeRequest,
   InitializeResponse,
-  ndJsonStream,
   NewSessionRequest,
   NewSessionResponse,
   PromptRequest,
@@ -15,8 +14,6 @@ import {
   ReadTextFileRequest,
   ReadTextFileResponse,
   RequestError,
-  SetSessionModeRequest,
-  SetSessionModeResponse,
   TerminalHandle,
   TerminalOutputResponse,
   WriteTextFileRequest,
@@ -25,7 +22,6 @@ import {
 import {
   McpServerConfig,
   Options,
-  PermissionMode,
   Query,
   query,
   SDKAssistantMessage,
@@ -35,14 +31,9 @@ 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, sleep, unreachable } from "./utils.js";
 import { SessionNotification } from "@zed-industries/agent-client-protocol";
-import {
-  createMcpServer,
-  createPermissionMcpServer,
-  PERMISSION_TOOL_NAME,
-  toolNames,
-} from "./mcp-server.js";
+import { createMcpServer } from "./mcp-server.js";
 import { AddressInfo } from "node:net";
 import { toolInfoFromToolUse, planEntries, toolUpdateFromToolResult } from "./tools.js";
 
@@ -50,7 +41,6 @@ type Session = {
   query: Query;
   input: Pushable<SDKUserMessage>;
   cancelled: boolean;
-  permissionMode: PermissionMode;
 };
 
 type BackgroundTerminal =
@@ -96,66 +86,42 @@ export class ClaudeAcpAgent implements Agent {
           image: true,
           embeddedContext: true,
         },
-        mcpCapabilities: {
-          http: true,
-          sse: true,
-        },
       },
       authMethods: [
         {
           description: "Run `claude /login` in the terminal",
-          name: "Log in with Claude Code",
+          name: "Login with Claude CLI",
           id: "claude-login",
         },
+        {
+          description: "Anthropic API KEY",
+          name: "Use Anthropic API Key",
+          id: "anthropic-api-key",
+        },
       ],
     };
   }
   async newSession(params: NewSessionRequest): Promise<NewSessionResponse> {
-    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) {
-        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,
-          };
-        }
+        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,
+        };
       }
     }
 
-    const server = createMcpServer(this, sessionId, this.clientCapabilities);
+    const server = await createMcpServer(this, sessionId, this.clientCapabilities);
+    const address = server.address() as AddressInfo;
     mcpServers["acp"] = {
-      type: "sdk",
-      name: "acp",
-      instance: server,
-    };
-
-    // Ideally replace with `canUseTool`
-    const permissionServer = await createPermissionMcpServer(this, sessionId);
-    const address = permissionServer.address() as AddressInfo;
-    mcpServers["acpPermission"] = {
       type: "http",
       url: "http://127.0.0.1:" + address.port + "/mcp",
       headers: {
@@ -166,25 +132,22 @@ export class ClaudeAcpAgent implements Agent {
     const options: Options = {
       cwd: params.cwd,
       mcpServers,
-      permissionPromptToolName: PERMISSION_TOOL_NAME,
+      permissionPromptToolName: "mcp__acp__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(toolNames.read);
+      allowedTools.push("mcp__acp__read");
       disallowedTools.push("Read");
     }
     if (this.clientCapabilities?.fs?.writeTextFile) {
-      allowedTools.push(toolNames.write);
+      allowedTools.push("mcp__acp__write");
       disallowedTools.push("Write", "Edit", "MultiEdit");
     }
     if (this.clientCapabilities?.terminal) {
-      allowedTools.push(toolNames.bashOutput, toolNames.killBash);
+      allowedTools.push("mcp__acp__BashOutput", "mcp__acp__KillBash");
       disallowedTools.push("Bash", "BashOutput", "KillBash");
     }
 
@@ -203,46 +166,12 @@ export class ClaudeAcpAgent implements Agent {
       query: q,
       input: input,
       cancelled: false,
-      permissionMode: "default",
     };
 
-    getAvailableSlashCommands(q).then((availableCommands) => {
-      this.client.sessionUpdate({
-        sessionId,
-        update: {
-          sessionUpdate: "available_commands_update",
-          availableCommands,
-        },
-      });
-    });
-
+    const availableCommands = await availableSlashCommands(q);
     return {
       sessionId,
-      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",
-          },
-        ],
-      },
+      availableCommands,
     };
   }
 
@@ -298,24 +227,6 @@ export class ClaudeAcpAgent implements Agent {
             continue;
           }
 
-          // Slash commands like /compact can generate invalid output... doesn't match
-          // their own docs: https://docs.anthropic.com/en/docs/claude-code/sdk/sdk-slash-commands#%2Fcompact-compact-conversation-history
-          if (
-            typeof message.message.content === "string" &&
-            message.message.content.includes("<local-command-stdout>")
-          ) {
-            console.log(message.message.content);
-            break;
-          }
-
-          if (
-            typeof message.message.content === "string" &&
-            message.message.content.includes("<local-command-stderr>")
-          ) {
-            console.error(message.message.content);
-            break;
-          }
-
           if (
             message.message.model === "<synthetic>" &&
             message.message.content.length === 1 &&
@@ -334,7 +245,7 @@ export class ClaudeAcpAgent implements Agent {
           break;
         }
         default:
-          unreachable(message as never);
+          unreachable(message);
       }
     }
     throw new Error("Session did not end in result");
@@ -348,29 +259,6 @@ export class ClaudeAcpAgent implements Agent {
     await this.sessions[params.sessionId].query.interrupt();
   }
 
-  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) {
@@ -386,13 +274,14 @@ export class ClaudeAcpAgent implements Agent {
   }
 }
 
-async function getAvailableSlashCommands(query: Query): Promise<AvailableCommand[]> {
+async function availableSlashCommands(query: Query): Promise<AvailableCommand[]> {
   const UNSUPPORTED_COMMANDS = [
     "add-dir",
     "agents", // Modal
     "bashes", // Modal
     "bug", // Modal
     "clear", // Escape Codes
+    "compact", // Not supported via SDK?
     "config", // Modal
     "context", // Escape Codes
     "cost", // Escape Codes
@@ -421,14 +310,26 @@ async function getAvailableSlashCommands(query: Query): Promise<AvailableCommand
     "todos", // Escape Codes
     "vim", // Not needed
   ];
-  const commands = await query.supportedCommands();
+
+  const commands = await Promise.race([
+    //todo: Do not use `as any` once `supportedCommands` is exposed via the typescript interface
+    (query as any).supportedCommands(),
+    sleep(5000).then(() => {
+      if (
+        fs.existsSync(path.resolve(os.homedir(), ".claude.json.backup")) &&
+        !fs.existsSync(path.resolve(os.homedir(), ".claude.json"))
+      ) {
+        throw RequestError.authRequired();
+      }
+      throw new Error("can't load supported slash commands");
+    }),
+  ]);
 
   return commands
-    .map((command) => {
+    .map((command: { name: string; description: string; argumentHint: string }) => {
       const input = command.argumentHint ? { hint: command.argumentHint } : null;
       return {
         name: command.name,
-        // @ts-expect-error type in the ts interface
         description: command.description || "",
         input,
       };
@@ -622,11 +523,11 @@ export function toAcpNotifications(
 }
 
 export function runAcp() {
-  const input = nodeToWebWritable(process.stdout);
-  const output = nodeToWebReadable(process.stdin);
-
-  const stream = ndJsonStream(input, output);
-  new AgentSideConnection((client) => new ClaudeAcpAgent(client), stream);
+  new AgentSideConnection(
+    (client) => new ClaudeAcpAgent(client),
+    nodeToWebWritable(process.stdout),
+    nodeToWebReadable(process.stdin),
+  );
 }
 
 type ContentChunk =

src/index.ts

@@ -1,13 +1,5 @@
 #!/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;
@@ -15,10 +7,6 @@ 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

@@ -6,10 +6,8 @@ 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 * as diff from "diff";
 
-import { sleep, unreachable, extractLinesWithByteLimit } from "./utils.js";
-import { PermissionResult } from "@anthropic-ai/claude-code";
+import { sleep, unreachable } from "./utils.js";
 
 export const SYSTEM_REMINDER = `
 
@@ -17,65 +15,34 @@ 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 defaults = { maxFileSize: 50000, linesToRead: 1000 };
-
-const unqualifiedToolNames = {
-  read: "read",
-  edit: "edit",
-  write: "write",
-  multiEdit: "multi-edit",
-  bash: "Bash",
-  killBash: "KillBash",
-  bashOutput: "BashOutput",
-};
-
-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,
-};
-
-const editToolNames = [toolNames.edit, toolNames.multiEdit, toolNames.write];
-
 export function createMcpServer(
   agent: ClaudeAcpAgent,
   sessionId: string,
   clientCapabilities: ClientCapabilities | undefined,
-): McpServer {
+): Promise<Server> {
   // Create MCP server
-  const server = new McpServer({ name: "acp", version: "1.0.0" }, { capabilities: { tools: {} } });
+  const server = new McpServer({
+    name: "acp-mcp-server",
+    version: "1.0.0",
+  });
 
   if (clientCapabilities?.fs?.readTextFile) {
     server.registerTool(
-      unqualifiedToolNames.read,
+      "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 ${toolNames.read} always use it instead of Read as it contains the most up-to-date contents.`,
+In sessions with mcp__acp__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."),
           offset: z
             .number()
             .optional()
-            .default(0)
-            .describe(
-              "Which line to start reading from (0-based). Omit to start from the beginning.",
-            ),
-          linesToRead: z
-            .number()
-            .optional()
-            .default(defaults.linesToRead)
-            .describe(
-              `How many lines to read. Omit for ${defaults.linesToRead}. (Reading files that are too large can fill up the context window unnecessarily, so be thoughtful about how much you read at a time.)`,
-            ),
+            .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",
@@ -98,43 +65,18 @@ In sessions with ${toolNames.read} always use it instead of Read as it contains
               ],
             };
           }
-
           const content = await agent.readTextFile({
             sessionId,
             path: input.abs_path,
+            limit: input.limit,
+            line: input.offset,
           });
 
-          // Extract lines with byte limit enforcement
-          const result = extractLinesWithByteLimit(
-            content.content,
-            input.offset ?? 0,
-            input.linesToRead,
-            defaults.maxFileSize,
-          );
-
-          // Construct informative message about what was read
-          let readInfo = "";
-          if (input.offset > 0 || result.wasLimited) {
-            readInfo = "\n\n<file-read-info>";
-
-            if (result.wasLimited) {
-              readInfo += `Read ${result.linesRead} lines (hit 50KB limit). `;
-            } else {
-              readInfo += `Read lines ${(input.offset ?? 0) + 1}-${result.actualEndLine}. `;
-            }
-
-            if (result.wasLimited) {
-              readInfo += `Continue with offset=${result.actualEndLine}.`;
-            }
-
-            readInfo += "</file-read-info>";
-          }
-
           return {
             content: [
               {
                 type: "text",
-                text: result.content + readInfo + SYSTEM_REMINDER,
+                text: content.content + SYSTEM_REMINDER,
               },
             ],
           };
@@ -154,12 +96,12 @@ In sessions with ${toolNames.read} always use it instead of Read as it contains
 
   if (clientCapabilities?.fs?.writeTextFile) {
     server.registerTool(
-      unqualifiedToolNames.write,
+      "write",
       {
         title: "Write",
         description: `Writes content to the specified file in the project.
 
-In sessions with ${toolNames.write} always use it instead of Write as it will
+In sessions with mcp__acp__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"),
@@ -209,12 +151,12 @@ allow the user to conveniently review changes.`,
     );
 
     server.registerTool(
-      unqualifiedToolNames.edit,
+      "edit",
       {
         title: "Edit",
         description: `Edit a file.
 
-In sessions with ${toolNames.edit} always use it instead of Edit as it will
+In sessions with mcp__acp__edit always use it instead of Edit as it will
 allow the user to conveniently review changes.
 
 File editing instructions:
@@ -225,8 +167,7 @@ File editing instructions:
   - 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.
-- 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.`,
+- Only edit the specified file.`,
         inputSchema: {
           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)"),
@@ -241,68 +182,64 @@ File editing instructions:
         },
       },
       async (input) => {
-        const session = agent.sessions[sessionId];
-        if (!session) {
+        try {
+          const session = agent.sessions[sessionId];
+          if (!session) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "The user has left the building",
+                },
+              ],
+            };
+          }
+
+          const { content } = await agent.readTextFile({
+            sessionId,
+            path: input.abs_path,
+          });
+
+          const { newContent, lineNumbers } = replaceAndCalculateLocation(content, [
+            {
+              oldText: input.old_string,
+              newText: input.new_string,
+              replaceAll: false,
+            },
+          ]);
+
+          await agent.writeTextFile({
+            sessionId,
+            path: input.abs_path,
+            content: newContent,
+          });
+
           return {
             content: [
               {
                 type: "text",
-                text: "The user has left the building",
+                text: JSON.stringify({ lineNumbers }),
+              },
+            ],
+          };
+        } catch (error: any) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Editing file failed: " + error.message,
               },
             ],
           };
         }
-
-        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(
-      unqualifiedToolNames.multiEdit,
+      "multi-edit",
       {
         title: "Multi Edit",
-        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.`,
+        description: `Edit a file with multiple sequential edits.`,
         inputSchema: {
           file_path: z.string().describe("The absolute path to the file to modify"),
           edits: z
@@ -345,7 +282,7 @@ File editing instructions:
           path: input.file_path,
         });
 
-        const { newContent } = replaceAndCalculateLocation(
+        const { newContent, lineNumbers } = replaceAndCalculateLocation(
           content,
           input.edits.map((edit) => ({
             oldText: edit.old_string,
@@ -354,8 +291,6 @@ File editing instructions:
           })),
         );
 
-        const patch = diff.createPatch(input.file_path, content, newContent);
-
         await agent.writeTextFile({
           sessionId,
           path: input.file_path,
@@ -366,7 +301,7 @@ File editing instructions:
           content: [
             {
               type: "text",
-              text: patch,
+              text: JSON.stringify({ lineNumbers }),
             },
           ],
         };
@@ -376,7 +311,7 @@ File editing instructions:
 
   if (agent.clientCapabilities?.terminal) {
     server.registerTool(
-      unqualifiedToolNames.bash,
+      "Bash",
       {
         title: "Bash",
         description: "Executes a bash command",
@@ -390,7 +325,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 \`${toolNames.bashOutput}\` tool to retrieve the current output, or the \`${toolNames.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 `mcp__acp__BashOutput` tool to retrieve the current output, or the `mcp__acp__KillBash` tool to stop it early.",
             ),
         },
       },
@@ -511,7 +446,7 @@ File editing instructions:
     );
 
     server.registerTool(
-      unqualifiedToolNames.bashOutput,
+      "BashOutput",
       {
         title: "BashOutput",
         description:
@@ -519,7 +454,7 @@ File editing instructions:
         inputSchema: {
           id: z
             .string()
-            .describe(`The id of the background bash command as returned by \`${toolNames.bash}\``),
+            .describe("The id of the background bash command as returned by `mcp__acp__Bash`"),
         },
       },
       async (input) => {
@@ -562,14 +497,14 @@ File editing instructions:
     );
 
     server.registerTool(
-      unqualifiedToolNames.killBash,
+      "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 \`${toolNames.bash}\``),
+            .describe("The id of the background bash command as returned by `mcp__acp__Bash`"),
         },
       },
       async (input) => {
@@ -620,30 +555,9 @@ File editing instructions:
     );
   }
 
-  return server;
-}
-
-const UNQUALIFIED_PERMISSION_TOOL_NAME = "permission";
-const PERMISSION_SERVER_PREFIX = "mcp__acpPermission__";
-export const PERMISSION_TOOL_NAME = PERMISSION_SERVER_PREFIX + UNQUALIFIED_PERMISSION_TOOL_NAME;
-
-/**
- * Separate permission tool. Needs to be an HTTP server for now, because Claude Code doesn't
- * support permission tools via SDK servers.
- * Ideally it moves to the `canUseTool` callback in the future.
- */
-export function createPermissionMcpServer(
-  agent: ClaudeAcpAgent,
-  sessionId: string,
-): Promise<Server> {
-  const server = new McpServer(
-    { name: "acpPermission", version: "1.0.0" },
-    { capabilities: { tools: {} } },
-  );
-
   const alwaysAllowedTools: { [key: string]: boolean } = {};
   server.registerTool(
-    UNQUALIFIED_PERMISSION_TOOL_NAME,
+    "permission",
     {
       title: "Permission Tool",
       description: "Used to request tool permissions",
@@ -654,37 +568,42 @@ export function createPermissionMcpServer(
       },
     },
     async (input) => {
-      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 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,
+              }),
+            },
+          ],
+        };
+      }
       const response = await agent.client.requestPermission({
         options: [
           {
             kind: "allow_always",
-            name: "Yes, and auto-accept edits",
-            optionId: "acceptEdits",
+            name: "Always Allow",
+            optionId: "allow_always",
           },
-          { kind: "allow_once", name: "Yes, and manually approve edits", optionId: "default" },
-          { kind: "reject_once", name: "No, keep planning", optionId: "plan" },
+          { kind: "allow_once", name: "Allow", optionId: "allow" },
+          { kind: "reject_once", name: "Reject", optionId: "reject" },
         ],
         sessionId,
         toolCall: {
@@ -692,80 +611,39 @@ export function createPermissionMcpServer(
           rawInput: input.input,
         },
       });
-
       if (
         response.outcome?.outcome === "selected" &&
-        (response.outcome.optionId === "default" || response.outcome.optionId === "acceptEdits")
+        (response.outcome.optionId === "allow" || response.outcome.optionId === "allow_always")
       ) {
-        session.permissionMode = response.outcome.optionId;
-        await agent.client.sessionUpdate({
-          sessionId,
-          update: {
-            sessionUpdate: "current_mode_update",
-            currentModeId: response.outcome.optionId,
-          },
-        });
-
+        if (response.outcome.optionId === "allow_always") {
+          alwaysAllowedTools[input.tool_name] = true;
+        }
         return {
-          behavior: "allow",
-          updatedInput: input.input,
-          updatedPermissions: [
-            { type: "setMode", mode: response.outcome.optionId, destination: "session" },
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                behavior: "allow",
+                updatedInput: input.input,
+              }),
+            },
           ],
         };
       } else {
         return {
-          behavior: "deny",
-          message: "User rejected request to exit plan mode.",
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                behavior: "deny",
+                message: "User refused permission to run tool",
+              }),
+            },
+          ],
         };
       }
-    }
-
-    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());
@@ -893,7 +771,7 @@ export function replaceAndCalculateLocation(
   for (const edit of edits) {
     // Skip empty oldText
     if (edit.oldText === "") {
-      throw new Error(`The provided \`old_string\` is empty.\n\nNo edits were applied.`);
+      continue;
     }
 
     if (edit.replaceAll) {
@@ -905,11 +783,6 @@ export function replaceAndCalculateLocation(
       while (true) {
         const index = currentContent.indexOf(edit.oldText, searchIndex);
         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;
         }
 
@@ -931,11 +804,7 @@ export function replaceAndCalculateLocation(
     } else {
       // Replace first occurrence only
       const index = currentContent.indexOf(edit.oldText);
-      if (index === -1) {
-        throw new Error(
-          `The provided \`old_string\` does not appear in the file: "${edit.oldText}".\n\nNo edits were applied.`,
-        );
-      } else {
+      if (index !== -1) {
         const marker = `${markerPrefix}${markerCounter++}__`;
         markers.push(marker);
         currentContent =

src/tests/acp-agent.test.ts

@@ -2,10 +2,8 @@ import { describe, it, expect, beforeAll, afterAll } from "vitest";
 import { spawn, spawnSync } from "child_process";
 import {
   Agent,
-  AvailableCommand,
   Client,
   ClientSideConnection,
-  ndJsonStream,
   NewSessionResponse,
   ReadTextFileRequest,
   ReadTextFileResponse,
@@ -49,15 +47,9 @@ describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("ACP subprocess integration"
     agent: Agent;
     files: Map<string, string> = new Map();
     receivedText: string = "";
-    resolveAvailableCommands: (commands: AvailableCommand[]) => void;
-    availableCommandsPromise: Promise<AvailableCommand[]>;
 
     constructor(agent: Agent) {
       this.agent = agent;
-      this.resolveAvailableCommands = () => {};
-      this.availableCommandsPromise = new Promise((resolve) => {
-        this.resolveAvailableCommands = resolve;
-      });
     }
 
     takeReceivedText() {
@@ -75,24 +67,17 @@ describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("ACP subprocess integration"
     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;
-        }
-        case "available_commands_update":
-          this.resolveAvailableCommands(params.update.availableCommands);
-          break;
-        default:
-          break;
+      if (
+        params.update.sessionUpdate === "agent_message_chunk" &&
+        params.update.content.type === "text"
+      ) {
+        this.receivedText += params.update.content.text;
       }
     }
 
     async writeTextFile(params: WriteTextFileRequest): Promise<WriteTextFileResponse> {
       this.files.set(params.path, params.content);
-      return {};
+      return null;
     }
 
     async readTextFile(params: ReadTextFileRequest): Promise<ReadTextFileResponse> {
@@ -109,13 +94,14 @@ describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("ACP subprocess integration"
     newSessionResponse: NewSessionResponse;
   }> {
     let client;
-    const input = nodeToWebWritable(child.stdin!);
-    const output = nodeToWebReadable(child.stdout!);
-    const stream = ndJsonStream(input, output);
-    const connection = new ClientSideConnection((agent) => {
-      client = new TestClient(agent);
-      return client;
-    }, stream);
+    const connection = new ClientSideConnection(
+      (agent) => {
+        client = new TestClient(agent);
+        return client;
+      },
+      nodeToWebWritable(child.stdin!),
+      nodeToWebReadable(child.stdout!),
+    );
 
     await connection.initialize({
       protocolVersion: 1,
@@ -154,14 +140,12 @@ describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("ACP subprocess integration"
   it("should include available commands", async () => {
     const { client, connection, newSessionResponse } = await setupTestSession(__dirname);
 
-    const commands = await client.availableCommandsPromise;
-
-    expect(commands).toContainEqual({
+    expect(newSessionResponse.availableCommands).toContainEqual({
       name: "quick-math",
       description: "10 * 3 = 30 (project)",
       input: null,
     });
-    expect(commands).toContainEqual({
+    expect(newSessionResponse.availableCommands).toContainEqual({
       name: "say-hello",
       description: "Say hello (project)",
       input: { hint: "[name]" },
@@ -191,50 +175,6 @@ describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("ACP subprocess integration"
 
     expect(client.takeReceivedText()).toContain("Hello GPT-5");
   }, 30000);
-
-  it("/compact works", async () => {
-    const { client, connection, newSessionResponse } = await setupTestSession(__dirname);
-
-    const commands = await client.availableCommandsPromise;
-
-    expect(commands).toContainEqual({
-      description:
-        "Clear conversation history but keep a summary in context. Optional: /compact [instructions for summarization]",
-      input: {
-        hint: "<optional custom summarization instructions>",
-      },
-      name: "compact",
-    });
-
-    // Error case (no previous message)
-    await connection.prompt({
-      prompt: [{ type: "text", text: "/compact" }],
-      sessionId: newSessionResponse.sessionId,
-    });
-
-    expect(client.takeReceivedText()).toBe("");
-
-    // Send something
-    await connection.prompt({
-      prompt: [{ type: "text", text: "Hi" }],
-      sessionId: newSessionResponse.sessionId,
-    });
-    // Clear response
-    client.takeReceivedText();
-
-    // Test with instruction
-    await connection.prompt({
-      prompt: [
-        {
-          type: "text",
-          text: "/compact greeting",
-        },
-      ],
-      sessionId: newSessionResponse.sessionId,
-    });
-
-    expect(client.takeReceivedText()).toContain("");
-  }, 30000);
 });
 
 describe("tool conversions", () => {
@@ -698,6 +638,36 @@ 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_string: "old content",
+        new_string: "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",
@@ -752,22 +722,110 @@ 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 return empty update for successful edit result", () => {
+  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_string: "def hello():",
+        new_string: "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_string: "nonexistent",
+        new_string: "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", () => {
     const toolUse = {
       type: "tool_use",
       id: "toolu_01MNO345",
-      name: "mcp__acp__edit",
+      name: "edit",
       input: {
         abs_path: "/Users/test/project/test.txt",
         old_string: "old",
@@ -782,9 +840,6 @@ describe("tool conversions", () => {
           text: "not valid json",
         },
       ],
-      tool_use_id: "test",
-      is_error: false,
-      type: "tool_result" as const,
     };
 
     const update = toolUpdateFromToolResult(toolResult, toolUse);
@@ -792,43 +847,6 @@ 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: "```\nFailed to find `old_string`\n```" },
-          type: "content",
-        },
-      ],
-    });
-  });
 });
 
 describe("escape markdown", () => {

src/tests/extract-lines.test.ts

@@ -1,174 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { extractLinesWithByteLimit } from "../utils.js";
-
-describe("extractLinesWithByteLimit", () => {
-  const simpleContent = "Line 1\nLine 2\nLine 3\nLine 4\nLine 5";
-
-  it("should extract all lines when under byte limit", () => {
-    const result = extractLinesWithByteLimit(simpleContent, 0, 5, 1000);
-
-    expect(result.content).toBe(simpleContent);
-    expect(result.actualEndLine).toBe(4);
-    expect(result.wasLimited).toBe(false);
-    expect(result.linesRead).toBe(5);
-  });
-
-  it("should extract partial lines with offset", () => {
-    const result = extractLinesWithByteLimit(simpleContent, 2, 2, 1000);
-
-    expect(result.content).toBe("Line 3\nLine 4");
-    expect(result.actualEndLine).toBe(3);
-    expect(result.wasLimited).toBe(false);
-    expect(result.linesRead).toBe(2);
-  });
-
-  it("should limit output when exceeding byte limit", () => {
-    // Create content that will exceed byte limit
-    const longLine = "x".repeat(100);
-    const manyLines = Array(10).fill(longLine).join("\n");
-
-    const result = extractLinesWithByteLimit(manyLines, 0, 10, 250);
-
-    expect(result.wasLimited).toBe(true);
-    expect(result.actualEndLine).toBe(1); // Should only get 2 lines
-    expect(result.linesRead).toBe(2);
-  });
-
-  it("should handle offset beyond file length", () => {
-    const result = extractLinesWithByteLimit(simpleContent, 10, 5, 1000);
-
-    expect(result.content).toBe("");
-    expect(result.actualEndLine).toBe(10);
-    expect(result.wasLimited).toBe(false);
-    expect(result.linesRead).toBe(0);
-  });
-
-  it("should handle empty content", () => {
-    const result = extractLinesWithByteLimit("", 0, 10, 1000);
-
-    expect(result.content).toBe("");
-    expect(result.actualEndLine).toBe(0); // Empty string splits to [""] and we process that one empty line
-    expect(result.wasLimited).toBe(false);
-    expect(result.linesRead).toBe(1); // We read the one empty line
-  });
-
-  it("should handle single line file", () => {
-    const singleLine = "This is a single line without newline";
-    const result = extractLinesWithByteLimit(singleLine, 0, 10, 1000);
-
-    expect(result.content).toBe(singleLine);
-    expect(result.actualEndLine).toBe(0);
-    expect(result.wasLimited).toBe(false);
-    expect(result.linesRead).toBe(1);
-  });
-
-  it("should correctly count bytes with multi-byte characters", () => {
-    const unicodeContent = "Hello 世界\n你好 World\nEmoji: 🌍\nNormal line";
-    const result = extractLinesWithByteLimit(unicodeContent, 0, 10, 1000);
-
-    expect(result.content).toBe(unicodeContent);
-    expect(result.linesRead).toBe(4);
-  });
-
-  it("should stop at byte limit even with one more line available", () => {
-    // Create lines where adding one more would exceed limit
-    const line1 = "a".repeat(40);
-    const line2 = "b".repeat(40);
-    const line3 = "c".repeat(40);
-    const content = `${line1}\n${line2}\n${line3}`;
-
-    const result = extractLinesWithByteLimit(content, 0, 3, 85);
-
-    expect(result.content).toBe(`${line1}\n${line2}`);
-    expect(result.actualEndLine).toBe(1);
-    expect(result.wasLimited).toBe(true);
-    expect(result.linesRead).toBe(2);
-  });
-
-  it("should read exactly to limit when possible", () => {
-    const exactContent = "12345\n67890\n12345"; // 17 bytes total
-    const result = extractLinesWithByteLimit(exactContent, 0, 3, 17);
-
-    expect(result.content).toBe(exactContent);
-    expect(result.actualEndLine).toBe(2);
-    expect(result.wasLimited).toBe(false);
-    expect(result.linesRead).toBe(3);
-  });
-
-  it("should handle reading from middle to end", () => {
-    const result = extractLinesWithByteLimit(simpleContent, 3, 100, 1000);
-
-    expect(result.content).toBe("Line 4\nLine 5");
-    expect(result.actualEndLine).toBe(4);
-    expect(result.wasLimited).toBe(false);
-    expect(result.linesRead).toBe(2);
-  });
-
-  it("should handle large content with typical parameters", () => {
-    const longContent = Array(2000).fill("Line content here").join("\n");
-    const result = extractLinesWithByteLimit(longContent, 0, 1000, 50000);
-
-    expect(result.actualEndLine).toBeLessThanOrEqual(1000); // Should be limited by line count
-  });
-
-  it("should provide correct data for partial read at start", () => {
-    const result = extractLinesWithByteLimit(simpleContent, 0, 2, 1000);
-
-    expect(result.actualEndLine).toBe(1);
-    expect(result.linesRead).toBe(2);
-  });
-
-  it("should provide correct data for partial read with offset", () => {
-    const result = extractLinesWithByteLimit(simpleContent, 1, 2, 1000);
-
-    expect(result.actualEndLine).toBe(2);
-    expect(result.linesRead).toBe(2);
-  });
-
-  it("should not add newline after last line", () => {
-    const result = extractLinesWithByteLimit("Line 1\nLine 2\nLine 3", 2, 1, 1000);
-
-    expect(result.content).toBe("Line 3"); // No trailing newline
-  });
-
-  it("should handle Windows-style line endings", () => {
-    const windowsContent = "Line 1\r\nLine 2\r\nLine 3";
-    const result = extractLinesWithByteLimit(windowsContent, 0, 3, 1000);
-
-    // Note: split("\n") will keep the \r characters
-    expect(result.content).toBe("Line 1\r\nLine 2\r\nLine 3");
-    expect(result.linesRead).toBe(3);
-  });
-
-  it("should handle very large files efficiently", () => {
-    // Create a 100KB file
-    const largeLine = "x".repeat(1000);
-    const largeContent = Array(110).fill(largeLine).join("\n");
-
-    const result = extractLinesWithByteLimit(largeContent, 0, 200, 50000);
-
-    expect(result.wasLimited).toBe(true);
-    expect(result.actualEndLine).toBeLessThan(50); // Should stop well before 200 lines
-  });
-
-  it("should handle line limit of 0", () => {
-    const result = extractLinesWithByteLimit(simpleContent, 0, 0, 1000);
-
-    expect(result.content).toBe("");
-    expect(result.actualEndLine).toBe(0);
-    expect(result.linesRead).toBe(0);
-    expect(result.wasLimited).toBe(false);
-  });
-
-  it("should allow at least one line even if it exceeds byte limit", () => {
-    const veryLongLine = "x".repeat(100000); // 100KB line
-    const result = extractLinesWithByteLimit(veryLongLine, 0, 1, 50000);
-
-    // Should return the line even though it exceeds the byte limit
-    // because we always allow at least one line if no lines have been added yet
-    expect(result.content).toBe(veryLongLine);
-    expect(result.actualEndLine).toBe(0);
-    expect(result.linesRead).toBe(1);
-    expect(result.wasLimited).toBe(false);
-  });
-});

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

@@ -22,9 +22,12 @@ describe("replaceAndCalculateLocation", () => {
 
   it("should return empty line numbers array when no match found", () => {
     const content = "line 1\nline 2\nline 3";
-    expect(() => {
-      replaceAndCalculateLocation(content, [{ oldText: "notfound", newText: "replaced" }]);
-    }).toThrow('The provided `old_string` does not appear in the file: "notfound"');
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "notfound", newText: "replaced" },
+    ]);
+
+    expect(result.newContent).toBe(content);
+    expect(result.lineNumbers).toEqual([]);
   });
 
   it("should handle Windows line endings (CRLF)", () => {
@@ -86,31 +89,35 @@ describe("replaceAndCalculateLocation", () => {
   });
 
   it("should handle empty file content", () => {
-    expect(() => {
-      replaceAndCalculateLocation("", [{ oldText: "text", newText: "replaced" }]);
-    }).toThrowError(
-      'The provided `old_string` does not appear in the file: "text".\n\nNo edits were applied.',
-    );
+    const content = "";
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
+
+    expect(result.newContent).toBe("");
+    expect(result.lineNumbers).toEqual([]);
   });
 
   it("should handle empty search text", () => {
     // Test with replaceAll false (default)
     const content1 = "line 1\nline 2\nline 3";
-    expect(() => {
-      replaceAndCalculateLocation(content1, [{ oldText: "", newText: "replaced" }]);
-    }).toThrowError("The provided `old_string` is empty.\n\nNo edits were applied.");
+    const result1 = replaceAndCalculateLocation(content1, [{ oldText: "", newText: "replaced" }]);
+    expect(result1.newContent).toBe(content1);
+    expect(result1.lineNumbers).toEqual([]);
 
     // Test with replaceAll true on single line
     const content2 = "abc";
-    expect(() => {
-      replaceAndCalculateLocation(content2, [{ oldText: "", newText: "X", replaceAll: true }]);
-    }).toThrowError("The provided `old_string` is empty.\n\nNo edits were applied.");
+    const result2 = replaceAndCalculateLocation(content2, [
+      { oldText: "", newText: "X", replaceAll: true },
+    ]);
+    expect(result2.newContent).toBe(content2);
+    expect(result2.lineNumbers).toEqual([]);
 
     // Test with replaceAll true on multiline content
     const content3 = "ab\ncd";
-    expect(() => {
-      replaceAndCalculateLocation(content3, [{ oldText: "", newText: "X", replaceAll: true }]);
-    }).toThrowError("The provided `old_string` is empty.\n\nNo edits were applied.");
+    const result3 = replaceAndCalculateLocation(content3, [
+      { oldText: "", newText: "X", replaceAll: true },
+    ]);
+    expect(result3.newContent).toBe(content3);
+    expect(result3.lineNumbers).toEqual([]);
   });
 
   it("should handle single line content", () => {

src/tools.ts

@@ -4,7 +4,7 @@ import {
   ToolCallLocation,
   ToolKind,
 } from "@zed-industries/agent-client-protocol";
-import { replaceAndCalculateLocation, SYSTEM_REMINDER, toolNames } from "./mcp-server.js";
+import { replaceAndCalculateLocation, SYSTEM_REMINDER } from "./mcp-server.js";
 
 interface ToolInfo {
   title: string;
@@ -67,7 +67,7 @@ export function toolInfoFromToolUse(
       };
 
     case "Bash":
-    case toolNames.bash:
+    case "mcp__acp__Bash":
       return {
         title: input?.command ? "`" + input.command.replaceAll("`", "\\`") + "`" : "Terminal",
         kind: "execute",
@@ -83,7 +83,7 @@ export function toolInfoFromToolUse(
       };
 
     case "BashOutput":
-    case toolNames.bashOutput:
+    case "mcp__acp__BashOutput":
       return {
         title: "Tail Logs",
         kind: "execute",
@@ -91,14 +91,14 @@ export function toolInfoFromToolUse(
       };
 
     case "KillBash":
-    case toolNames.killBash:
+    case "mcp__acp__KillBash":
       return {
         title: "Kill Process",
         kind: "execute",
         content: [],
       };
 
-    case toolNames.read: {
+    case "mcp__acp__read": {
       let limit = "";
       if (input.limit) {
         limit =
@@ -135,26 +135,26 @@ export function toolInfoFromToolUse(
         locations: [],
       };
 
-    case toolNames.edit:
+    case "mcp__acp__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[] = [];
+      let line = null;
 
-      if (path && oldText) {
+      if (path && input.old_text) {
         try {
           const oldContent = cachedFileContent[path] || "";
           const newContent = replaceAndCalculateLocation(oldContent, [
             {
-              oldText,
-              newText,
+              oldText: input.old_string,
+              newText: input.new_string,
               replaceAll: false,
             },
           ]);
           oldText = oldContent;
           newText = newContent.newContent;
-          affectedLines = newContent.lineNumbers;
+          line = newContent.lineNumbers[0];
         } catch (e) {
           console.error(e);
         }
@@ -173,15 +173,11 @@ export function toolInfoFromToolUse(
                 },
               ]
             : [],
-        locations: path
-          ? affectedLines.length > 0
-            ? affectedLines.map((line) => ({ line, path }))
-            : [{ path }]
-          : [],
+        locations: path ? [{ path, line }] : [],
       };
     }
 
-    case toolNames.multiEdit:
+    case "mcp__acp__multi-edit":
     case "MultiEdit": {
       const multiInput = input as {
         file_path: string;
@@ -193,7 +189,6 @@ export function toolInfoFromToolUse(
       };
       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) {
           const oldContent =
@@ -209,7 +204,6 @@ export function toolInfoFromToolUse(
           );
           oldTextMulti = oldContent;
           newTextMulti = newContent.newContent;
-          affectedLines = newContent.lineNumbers;
         }
       } catch (e) {
         console.error(e);
@@ -227,14 +221,10 @@ export function toolInfoFromToolUse(
             newText: newTextMulti,
           },
         ],
-        locations: input?.file_path
-          ? affectedLines.length > 0
-            ? affectedLines.map((line) => ({ line, path: input.file_path }))
-            : [{ path: input.file_path }]
-          : [],
+        locations: input?.file_path ? [{ path: input.file_path }] : [],
       };
     }
-    case toolNames.write: {
+    case "mcp__acp__write": {
       let content: ToolCallContent[] = [];
       if (input && input.abs_path) {
         content = [
@@ -400,10 +390,10 @@ export function toolInfoFromToolUse(
         content: [],
       };
 
-    case "ExitPlanMode":
+    case "exit_plan_mode":
       return {
-        title: "Ready to code?",
-        kind: "switch_mode",
+        title: "Exit Plan Mode",
+        kind: "think",
         content:
           input && input.plan
             ? [{ type: "content", content: { type: "text", text: input.plan } }]
@@ -434,20 +424,62 @@ export function toolInfoFromToolUse(
   }
 }
 
-type ToolResult = {
-  type: "tool_result";
-  content: any;
-  tool_use_id: string;
-  is_error: boolean;
-};
-
-export function toolUpdateFromToolResult(
-  toolResult: ToolResult,
-  toolUse: any | undefined,
-): ToolUpdate {
+export function toolUpdateFromToolResult(toolResult: any, 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 (error) {
+          console.error(`Error parsing edit tool result: ${error}`);
+          // 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 (error) {
+          console.error(`Error parsing edit tool result: ${error}`);
+
+          // If parsing fails, return empty object
+          return {};
+        }
+      }
+      return {};
+    }
+
+    case "mcp__acp__write":
+    case "Write":
+      return {};
+
     case "Read":
-    case toolNames.read:
+    case "mcp__acp__read":
       if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
         return {
           content: toolResult.content.map((content: any) => ({
@@ -476,25 +508,9 @@ export function toolUpdateFromToolResult(
       }
       return {};
 
-    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, true);
-      }
+    case "mcp__acp__Bash":
+      // The bash tool already embeds a terminal
       return {};
-    }
-
-    case "ExitPlanMode": {
-      return { title: "Exited Plan Mode" };
-    }
 
     case "Task":
     case "NotebookEdit":
@@ -511,44 +527,31 @@ export function toolUpdateFromToolResult(
     case "WebSearch":
     case "Other":
     default: {
-      return toAcpContentUpdate(toolResult.content, toolResult.is_error);
+      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 {};
     }
   }
 }
 
-function toAcpContentUpdate(
-  content: any,
-  isError: boolean = false,
-): { content?: ToolCallContent[] } {
-  if (Array.isArray(content) && content.length > 0) {
-    return {
-      content: content.map((content: any) => ({
-        type: "content",
-        content:
-          isError && content.type === "text"
-            ? {
-                ...content,
-                text: `\`\`\`\n${content.text}\n\`\`\``,
-              }
-            : content,
-      })),
-    };
-  } else if (typeof content === "string" && content.length > 0) {
-    return {
-      content: [
-        {
-          type: "content",
-          content: {
-            type: "text",
-            text: isError ? `\`\`\`\n${content}\n\`\`\`` : content,
-          },
-        },
-      ],
-    };
-  }
-  return {};
-}
-
 type ClaudePlanEntry = {
   content: string;
   status: "pending" | "in_progress" | "completed";

src/utils.ts

@@ -2,8 +2,6 @@
 
 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> {
@@ -82,153 +80,3 @@ export function unreachable(value: never): never {
 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;
-    }
-  }
-}
-
-export interface ExtractLinesResult {
-  content: string;
-  actualEndLine: number;
-  wasLimited: boolean;
-  linesRead: number;
-}
-
-/**
- * Extracts lines from file content with byte limit enforcement.
- *
- * @param fullContent - The complete file content
- * @param linesToSkip - Starting line number (0-based)
- * @param linesToRead - Maximum number of lines to read
- * @param maxContentLength - Maximum number of UTF-16 Code Units to return
- * @returns Object containing extracted content and metadata
- */
-export function extractLinesWithByteLimit(
-  fullContent: string,
-  linesToSkip: number,
-  linesToRead: number,
-  maxContentLength: number,
-): ExtractLinesResult {
-  if (fullContent === "" || linesToRead === 0) {
-    if (linesToSkip === 0 && linesToRead > 0) {
-      return {
-        content: "",
-        actualEndLine: 0,
-        wasLimited: false,
-        linesRead: 1,
-      };
-    } else {
-      return {
-        content: "",
-        actualEndLine: linesToSkip,
-        wasLimited: false,
-        linesRead: 0,
-      };
-    }
-  }
-
-  let linesSeen = 0;
-  let index = 0;
-
-  while (linesSeen < linesToSkip) {
-    const nextIndex = fullContent.indexOf("\n", index);
-
-    // There were not enough lines to skip.
-    if (nextIndex < 0) {
-      return {
-        content: "",
-        actualEndLine: linesToSkip,
-        wasLimited: false,
-        linesRead: 0,
-      };
-    }
-
-    linesSeen += 1;
-    index = nextIndex + 1;
-  }
-
-  // We've successfully skipped over all the lines we were supposed to.
-  // Now we can actually start reading!
-  const startIndex = index;
-  linesSeen = 0;
-
-  let contentLength = 0;
-  let wasLimited = false;
-
-  while (linesSeen < linesToRead) {
-    const nextIndex = fullContent.indexOf("\n", index);
-
-    if (nextIndex < 0) {
-      // Last line in file (no trailing newline)
-      const newContentLength = fullContent.length - startIndex;
-      if (linesSeen > 0 && newContentLength > maxContentLength) {
-        wasLimited = true;
-        break;
-      }
-      linesSeen += 1;
-      contentLength = newContentLength;
-      break;
-    } else {
-      // Line with newline - include up to the newline
-      const newContentLength = nextIndex + 1 - startIndex;
-      if (linesSeen > 0 && newContentLength > maxContentLength) {
-        wasLimited = true;
-        break;
-      }
-      linesSeen += 1;
-      contentLength = newContentLength;
-      index = nextIndex + 1;
-    }
-  }
-
-  // If we ended with a newline and we stopped due to byte limit or line limit (not end of file), remove the trailing newline
-  if (contentLength > 0 && fullContent[startIndex + contentLength - 1] === "\n") {
-    // Check if there's more content after our current position that we didn't read
-    if (startIndex + contentLength < fullContent.length) {
-      contentLength -= 1;
-    }
-  }
-
-  return {
-    content: fullContent.slice(startIndex, startIndex + contentLength),
-    actualEndLine: linesSeen > 0 ? linesToSkip + linesSeen - 1 : linesToSkip,
-    wasLimited,
-    linesRead: linesSeen,
-  };
-}