feat(acp-nats): add fs_read_text_file client handler

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com>

Author: yordis

rsworkspace/crates/acp-nats/src/client/fs_read_text_file.rs

@@ -0,0 +1,241 @@
+use crate::jsonrpc::extract_request_id;
+use crate::nats::{FlushClient, PublishClient, headers_with_trace_context};
+use agent_client_protocol::{
+    Client, Error, ErrorCode, ReadTextFileRequest, ReadTextFileResponse, Request, RequestId,
+    Response,
+};
+use bytes::Bytes;
+use tracing::{instrument, warn};
+
+async fn publish_reply<N: PublishClient + FlushClient>(
+    nats: &N,
+    reply_to: &str,
+    bytes: Bytes,
+    context: &str,
+) {
+    let headers = headers_with_trace_context();
+    if let Err(e) = nats
+        .publish_with_headers(reply_to.to_string(), headers, bytes)
+        .await
+    {
+        warn!(error = %e, "Failed to publish {}", context);
+    }
+    if let Err(e) = nats.flush().await {
+        warn!(error = %e, "Failed to flush {}", context);
+    }
+}
+
+fn error_response_bytes(request_id: RequestId, code: ErrorCode, message: &str) -> Bytes {
+    serde_json::to_vec(&Response::<()>::Error {
+        id: request_id,
+        error: Error::new(i32::from(code), message),
+    })
+    .unwrap_or_else(|e| {
+        serde_json::to_vec(&Response::<()>::Error {
+            id: RequestId::Null,
+            error: Error::new(
+                i32::from(code),
+                format!("{} (serialization failed: {})", message, e),
+            ),
+        })
+        .unwrap()
+    })
+    .into()
+}
+
+#[derive(Debug)]
+pub enum FsReadTextFileError {
+    InvalidRequest(serde_json::Error),
+    ClientError(agent_client_protocol::Error),
+}
+
+impl std::fmt::Display for FsReadTextFileError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::InvalidRequest(e) => write!(f, "invalid request: {}", e),
+            Self::ClientError(e) => write!(f, "client error: {}", e),
+        }
+    }
+}
+
+impl std::error::Error for FsReadTextFileError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::InvalidRequest(e) => Some(e),
+            Self::ClientError(e) => Some(e),
+        }
+    }
+}
+
+pub fn error_code_and_message(e: &FsReadTextFileError) -> (ErrorCode, String) {
+    match e {
+        FsReadTextFileError::InvalidRequest(inner) => (
+            ErrorCode::InvalidParams,
+            format!("Invalid read_text_file request: {}", inner),
+        ),
+        FsReadTextFileError::ClientError(inner) => (inner.code, inner.message.clone()),
+    }
+}
+
+/// Handles read_text_file: parses request, calls client, wraps response in JSON-RPC envelope,
+/// and publishes to reply subject. Reply is required (request-reply pattern).
+#[instrument(name = "acp.client.fs.read_text_file", skip(payload, client, nats))]
+pub async fn handle<N: PublishClient + FlushClient, C: Client>(
+    payload: &[u8],
+    client: &C,
+    reply: Option<&str>,
+    nats: &N,
+    session_id: &str,
+) {
+    let reply_to = match reply {
+        Some(r) => r,
+        None => {
+            warn!(
+                session_id = %session_id,
+                "read_text_file requires reply subject; ignoring message"
+            );
+            return;
+        }
+    };
+
+    let request_id = extract_request_id(payload);
+    match forward_to_client(payload, client).await {
+        Ok(response) => {
+            let response_bytes = serde_json::to_vec(&Response::Result {
+                id: request_id.clone(),
+                result: response,
+            })
+            .map(Bytes::from)
+            .unwrap_or_else(|e| {
+                error_response_bytes(
+                    request_id,
+                    ErrorCode::InternalError,
+                    &format!("Failed to serialize read_text_file response: {}", e),
+                )
+            });
+            publish_reply(nats, reply_to, response_bytes, "fs_read_text_file reply").await;
+        }
+        Err(e) => {
+            let (code, message) = error_code_and_message(&e);
+            warn!(
+                error = %e,
+                session_id = %session_id,
+                "Failed to handle fs_read_text_file"
+            );
+            let bytes = error_response_bytes(request_id, code, &message);
+            publish_reply(nats, reply_to, bytes, "fs_read_text_file error reply").await;
+        }
+    }
+}
+
+async fn forward_to_client<C: Client>(
+    payload: &[u8],
+    client: &C,
+) -> Result<ReadTextFileResponse, FsReadTextFileError> {
+    let envelope: Request<ReadTextFileRequest> =
+        serde_json::from_slice(payload).map_err(FsReadTextFileError::InvalidRequest)?;
+    let request = envelope.params.ok_or_else(|| {
+        FsReadTextFileError::InvalidRequest(
+            serde_json::from_value::<ReadTextFileRequest>(serde_json::Value::Null).unwrap_err(),
+        )
+    })?;
+    client
+        .read_text_file(request)
+        .await
+        .map_err(FsReadTextFileError::ClientError)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use agent_client_protocol::{
+        ReadTextFileRequest, ReadTextFileResponse, Request, RequestId, RequestPermissionRequest,
+        RequestPermissionResponse, SessionNotification,
+    };
+    use async_trait::async_trait;
+
+    struct MockClient {
+        content: String,
+    }
+
+    impl MockClient {
+        fn new(content: &str) -> Self {
+            Self {
+                content: content.to_string(),
+            }
+        }
+    }
+
+    #[async_trait(?Send)]
+    impl Client for MockClient {
+        async fn session_notification(
+            &self,
+            _: SessionNotification,
+        ) -> agent_client_protocol::Result<()> {
+            Ok(())
+        }
+
+        async fn request_permission(
+            &self,
+            _: RequestPermissionRequest,
+        ) -> agent_client_protocol::Result<RequestPermissionResponse> {
+            Err(agent_client_protocol::Error::new(
+                -32603,
+                "not implemented in test mock",
+            ))
+        }
+
+        async fn read_text_file(
+            &self,
+            _: ReadTextFileRequest,
+        ) -> agent_client_protocol::Result<ReadTextFileResponse> {
+            Ok(ReadTextFileResponse::new(self.content.clone()))
+        }
+    }
+
+    #[tokio::test]
+    async fn fs_read_text_file_forwards_request_and_returns_response() {
+        let client = MockClient::new("hello world");
+        let request = ReadTextFileRequest::new(
+            agent_client_protocol::SessionId::from("sess-1"),
+            "/tmp/foo.txt".to_string(),
+        );
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("fs/read_text_file"),
+            params: Some(request),
+        };
+        let payload = serde_json::to_vec(&envelope).unwrap();
+
+        let result = forward_to_client(&payload, &client).await;
+        assert!(result.is_ok());
+        let response = result.unwrap();
+        assert_eq!(response.content, "hello world");
+    }
+
+    #[tokio::test]
+    async fn fs_read_text_file_returns_error_when_payload_is_invalid_json() {
+        let client = MockClient::new("hello");
+        let result = forward_to_client(b"not json", &client).await;
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn error_code_and_message_invalid_request_returns_invalid_params() {
+        let err = serde_json::from_slice::<ReadTextFileRequest>(b"not json").unwrap_err();
+        let fs_err = FsReadTextFileError::InvalidRequest(err);
+        let (code, message) = error_code_and_message(&fs_err);
+        assert_eq!(code, ErrorCode::InvalidParams);
+        assert!(message.contains("Invalid read_text_file request"));
+    }
+
+    #[test]
+    fn error_code_and_message_client_error_preserves_client_code() {
+        let client_err =
+            agent_client_protocol::Error::new(ErrorCode::InvalidParams.into(), "file not found");
+        let fs_err = FsReadTextFileError::ClientError(client_err);
+        let (code, message) = error_code_and_message(&fs_err);
+        assert_eq!(code, ErrorCode::InvalidParams);
+        assert_eq!(message, "file not found");
+    }
+}