read output in a code block

.github/workflows/ci.yml

@@ -1,42 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: "ci-${{ github.ref }}"
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-
-    steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8
-
-      - name: Use Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020
-        with:
-          node-version: latest
-          cache: "npm"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Check formatting
-        run: npm run format:check
-
-      - name: Build
-        run: npm run build
-
-      - name: Run tests
-        run: npm run test:run

.github/workflows/publish.yml

@@ -1,23 +0,0 @@
-name: Publish Package to npmjs
-on:
-  push:
-    tags:
-      - "v*.*.*"
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8
-      # Setup .npmrc file to publish to npm
-      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020
-        with:
-          node-version: "lts/*"
-          registry-url: "https://registry.npmjs.org"
-      - run: npm ci
-        # Add back provenance once repo is public
-      - run: npm publish # --provenance --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package.json

@@ -3,24 +3,19 @@
   "publishConfig": {
     "access": "public"
   },
-  "bin": {
-    "claude-code-acp": "./dist/index.js"
-  },
-  "version": "0.1.8",
+  "version": "0.1.0",
   "description": "An ACP-compatible coding agent powered by the Claude Code SDK (TypeScript)",
-  "main": "dist/index.js",
+  "main": "dist/acp-agent.js",
   "type": "module",
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "npm run build && npm run start",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
+    "lint": "eslint src --ext .ts",
     "test": "vitest",
     "test:integration": "RUN_INTEGRATION_TESTS=true vitest run",
     "test:run": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "prepublishOnly": "npm run build"
