Use latest version of ACP

Author: erbenmo

Cargo.lock

@@ -8,7 +8,7 @@ version.workspace = true
 license.workspace = true
 
 [dependencies]
-agent-client-protocol = "0.1.0"
+agent-client-protocol = "0.7.0"
 amzn-codewhisperer-client.workspace = true
 amzn-codewhisperer-streaming-client.workspace = true
 amzn-consolas-client.workspace = true

crates/agent/Cargo.toml

@@ -11,7 +11,7 @@
 
 use std::process::ExitCode;
 
-use agent_client_protocol as acp;
+use agent_client_protocol::{self as acp, Agent as _};
 use eyre::Result;
 use tokio_util::compat::{
     TokioAsyncReadCompatExt,
@@ -20,12 +20,15 @@ use tokio_util::compat::{
 
 struct AcpClient;
 
+#[async_trait::async_trait(?Send)]
 impl acp::Client for AcpClient {
-    async fn session_notification(&self, args: acp::SessionNotification) -> Result<(), acp::Error> {
+    async fn session_notification(&self, args: acp::SessionNotification) -> acp::Result<()> {
         match args.update {
-            acp::SessionUpdate::AgentMessageChunk { content } => match content {
-                acp::ContentBlock::Text(text) => println!("Agent: {}", text.text),
-                _ => println!("Agent: <non-text content>"),
+            acp::SessionUpdate::AgentMessageChunk(acp::ContentChunk { content, .. }) => {
+                match content {
+                    acp::ContentBlock::Text(text) => println!("Agent: {}", text.text),
+                    _ => println!("Agent: <non-text content>"),
+                }
             },
             acp::SessionUpdate::ToolCall(tool_call) => {
                 println!("🔧 Tool Call: {:#?}", tool_call);
@@ -40,8 +43,7 @@ impl acp::Client for AcpClient {
     async fn request_permission(
         &self,
         args: acp::RequestPermissionRequest,
-    ) -> Result<acp::RequestPermissionResponse, acp::Error> {
-        eprintln!("ACP Client received permission request: {:?}", args);
+    ) -> acp::Result<acp::RequestPermissionResponse> {
 
         // Auto-approve first option if available
         let option_id = args
@@ -50,18 +52,46 @@ impl acp::Client for AcpClient {
             .map(|opt| opt.id.clone())
             .ok_or_else(|| acp::Error::internal_error())?;
 
-        eprintln!("ACP Client auto-approving with option: {:?}", option_id);
 
         Ok(acp::RequestPermissionResponse {
             outcome: acp::RequestPermissionOutcome::Selected { option_id },
+            meta: None,
         })
     }
 
-    async fn write_text_file(&self, _args: acp::WriteTextFileRequest) -> Result<(), acp::Error> {
+    async fn write_text_file(&self, _args: acp::WriteTextFileRequest) -> acp::Result<acp::WriteTextFileResponse> {
+        Err(acp::Error::method_not_found())
+    }
+
+    async fn read_text_file(&self, _args: acp::ReadTextFileRequest) -> acp::Result<acp::ReadTextFileResponse> {
+        Err(acp::Error::method_not_found())
+    }
+
+    async fn create_terminal(&self, _args: acp::CreateTerminalRequest) -> acp::Result<acp::CreateTerminalResponse> {
+        Err(acp::Error::method_not_found())
+    }
+
+    async fn terminal_output(&self, _args: acp::TerminalOutputRequest) -> acp::Result<acp::TerminalOutputResponse> {
+        Err(acp::Error::method_not_found())
+    }
+
+    async fn release_terminal(&self, _args: acp::ReleaseTerminalRequest) -> acp::Result<acp::ReleaseTerminalResponse> {
+        Err(acp::Error::method_not_found())
+    }
+
+    async fn wait_for_terminal_exit(&self, _args: acp::WaitForTerminalExitRequest) -> acp::Result<acp::WaitForTerminalExitResponse> {
+        Err(acp::Error::method_not_found())
+    }
+
+    async fn kill_terminal_command(&self, _args: acp::KillTerminalCommandRequest) -> acp::Result<acp::KillTerminalCommandResponse> {
+        Err(acp::Error::method_not_found())
+    }
+
+    async fn ext_method(&self, _args: acp::ExtRequest) -> acp::Result<acp::ExtResponse> {
         Err(acp::Error::method_not_found())
     }
 
-    async fn read_text_file(&self, _args: acp::ReadTextFileRequest) -> Result<acp::ReadTextFileResponse, acp::Error> {
+    async fn ext_notification(&self, _args: acp::ExtNotification) -> acp::Result<()> {
         Err(acp::Error::method_not_found())
     }
 }
@@ -87,16 +117,23 @@ pub async fn execute(agent_path: String) -> Result<ExitCode> {
             tokio::task::spawn_local(handle_io);
 
             // Initialize connection
-            acp::Agent::initialize(&conn, acp::InitializeRequest {
+            conn.initialize(acp::InitializeRequest {
                 protocol_version: acp::V1,
                 client_capabilities: acp::ClientCapabilities::default(),
+                client_info: Some(acp::Implementation {
+                    name: "acp-test-client".to_string(),
+                    title: Some("ACP Test Client".to_string()),
+                    version: "0.1.0".to_string(),
+                }),
+                meta: None,
             })
             .await?;
 
             // Create session
-            let session = acp::Agent::new_session(&conn, acp::NewSessionRequest {
+            let session = conn.new_session(acp::NewSessionRequest {
                 mcp_servers: Vec::new(),
                 cwd: std::env::current_dir()?,
+                meta: None,
             })
             .await?;
 
@@ -116,12 +153,14 @@ pub async fn execute(agent_path: String) -> Result<ExitCode> {
                     continue;
                 }
 
-                acp::Agent::prompt(&conn, acp::PromptRequest {
+                conn.prompt(acp::PromptRequest {
                     session_id: session.session_id.clone(),
                     prompt: vec![acp::ContentBlock::Text(acp::TextContent {
                         text: input.to_string(),
                         annotations: None,
+                        meta: None,
                     })],
+                    meta: None,
                 })
                 .await?;
             }