diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock index 1036f4815f..55d02cd8b1 100644 --- a/codex-rs/Cargo.lock +++ b/codex-rs/Cargo.lock @@ -3049,7 +3049,6 @@ dependencies = [ "codex-utils-path-uri", "futures", "serde", - "serde_json", ] [[package]] diff --git a/codex-rs/exec-server/src/client.rs b/codex-rs/exec-server/src/client.rs index 66a5708f44..88c0c80342 100644 --- a/codex-rs/exec-server/src/client.rs +++ b/codex-rs/exec-server/src/client.rs @@ -97,7 +97,6 @@ use crate::protocol::TerminateParams; use crate::protocol::TerminateResponse; use crate::protocol::WriteParams; use crate::protocol::WriteResponse; -use crate::rpc::RpcBatchCall; use crate::rpc::RpcCallError; use crate::rpc::RpcClient; @@ -762,29 +761,6 @@ impl ExecServerClient { self.call_rpc(&rpc_client, method, params).await } - pub(crate) async fn call_batch( - &self, - calls: Vec, - ) -> Result>, ExecServerError> { - let rpc_client = self.inner.rpc_client().await?; - match rpc_client.call_batch(calls).await { - Ok(results) => Ok(results - .into_iter() - .map(|result| result.map_err(ExecServerError::from)) - .collect()), - Err(error) => { - let error = ExecServerError::from(error); - if is_transport_closed_error(&error) { - Err(ExecServerError::Disconnected(disconnected_message( - /*reason*/ None, - ))) - } else { - Err(error) - } - } - } - } - async fn call_rpc( &self, rpc_client: &Arc, @@ -837,7 +813,6 @@ impl From for ExecServerError { code: error.code, message: error.message, }, - RpcCallError::InvalidBatch(message) => Self::Protocol(message), } } } diff --git a/codex-rs/exec-server/src/lib.rs b/codex-rs/exec-server/src/lib.rs index c1779148d8..3b97299703 100644 --- a/codex-rs/exec-server/src/lib.rs +++ b/codex-rs/exec-server/src/lib.rs @@ -42,8 +42,6 @@ pub use codex_file_system::CopyOptions; pub use codex_file_system::CreateDirectoryOptions; pub use codex_file_system::ExecutorFileSystem; pub use codex_file_system::ExecutorFileSystemFuture; -pub use codex_file_system::ExecutorRpcBatchCall; -pub use codex_file_system::ExecutorRpcBatchResult; pub use codex_file_system::FILE_READ_CHUNK_SIZE; pub use codex_file_system::FileMetadata; pub use codex_file_system::FileSystemReadStream; diff --git a/codex-rs/exec-server/src/local_file_system.rs b/codex-rs/exec-server/src/local_file_system.rs index f5cc597771..3129606d6b 100644 --- a/codex-rs/exec-server/src/local_file_system.rs +++ b/codex-rs/exec-server/src/local_file_system.rs @@ -1,10 +1,5 @@ -use base64::Engine as _; -use base64::engine::general_purpose::STANDARD; use codex_utils_absolute_path::AbsolutePathBuf; use codex_utils_path_uri::PathUri; -use futures::StreamExt; -use serde::Serialize; -use serde::de::DeserializeOwned; use std::path::Path; use std::path::PathBuf; use std::sync::Arc; @@ -20,7 +15,6 @@ use crate::CreateDirectoryOptions; use crate::ExecServerRuntimePaths; use crate::ExecutorFileSystem; use crate::ExecutorFileSystemFuture; -use crate::ExecutorRpcBatchCall; use crate::FILE_READ_CHUNK_SIZE; use crate::FileMetadata; use crate::FileSystemReadStream; @@ -28,36 +22,10 @@ use crate::FileSystemResult; use crate::FileSystemSandboxContext; use crate::ReadDirectoryEntry; use crate::RemoveOptions; -use crate::protocol::FS_CANONICALIZE_METHOD; -use crate::protocol::FS_COPY_METHOD; -use crate::protocol::FS_CREATE_DIRECTORY_METHOD; -use crate::protocol::FS_GET_METADATA_METHOD; -use crate::protocol::FS_READ_DIRECTORY_METHOD; -use crate::protocol::FS_READ_FILE_METHOD; -use crate::protocol::FS_REMOVE_METHOD; -use crate::protocol::FS_WRITE_FILE_METHOD; -use crate::protocol::FsCanonicalizeParams; -use crate::protocol::FsCanonicalizeResponse; -use crate::protocol::FsCopyParams; -use crate::protocol::FsCopyResponse; -use crate::protocol::FsCreateDirectoryParams; -use crate::protocol::FsCreateDirectoryResponse; -use crate::protocol::FsGetMetadataParams; -use crate::protocol::FsGetMetadataResponse; -use crate::protocol::FsReadDirectoryEntry; -use crate::protocol::FsReadDirectoryParams; -use crate::protocol::FsReadDirectoryResponse; -use crate::protocol::FsReadFileParams; -use crate::protocol::FsReadFileResponse; -use crate::protocol::FsRemoveParams; -use crate::protocol::FsRemoveResponse; -use crate::protocol::FsWriteFileParams; -use crate::protocol::FsWriteFileResponse; use crate::regular_file; use crate::sandboxed_file_system::SandboxedFileSystem; const MAX_READ_FILE_BYTES: u64 = 512 * 1024 * 1024; -const LOCAL_RPC_BATCH_CONCURRENCY: usize = 32; fn file_too_large_error() -> io::Error { io::Error::new( @@ -224,124 +192,6 @@ impl LocalFileSystem { .copy(source_path, destination_path, options, sandbox) .await } - - async fn execute_rpc_batch( - &self, - calls: Vec, - ) -> FileSystemResult>> { - Ok(futures::stream::iter(calls) - .map(|call| self.execute_rpc_request(call)) - .buffered(LOCAL_RPC_BATCH_CONCURRENCY) - .collect() - .await) - } - - async fn execute_rpc_request( - &self, - call: ExecutorRpcBatchCall, - ) -> FileSystemResult { - match call.method.as_str() { - FS_READ_FILE_METHOD => { - let params: FsReadFileParams = decode_rpc_params(call.params)?; - encode_rpc_response(FsReadFileResponse { - data_base64: STANDARD.encode( - self.read_file(¶ms.path, params.sandbox.as_ref()) - .await?, - ), - }) - } - FS_WRITE_FILE_METHOD => { - let params: FsWriteFileParams = decode_rpc_params(call.params)?; - let contents = STANDARD.decode(params.data_base64).map_err(|err| { - io::Error::new( - io::ErrorKind::InvalidData, - format!("fs/writeFile received invalid base64 dataBase64: {err}"), - ) - })?; - self.write_file(¶ms.path, contents, params.sandbox.as_ref()) - .await?; - encode_rpc_response(FsWriteFileResponse {}) - } - FS_CREATE_DIRECTORY_METHOD => { - let params: FsCreateDirectoryParams = decode_rpc_params(call.params)?; - self.create_directory( - ¶ms.path, - CreateDirectoryOptions { - recursive: params.recursive.unwrap_or(false), - }, - params.sandbox.as_ref(), - ) - .await?; - encode_rpc_response(FsCreateDirectoryResponse {}) - } - FS_GET_METADATA_METHOD => { - let params: FsGetMetadataParams = decode_rpc_params(call.params)?; - let metadata = self - .get_metadata(¶ms.path, params.sandbox.as_ref()) - .await?; - encode_rpc_response(FsGetMetadataResponse { - is_directory: metadata.is_directory, - is_file: metadata.is_file, - is_symlink: metadata.is_symlink, - size: metadata.size, - created_at_ms: metadata.created_at_ms, - modified_at_ms: metadata.modified_at_ms, - }) - } - FS_CANONICALIZE_METHOD => { - let params: FsCanonicalizeParams = decode_rpc_params(call.params)?; - encode_rpc_response(FsCanonicalizeResponse { - path: self - .canonicalize(¶ms.path, params.sandbox.as_ref()) - .await?, - }) - } - FS_READ_DIRECTORY_METHOD => { - let params: FsReadDirectoryParams = decode_rpc_params(call.params)?; - let entries = self - .read_directory(¶ms.path, params.sandbox.as_ref()) - .await? - .into_iter() - .map(|entry| FsReadDirectoryEntry { - file_name: entry.file_name, - is_directory: entry.is_directory, - is_file: entry.is_file, - }) - .collect(); - encode_rpc_response(FsReadDirectoryResponse { entries }) - } - FS_REMOVE_METHOD => { - let params: FsRemoveParams = decode_rpc_params(call.params)?; - self.remove( - ¶ms.path, - RemoveOptions { - recursive: params.recursive.unwrap_or(false), - force: params.force.unwrap_or(false), - }, - params.sandbox.as_ref(), - ) - .await?; - encode_rpc_response(FsRemoveResponse {}) - } - FS_COPY_METHOD => { - let params: FsCopyParams = decode_rpc_params(call.params)?; - self.copy( - ¶ms.source_path, - ¶ms.destination_path, - CopyOptions { - recursive: params.recursive, - }, - params.sandbox.as_ref(), - ) - .await?; - encode_rpc_response(FsCopyResponse {}) - } - method => Err(io::Error::new( - io::ErrorKind::InvalidInput, - format!("local filesystem RPC batch does not support `{method}`"), - )), - } - } } impl ExecutorFileSystem for LocalFileSystem { @@ -429,21 +279,6 @@ impl ExecutorFileSystem for LocalFileSystem { sandbox, )) } - - fn execute_rpc_batch<'a>( - &'a self, - calls: Vec, - ) -> ExecutorFileSystemFuture<'a, Vec>> { - Box::pin(LocalFileSystem::execute_rpc_batch(self, calls)) - } -} - -fn decode_rpc_params(params: serde_json::Value) -> FileSystemResult { - serde_json::from_value(params).map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err)) -} - -fn encode_rpc_response(response: T) -> FileSystemResult { - serde_json::to_value(response).map_err(io::Error::other) } impl UnsandboxedFileSystem { diff --git a/codex-rs/exec-server/src/remote_file_system.rs b/codex-rs/exec-server/src/remote_file_system.rs index 5950e919f1..f9136e1461 100644 --- a/codex-rs/exec-server/src/remote_file_system.rs +++ b/codex-rs/exec-server/src/remote_file_system.rs @@ -9,8 +9,6 @@ use crate::CreateDirectoryOptions; use crate::ExecServerError; use crate::ExecutorFileSystem; use crate::ExecutorFileSystemFuture; -use crate::ExecutorRpcBatchCall; -use crate::ExecutorRpcBatchResult; use crate::FileMetadata; use crate::FileSystemReadStream; use crate::FileSystemResult; @@ -18,7 +16,6 @@ use crate::FileSystemSandboxContext; use crate::ReadDirectoryEntry; use crate::RemoveOptions; use crate::client::LazyRemoteExecServerClient; -use crate::connection::MAX_RPC_BATCH_REQUESTS; use crate::protocol::FsCanonicalizeParams; use crate::protocol::FsCopyParams; use crate::protocol::FsCreateDirectoryParams; @@ -27,7 +24,6 @@ use crate::protocol::FsReadDirectoryParams; use crate::protocol::FsReadFileParams; use crate::protocol::FsRemoveParams; use crate::protocol::FsWriteFileParams; -use crate::rpc::RpcBatchCall; const INVALID_REQUEST_ERROR_CODE: i64 = -32600; const NOT_FOUND_ERROR_CODE: i64 = -32004; @@ -227,43 +223,6 @@ impl RemoteFileSystem { .map_err(map_remote_error)?; Ok(()) } - - async fn execute_rpc_batch( - &self, - calls: Vec, - ) -> FileSystemResult> { - if calls.is_empty() { - return Ok(Vec::new()); - } - - let client = self.client.get().await.map_err(map_remote_error)?; - let mut decoded = Vec::with_capacity(calls.len()); - let mut calls = calls.into_iter(); - loop { - let call_chunk = calls - .by_ref() - .take(MAX_RPC_BATCH_REQUESTS) - .map(|call| RpcBatchCall { - method: call.method, - params: call.params, - }) - .collect::>(); - if call_chunk.is_empty() { - break; - } - - let results = client - .call_batch(call_chunk) - .await - .map_err(map_remote_error)?; - decoded.extend( - results - .into_iter() - .map(|result| result.map_err(map_remote_error)), - ); - } - Ok(decoded) - } } impl ExecutorFileSystem for RemoteFileSystem { @@ -351,13 +310,6 @@ impl ExecutorFileSystem for RemoteFileSystem { sandbox, )) } - - fn execute_rpc_batch<'a>( - &'a self, - calls: Vec, - ) -> ExecutorFileSystemFuture<'a, Vec> { - Box::pin(RemoteFileSystem::execute_rpc_batch(self, calls)) - } } fn remote_sandbox_context( diff --git a/codex-rs/exec-server/src/rpc.rs b/codex-rs/exec-server/src/rpc.rs index b16a321511..d19c7e0f7c 100644 --- a/codex-rs/exec-server/src/rpc.rs +++ b/codex-rs/exec-server/src/rpc.rs @@ -26,7 +26,6 @@ use crate::connection::JsonRpcConnection; use crate::connection::JsonRpcConnectionEvent; use crate::connection::JsonRpcTransport; use crate::connection::JsonRpcWireMessage; -use crate::connection::MAX_RPC_BATCH_REQUESTS; pub(crate) const SESSION_ALREADY_ATTACHED_ERROR_CODE: i64 = -32010; @@ -38,13 +37,6 @@ pub(crate) enum RpcCallError { Json(serde_json::Error), /// The executor returned a JSON-RPC error response for this call. Server(JSONRPCErrorError), - /// The caller attempted to construct a batch that cannot be represented safely. - InvalidBatch(String), -} - -pub(crate) struct RpcBatchCall { - pub(crate) method: String, - pub(crate) params: Value, } type PendingRequest = oneshot::Sender>; @@ -412,70 +404,6 @@ impl RpcClient { serde_json::from_value(response).map_err(RpcCallError::Json) } - /// Sends independent RPC requests as one JSON-RPC batch. - /// - /// The server may execute batch entries concurrently and does not guarantee execution order. - /// Callers must only batch requests that are safe to run in any order, and must send dependent - /// requests separately. Results are returned in the same order as `calls` by matching request - /// ids in the responses. - pub(crate) async fn call_batch( - &self, - calls: Vec, - ) -> Result>, RpcCallError> { - if calls.is_empty() { - return Ok(Vec::new()); - } - if calls.len() > MAX_RPC_BATCH_REQUESTS { - return Err(RpcCallError::InvalidBatch(format!( - "JSON-RPC batch contains {} requests; maximum is {MAX_RPC_BATCH_REQUESTS}", - calls.len() - ))); - } - - let mut request_ids = Vec::with_capacity(calls.len()); - let mut requests = Vec::with_capacity(calls.len()); - let mut response_receivers = Vec::with_capacity(calls.len()); - { - let mut pending = self.pending.lock().await; - if self.closed.load(Ordering::Acquire) || *self.disconnected_rx.borrow() { - return Err(RpcCallError::Closed); - } - for RpcBatchCall { method, params } in calls { - let request_id = - RequestId::Integer(self.next_request_id.fetch_add(1, Ordering::SeqCst)); - let (response_tx, response_rx) = oneshot::channel(); - pending.insert(request_id.clone(), response_tx); - request_ids.push(request_id.clone()); - requests.push(JSONRPCMessage::Request(JSONRPCRequest { - id: request_id, - method, - params: Some(params), - trace: None, - })); - response_receivers.push(response_rx); - } - } - - if self - .write_tx - .send(JsonRpcWireMessage::Batch(requests)) - .await - .is_err() - { - let mut pending = self.pending.lock().await; - for request_id in request_ids { - pending.remove(&request_id); - } - return Err(RpcCallError::Closed); - } - - let mut results = Vec::with_capacity(response_receivers.len()); - for response_rx in response_receivers { - results.push(response_rx.await.map_err(|_| RpcCallError::Closed)?); - } - Ok(results) - } - #[cfg(test)] pub(crate) async fn pending_request_count(&self) -> usize { self.pending.lock().await.len() diff --git a/codex-rs/exec-server/src/server/processor.rs b/codex-rs/exec-server/src/server/processor.rs index 6837832c40..23d7d81f20 100644 --- a/codex-rs/exec-server/src/server/processor.rs +++ b/codex-rs/exec-server/src/server/processor.rs @@ -1,6 +1,5 @@ use std::sync::Arc; -use futures::StreamExt; use tokio::sync::mpsc; use tracing::debug; use tracing::warn; @@ -20,8 +19,6 @@ use crate::server::ExecServerHandler; use crate::server::registry::build_router; use crate::server::session_registry::SessionRegistry; -const MAX_RPC_BATCH_CONCURRENCY: usize = 32; - #[derive(Clone)] pub(crate) struct ConnectionProcessor { session_registry: Arc, @@ -182,59 +179,54 @@ async fn run_connection( continue; } - let batch = futures::stream::iter(messages) - .map(|message| { - let router = Arc::clone(&router); - let handler = Arc::clone(&handler); - async move { - match message { - codex_app_server_protocol::JSONRPCMessage::Request(request) => { - dispatch_request(router, handler, request).await - } - codex_app_server_protocol::JSONRPCMessage::Notification(_) => { - Some(RpcServerOutboundMessage::Error { - request_id: codex_app_server_protocol::RequestId::Integer( - -1, - ), - error: invalid_request( - "notifications cannot be sent in a JSON-RPC batch" - .to_string(), - ), - }) - } - codex_app_server_protocol::JSONRPCMessage::Response(response) => { - Some(RpcServerOutboundMessage::Error { - request_id: response.id, - error: invalid_request( - "client responses cannot be sent in a JSON-RPC batch" - .to_string(), - ), - }) - } - codex_app_server_protocol::JSONRPCMessage::Error(error) => { - Some(RpcServerOutboundMessage::Error { - request_id: error.id, - error: invalid_request( - "client errors cannot be sent in a JSON-RPC batch" - .to_string(), - ), - }) + let mut responses = Vec::new(); + for message in messages { + let response = match message { + codex_app_server_protocol::JSONRPCMessage::Request(request) => { + tokio::select! { + response = dispatch_request( + Arc::clone(&router), + Arc::clone(&handler), + request, + ) => response, + _ = disconnected_rx.changed() => { + debug!("exec-server transport disconnected while handling batch"); + break; } } } - }) - .buffered(MAX_RPC_BATCH_CONCURRENCY) - .filter_map(std::future::ready) - .collect::>(); - let messages = tokio::select! { - messages = batch => messages, - _ = disconnected_rx.changed() => { - debug!("exec-server transport disconnected while handling batch"); - break; + codex_app_server_protocol::JSONRPCMessage::Notification(_) => { + Some(RpcServerOutboundMessage::Error { + request_id: codex_app_server_protocol::RequestId::Integer(-1), + error: invalid_request( + "notifications cannot be sent in a JSON-RPC batch".to_string(), + ), + }) + } + codex_app_server_protocol::JSONRPCMessage::Response(response) => { + Some(RpcServerOutboundMessage::Error { + request_id: response.id, + error: invalid_request( + "client responses cannot be sent in a JSON-RPC batch" + .to_string(), + ), + }) + } + codex_app_server_protocol::JSONRPCMessage::Error(error) => { + Some(RpcServerOutboundMessage::Error { + request_id: error.id, + error: invalid_request( + "client errors cannot be sent in a JSON-RPC batch".to_string(), + ), + }) + } + }; + if let Some(response) = response { + responses.push(response); } - }; + } if outgoing_tx - .send(RpcServerOutboundMessage::Batch(messages)) + .send(RpcServerOutboundMessage::Batch(responses)) .await .is_err() { diff --git a/codex-rs/file-system/Cargo.toml b/codex-rs/file-system/Cargo.toml index 68a63620c8..382eacb43d 100644 --- a/codex-rs/file-system/Cargo.toml +++ b/codex-rs/file-system/Cargo.toml @@ -14,7 +14,6 @@ codex-utils-absolute-path = { workspace = true } codex-utils-path-uri = { workspace = true } futures = { workspace = true } serde = { workspace = true, features = ["derive"] } -serde_json = { workspace = true } [lib] test = false diff --git a/codex-rs/file-system/src/lib.rs b/codex-rs/file-system/src/lib.rs index 18ecfc0cca..3ba7874404 100644 --- a/codex-rs/file-system/src/lib.rs +++ b/codex-rs/file-system/src/lib.rs @@ -56,14 +56,6 @@ pub struct ReadDirectoryEntry { pub is_file: bool, } -#[derive(Clone, Debug, PartialEq)] -pub struct ExecutorRpcBatchCall { - pub method: String, - pub params: serde_json::Value, -} - -pub type ExecutorRpcBatchResult = FileSystemResult; - #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)] #[serde(rename_all = "camelCase")] pub struct FileSystemSandboxContext { @@ -271,21 +263,4 @@ pub trait ExecutorFileSystem: Send + Sync { copy_options: CopyOptions, sandbox: Option<&'a FileSystemSandboxContext>, ) -> ExecutorFileSystemFuture<'a, ()>; - - /// Sends independent executor RPC requests as one batch. - /// - /// The executor may execute entries concurrently and does not guarantee execution order. - /// Callers must only batch requests that are safe to run in any order, and must send dependent - /// requests separately. Results are matched back to the input order by request id. - fn execute_rpc_batch<'a>( - &'a self, - _calls: Vec, - ) -> ExecutorFileSystemFuture<'a, Vec> { - Box::pin(async move { - Err(io::Error::new( - io::ErrorKind::Unsupported, - "filesystem does not support RPC batching", - )) - }) - } }