+    "test:coverage": "vitest run --coverage"
   },
   "keywords": [
     "claude",
@@ -34,10 +29,10 @@
   "author": "Zed Industries",
   "license": "Apache-2.0",
   "dependencies": {
-    "@anthropic-ai/claude-code": "^1.0.100",
+    "@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",
+    "@zed-industries/agent-client-protocol": "0.1.2",
     "express": "^5.1.0",
     "minimist": "^1.2.8",
     "uuid": "11.1.0"
@@ -47,7 +42,7 @@
     "@types/node": "^24.3.0",
     "@types/uuid": "^10.0.0",
     "@vitest/ui": "^3.2.4",
-    "prettier": "^3.6.2",
+    "eslint": "^8.56.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.4.0",
     "vitest": "^3.2.4"

src/acp-agent.ts

@@ -2,42 +2,36 @@ import {
   Agent,
   AgentSideConnection,
   AuthenticateRequest,
-  AvailableCommand,
   CancelNotification,
-  ClientCapabilities,
+  Client,
   InitializeRequest,
   InitializeResponse,
+  LoadSessionRequest,
   NewSessionRequest,
   NewSessionResponse,
   PromptRequest,
   PromptResponse,
-  ReadTextFileRequest,
-  ReadTextFileResponse,
   RequestError,
-  TerminalHandle,
-  TerminalOutputResponse,
-  WriteTextFileRequest,
-  WriteTextFileResponse,
+  ToolCallContent,
+  ToolKind,
 } from "@zed-industries/agent-client-protocol";
 import {
   McpServerConfig,
-  Options,
   Query,
   query,
   SDKAssistantMessage,
+  SDKMessage,
   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 * as readline from "node:readline";
 import { v7 as uuidv7 } from "uuid";
 import {
   nodeToWebReadable,
   nodeToWebWritable,
   Pushable,
-  sleep,
   unreachable,
 } from "./utils.js";
+import { ContentBlock } from "@zed-industries/agent-client-protocol";
 import { SessionNotification } from "@zed-industries/agent-client-protocol";
 import { createMcpServer } from "./mcp-server.js";
 import { AddressInfo } from "node:net";
@@ -53,45 +47,25 @@ type Session = {
   cancelled: boolean;
 };
 
-type BackgroundTerminal =
-  | {
-      handle: TerminalHandle;
-      status: "started";
-      lastOutput: TerminalOutputResponse | null;
-    }
-  | {
-      status: "aborted" | "exited" | "killed" | "timedOut";
-      pendingOutput: TerminalOutputResponse;
-    };
-
 // Implement the ACP Agent interface
 export class ClaudeAcpAgent implements Agent {
   sessions: {
     [key: string]: Session;
   };
-  client: AgentSideConnection;
+  client: Client;
   toolUseCache: { [key: string]: any };
-  fileContentCache: { [key: string]: any };
-  backgroundTerminals: { [key: string]: BackgroundTerminal } = {};
-  clientCapabilities?: ClientCapabilities;
 
-  constructor(client: AgentSideConnection) {
+  constructor(client: Client) {
     this.sessions = {};
     this.client = client;
     this.toolUseCache = {};
-    this.fileContentCache = {};
   }
-
-  async initialize(request: InitializeRequest): Promise<InitializeResponse> {
-    this.clientCapabilities = request.clientCapabilities;
+  async initialize(params: InitializeRequest): Promise<InitializeResponse> {
     return {
       protocolVersion: 1,
       // todo!()
       agentCapabilities: {
-        promptCapabilities: {
-          image: true,
-          embeddedContext: true,
-        },
+        promptCapabilities: { image: true, embeddedContext: true },
       },
       authMethods: [
         {
@@ -125,11 +99,8 @@ export class ClaudeAcpAgent implements Agent {
       }
     }
 
-    let server = await createMcpServer(
-      this,
-      sessionId,
-      this.clientCapabilities,
-    );
+    // todo!() auth
+    let server = await createMcpServer(this, sessionId);
     let address = server.address() as AddressInfo;
     mcpServers["acp"] = {
       type: "http",
@@ -139,38 +110,17 @@ export class ClaudeAcpAgent implements Agent {
       },
     };
 
-    let options: Options = {
-      cwd: params.cwd,
-      mcpServers,
-      permissionPromptToolName: "mcp__acp__permission",
-      stderr: (err) => console.error(err),
-    };
-
-    const allowedTools = [];
-    const disallowedTools = [];
-    if (this.clientCapabilities?.fs?.readTextFile) {
-      allowedTools.push("mcp__acp__read");
-      disallowedTools.push("Read");
-    }
-    if (this.clientCapabilities?.fs?.writeTextFile) {
-      allowedTools.push("mcp__acp__write");
-      disallowedTools.push("Write", "Edit", "MultiEdit");
-    }
-    if (this.clientCapabilities?.terminal) {
-      allowedTools.push("mcp__acp__BashOutput", "mcp__acp__KillBash");
-      disallowedTools.push("Bash", "BashOutput", "KillBash");
-    }
-
-    if (allowedTools.length > 0) {
-      options.allowedTools = allowedTools;
-    }
-    if (disallowedTools.length > 0) {
-      options.disallowedTools = disallowedTools;
-    }
-
-    const q = query({
+    let q = query({
       prompt: input,
-      options,
+      options: {
+        cwd: params.cwd,
+        mcpServers,
+        allowedTools: ["mcp__acp__read"],
+        disallowedTools: ["Read", "Write", "Edit", "MultiEdit"],
+        strictMcpConfig: true,
+        permissionPromptToolName: "mcp__acp__permission",
+        stderr: (err) => console.error(err),
+      },
     });
     this.sessions[sessionId] = {
       query: q,
@@ -178,14 +128,12 @@ export class ClaudeAcpAgent implements Agent {
       cancelled: false,
     };
 
-    const availableCommands = await availableSlashCommands(q);
     return {
       sessionId,
-      availableCommands,
     };
   }
 
-  async authenticate(_params: AuthenticateRequest): Promise<void> {
+  async authenticate(params: AuthenticateRequest): Promise<void> {
     throw new Error("Method not implemented.");
   }
 
@@ -248,7 +196,6 @@ export class ClaudeAcpAgent implements Agent {
             message,
             params.sessionId,
             this.toolUseCache,
-            this.fileContentCache,
           )) {
             await this.client.sessionUpdate(notification);
           }
@@ -268,97 +215,6 @@ export class ClaudeAcpAgent implements Agent {
     this.sessions[params.sessionId].cancelled = true;
     await this.sessions[params.sessionId].query.interrupt();
   }
-
-  async readTextFile(
-    params: ReadTextFileRequest,
-  ): Promise<ReadTextFileResponse> {
-    let 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);
-    this.fileContentCache[params.path] = params.content;
-    return response;
-  }
-}
-
-async function availableSlashCommands(
-  query: Query,
-): Promise<AvailableCommand[]> {
-  const UNSUPPORTED_COMMANDS = [
-    "agents", // Modal
-    "bashes", // Modal
-    "bug", // Modal
-    "clear", // Escape Codes
-    "compact", // Not supported via SDK?
-    "config", // Modal
-    "context", // Escape Codes
-    "cost", // Escape Codes
-    "doctor", // Escape Codes
-    "exit",
-    "export", // Modal
-    "help", // Modal
-    "hooks", // Modal
-    "ide", // Modal
-    "install-github-app", // Modal
-    "login",
-    "logout",
-    "mcp",
-    "migrate-installer", // Modal
-    "model", // Not supported via SDK?
-    "output-style", // Modal
-    "output-style:new", // Modal
-    "permissions", // Modal
-    "release-notes", // Escape Codes
-    "resume",
-    "status", // Not supported via SDK?
-    "statusline", // Not needed
-    "terminal-setup", // Not needed
-    "todos", // Escape Codes
-    "vim", // Not needed
-  ];
-
-  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: {
-        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),
-    );
 }
 
 function formatUriAsLink(uri: string): string {
@@ -456,16 +312,13 @@ function promptToClaude(prompt: PromptRequest): SDKUserMessage {
 export function toAcpNotifications(
   message: SDKAssistantMessage | SDKUserMessage,
   sessionId: string,
-  toolUseCache: {
-    [key: string]: { type: "tool_use"; id: string; name: string; input: any };
-  },
-  fileContentCache: { [key: string]: string },
+  toolUseCache: { [key: string]: any },
 ): SessionNotification[] {
   let chunks = message.message.content as ContentChunk[];
   let output = [];
   // Only handle the first chunk for streaming; extend as needed for batching
   for (const chunk of chunks) {
-    let update: SessionNotification["update"] | null = null;
+    let update: SessionNotification["update"];
     switch (chunk.type) {
       case "text":
         update = {
@@ -510,37 +363,24 @@ export function toAcpNotifications(
             sessionUpdate: "tool_call",
             rawInput: chunk.input,
             status: "pending",
-            ...toolInfoFromToolUse(chunk, fileContentCache),
+            ...toolInfoFromToolUse(chunk),
           };
         }
         break;
 
-      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]),
-          };
-        }
+      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]),
+        };
         break;
-      }
 
       default:
         throw new Error("unhandled chunk type: " + chunk.type);
     }
-    if (update) {
-      output.push({ sessionId, update });
-    }
+    output.push({ sessionId, update });
   }
 
   return output;

src/index.ts

@@ -1,5 +1,3 @@
-#!/usr/bin/env node
-
 import { runAcp as runAcp } from "./acp-agent.js";
 runAcp();
 

src/mcp-server.ts

@@ -5,23 +5,10 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 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 { sleep } from "./utils.js";
-
-export const SYSTEM_REMINDER = `
-
-<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>`;
 
 export function createMcpServer(
   agent: ClaudeAcpAgent,
   sessionId: string,
-  clientCapabilities: ClientCapabilities | undefined,
 ): Promise<Server> {
   // Create MCP server
   const server = new McpServer({
@@ -29,267 +16,173 @@ export function createMcpServer(
     version: "1.0.0",
   });
 
-  if (clientCapabilities?.fs?.readTextFile) {
-    server.registerTool(
-      "read",
-      {
-        title: "Read",
-        description: `Reads the content of the given file in the project.
+  server.registerTool(
+    "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.`,
-        inputSchema: {
-          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."),
-        },
-        annotations: {
-          title: "Read file",
-          readOnlyHint: true,
-          destructiveHint: false,
-          openWorldHint: false,
-          idempotentHint: false,
-        },
+      inputSchema: {
+        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."),
       },
-      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,
-            limit: input.limit,
-            line: input.offset,
-          });
-
+      annotations: {
+        title: "Read file",
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false,
+        idempotentHint: false,
+      },
+    },
+    async (input) => {
+      try {
+        const session = agent.sessions[sessionId];
+        if (!session) {
           return {
             content: [
               {
                 type: "text",
-                text: content.content + SYSTEM_REMINDER,
-              },
-            ],
-          };
-        } catch (error: any) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Reading file failed: " + error.message,
+                text: "The user has left the building",
               },
             ],
           };
         }
-      },
-    );
-  }
+        let content = await agent.client.readTextFile({
+          sessionId,
+          path: input.abs_path,
+          limit: input.limit,
+          line: input.offset,
+        });
 
