codeep 1.2.22 → 1.2.24

package/dist/acp/protocol.d.ts

@@ -26,29 +26,32 @@ export interface InitializeParams {
     }[];
 }
 export interface InitializeResult {
-    capabilities: {
+    protocolVersion: number;
+    agentCapabilities: {
         streaming?: boolean;
         fileEditing?: boolean;
     };
-    serverInfo: {
+    agentInfo: {
         name: string;
         version: string;
     };
+    authMethods: unknown[];
 }
-export interface AgentRunParams {
-    prompt: string;
-    workspaceRoot?: string;
-    conversationId?: string;
+export interface SessionNewParams {
+    cwd: string;
+    mcpServers?: {
+        name: string;
+        command: string;
+        args: string[];
+        env?: Record<string, string>;
+    }[];
 }
-export interface AgentStreamParams {
-    conversationId: string;
+export interface ContentBlock {
+    type: 'text';
     text: string;
-    done?: boolean;
 }
-export interface ApplyEditParams {
-    changes: {
-        uri: string;
-        newText: string;
-    }[];
+export interface SessionPromptParams {
+    sessionId: string;
+    prompt: ContentBlock[];
 }
 export type AcpMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;

package/dist/acp/server.js

@@ -1,10 +1,12 @@
 // src/acp/server.ts
 // Codeep ACP adapter — started via `codeep acp` CLI subcommand
+import { randomUUID } from 'crypto';
 import { StdioTransport } from './transport.js';
 import { runAgentSession } from './session.js';
 export function startAcpServer() {
     const transport = new StdioTransport();
-    const activeSessions = new Map();
+    // sessionId → { workspaceRoot, abortController }
+    const sessions = new Map();
     transport.start((msg) => {
         switch (msg.method) {
             case 'initialize':
@@ -13,11 +15,14 @@ export function startAcpServer() {
             case 'initialized':
                 // no-op acknowledgment
                 break;
-            case 'agent/run':
-                handleAgentRun(msg);
+            case 'session/new':
+                handleSessionNew(msg);
                 break;
-            case 'agent/cancel':
-                handleAgentCancel(msg);
+            case 'session/prompt':
+                handleSessionPrompt(msg);
+                break;
+            case 'session/cancel':
+                handleSessionCancel(msg);
                 break;
             default:
                 transport.error(msg.id, -32601, `Method not found: ${msg.method}`);
@@ -26,53 +31,72 @@ export function startAcpServer() {
     function handleInitialize(msg) {
         const _params = msg.params;
         const result = {
-            capabilities: {
+            protocolVersion: 1,
+            agentCapabilities: {
                 streaming: true,
                 fileEditing: true,
             },
-            serverInfo: {
+            agentInfo: {
                 name: 'codeep',
                 version: '1.0.0',
             },
+            authMethods: [],
         };
         transport.respond(msg.id, result);
     }
-    function handleAgentRun(msg) {
+    function handleSessionNew(msg) {
+        const params = msg.params;
+        const sessionId = randomUUID();
+        sessions.set(sessionId, { workspaceRoot: params.cwd, abortController: null });
+        transport.respond(msg.id, { sessionId });
+    }
+    function handleSessionPrompt(msg) {
         const params = msg.params;
-        const conversationId = params.conversationId ?? String(msg.id);
+        const session = sessions.get(params.sessionId);
+        if (!session) {
+            transport.error(msg.id, -32602, `Unknown sessionId: ${params.sessionId}`);
+            return;
+        }
+        // Extract text from ContentBlock[]
+        const prompt = params.prompt
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text)
+            .join('\n');
         const abortController = new AbortController();
-        activeSessions.set(conversationId, abortController);
+        session.abortController = abortController;
         runAgentSession({
-            prompt: params.prompt,
-            workspaceRoot: params.workspaceRoot ?? process.cwd(),
-            conversationId,
+            prompt,
+            workspaceRoot: session.workspaceRoot,
+            conversationId: params.sessionId,
             abortSignal: abortController.signal,
             onChunk: (text) => {
-                transport.notify('agent/stream', { conversationId, text });
-            },
-            onFileEdit: (uri, newText) => {
-                transport.notify('workspace/applyEdit', {
-                    changes: [{ uri, newText }],
+                transport.notify('session/update', {
+                    sessionId: params.sessionId,
+                    type: 'agent_message_chunk',
+                    text,
                 });
             },
+            onFileEdit: (_uri, _newText) => {
+                // file edits are streamed via onChunk for now
+            },
         }).then(() => {
-            transport.respond(msg.id, { done: true });
+            transport.respond(msg.id, { stopReason: 'end_turn' });
         }).catch((err) => {
             if (err.name === 'AbortError') {
-                transport.respond(msg.id, { cancelled: true });
+                transport.respond(msg.id, { stopReason: 'cancelled' });
             }
             else {
                 transport.error(msg.id, -32000, err.message);
             }
         }).finally(() => {
-            activeSessions.delete(conversationId);
+            if (session)
+                session.abortController = null;
         });
     }
-    function handleAgentCancel(msg) {
-        const { conversationId } = msg.params;
-        activeSessions.get(conversationId)?.abort();
-        activeSessions.delete(conversationId);
-        transport.respond(msg.id, { cancelled: true });
+    function handleSessionCancel(msg) {
+        const { sessionId } = msg.params;
+        sessions.get(sessionId)?.abortController?.abort();
+        transport.respond(msg.id, {});
     }
     // Keep process alive until stdin closes (Zed terminates us)
     return new Promise((resolve) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.2.22",
+  "version": "1.2.24",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",