amp-acp 0.1.0 → 0.3.0

package/README.md

@@ -1,45 +1,62 @@
-# ACP adapter for Amp
+# ACP adapter for AmpCode
 
-Use [Amp](https://ampcode.com) from ACP-compatible clients such as [Zed](https://zed.dev).
+![Screenshot](img/screenshot.png)
+
+Use [Amp](https://ampcode.com) from [ACP](https://agentclientprotocol.com/)-compatible clients such as [Zed](https://zed.dev) or [Toad](https://github.com/batrachianai/toad).
 
 ## Prerequisites
 
-- [Amp CLI](https://ampcode.com) installed and authenticated (`amp login`)
-- Node.js (for running the adapter)
+- Node.js 18+ (the adapter will be installed automatically via `npx`)
 
 ## Installation
 
-```bash
-npm install -g amp-acp
+Add to your Zed `settings.json` (open with `cmd+,` or `ctrl+,`):
+
+```json
+{
+  "agent_servers": {
+    "Amp": {
+      "command": "npx",
+      "args": ["-y", "amp-acp"]
+    }
+  }
+}
 ```
 
-Or run locally:
+That's it! The SDK handles authentication and Amp integration automatically.
 
-```bash
-npm install
-npm start
-```
+## First Use
 
-## Usage
+**If you don't have Amp CLI installed**: Add the `AMP_API_KEY` environment variable to your Zed config. You can get your API key from https://ampcode.com/settings
 
-1. Start the adapter:
-   ```bash
-   amp-acp
-   ```
+```json
+{
+  "agent_servers": {
+    "Amp": {
+      "command": "npx",
+      "args": ["-y", "amp-acp"],
+      "env": {
+        "AMP_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
 
-2. In Zed:
-   - Open Settings → External Agents (ACP)
-   - Connect to the adapter
-   - Start a new Amp thread
+**If you [have Amp CLI installed](https://ampcode.com/manual#getting-started-command-line-interface)**: Run `amp login` first to authenticate.
 
 ## How it Works
 
-- Streams Amp's Claude Code–compatible JSON over ACP
-- Renders Amp messages and interactions in Zed
+- Uses the official Amp SDK to communicate with AmpCode
+- Streams Amp's responses over the Agent Client Protocol (ACP)
+- Renders Amp messages and interactions natively in Zed
 - Tool permissions are handled by Amp (no additional configuration needed)
+- Supports conversation continuity across multiple prompts
 
 ## Troubleshooting
 
-**Connection fails**: Ensure `amp login` was successful and the CLI is in your PATH.
+**Adapter doesn't start**: Make sure you have Node.js 18 or later installed. Run `node --version` to check.
+
+**Connection issues**: Restart Zed and try again. The adapter creates a fresh connection each time.
 
-**Adapter not found**: Check that `amp-acp` is running before connecting from Zed.
+**Tool execution problems**: Check Zed's output panel for detailed error messages from the Amp SDK.

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "amp-acp",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "private": false,
   "type": "module",
   "bin": {
-    "amp-acp": "./src/index.js"
+    "amp-acp": "src/index.js"
   },
-  "description": "ACP adapter that bridges Amp CLI to Agent Client Protocol (Zed external agent)",
+  "description": "ACP adapter that bridges Amp Code to Agent Client Protocol (Zed external agent)",
   "license": "Apache-2.0",
   "scripts": {
     "start": "node src/index.js",
@@ -14,6 +14,8 @@
     "test": "node -e 'console.log(\"OK\")'"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "0.4.8"
+    "@agentclientprotocol/sdk": "0.4.8",
+    "@sourcegraph/amp": "^0.0.1765685598-g5365e6",
+    "@sourcegraph/amp-sdk": "^0.1.0-20251214200908-g3251f72"
   }
-}
+}

package/src/server.js

@@ -1,6 +1,5 @@
 import { RequestError } from '@agentclientprotocol/sdk';
-import { spawn } from 'node:child_process';
-import readline from 'node:readline';
+import { execute } from '@sourcegraph/amp-sdk';
 import { toAcpNotifications } from './to-acp.js';
 
 export class AmpAcpAgent {
@@ -15,6 +14,7 @@ export class AmpAcpAgent {
       protocolVersion: 1,
       agentCapabilities: {
         promptCapabilities: { image: true, embeddedContext: true },
+        mcpCapabilities: { http: true, sse: true },
       },
       authMethods: [],
     };
@@ -23,24 +23,40 @@ export class AmpAcpAgent {
   async newSession(params) {
     const sessionId = `S-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 
+    // Convert ACP mcpServers to Amp SDK mcpConfig format
+    const mcpConfig = {};
+    if (Array.isArray(params.mcpServers)) {
+      for (const server of params.mcpServers) {
+        if ('type' in server && (server.type === 'http' || server.type === 'sse')) {
+          // HTTP/SSE type - Amp SDK may not support this directly
+          // Skip for now or handle if SDK supports it
+        } else {
+          // stdio type
+          mcpConfig[server.name] = {
+            command: server.command,
+            args: server.args,
+            env: server.env ? Object.fromEntries(server.env.map((e) => [e.name, e.value])) : undefined,
+          };
+        }
+      }
+    }
+
     this.sessions.set(sessionId, {
-      proc: null,
-      rl: null,
-      queue: null,
+      threadId: null,
+      controller: null,
       cancelled: false,
       active: false,
+      mode: 'default',
+      mcpConfig,
     });
 
     return {
       sessionId,
-      models: { currentModelId: 'default', availableModels: [{ modelId: 'default', name: 'Default', description: 'Amp default' }] },
       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: 'Analyze but not modify files or execute commands' },
+          { id: 'default', name: 'Default', description: 'Prompts for permission on first use of each tool' },
+          { id: 'bypass', name: 'Bypass', description: 'Skips all permission prompts' },
         ],
       },
     };
@@ -56,160 +72,105 @@ export class AmpAcpAgent {
     s.cancelled = false;
     s.active = true;
 
-    // Start a fresh Amp process per turn (amp -x is single-turn). Avoid reusing prior proc to prevent races.
-    const proc = spawn('amp', ['-x', '--stream-json', '--stream-json-input'], {
-      cwd: params.cwd || process.cwd(),
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: process.env,
-    });
-    const rl = readline.createInterface({ input: proc.stdout });
-    const queue = createJsonQueue(rl);
-    // Capture exit to clean state
-    proc.on('close', () => {
-      // Do not null out queue while a turn may still await next(); just signal end
-      try { queue?.end?.(); } catch {}
-    });
-    // Optionally log stderr (redirected to our stderr by default)
-    proc.stderr?.on('data', (d) => {
-      console.error(`[amp] ${d.toString()}`.trim());
-    });
-    s.proc = proc;
-    s.rl = rl;
-    s.queue = queue;
-    // Don't wait for init; amp will emit it before assistant/user events
-
-    // Build Amp user message JSON line from ACP prompt chunks
-    const content = [];
+    // Build plain-text input for Amp from ACP prompt chunks
+    let textInput = '';
     for (const chunk of params.prompt) {
       switch (chunk.type) {
         case 'text':
-          content.push({ type: 'text', text: chunk.text });
+          textInput += chunk.text;
           break;
         case 'resource_link':
-          content.push({ type: 'text', text: chunk.uri });
+          textInput += `\n${chunk.uri}\n`;
           break;
         case 'resource':
           if ('text' in chunk.resource) {
-            content.push({ type: 'text', text: chunk.resource.uri });
-            content.push({ type: 'text', text: `\n<context ref="${chunk.resource.uri}">\n${chunk.resource.text}\n</context>` });
+            textInput += `\n<context ref="${chunk.resource.uri}">\n${chunk.resource.text}\n</context>\n`;
           }
           break;
         case 'image':
-          if (chunk.data) {
-            content.push({ type: 'image', source: { type: 'base64', data: chunk.data, media_type: chunk.mimeType } });
-          } else if (chunk.uri && chunk.uri.startsWith('http')) {
-            content.push({ type: 'image', source: { type: 'url', url: chunk.uri } });
-          }
+          // Images not supported by Amp SDK yet via simple prompt string; ignore for now
           break;
         default:
           break;
       }
     }
 
-    const userMsg = {
-      type: 'user',
-      message: { role: 'user', content },
-      parent_tool_use_id: null,
-      session_id: params.sessionId,
+    const options = {
+      cwd: params.cwd || process.cwd(),
     };
 
-    s.proc.stdin.write(JSON.stringify(userMsg) + '\n');
+    if (s.mode === 'bypass') {
+      options.dangerouslyAllowAll = true;
+    }
+
+    if (Object.keys(s.mcpConfig).length > 0) {
+      options.mcpConfig = s.mcpConfig;
+    }
+
+    if (s.threadId) {
+      options.continue = s.threadId;
+    }
+
+    const controller = new AbortController();
+    s.controller = controller;
 
     try {
-      while (true) {
-        const msg = await s.queue.next();
-        if (msg == null) {
-          return { stopReason: s.cancelled ? 'cancelled' : 'refusal' };
+      for await (const message of execute({ prompt: textInput, options, signal: controller.signal })) {
+        if (!s.threadId && message.session_id) {
+          s.threadId = message.session_id;
         }
-        switch (msg.type) {
-        case 'system':
-          // ignore init/compact/etc
-          break;
-        case 'assistant': {
-          const notifs = toAcpNotifications(msg, params.sessionId);
-          for (const n of notifs) await this.client.sessionUpdate(n);
-          break;
-        }
-        case 'user': {
-          // Skip echoing user messages to avoid duplicates in the client UI
-          break;
-        }
-        case 'result': {
-          if (msg.subtype === 'success') return { stopReason: 'end_turn' };
-          if (msg.subtype === 'error_max_turns') return { stopReason: 'max_turn_requests' };
-          return { stopReason: 'refusal' };
+
+        if (message.type === 'assistant') {
+          for (const n of toAcpNotifications(message, params.sessionId)) {
+            try {
+              await this.client.sessionUpdate(n);
+            } catch (e) {
+              console.error('[acp] sessionUpdate failed', e);
+            }
+          }
         }
-        default:
-          break;
+
+        if (message.type === 'result' && message.is_error) {
+          await this.client.sessionUpdate({
+            sessionId: params.sessionId,
+            update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: `Error: ${message.error}` } },
+          });
         }
       }
-      throw new Error('Session did not end in result');
+
+      return { stopReason: s.cancelled ? 'cancelled' : 'end_turn' };
+    } catch (err) {
+      if (s.cancelled || (err.name === 'AbortError') || err.message.includes('aborted')) {
+        return { stopReason: 'cancelled' };
+      }
+      console.error('[amp] Execution error:', err);
+      throw err;
     } finally {
       s.active = false;
       s.cancelled = false;
+      s.controller = null;
     }
   }
 
   async cancel(params) {
     const s = this.sessions.get(params.sessionId);
     if (!s) return {};
-    if (s.active && s.proc) {
+    if (s.active && s.controller) {
       s.cancelled = true;
-      try { s.proc.kill('SIGINT'); } catch {}
-      // ensure readers unblock
-      try { s.queue?.end?.(); } catch {}
+      s.controller.abort();
     }
     return {};
   }
 
   async setSessionModel(_params) { return {}; }
 
-  async setSessionMode(_params) { return {}; }
+  async setSessionMode(params) {
+    const s = this.sessions.get(params.sessionId);
+    if (!s) throw new Error('Session not found');
+    s.mode = params.modeId;
+    return {};
+  }
 
   async readTextFile(params) { return this.client.readTextFile(params); }
   async writeTextFile(params) { return this.client.writeTextFile(params); }
 }
-
-function createJsonQueue(rl) {
-  const buf = [];
-  const waiters = [];
-  rl.on('line', (line) => {
-    let obj;
-    try {
-      obj = JSON.parse(line);
-    } catch {
-      return; // ignore non-JSON
-    }
-    if (waiters.length) {
-      const resolve = waiters.shift();
-      resolve(obj);
-    } else {
-      buf.push(obj);
-    }
-  });
-  let ended = false;
-  function end() {
-    if (ended) return;
-    ended = true;
-    while (waiters.length) {
-      const resolve = waiters.shift();
-      resolve(null);
-    }
-  }
-  rl.on('close', end);
-  rl.on('SIGINT', end);
-  return {
-    next() {
-      return new Promise((resolve) => {
-        if (buf.length) {
-          resolve(buf.shift());
-        } else if (ended) {
-          resolve(null);
-        } else {
-          waiters.push(resolve);
-        }
-      });
-    },
-    end,
-  };
-}