-  if (clientCapabilities?.fs?.writeTextFile) {
-    server.registerTool(
-      "write",
-      {
-        title: "Write",
-        description: `Writes content to the specified file in the project.
+        return {
+          content: [
+            {
+              type: "text",
+              text:
+                content.content +
+                `
+
+<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>`,
+            },
+          ],
+        };
+      } catch (error: any) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Reading file failed: " + error.message,
+            },
+          ],
+        };
+      }
+    },
+  );
+
+  server.registerTool(
+    "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
 allow the user to conveniently review changes.`,
-        inputSchema: {
-          abs_path: z
-            .string()
-            .describe("The absolute path to the file to write"),
-          content: z.string().describe("The full content to write"),
-        },
-        annotations: {
-          title: "Write file",
-          readOnlyHint: false,
-          destructiveHint: false,
-          openWorldHint: false,
-          idempotentHint: false,
-        },
+      inputSchema: {
+        abs_path: z.string().describe("The absolute path to the file to write"),
+        content: z.string().describe("The full content to write"),
       },
-      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.writeTextFile({
-            sessionId,
-            path: input.abs_path,
-            content: input.content,
-          });
-
-          return {
-            content: [],
-          };
-        } catch (error: any) {
+      annotations: {
+        title: "Write file",
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+        idempotentHint: false,
+      },
+    },
+    async (input) => {
+      try {
+        const session = agent.sessions[sessionId];
+        if (!session) {
           return {
             content: [
               {
                 type: "text",
-                text: "Writing file failed: " + error.message,
+                text: "The user has left the building",
               },
             ],
           };
         }
-      },
-    );
+        let content = await agent.client.writeTextFile({
+          sessionId,
+          path: input.abs_path,
+          content: input.content,
+        });
 
-    server.registerTool(
-      "edit",
-      {
-        title: "Edit",
-        description: `Edit a file.
+        return {
+          content: [],
+        };
+      } catch (error: any) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Writing file failed: " + error.message,
+            },
+          ],
+        };
+      }
+    },
+  );
+
+  server.registerTool(
+    "edit",
+    {
+      title: "Edit",
+      description: `Edit a file.
 
 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:
-- 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.
+- 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.
 - 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.`,
-        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)"),
-          new_string: z.string().describe("The new text."),
-        },
-        annotations: {
-          title: "Edit file",
-          readOnlyHint: false,
-          destructiveHint: false,
-          openWorldHint: false,
-          idempotentHint: false,
-        },
+      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."),
       },
-      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_string,
-                newText: input.new_string,
-                replaceAll: false,
-              },
-            ],
-          );
-
-          await agent.writeTextFile({
-            sessionId,
-            path: input.abs_path,
-            content: newContent,
-          });
-
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({ lineNumbers }),
-              },
-            ],
-          };
-        } catch (error: any) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Editing file failed: " + error.message,
-              },
-            ],
-          };
-        }
+      annotations: {
+        title: "Edit file",
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+        idempotentHint: false,
       },
-    );
-
-    server.registerTool(
-      "multi-edit",
-      {
-        title: "Multi Edit",
-        description: `Edit a file with multiple sequential edits.`,
-        inputSchema: {
-          file_path: z
-            .string()
-            .describe("The absolute path to the file to modify"),
-          edits: z
-            .array(
-              z.object({
-                old_string: z.string().describe("The text to replace"),
-                new_string: z.string().describe("The text to replace it with"),
-                replace_all: z
-                  .boolean()
-                  .optional()
-                  .describe(
-                    "Replace all occurrences of old_string (default false)",
-                  ),
-              }),
-            )
-            .min(1)
-            .describe(
-              "Array of edit operations to perform sequentially on the file",
-            ),
-        },
-        annotations: {
-          title: "Multi Edit file",
-          readOnlyHint: false,
-          destructiveHint: false,
-          openWorldHint: false,
-          idempotentHint: false,
-        },
-      },
-      async (input) => {
+    },
+    async (input) => {
+      try {
         const session = agent.sessions[sessionId];
         if (!session) {
           return {
@@ -302,23 +195,25 @@ File editing instructions:
           };
         }
 
-        let { content } = await agent.readTextFile({
+        let { content } = await agent.client.readTextFile({
           sessionId,
-          path: input.file_path,
+          path: input.abs_path,
         });
 
         const { newContent, lineNumbers } = replaceAndCalculateLocation(
           content,
-          input.edits.map((edit) => ({
-            oldText: edit.old_string,
-            newText: edit.new_string,
-            replaceAll: edit.replace_all ?? false,
-          })),
+          [
+            {
+              oldText: input.old_text,
+              newText: input.new_text,
+              replaceAll: false,
+            },
+          ],
         );
 
-        await agent.writeTextFile({
+        await agent.client.writeTextFile({
           sessionId,
-          path: input.file_path,
+          path: input.abs_path,
           content: newContent,
         });
 
@@ -330,323 +225,97 @@ File editing instructions:
             },
           ],
         };
-      },
-    );
-  }
-
-  if (agent.clientCapabilities?.terminal) {
-    server.registerTool(
-      "Bash",
-      {
-        title: "Bash",
-        description: "Executes a bash command",
-        inputSchema: {
-          command: z
-            .string()
-            .describe("The bash command to execute as a one-liner"),
-          timeout_ms: z
-            .number()
-            .default(2 * 60 * 1000)
-            .describe("Optional timeout in milliseconds"),
-          run_in_background: z
-            .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.",
-            ),
-        },
-      },
-      async (input, extra) => {
-        const session = agent.sessions[sessionId];
-        if (!session) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "The user has left the building",
-              },
-            ],
-          };
-        }
-
-        const toolCallId = extra._meta?.["claudecode/toolUseId"];
-
-        if (typeof toolCallId !== "string") {
-          throw new Error("No tool call ID found");
-        }
-
-        if (
-          !agent.clientCapabilities?.terminal ||
-          !agent.client.createTerminal
-        ) {
-          throw new Error("unreachable");
-        }
-
-        const handle = await agent.client.createTerminal({
-          command: input.command,
-          sessionId,
-          outputByteLimit: 32_000,
-        });
-
-        await agent.client.sessionUpdate({
-          sessionId,
-          update: {
-            sessionUpdate: "tool_call_update",
-            toolCallId,
-            status: "in_progress",
-            content: [{ type: "terminal", terminalId: handle.id }],
-          },
-        });
-
-        const abortPromise = new Promise((resolve) => {
-          if (extra.signal.aborted) {
-            resolve(null);
-          } else {
-            extra.signal.addEventListener("abort", () => {
-              resolve(null);
-            });
-          }
-        });
-
-        const statusPromise = Promise.race([
-          handle.waitForExit().then(() => ({ status: "exited" as const })),
-          abortPromise.then(() => ({ status: "aborted" as const })),
-          sleep(input.timeout_ms).then(async () => {
-            if (agent.backgroundTerminals[handle.id]?.status === "started") {
-              await handle.kill();
-            }
-            return { status: "timedOut" as const };
-          }),
-        ]);
-
-        if (input.run_in_background) {
-          agent.backgroundTerminals[handle.id] = {
-            handle,
-            lastOutput: null,
-            status: "started",
-          };
-
-          statusPromise.then(async ({ status }) => {
-            const bgTerm = agent.backgroundTerminals[handle.id];
-
-            if (bgTerm.status !== "started") {
-              return;
-            }
-
-            const currentOutput = await handle.currentOutput();
-
-            agent.backgroundTerminals[handle.id] = {
-              status,
-              pendingOutput: {
-                ...currentOutput,
-                output: stripCommonPrefix(
-                  bgTerm.lastOutput?.output ?? "",
-                  currentOutput.output,
-                ),
-              },
-            };
-
-            return handle.release();
-          });
-
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Command started in background with id: ${handle.id}`,
-              },
-            ],
-          };
-        }
-
-        await using terminal = handle;
-
-        const { status } = await statusPromise;
-
-        if (status === "aborted") {
-          return {
-            content: [{ type: "text", text: "Tool cancelled by user" }],
-          };
-        }
-
-        const output = await terminal.currentOutput();
-
+      } catch (error: any) {
         return {
-          content: [{ type: "text", text: toolCommandOutput(status, output) }],
+          content: [
+            {
+              type: "text",
+              text: "Editing file failed: " + error.message,
+            },
+          ],
         };
-      },
-    );
+      }
+    },
+  );
 
-    server.registerTool(
-      "BashOutput",
-      {
-        title: "BashOutput",
-        description:
-          "Returns the current output and exit status of a background bash command by its id. Includes only new output since last invocation.",
-        inputSchema: {
-          id: z
-            .string()
-            .describe(
-              "The id of the background bash command as returned by `mcp__acp__Bash`",
-            ),
-        },
-      },
-      async (input) => {
-        const bgTerm = agent.backgroundTerminals[input.id];
-
-        if (!bgTerm) {
-          throw new Error(`Unknown shell ${input.id}`);
-        }
-
-        if (bgTerm.status === "started") {
-          const newOutput = await bgTerm.handle.currentOutput();
-          const strippedOutput = stripCommonPrefix(
-            bgTerm.lastOutput?.output ?? "",
-            newOutput.output,
-          );
-          bgTerm.lastOutput = newOutput;
-
-          return {
-            content: [
-              {
-                type: "text",
-                text: toolCommandOutput(bgTerm.status, {
-                  ...newOutput,
-                  output: strippedOutput,
-                }),
-              },
-            ],
-          };
-        } else {
-          return {
-            content: [
-              {
-                type: "text",
-                text: toolCommandOutput(bgTerm.status, bgTerm.pendingOutput),
-              },
-            ],
-          };
-        }
-      },
-    );
-
-    server.registerTool(
-      "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`",
-            ),
-        },
-      },
-      async (input) => {
-        const bgTerm = agent.backgroundTerminals[input.id];
-
-        if (!bgTerm) {
-          throw new Error(`Unknown shell ${input.id}`);
-        }
-
-        switch (bgTerm.status) {
-          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,
+  server.registerTool(
+    "multi-edit",
+    {
+      title: "Multi Edit",
+      description: `Edit a file with multiple sequential edits.`,
+      inputSchema: {
+        file_path: z
+          .string()
+          .describe("The absolute path to the file to modify"),
+        edits: z
+          .array(
+            z.object({
+              old_string: z.string().describe("The text to replace"),
+              new_string: z.string().describe("The text to replace it with"),
+              replace_all: z
+                .boolean()
+                .optional()
+                .describe(
+                  "Replace all occurrences of old_string (default false)",
                 ),
-              },
-            };
-            await bgTerm.handle.release();
-
-            return {
-              content: [{ type: "text", text: "Command killed successfully." }],
-            };
-          case "aborted":
-            return {
-              content: [{ type: "text", text: "Command aborted by user." }],
-            };
-          case "exited":
-            return {
-              content: [{ type: "text", text: "Command had already exited." }],
-            };
-          case "killed":
-            return {
-              content: [{ type: "text", text: "Command was already killed." }],
-            };
-          case "timedOut":
-            return {
-              content: [{ type: "text", text: "Command killed by timeout." }],
-            };
-          default: {
-            const unreachable: never = bgTerm;
-            return unreachable;
-          }
-        }
+            }),
+          )
+          .min(1)
+          .describe(
+            "Array of edit operations to perform sequentially on the file",
+          ),
       },
-    );
-
-    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": {
-          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;
-        }
+      annotations: {
+        title: "Multi Edit file",
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+        idempotentHint: false,
+      },
+    },
+    async (input) => {
+      const session = agent.sessions[sessionId];
+      if (!session) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "The user has left the building",
+            },
+          ],
+        };
       }
 
-      if (exitStatus?.exitCode != null && exitStatus.exitCode !== 0) {
-        toolOutput += `Failed with exit code ${exitStatus.exitCode}.`;
-      }
+      let { content } = await agent.client.readTextFile({
+        sessionId,
+        path: input.file_path,
+      });
 
-      if (exitStatus?.signal != null) {
-        toolOutput += `Signal \`${exitStatus.signal}\`. `;
-      }
+      const { newContent, lineNumbers } = replaceAndCalculateLocation(
+        content,
+        input.edits.map((edit) => ({
+          oldText: edit.old_string,
+          newText: edit.new_string,
+          replaceAll: edit.replace_all ?? false,
+        })),
+      );
 
-      toolOutput += "Output:\n\n";
-      toolOutput += commandOutput;
+      await agent.client.writeTextFile({
+        sessionId,
+        path: input.file_path,
+        content: newContent,
+      });
 
-      if (truncated) {
-        toolOutput += `\n\nCommand output was too long, so it was truncated to ${commandOutput.length} bytes.`;
-      }
-
-      return toolOutput;
-    }
-  }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ lineNumbers }),
+          },
+        ],
+      };
+    },
+  );
 
   let alwaysAllowedTools: { [key: string]: boolean } = {};
   server.registerTool(

src/tests/.claude/commands/quick-math.md

@@ -1,5 +0,0 @@
----
-description: 10 * 3 = 30
----
-
-What is 10 \* 3. Only respond with the number.

src/tests/.claude/commands/say-hello.md

@@ -1,6 +0,0 @@
----
-description: Say hello
-argument-hint: [name]
----
-
-Respond with "Hello $1" and nothing else.

src/tests/acp-agent.test.ts

@@ -4,7 +4,6 @@ import {
   Agent,
   Client,
   ClientSideConnection,
-  NewSessionResponse,
   ReadTextFileRequest,
   ReadTextFileResponse,
   RequestPermissionRequest,
@@ -14,11 +13,7 @@ import {
   WriteTextFileResponse,
 } from "@zed-industries/agent-client-protocol";
 import { nodeToWebWritable, nodeToWebReadable } from "../utils.js";
-import {
-  markdownEscape,
-  toolInfoFromToolUse,
-  toolUpdateFromToolResult,
-} from "../tools.js";
+import { toolInfoFromToolUse, toolUpdateFromToolResult } from "../tools.js";
 import { toAcpNotifications } from "../acp-agent.js";
 import { SDKAssistantMessage } from "@anthropic-ai/claude-code";
 
@@ -51,146 +46,54 @@ describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)(
 
     class TestClient implements Client {
       agent: Agent;
-      files: Map<string, string> = new Map();
-      receivedText: string = "";
 
       constructor(agent: Agent) {
         this.agent = agent;
       }
-
-      takeReceivedText() {
-        const text = this.receivedText;
-        this.receivedText = "";
-        return text;
-      }
-
-      async requestPermission(
+      requestPermission(
         params: RequestPermissionRequest,
       ): Promise<RequestPermissionResponse> {
-        const optionId = params.options.find(
-          (p) => p.kind === "allow_once",
-        )!.optionId;
-
-        return { outcome: { outcome: "selected", optionId } };
+        throw new Error("Method not implemented.");
       }
-
       async sessionUpdate(params: SessionNotification): Promise<void> {
-        console.error("RECEIVED", JSON.stringify(params, null, 4));
-
-        if (
-          params.update.sessionUpdate === "agent_message_chunk" &&
-          params.update.content.type === "text"
-        ) {
-          this.receivedText += params.update.content.text;
-        }
+        console.error("RECEVIED", params);
       }
-
-      async writeTextFile(
+      writeTextFile(
         params: WriteTextFileRequest,
       ): Promise<WriteTextFileResponse> {
-        this.files.set(params.path, params.content);
-        return null;
+        throw new Error("Method not implemented.");
       }
-
       async readTextFile(
         params: ReadTextFileRequest,
       ): Promise<ReadTextFileResponse> {
-        const content = this.files.get(params.path) ?? "";
         return {
-          content,
+          content:
+            "This project attempts to take over the world by solving the Goldbach conjecture.",
         };
       }
     }
 
-    async function setupTestSession(cwd: string): Promise<{
-      client: TestClient;
-      connection: ClientSideConnection;
-      newSessionResponse: NewSessionResponse;
-    }> {
-      let client;
+    it("should connect to the ACP subprocess", async () => {
       const connection = new ClientSideConnection(
         (agent) => {
-          client = new TestClient(agent);
-          return client;
+          return new TestClient(agent);
         },
         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 };
-    }
-
-    it("should connect to the ACP subprocess", async () => {
-      const { client, connection, newSessionResponse } =
-        await setupTestSession("./");
-
+      let session = await connection.newSession({ cwd: "./", mcpServers: [] });
       await connection.prompt({
         prompt: [
           {
             type: "text",
-            text: "Hello",
+            text: "What does this project do? Read the README.md file.",
           },
         ],
-        sessionId: newSessionResponse.sessionId,
+        sessionId: session.sessionId,
       });
-
-      expect(client.takeReceivedText()).not.toEqual("");
-    }, 30000);
-
-    it("should include available commands", async () => {
-      const { client, connection, newSessionResponse } =
-        await setupTestSession(__dirname);
-
-      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]" },
-      });
-
-      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);
+      console.log("DONE AWAITING");
+    }, 20000);
   },
 );
 
@@ -206,7 +109,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "execute",
       title: "`rm README.md.rm`",
       content: [
@@ -231,7 +134,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "search",
       title: "Find */**.ts",
       content: [],
@@ -252,7 +155,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "think",
       title: "Handle user's work request",
       content: [
@@ -273,16 +176,15 @@ describe("tool conversions", () => {
       id: "toolu_01EEqsX7Eb9hpx87KAHVPTey",
       name: "LS",
       input: {
-        path: "/Users/test/github/claude-code-acp",
+        path: "/Users/benbrandt/github/claude-code-acp",
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "search",
-      title:
-        "List the `/Users/test/github/claude-code-acp` directory's contents",
+      title: "/Users/benbrandt/github/claude-code-acp",
       content: [],
-      locations: [],
+      locations: [{ path: "/Users/benbrandt/github/claude-code-acp" }],
     });
   });
 
@@ -296,7 +198,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "search",
       title: 'grep ".*"',
       content: [],
@@ -309,12 +211,12 @@ describe("tool conversions", () => {
       id: "toolu_01ABC123XYZ789",
       name: "Write",
       input: {
-        file_path: "/Users/test/project/example.txt",
+        abs_path: "/Users/test/project/example.txt",
         content: "Hello, World!\nThis is test content.",
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "edit",
       title: "Write /Users/test/project/example.txt",
       content: [
@@ -340,7 +242,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "edit",
       title: "Write /Users/test/project/config.json",
       content: [
@@ -361,14 +263,19 @@ describe("tool conversions", () => {
       id: "toolu_01MNO456PQR789",
       name: "Read",
       input: {
-        file_path: "/Users/test/project/readme.md",
+        abs_path: "/Users/test/project/readme.md",
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "read",
       title: "Read File",
-      content: [],
+      content: [
+        {
+          type: "content",
+          content: { type: "text", text: "/Users/test/project/readme.md" },
+        },
+      ],
       locations: [{ path: "/Users/test/project/readme.md", line: 0 }],
     });
   });
@@ -383,7 +290,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "read",
       title: "Read /Users/test/project/data.json",
       content: [],
@@ -402,7 +309,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "read",
       title: "Read /Users/test/project/large.txt (1 - 100)",
       content: [],
@@ -422,7 +329,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "read",
       title: "Read /Users/test/project/large.txt (51 - 150)",
       content: [],
@@ -441,7 +348,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "read",
       title: "Read /Users/test/project/large.txt (from line 201)",
       content: [],
@@ -461,7 +368,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "fetch",
       title: "Fetch https://agentclientprotocol.com",
       content: [
@@ -486,7 +393,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "fetch",
       title: '"agentclientprotocol.com"',
       content: [],
@@ -503,7 +410,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "execute",
       title: `Kill Process`,
       content: [],
@@ -520,7 +427,7 @@ describe("tool conversions", () => {
       },
     };
 
-    expect(toolInfoFromToolUse(tool_use, {})).toStrictEqual({
+    expect(toolInfoFromToolUse(tool_use)).toStrictEqual({
       kind: "execute",
       title: `Tail Logs`,
       content: [],
@@ -605,7 +512,7 @@ describe("tool conversions", () => {
       session_id: "d056596f-e328-41e9-badd-b07122ae5227",
       uuid: "b7c3330c-de8f-4bba-ac53-68c7f76ffeb5",
     };
-    expect(toAcpNotifications(received, "test", {}, {})).toStrictEqual([
+    expect(toAcpNotifications(received, "test", {})).toStrictEqual([
       {
         sessionId: "test",
         update: {
@@ -664,8 +571,8 @@ describe("tool conversions", () => {
       name: "edit",
       input: {
         abs_path: "/Users/test/project/example.txt",
-        old_string: "old content",
-        new_string: "new content",
+        old_text: "old content",
+        new_text: "new content",
       },
     };
 
@@ -687,66 +594,6 @@ describe("tool conversions", () => {
     ]);
   });
 
-  it("should show full diff for multi edit tool", () => {
-    const toolUse = {
-      type: "tool_use",
-      id: "toolu_01DEF456",
-      name: "mcp__acp__multi-edit",
-      input: {
-        file_path: "/Users/test/project/config.json",
-        edits: [
-          {
-            old_string: 'version": 1',
-            new_string: 'version": 2',
-            replace_all: false,
-          },
-          {
-            old_string: 'enabled": false',
-            new_string: 'enabled": true',
-            replace_all: true,
-          },
-        ],
-      },
-    };
-    let fileCache: { [key: string]: string } = {
-      "/Users/test/project/config.json": JSON.stringify(
-        {
-          version: 1,
-          filler: "filler",
-          enabled: false,
-        },
-        null,
-        4,
-      ),
-    };
-
-    expect(toolInfoFromToolUse(toolUse, fileCache)).toEqual({
-      content: [
-        {
-          newText: `{
-    \"version\": 2,
-    \"filler\": \"filler\",
-    \"enabled\": true
-}`,
-          oldText: `{
-    \"version\": 1,
-    \"filler\": \"filler\",
-    \"enabled\": false
-}`,
-          path: "/Users/test/project/config.json",
-          type: "diff",
-        },
-      ],
-      kind: "edit",
-      locations: [
-        {
-          path: "/Users/test/project/config.json",
-        },
-      ],
-      title: "Edit /Users/test/project/config.json",
-    });
-  });
-
   it("should extract locations from multi-edit tool results", () => {
     const toolUse = {
       type: "tool_use",
@@ -795,8 +642,8 @@ describe("tool conversions", () => {
       name: "mcp__acp__edit",
       input: {
         abs_path: "/Users/test/project/main.py",
-        old_string: "def hello():",
-        new_string: "def hello_world():",
+        old_text: "def hello():",
+        new_text: "def hello_world():",
       },
     };
 
@@ -823,8 +670,8 @@ describe("tool conversions", () => {
       name: "edit",
       input: {
         abs_path: "/Users/test/project/notfound.txt",
-        old_string: "nonexistent",
-        new_string: "replacement",
+        old_text: "nonexistent",
+        new_text: "replacement",
       },
     };
 
@@ -849,8 +696,8 @@ describe("tool conversions", () => {
       name: "edit",
       input: {
         abs_path: "/Users/test/project/test.txt",
-        old_string: "old",
-        new_string: "new",
+        old_text: "old",
+        new_text: "new",
       },
     };
 
@@ -869,17 +716,3 @@ describe("tool conversions", () => {
     expect(update).toEqual({});
   });
 });
-
-describe("escape markdown", () => {
-  it("should escape markdown characters", () => {
-    let text = "Hello *world*!";
-    let escaped = markdownEscape(text);
-    expect(escaped).toEqual("```\nHello *world*!\n```");
-
-    text = "for example:\n```markdown\nHello *world*!\n```\n";
-    escaped = markdownEscape(text);
-    expect(escaped).toEqual(
-      "````\nfor example:\n```markdown\nHello *world*!\n```\n````",
-    );
-  });
-});

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";
 
 interface ToolInfo {
   title: string;
@@ -22,10 +19,7 @@ interface ToolUpdate {
   locations?: ToolCallLocation[];
 }
 
-export function toolInfoFromToolUse(
-  toolUse: any,
-  cachedFileContent: { [key: string]: string },
-): ToolInfo {
+export function toolInfoFromToolUse(toolUse: any): ToolInfo {
   const name = toolUse.name;
   const input = toolUse.input;
 
@@ -51,7 +45,18 @@ export function toolInfoFromToolUse(
           ? `Read Notebook ${input.notebook_path}`
           : "Read Notebook",
         kind: "read",
-        content: [],
+        content:
+          input && input.notebook_path
+            ? [
+                {
+                  type: "content",
+                  content: {
+                    type: "text",
+                    text: input.notebook_path.toString(),
+                  },
+                },
+              ]
+            : [],
         locations: input?.notebook_path ? [{ path: input.notebook_path }] : [],
       };
 
@@ -74,14 +79,13 @@ export function toolInfoFromToolUse(
       };
 
     case "Bash":
-    case "mcp__acp__Bash":
       return {
         title: input?.command
           ? "`" + input.command.replaceAll("`", "\\`") + "`"
           : "Terminal",
         kind: "execute",
         content:
-          input && input.description
+          input && input.command
             ? [
                 {
                   type: "content",
@@ -92,7 +96,6 @@ export function toolInfoFromToolUse(
       };
 
     case "BashOutput":
-    case "mcp__acp__BashOutput":
       return {
         title: "Tail Logs",
         kind: "execute",
@@ -100,7 +103,6 @@ export function toolInfoFromToolUse(
       };
 
     case "KillBash":
-    case "mcp__acp__KillBash":
       return {
         title: "Kill Process",
         kind: "execute",
@@ -136,108 +138,61 @@ export function toolInfoFromToolUse(
       return {
         title: "Read File",
         kind: "read",
-        content: [],
-        locations: [{ path: input.file_path, line: input.offset ?? 0 }],
+        content:
+          input && input.abs_path
+            ? [
+                {
+                  type: "content",
+                  content: { type: "text", text: input.abs_path.toString() },
+                },
+              ]
+            : [],
+        locations: [{ path: input.abs_path, line: input.offset ?? 0 }],
       };
 
     case "LS":
       return {
-        title: `List the ${input?.path ? "`" + input.path + "`" : "current"} directory's contents`,
+        title: input?.path ? input.path : "Current Directory",
         kind: "search",
         content: [],
-        locations: [],
+        locations: input?.path ? [{ path: input.path }] : [],
       };
 
     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 line = null;
-
-      if (path && input.old_text) {
-        try {
-          let oldContent = cachedFileContent[path] || "";
-          let newContent = replaceAndCalculateLocation(oldContent, [
-            {
-              oldText: input.old_string,
-              newText: input.new_string,
-              replaceAll: false,
-            },
-          ]);
-          oldText = oldContent;
-          newText = newContent.newContent;
-          line = newContent.lineNumbers[0];
-        } catch (e) {
-          console.error(e);
-        }
-      }
+    case "Edit":
       return {
-        title: path ? `Edit ${path}` : "Edit",
+        title: input?.abs_path ? `Edit ${input.abs_path}` : "Edit",
         kind: "edit",
         content:
-          input && path
+          input && input.abs_path
             ? [
                 {
                   type: "diff",
-                  path,
-                  oldText,
-                  newText,
+                  path: input.abs_path,
+                  oldText: input.old_text || null,
+                  newText: input.new_text,
                 },
               ]
             : [],
-        locations: path ? [{ path, line }] : [],
+        locations: input?.abs_path ? [{ path: input.abs_path }] : [],
       };
-    }
 
     case "mcp__acp__multi-edit":
     case "MultiEdit":
-      let multiInput = input as {
-        file_path: string;
-        edits: {
-          old_string: string;
-          new_string: string;
-          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");
-      try {
-        if (multiInput.edits && multiInput.file_path) {
-          let oldContent =
-            cachedFileContent[multiInput.file_path] ||
-            multiInput.edits.map((edit: any) => edit.oldText).join("\n");
-          let newContent = replaceAndCalculateLocation(
-            oldContent,
-            multiInput.edits.map((edit) => ({
-              oldText: edit.old_string,
-              newText: edit.new_string,
-              replaceAll: edit.replace_all,
-            })),
-          );
-          oldTextMulti = oldContent;
-          newTextMulti = newContent.newContent;
-        }
-      } catch (e) {
-        console.error(e);
-      }
       // Display it as a normal edit, because end users don't care about
       // the distinction between edits and multi-edits.
       return {
         title: input?.file_path ? `Edit ${input.file_path}` : "Edit",
         kind: "edit",
-        content: [
-          {
-            type: "diff" as const,
-            path: input.file_path,
-            oldText: oldTextMulti,
-            newText: newTextMulti,
-          },
-        ],
+        content:
+          input && input.edits && input.edits.length > 0
+            ? input.edits.map((edit: any) => ({
+                type: "diff" as const,
+                path: input.file_path,
+                oldText: edit.old_string || null,
+                newText: edit.new_string,
+              }))
+            : [],
         locations: input?.file_path ? [{ path: input.file_path }] : [],
       };
 
@@ -269,20 +224,20 @@ export function toolInfoFromToolUse(
 
     case "Write":
       return {
-        title: input?.file_path ? `Write ${input.file_path}` : "Write",
+        title: input?.abs_path ? `Write ${input.abs_path}` : "Write",
         kind: "edit",
         content:
-          input && input.file_path
+          input && input.abs_path
             ? [
                 {
                   type: "diff",
-                  path: input.file_path,
+                  path: input.abs_path,
                   oldText: null,
                   newText: input.content,
                 },
               ]
             : [],
-        locations: input?.file_path ? [{ path: input.file_path }] : [],
+        locations: input?.abs_path ? [{ path: input.abs_path }] : [],
       };
 
     case "Glob": {
@@ -492,55 +447,11 @@ export function toolUpdateFromToolResult(
       }
       return {};
     }
-
-    case "mcp__acp__write":
-    case "Write":
-      return {};
-
-    case "Read":
-    case "mcp__acp__read":
-      if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
-        return {
-          content: toolResult.content.map((content: any) => ({
-            type: "content",
-            content:
-              content.type == "text"
-                ? {
-                    type: "text",
-                    text: markdownEscape(
-                      content.text.replace(SYSTEM_REMINDER, ""),
-                    ),
-                  }
-                : content,
-          })),
-        };
-      } else if (
-        typeof toolResult.content === "string" &&
-        toolResult.content.length > 0
-      ) {
-        return {
-          content: [
-            {
-              type: "content",
-              content: {
-                type: "text",
-                text: markdownEscape(
-                  toolResult.content.replace(SYSTEM_REMINDER, ""),
-                ),
-              },
-            },
-          ],
-        };
-      }
-      return {};
-
-    case "mcp__acp__Bash":
-      // The bash tool already embeds a terminal
-      return {};
-
     case "Task":
     case "NotebookEdit":
     case "NotebookRead":
+    case "mcp__acp__write":
+    case "Write":
     case "TodoWrite":
     case "exit_plan_mode":
     case "Bash":
@@ -552,26 +463,33 @@ export function toolUpdateFromToolResult(
     case "WebFetch":
     case "WebSearch":
     case "Other":
+    case "mcp__acp__read":
+      if (Array.isArray(toolResult.content)) {
+        return {
+          content: toolResult.content.map((content: any) => ({
+            type: "content",
+            content: {
+              type: "text",
+              text: `\`\`\`${toolUse.input?.abs_path ?? ""}\n${content.text ?? ""}\n\`\`\``,
+            },
+          })),
+        };
+      }
+      return {};
     default: {
-      if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
+      if (Array.isArray(toolResult.content)) {
         return {
           content: toolResult.content.map((content: any) => ({
             type: "content",
             content,
           })),
         };
-      } else if (
-        typeof toolResult.content === "string" &&
-        toolResult.content.length > 0
-      ) {
+      } else if (typeof toolResult.content === "string") {
         return {
           content: [
             {
               type: "content",
-              content: {
-                type: "text",
-                text: toolResult.content,
-              },
+              content: { type: "text", text: toolResult.content },
             },
           ],
         };
@@ -594,13 +512,3 @@ export function planEntries(input: { todos: ClaudePlanEntry[] }): PlanEntry[] {
     priority: "medium",
   }));
 }
-
-export function markdownEscape(text: string): string {
-  let escape = "```";
-  for (let [m] of text.matchAll(/^```+/gm)) {
-    while (m.length >= escape.length) {
-      escape += "`";
-    }
-  }
-  return escape + "\n" + text + (text.endsWith("\n") ? "" : "\n") + escape;
-}

src/utils.ts

@@ -77,7 +77,3 @@ 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));
-}