Lightweight coding agent that runs in your terminal
Rust
Add opt-in concurrent exec-server request dispatch (#36987)
Adam Perry @ OpenAIeeae88d8a65e
diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rsindex 239f8a2c86..2efa5dc927 100644--- a/codex-rs/cli/src/main.rs+++ b/codex-rs/cli/src/main.rs@@ -573,6 +573,14 @@ struct ExecServerCommand {#[arg(long = "strict-config", default_value_t = false)]strict_config: bool,+ /// Maximum number of requests to process concurrently on each connection.+ #[arg(+ long = "concurrent-requests",+ value_name = "COUNT",+ default_value = "1"+ )]+ request_dispatch_mode: codex_exec_server::RequestDispatchMode,+/// Transport endpoint URL. Supported values: `ws://IP:PORT` (default), `stdio`, `stdio://`.#[arg(long = "listen", value_name = "URL", conflicts_with = "remote")]listen: Option<String>,@@ -1745,6 +1753,7 @@ async fn run_exec_server_command(if let Some(name) = cmd.name {remote_config.name = name;}+ remote_config.request_dispatch_mode = cmd.request_dispatch_mode;let remote_config = remote_config.with_telemetry(telemetry);let parent_lifetime = if cmd.exit_on_stdin_close {exec_server_telemetry::ParentLifetime::StdinPipe@@ -1794,6 +1803,7 @@ async fn run_exec_server_command(runtime_paths,telemetry,http_client_factory,+ cmd.request_dispatch_mode,).await},diff --git a/codex-rs/cli/tests/exec_server.rs b/codex-rs/cli/tests/exec_server.rsindex 29729644da..42bf2bc5cf 100644--- a/codex-rs/cli/tests/exec_server.rs+++ b/codex-rs/cli/tests/exec_server.rs@@ -90,6 +90,24 @@ fn local_exec_server_ignores_invalid_config_without_strict_config() -> Result<()Ok(())}+/// The standalone exec-server accepts an explicit per-connection concurrency limit.+#[test]+fn local_exec_server_accepts_concurrent_requests_flag() -> Result<()> {+ let codex_home = TempDir::new()?;+ let mut cmd = codex_command(codex_home.path())?;+ cmd.args([+ "exec-server",+ "--listen",+ "stdio",+ "--concurrent-requests",+ "2",+ ])+ .assert()+ .success();++ Ok(())+}+#[test]fn local_exec_server_allows_disabled_parent_lifetime_environment_variable() -> Result<()> {let codex_home = TempDir::new()?;@@ -173,6 +191,8 @@ metrics_exporter = {{ otlp-http = {{ endpoint = "{collector_url}/v1/metrics", pr®istry.uri(),"--environment-id",ENVIRONMENT_ID,+ "--concurrent-requests",+ "2",]).stdin(Stdio::piped()).stderr(Stdio::piped())diff --git a/codex-rs/exec-server/README.md b/codex-rs/exec-server/README.mdindex d98bc304bf..b560f568bf 100644--- a/codex-rs/exec-server/README.md+++ b/codex-rs/exec-server/README.md@@ -115,6 +115,9 @@ Each connection follows this sequence:3. Send `initialized`.4. Call process or filesystem RPCs.+Requests run sequentially by default. Pass `--concurrent-requests <COUNT>` to+enable concurrent processing.+If the server receives any notification other than `initialized`, it replieswith an error using request id `-1`.diff --git a/codex-rs/exec-server/src/lib.rs b/codex-rs/exec-server/src/lib.rsindex 50a1a521e1..17fdb78ef8 100644--- a/codex-rs/exec-server/src/lib.rs+++ b/codex-rs/exec-server/src/lib.rs@@ -189,8 +189,10 @@ pub use remote::run_remote_environment_until_shutdown;pub use resolved_capability::ResolvedSelectedCapabilityRoot;pub use resolved_capability::SelectedCapabilityRootsStatus;pub use runtime_paths::ExecServerRuntimePaths;+pub use server::ConcurrentRequestLimit;pub use server::DEFAULT_LISTEN_URL;pub use server::ExecServerListenUrlParseError;+pub use server::RequestDispatchMode;pub use server::run_main;pub use server::run_main_with_telemetry;pub use telemetry::ExecServerTelemetry;diff --git a/codex-rs/exec-server/src/remote.rs b/codex-rs/exec-server/src/remote.rsindex 536097661a..eb26e69fb1 100644--- a/codex-rs/exec-server/src/remote.rs+++ b/codex-rs/exec-server/src/remote.rs@@ -43,6 +43,7 @@ use crate::noise_relay::noise_relay_websocket_config;use crate::relay::HarnessKeyValidator;use crate::relay::run_multiplexed_environment;use crate::server::ConnectionProcessor;+use crate::server::RequestDispatchMode;use crate::trace_context::current_trace_context_headers;const ERROR_BODY_PREVIEW_BYTES: usize = 4096;@@ -464,6 +465,7 @@ pub struct RemoteEnvironmentConfig {pub base_url: String,pub environment_id: String,pub name: String,+ pub request_dispatch_mode: RequestDispatchMode,auth_provider: SharedAuthProvider,telemetry: ExecServerTelemetry,http_client_factory: HttpClientFactory,@@ -475,6 +477,7 @@ impl std::fmt::Debug for RemoteEnvironmentConfig {.field("base_url", &self.base_url).field("environment_id", &self.environment_id).field("name", &self.name)+ .field("request_dispatch_mode", &self.request_dispatch_mode).field("auth_provider", &"<redacted>").finish()}@@ -492,6 +495,7 @@ impl RemoteEnvironmentConfig {base_url,environment_id,name: "codex-exec-server".to_string(),+ request_dispatch_mode: RequestDispatchMode::Inline,auth_provider,telemetry: ExecServerTelemetry::default(),http_client_factory,@@ -539,6 +543,7 @@ whereruntime_paths,config.telemetry.clone(),config.http_client_factory.clone(),+ config.request_dispatch_mode,);let result = {diff --git a/codex-rs/exec-server/src/server.rs b/codex-rs/exec-server/src/server.rsindex 3db6b58a4a..c04e1fa166 100644--- a/codex-rs/exec-server/src/server.rs+++ b/codex-rs/exec-server/src/server.rs@@ -9,6 +9,8 @@ mod transport;pub(crate) use handler::ExecServerHandler;pub(crate) use processor::ConnectionProcessor;+pub use request_dispatcher::ConcurrentRequestLimit;+pub use request_dispatcher::RequestDispatchMode;pub use transport::DEFAULT_LISTEN_URL;pub use transport::ExecServerListenUrlParseError;@@ -26,6 +28,7 @@ pub async fn run_main(runtime_paths,ExecServerTelemetry::default(),http_client_factory,+ RequestDispatchMode::Inline,).await}@@ -40,8 +43,16 @@ pub async fn run_main_with_telemetry(runtime_paths: ExecServerRuntimePaths,telemetry: ExecServerTelemetry,http_client_factory: HttpClientFactory,+ request_dispatch_mode: RequestDispatchMode,) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {- transport::run_transport(listen_url, runtime_paths, telemetry, http_client_factory).await+ transport::run_transport(+ listen_url,+ runtime_paths,+ telemetry,+ http_client_factory,+ request_dispatch_mode,+ )+ .await}#[cfg(test)]@@ -78,6 +89,7 @@ mod tests {.expect("runtime paths"),ExecServerTelemetry::default(),HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),+ super::RequestDispatchMode::Inline,).await.expect_err("invalid listen URL should fail");diff --git a/codex-rs/exec-server/src/server/processor.rs b/codex-rs/exec-server/src/server/processor.rsindex 72ec510bf3..1aa70cbc4e 100644--- a/codex-rs/exec-server/src/server/processor.rs+++ b/codex-rs/exec-server/src/server/processor.rs@@ -9,10 +9,13 @@ use crate::ExecServerRuntimePaths;use crate::connection::CHANNEL_CAPACITY;use crate::connection::JsonRpcConnection;use crate::connection::JsonRpcConnectionEvent;+use crate::rpc::RpcCallError;use crate::rpc::RpcNotificationSender;use crate::rpc::RpcServerOutboundMessage;use crate::rpc::encode_server_message;+use crate::rpc_server_requests::RpcServerRequestSender;use crate::server::ExecServerHandler;+use crate::server::RequestDispatchMode;use crate::server::registry::build_router;use crate::server::request_dispatcher::RequestDispatcher;use crate::server::request_dispatcher::RequestTaskResult;@@ -27,6 +30,7 @@ pub(crate) struct ConnectionProcessor {runtime_paths: ExecServerRuntimePaths,telemetry: ExecServerTelemetry,http_client_factory: HttpClientFactory,+ request_dispatch_mode: RequestDispatchMode,}impl ConnectionProcessor {@@ -38,6 +42,7 @@ impl ConnectionProcessor {codex_http_client::HttpClientFactory::new(codex_http_client::OutboundProxyPolicy::ReqwestDefault,),+ RequestDispatchMode::Inline,)}@@ -45,12 +50,14 @@ impl ConnectionProcessor {runtime_paths: ExecServerRuntimePaths,telemetry: ExecServerTelemetry,http_client_factory: HttpClientFactory,+ request_dispatch_mode: RequestDispatchMode,) -> Self {Self {session_registry: SessionRegistry::new(telemetry.clone()),runtime_paths,telemetry,http_client_factory,+ request_dispatch_mode,}}@@ -66,6 +73,7 @@ impl ConnectionProcessor {self.telemetry.clone(),self.http_client_factory.clone(),transport,+ self.request_dispatch_mode,).await;}@@ -82,13 +90,13 @@ async fn run_connection(telemetry: ExecServerTelemetry,http_client_factory: HttpClientFactory,transport: ConnectionTransport,+ request_dispatch_mode: RequestDispatchMode,) {let _connection_metrics = telemetry.connection_started(transport);- let router = Arc::new(build_router());let JsonRpcConnection {outgoing_tx: json_outgoing_tx,mut incoming_rx,- disconnected_rx,+ mut disconnected_rx,task_handles: connection_tasks,transport: _transport,} = connection;@@ -119,20 +127,41 @@ async fn run_connection(});let mut dispatcher = RequestDispatcher::new(- router,+ Arc::new(build_router()),Arc::clone(&handler),outgoing_tx.clone(),- disconnected_rx,+ disconnected_rx.clone(),requests.clone(),telemetry,+ request_dispatch_mode,);- // Process inbound events sequentially to preserve initialize/initialized ordering.- while let Some(event) = incoming_rx.recv().await {+ loop {+ let has_request_tasks = dispatcher.has_tasks();+ let event = tokio::select! {+ result = dispatcher.join_next(), if has_request_tasks => {+ if result == RequestTaskResult::ConnectionClosed {+ break;+ }+ continue;+ }+ _ = disconnected_rx.changed() => {+ debug!("exec-server transport disconnected");+ break;+ }+ event = incoming_rx.recv() => {+ let Some(event) = event else {+ break;+ };+ event+ }+ };+if !handler.is_session_attached() {debug!("exec-server connection evicted after session resume");break;}+let result = match event {JsonRpcConnectionEvent::MalformedMessage { reason } => {dispatcher.handle_malformed_message(reason).await@@ -157,8 +186,11 @@ async fn run_connection(}}+ if *disconnected_rx.borrow() {+ complete_queued_client_responses(&requests, &mut incoming_rx);+ }requests.close();- drop(dispatcher);+ dispatcher.shutdown().await;handler.shutdown().await;drop(handler);drop(requests);@@ -170,6 +202,30 @@ async fn run_connection(let _ = outbound_task.await;}+fn complete_queued_client_responses(+ requests: &RpcServerRequestSender,+ incoming_rx: &mut mpsc::Receiver<JsonRpcConnectionEvent>,+) {+ while let Ok(event) = incoming_rx.try_recv() {+ let (request_id, response) = match event {+ JsonRpcConnectionEvent::Message(JSONRPCMessage::Response(response)) => {+ (response.id, Ok(response.result))+ }+ JsonRpcConnectionEvent::Message(JSONRPCMessage::Error(error)) => {+ (error.id, Err(RpcCallError::Server(error.error)))+ }+ JsonRpcConnectionEvent::Message(+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_),+ )+ | JsonRpcConnectionEvent::MalformedMessage { .. }+ | JsonRpcConnectionEvent::Disconnected { .. } => continue,+ };+ if !requests.complete(request_id.clone(), response) {+ warn!("ignoring unexpected client response while disconnecting: {request_id:?}");+ }+ }+}+#[cfg(test)]mod tests {use std::collections::HashMap;@@ -191,13 +247,16 @@ mod tests {use tokio::io::DuplexStream;use tokio::io::Lines;use tokio::io::duplex;+ use tokio::sync::mpsc;use tokio::task::JoinHandle;use tokio::time::timeout;+ use super::complete_queued_client_responses;use super::run_connection;use crate::ExecServerRuntimePaths;use crate::ProcessId;use crate::connection::JsonRpcConnection;+ use crate::connection::JsonRpcConnectionEvent;use crate::protocol::ENVIRONMENT_INFO_METHOD;use crate::protocol::ENVIRONMENT_STATUS_METHOD;use crate::protocol::EXEC_METHOD;@@ -208,13 +267,19 @@ mod tests {use crate::protocol::EnvironmentStatusKind;use crate::protocol::ExecParams;use crate::protocol::ExecResponse;+ use crate::protocol::ExecServerNetworkPolicyDecision;use crate::protocol::INITIALIZE_METHOD;use crate::protocol::INITIALIZED_METHOD;use crate::protocol::InitializeParams;use crate::protocol::InitializeResponse;+ use crate::protocol::NETWORK_POLICY_REQUEST_METHOD;+ use crate::protocol::NetworkPolicyRequestResponse;use crate::protocol::ReadParams;use crate::protocol::TerminateParams;use crate::protocol::TerminateResponse;+ use crate::rpc::RpcServerOutboundMessage;+ use crate::rpc_server_requests::RpcServerRequestSender;+ use crate::server::RequestDispatchMode;use crate::server::session_registry::SessionRegistry;#[tokio::test]@@ -256,6 +321,61 @@ mod tests {.expect("processor should join");}+ /// A callback response received before EOF must survive transport shutdown.+ #[tokio::test]+ async fn disconnect_completes_queued_network_policy_response() {+ let (outgoing_tx, mut outgoing_rx) = mpsc::channel(/*buffer*/ 1);+ let requests = RpcServerRequestSender::new(outgoing_tx);+ let pending_request = {+ let requests = requests.clone();+ tokio::spawn(async move {+ requests+ .call_with_timeout::<_, NetworkPolicyRequestResponse>(+ NETWORK_POLICY_REQUEST_METHOD,+ &(),+ Duration::from_secs(1),+ )+ .await+ })+ };+ let RpcServerOutboundMessage::Request(request) = outgoing_rx+ .recv()+ .await+ .expect("network policy request should be queued")+ else {+ panic!("expected outbound network policy request");+ };++ let (incoming_tx, mut incoming_rx) = mpsc::channel(/*buffer*/ 2);+ incoming_tx+ .try_send(JsonRpcConnectionEvent::Message(JSONRPCMessage::Response(+ JSONRPCResponse {+ id: request.id,+ result: serde_json::to_value(NetworkPolicyRequestResponse {+ decision: ExecServerNetworkPolicyDecision::Allow,+ })+ .expect("serialize network policy response"),+ },+ )))+ .expect("queue network policy response");+ incoming_tx+ .try_send(JsonRpcConnectionEvent::Disconnected { reason: None })+ .expect("queue transport disconnect");++ complete_queued_client_responses(&requests, &mut incoming_rx);+ requests.close();++ assert_eq!(+ pending_request+ .await+ .expect("network policy request should join")+ .expect("network policy request should complete"),+ NetworkPolicyRequestResponse {+ decision: ExecServerNetworkPolicyDecision::Allow,+ }+ );+ }+#[tokio::test]async fn transport_disconnect_detaches_session_during_in_flight_read() {let registry = SessionRegistry::new(crate::ExecServerTelemetry::default());@@ -363,6 +483,7 @@ mod tests {codex_http_client::OutboundProxyPolicy::ReqwestDefault,),crate::telemetry::ConnectionTransport::Stdio,+ RequestDispatchMode::Inline,));(client_writer, BufReader::new(client_reader).lines(), task)}diff --git a/codex-rs/exec-server/src/server/request_dispatcher.rs b/codex-rs/exec-server/src/server/request_dispatcher.rsindex 1d4bcbae37..6407794dce 100644--- a/codex-rs/exec-server/src/server/request_dispatcher.rs+++ b/codex-rs/exec-server/src/server/request_dispatcher.rs@@ -1,3 +1,6 @@+use std::num::NonZeroUsize;+use std::num::ParseIntError;+use std::str::FromStr;use std::sync::Arc;use std::time::Instant;@@ -6,12 +9,21 @@ use codex_exec_server_protocol::JSONRPCNotification;use codex_exec_server_protocol::JSONRPCRequest;use codex_exec_server_protocol::JSONRPCResponse;use codex_exec_server_protocol::RequestId;+use tokio::sync::Semaphore;use tokio::sync::mpsc;use tokio::sync::watch;+use tokio::task::JoinSet;use tracing::Instrument;use tracing::debug;use tracing::warn;+use crate::protocol::ENVIRONMENT_INFO_METHOD;+use crate::protocol::ENVIRONMENT_STATUS_METHOD;+use crate::protocol::EXEC_SIGNAL_METHOD;+use crate::protocol::EXEC_TERMINATE_METHOD;+use crate::protocol::FS_CLOSE_METHOD;+use crate::protocol::INITIALIZE_METHOD;+use crate::protocol::INITIALIZED_METHOD;use crate::rpc::RpcCallError;use crate::rpc::RpcRouter;use crate::rpc::RpcServerOutboundMessage;@@ -28,6 +40,9 @@ pub(super) struct RequestDispatcher {disconnected_rx: watch::Receiver<bool>,requests: RpcServerRequestSender,telemetry: ExecServerTelemetry,+ lanes: Option<RequestLanes>,+ tasks: JoinSet<RequestTaskResult>,+ initialized: bool,}impl RequestDispatcher {@@ -38,7 +53,18 @@ impl RequestDispatcher {disconnected_rx: watch::Receiver<bool>,requests: RpcServerRequestSender,telemetry: ExecServerTelemetry,+ mode: RequestDispatchMode,) -> Self {+ let lanes = match mode {+ RequestDispatchMode::Inline => None,+ RequestDispatchMode::Concurrent {+ max_concurrent_requests,+ } => Some(RequestLanes {+ ordinary: Arc::new(Semaphore::new(max_concurrent_requests.get())),+ control: Arc::new(Semaphore::new(max_concurrent_requests.get())),+ }),+ };+Self {router,handler,@@ -46,6 +72,24 @@ impl RequestDispatcher {disconnected_rx,requests,telemetry,+ lanes,+ tasks: JoinSet::new(),+ initialized: false,+ }+ }++ pub(super) fn has_tasks(&self) -> bool {+ !self.tasks.is_empty()+ }++ pub(super) async fn join_next(&mut self) -> RequestTaskResult {+ match self.tasks.join_next().await {+ Some(Ok(result)) => result,+ Some(Err(error)) => {+ warn!("exec-server request task failed: {error}");+ RequestTaskResult::ConnectionClosed+ }+ None => RequestTaskResult::Completed,}}@@ -70,6 +114,7 @@ impl RequestDispatcher {&mut self,notification: JSONRPCNotification,) -> RequestTaskResult {+ let is_initialized = notification.method == INITIALIZED_METHOD;let Some(route) = self.router.notification_route(notification.method.as_str()) else {warn!("closing exec-server connection after unexpected notification: {}",@@ -88,6 +133,9 @@ impl RequestDispatcher {warn!("closing exec-server connection after protocol error: {error}");return RequestTaskResult::ConnectionClosed;}+ if is_initialized {+ self.initialized = true;+ }RequestTaskResult::Completed}@@ -150,33 +198,126 @@ impl RequestDispatcher {return RequestTaskResult::Completed;};- let span = request_span(method, &request);- let message = tokio::select! {- message = route(Arc::clone(&self.handler), request).instrument(span.clone()) => message,- _ = self.disconnected_rx.changed() => {- span.record("result", "disconnected");- self.telemetry- .request_completed(method, "disconnected", started_at.elapsed());- debug!("exec-server transport disconnected while handling request");+ let task_span = request_span(method, &request);+ let route = route(Arc::clone(&self.handler), request);+ let outgoing_tx = self.outgoing_tx.clone();+ let mut disconnected_rx = self.disconnected_rx.clone();+ let telemetry = self.telemetry.clone();+ let task = async move {+ let message = tokio::select! {+ message = route.instrument(task_span.clone()) => message,+ _ = disconnected_rx.changed() => {+ task_span.record("result", "disconnected");+ telemetry.request_completed(method, "disconnected", started_at.elapsed());+ return RequestTaskResult::ConnectionClosed;+ }+ };+ let result = request_result(&message);+ let response_sent = match message {+ Some(message) => tokio::select! {+ result = outgoing_tx.send(message) => result.is_ok(),+ _ = disconnected_rx.changed() => false,+ },+ None => true,+ };+ if !response_sent {+ task_span.record("result", "disconnected");+ telemetry.request_completed(method, "disconnected", started_at.elapsed());return RequestTaskResult::ConnectionClosed;}+ task_span.record("result", result);+ telemetry.request_completed(method, result, started_at.elapsed());+ RequestTaskResult::Completed};- let result = request_result(&message);- if let Some(message) = message- && self.outgoing_tx.send(message).await.is_err()- {- span.record("result", "disconnected");- self.telemetry- .request_completed(method, "disconnected", started_at.elapsed());- return RequestTaskResult::ConnectionClosed;++ let Some(RequestLanes { ordinary, control }) = &self.lanes else {+ // Keep requests ordered when concurrent dispatch is not enabled.+ return task.await;+ };+ // Finish the handshake before concurrent requests can observe session state.+ if method == INITIALIZE_METHOD || !self.initialized {+ return task.await;}- span.record("result", result);- self.telemetry- .request_completed(method, result, started_at.elapsed());- drop(span);+ // Reserve capacity for health checks and cleanup while ordinary requests are blocked.+ let admission = if matches!(+ method,+ ENVIRONMENT_INFO_METHOD+ | ENVIRONMENT_STATUS_METHOD+ | EXEC_SIGNAL_METHOD+ | EXEC_TERMINATE_METHOD+ | FS_CLOSE_METHOD+ ) {+ Arc::clone(control)+ } else {+ Arc::clone(ordinary)+ };++ // TODO(anp) bound queued request bytes without blocking later responses or cleanup.+ self.tasks.spawn(async move {+ let Ok(_permit) = admission.acquire_owned().await else {+ return RequestTaskResult::ConnectionClosed;+ };+ task.await+ });RequestTaskResult::Completed}++ pub(super) async fn shutdown(mut self) {+ self.tasks.abort_all();+ while self.tasks.join_next().await.is_some() {}+ }+}++/// Per-connection request dispatch policy for local and remote exec-servers.+#[derive(Clone, Copy, Debug)]+pub enum RequestDispatchMode {+ Inline,+ Concurrent {+ max_concurrent_requests: ConcurrentRequestLimit,+ },+}++/// A valid request concurrency limit accepted by Tokio's semaphore.+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub struct ConcurrentRequestLimit(usize);++impl ConcurrentRequestLimit {+ /// Returns a limit when it enables concurrency and fits Tokio's semaphore.+ pub fn new(max_concurrent_requests: usize) -> Option<Self> {+ if !(2..=Semaphore::MAX_PERMITS).contains(&max_concurrent_requests) {+ return None;+ }++ Some(Self(max_concurrent_requests))+ }++ /// Returns the validated number of concurrent requests.+ pub fn get(self) -> usize {+ self.0+ }+}++impl FromStr for RequestDispatchMode {+ type Err = ParseIntError;++ fn from_str(value: &str) -> Result<Self, Self::Err> {+ let max_concurrent_requests = value.parse::<NonZeroUsize>()?.get();+ if max_concurrent_requests == 1 {+ Ok(Self::Inline)+ } else {+ Ok(Self::Concurrent {+ max_concurrent_requests: ConcurrentRequestLimit(+ max_concurrent_requests.min(Semaphore::MAX_PERMITS),+ ),+ })+ }+ }+}++struct RequestLanes {+ ordinary: Arc<Semaphore>,+ control: Arc<Semaphore>,}#[derive(Eq, PartialEq)]diff --git a/codex-rs/exec-server/src/server/request_dispatcher_tests.rs b/codex-rs/exec-server/src/server/request_dispatcher_tests.rsindex 619c6eda9f..26bf27acf5 100644--- a/codex-rs/exec-server/src/server/request_dispatcher_tests.rs+++ b/codex-rs/exec-server/src/server/request_dispatcher_tests.rs@@ -6,11 +6,54 @@ use opentelemetry::trace::TracerProvider as _;use opentelemetry_sdk::trace::InMemorySpanExporter;use opentelemetry_sdk::trace::SdkTracerProvider;use pretty_assertions::assert_eq;+use tokio::sync::Semaphore;use tracing_subscriber::filter::filter_fn;use tracing_subscriber::prelude::*;+use super::ConcurrentRequestLimit;+use super::RequestDispatchMode;use super::request_span;+/// Public limits reject values that cannot safely enable semaphore-backed concurrency.+#[test]+fn concurrent_request_limit_rejects_invalid_values() {+ assert_eq!(+ ConcurrentRequestLimit::new(/*max_concurrent_requests*/ 0),+ None+ );+ assert_eq!(+ ConcurrentRequestLimit::new(/*max_concurrent_requests*/ 1),+ None+ );+ assert_eq!(+ ConcurrentRequestLimit::new(Semaphore::MAX_PERMITS.saturating_add(1)),+ None+ );+ assert_eq!(+ ConcurrentRequestLimit::new(/*max_concurrent_requests*/ 2).map(ConcurrentRequestLimit::get),+ Some(2)+ );+}++/// CLI parsing keeps one request inline and bounds larger positive concurrency limits.+#[test]+fn request_dispatch_mode_parses_bounded_concurrency() {+ assert!(matches!("1".parse(), Ok(RequestDispatchMode::Inline)));+ assert!("0".parse::<RequestDispatchMode>().is_err());++ let oversized_limit = Semaphore::MAX_PERMITS.saturating_add(1).to_string();+ let mode = oversized_limit+ .parse::<RequestDispatchMode>()+ .expect("parse oversized concurrent request limit");+ let RequestDispatchMode::Concurrent {+ max_concurrent_requests,+ } = mode+ else {+ panic!("expected concurrent request dispatch");+ };+ assert_eq!(max_concurrent_requests.get(), Semaphore::MAX_PERMITS);+}+/// Request spans retain the wire method and inbound trace while bounding their exported names.#[test]fn request_span_uses_bounded_name_wire_method_and_inbound_trace_parent() {diff --git a/codex-rs/exec-server/src/server/transport.rs b/codex-rs/exec-server/src/server/transport.rsindex 7e8e24b902..9d556b0dba 100644--- a/codex-rs/exec-server/src/server/transport.rs+++ b/codex-rs/exec-server/src/server/transport.rs@@ -25,6 +25,7 @@ use tracing::warn;use crate::ExecServerRuntimePaths;use crate::ExecServerTelemetry;use crate::connection::JsonRpcConnection;+use crate::server::RequestDispatchMode;use crate::server::processor::ConnectionProcessor;use crate::telemetry::ConnectionTransport;@@ -85,14 +86,27 @@ pub(crate) async fn run_transport(runtime_paths: ExecServerRuntimePaths,telemetry: ExecServerTelemetry,http_client_factory: HttpClientFactory,+ request_dispatch_mode: RequestDispatchMode,) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {match parse_listen_url(listen_url)? {ExecServerListenTransport::WebSocket(bind_address) => {- run_websocket_listener(bind_address, runtime_paths, telemetry, http_client_factory)- .await+ run_websocket_listener(+ bind_address,+ runtime_paths,+ telemetry,+ http_client_factory,+ request_dispatch_mode,+ )+ .await}ExecServerListenTransport::Stdio => {- run_stdio_connection(runtime_paths, telemetry, http_client_factory).await+ run_stdio_connection(+ runtime_paths,+ telemetry,+ http_client_factory,+ request_dispatch_mode,+ )+ .await}}}@@ -101,6 +115,7 @@ async fn run_stdio_connection(runtime_paths: ExecServerRuntimePaths,telemetry: ExecServerTelemetry,http_client_factory: HttpClientFactory,+ request_dispatch_mode: RequestDispatchMode,) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {run_stdio_connection_with_io(io::stdin(),@@ -108,6 +123,7 @@ async fn run_stdio_connection(runtime_paths,telemetry,http_client_factory,+ request_dispatch_mode,).await}@@ -118,13 +134,18 @@ async fn run_stdio_connection_with_io<R, W>(runtime_paths: ExecServerRuntimePaths,telemetry: ExecServerTelemetry,http_client_factory: HttpClientFactory,+ request_dispatch_mode: RequestDispatchMode,) -> Result<(), Box<dyn std::error::Error + Send + Sync>>whereR: AsyncRead + Unpin + Send + 'static,W: AsyncWrite + Unpin + Send + 'static,{- let processor =- ConnectionProcessor::new_with_telemetry(runtime_paths, telemetry, http_client_factory);+ let processor = ConnectionProcessor::new_with_telemetry(+ runtime_paths,+ telemetry,+ http_client_factory,+ request_dispatch_mode,+ );tracing::info!("codex-exec-server listening on stdio");processor.run_connection(@@ -142,11 +163,16 @@ async fn run_websocket_listener(runtime_paths: ExecServerRuntimePaths,telemetry: ExecServerTelemetry,http_client_factory: HttpClientFactory,+ request_dispatch_mode: RequestDispatchMode,) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {let listener = TcpListener::bind(bind_address).await?;let local_addr = listener.local_addr()?;- let processor =- ConnectionProcessor::new_with_telemetry(runtime_paths, telemetry, http_client_factory);+ let processor = ConnectionProcessor::new_with_telemetry(+ runtime_paths,+ telemetry,+ http_client_factory,+ request_dispatch_mode,+ );info!("codex-exec-server listening on ws://{local_addr}");println!("ws://{local_addr}");std::io::stdout().flush()?;diff --git a/codex-rs/exec-server/src/server/transport_tests.rs b/codex-rs/exec-server/src/server/transport_tests.rsindex f25203c6a3..c26109a3b8 100644--- a/codex-rs/exec-server/src/server/transport_tests.rs+++ b/codex-rs/exec-server/src/server/transport_tests.rs@@ -22,6 +22,7 @@ use crate::protocol::INITIALIZE_METHOD;use crate::protocol::INITIALIZED_METHOD;use crate::protocol::InitializeParams;use crate::protocol::InitializeResponse;+use crate::server::RequestDispatchMode;#[test]fn parse_listen_url_accepts_default_websocket_url() {@@ -65,6 +66,7 @@ async fn stdio_listen_transport_serves_initialize() {codex_http_client::HttpClientFactory::new(codex_http_client::OutboundProxyPolicy::ReqwestDefault,),+ RequestDispatchMode::Inline,));let mut client_lines = BufReader::new(client_reader).lines();diff --git a/codex-rs/exec-server/tests/chatgpt_cloudflare_affinity.rs b/codex-rs/exec-server/tests/chatgpt_cloudflare_affinity.rsindex a27be91c12..d754fa8c4b 100644--- a/codex-rs/exec-server/tests/chatgpt_cloudflare_affinity.rs+++ b/codex-rs/exec-server/tests/chatgpt_cloudflare_affinity.rs@@ -87,7 +87,7 @@ async fn exec_server_replays_only_chatgpt_cloudflare_cookies() -> anyhow::Result(OsString::from("NO_PROXY"), empty.clone()),(OsString::from("no_proxy"), empty),];- let mut server = exec_server_with_env(env).await?;+ let mut server = exec_server_with_env(env, &[]).await?;initialize_exec_server(&mut server).await?;let first_response = execute_http_request(&mut server, CHATGPT_MCP_URL, "first").await?;diff --git a/codex-rs/exec-server/tests/common/exec_server.rs b/codex-rs/exec-server/tests/common/exec_server.rsindex 6b7b258642..5040e4926a 100644--- a/codex-rs/exec-server/tests/common/exec_server.rs+++ b/codex-rs/exec-server/tests/common/exec_server.rs@@ -76,10 +76,13 @@ pub(crate) fn test_codex_helper_paths() -> anyhow::Result<TestCodexHelperPaths>}pub(crate) async fn exec_server() -> anyhow::Result<ExecServerHarness> {- exec_server_with_env(std::iter::empty::<(&str, &str)>()).await+ exec_server_with_env(std::iter::empty::<(&str, &str)>(), &[]).await}-pub(crate) async fn exec_server_with_env<I, K, V>(env: I) -> anyhow::Result<ExecServerHarness>+pub(crate) async fn exec_server_with_env<I, K, V>(+ env: I,+ args: &[&str],+) -> anyhow::Result<ExecServerHarness>whereI: IntoIterator<Item = (K, V)>,K: AsRef<std::ffi::OsStr>,@@ -89,6 +92,7 @@ wherelet codex_home = TempDir::new()?;let mut child = Command::new(&helper_paths.codex_exe);child.args(["exec-server", "--listen", "ws://127.0.0.1:0"]);+ child.args(args);child.stdin(Stdio::null());child.stdout(Stdio::piped());child.stderr(Stdio::inherit());diff --git a/codex-rs/exec-server/tests/common/mod.rs b/codex-rs/exec-server/tests/common/mod.rsindex 05a19fcba3..e95aa55639 100644--- a/codex-rs/exec-server/tests/common/mod.rs+++ b/codex-rs/exec-server/tests/common/mod.rs@@ -9,6 +9,8 @@ use std::time::Duration;use codex_exec_server::CODEX_ARG0_EXEC_HELPER_ARG1;use codex_exec_server::CODEX_FS_HELPER_ARG1;use codex_exec_server::ExecServerRuntimePaths;+use codex_exec_server::ExecServerTelemetry;+use codex_exec_server::RequestDispatchMode;use codex_http_client::HttpClientFactory;use codex_http_client::OutboundProxyPolicy;use codex_sandboxing::landlock::CODEX_LINUX_SANDBOX_ARG0;@@ -161,10 +163,21 @@ fn maybe_run_exec_server_from_test_binary(guard: Option<&TestBinaryDispatchGuardeprintln!("expected listen URL");std::process::exit(1);};- if args.next().is_some() {- eprintln!("unexpected extra arguments");- std::process::exit(1);- }+ let remaining_args = args.collect::<Vec<_>>();+ let request_dispatch_mode = match remaining_args.as_slice() {+ [] => RequestDispatchMode::Inline,+ [flag, value] if flag == "--concurrent-requests" => match value.parse() {+ Ok(mode) => mode,+ Err(error) => {+ eprintln!("invalid concurrent request count: {error}");+ std::process::exit(1);+ }+ },+ args => {+ eprintln!("unexpected exec-server arguments: {args:?}");+ std::process::exit(1);+ }+ };let current_exe = match env::current_exe() {Ok(current_exe) => current_exe,@@ -209,10 +222,12 @@ fn maybe_run_exec_server_from_test_binary(guard: Option<&TestBinaryDispatchGuardstd::process::exit(1);}};- let exit_code = match runtime.block_on(codex_exec_server::run_main(+ let exit_code = match runtime.block_on(codex_exec_server::run_main_with_telemetry(&listen_url,runtime_paths,+ ExecServerTelemetry::default(),http_client_factory,+ request_dispatch_mode,)) {Ok(()) => 0,Err(error) => {diff --git a/codex-rs/exec-server/tests/file_system_unix.rs b/codex-rs/exec-server/tests/file_system_unix.rsindex 4e5980e345..497f998264 100644--- a/codex-rs/exec-server/tests/file_system_unix.rs+++ b/codex-rs/exec-server/tests/file_system_unix.rs@@ -190,7 +190,7 @@ async fn sandboxed_file_system_helper_finds_bwrap_on_preserved_path() -> Result<}let helper_path = std::env::join_paths(path_entries)?;- let server = exec_server_with_env([("PATH", helper_path.as_os_str())]).await?;+ let server = exec_server_with_env([("PATH", helper_path.as_os_str())], &[]).await?;let environment = Environment::create_for_tests(Some(server.websocket_url().to_string()))?;let file_system = environment.get_filesystem();let workspace = tmp.path().join("workspace");diff --git a/codex-rs/exec-server/tests/http_request.rs b/codex-rs/exec-server/tests/http_request.rsindex ede59132e5..4713f8a114 100644--- a/codex-rs/exec-server/tests/http_request.rs+++ b/codex-rs/exec-server/tests/http_request.rs@@ -162,18 +162,21 @@ async fn exec_server_http_request_uses_configured_system_proxy() -> anyhow::Resulet proxy_listener = TcpListener::bind("127.0.0.1:0").await?;let proxy_url = format!("http://{}", proxy_listener.local_addr()?);let request_url = "http://exec-server-system-proxy.invalid/delegated?route=system";- let mut server = exec_server_with_env([- (SYSTEM_PROXY_REQUEST_URL_ENV, request_url),- (SYSTEM_PROXY_URL_ENV, proxy_url.as_str()),- ("HTTP_PROXY", ""),- ("http_proxy", ""),- ("HTTPS_PROXY", ""),- ("https_proxy", ""),- ("ALL_PROXY", ""),- ("all_proxy", ""),- ("NO_PROXY", ""),- ("no_proxy", ""),- ])+ let mut server = exec_server_with_env(+ [+ (SYSTEM_PROXY_REQUEST_URL_ENV, request_url),+ (SYSTEM_PROXY_URL_ENV, proxy_url.as_str()),+ ("HTTP_PROXY", ""),+ ("http_proxy", ""),+ ("HTTPS_PROXY", ""),+ ("https_proxy", ""),+ ("ALL_PROXY", ""),+ ("all_proxy", ""),+ ("NO_PROXY", ""),+ ("no_proxy", ""),+ ],+ &[],+ ).await?;initialize_exec_server(&mut server).await?;@@ -218,18 +221,21 @@ async fn exec_server_http_request_normalizes_unicode_hostname() -> anyhow::Resullet proxy_url = format!("http://{}", proxy_listener.local_addr()?);let request_url = "http://münich.invalid/mcp?route=unicode";let normalized_url = "http://xn--mnich-kva.invalid/mcp?route=unicode";- let mut server = exec_server_with_env([- (SYSTEM_PROXY_REQUEST_URL_ENV, normalized_url),- (SYSTEM_PROXY_URL_ENV, proxy_url.as_str()),- ("HTTP_PROXY", ""),- ("http_proxy", ""),- ("HTTPS_PROXY", ""),- ("https_proxy", ""),- ("ALL_PROXY", ""),- ("all_proxy", ""),- ("NO_PROXY", ""),- ("no_proxy", ""),- ])+ let mut server = exec_server_with_env(+ [+ (SYSTEM_PROXY_REQUEST_URL_ENV, normalized_url),+ (SYSTEM_PROXY_URL_ENV, proxy_url.as_str()),+ ("HTTP_PROXY", ""),+ ("http_proxy", ""),+ ("HTTPS_PROXY", ""),+ ("https_proxy", ""),+ ("ALL_PROXY", ""),+ ("all_proxy", ""),+ ("NO_PROXY", ""),+ ("no_proxy", ""),+ ],+ &[],+ ).await?;initialize_exec_server(&mut server).await?;diff --git a/codex-rs/exec-server/tests/initialize.rs b/codex-rs/exec-server/tests/initialize.rsindex daf4306db6..27bd9a7eb1 100644--- a/codex-rs/exec-server/tests/initialize.rs+++ b/codex-rs/exec-server/tests/initialize.rs@@ -1,12 +1,13 @@-#![cfg(unix)]-mod common;use codex_exec_server::InitializeParams;use codex_exec_server::InitializeResponse;+use codex_exec_server_protocol::JSONRPCError;+use codex_exec_server_protocol::JSONRPCErrorError;use codex_exec_server_protocol::JSONRPCMessage;use codex_exec_server_protocol::JSONRPCResponse;use common::exec_server::exec_server;+use common::exec_server::exec_server_with_env;use pretty_assertions::assert_eq;use uuid::Uuid;@@ -34,3 +35,64 @@ async fn exec_server_accepts_initialize() -> anyhow::Result<()> {server.shutdown().await?;Ok(())}++/// Requests retain their wire-order initialization errors even when later handshake messages are pipelined.+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn exec_server_rejects_pipelined_requests_before_initialized() -> anyhow::Result<()> {+ let mut server = exec_server_with_env(+ std::iter::empty::<(&str, &str)>(),+ &["--concurrent-requests", "32"],+ )+ .await?;+ let before_initialize_id = server+ .send_request("environment/info", serde_json::json!({}))+ .await?;+ let initialize_id = server+ .send_request(+ "initialize",+ serde_json::to_value(InitializeParams {+ client_name: "exec-server-test".to_string(),+ resume_session_id: None,+ })?,+ )+ .await?;++ assert_eq!(+ server.next_event().await?,+ JSONRPCMessage::Error(JSONRPCError {+ id: before_initialize_id,+ error: JSONRPCErrorError {+ code: -32600,+ data: None,+ message: "client must call initialize before using environment info methods"+ .to_string(),+ },+ })+ );+ let JSONRPCMessage::Response(JSONRPCResponse { id, .. }) = server.next_event().await? else {+ panic!("expected initialize response");+ };+ assert_eq!(id, initialize_id);++ let before_initialized_id = server+ .send_request("environment/info", serde_json::json!({}))+ .await?;+ server+ .send_notification("initialized", serde_json::json!({}))+ .await?;+ assert_eq!(+ server.next_event().await?,+ JSONRPCMessage::Error(JSONRPCError {+ id: before_initialized_id,+ error: JSONRPCErrorError {+ code: -32600,+ data: None,+ message: "client must send initialized before using environment info methods"+ .to_string(),+ },+ })+ );++ server.shutdown().await?;+ Ok(())+}diff --git a/codex-rs/exec-server/tests/process.rs b/codex-rs/exec-server/tests/process.rsindex 273c022eaa..0ca6ce4248 100644--- a/codex-rs/exec-server/tests/process.rs+++ b/codex-rs/exec-server/tests/process.rs@@ -1,8 +1,10 @@-#![cfg(unix)]-mod common;+use std::collections::HashMap;+use codex_exec_server::EnvironmentInfo;+use codex_exec_server::EnvironmentStatus;+use codex_exec_server::EnvironmentStatusKind;use codex_exec_server::ExecResponse;use codex_exec_server::InitializeParams;use codex_exec_server::InitializeResponse;@@ -16,11 +18,17 @@ use codex_exec_server_protocol::JSONRPCResponse;use codex_exec_server_protocol::ProcessSandboxType;use codex_utils_path_uri::PathUri;use common::exec_server::exec_server;+use common::exec_server::exec_server_with_env;use pretty_assertions::assert_eq;#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn exec_server_starts_process_over_websocket() -> anyhow::Result<()> {let mut server = exec_server().await?;+ let process_argv = if cfg!(windows) {+ vec!["cmd.exe", "/D", "/C", "exit 0"]+ } else {+ vec!["true"]+ };let initialize_id = server.send_request("initialize",@@ -48,7 +56,7 @@ async fn exec_server_starts_process_over_websocket() -> anyhow::Result<()> {"process/start",serde_json::json!({"processId": "proc-1",- "argv": ["true"],+ "argv": process_argv,"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,"env": {},"tty": false,@@ -86,6 +94,20 @@ async fn exec_server_starts_process_over_websocket() -> anyhow::Result<()> {#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Result<()> {let mut server = exec_server().await?;+ let process_argv = if cfg!(windows) {+ vec!["cmd.exe", "/D", "/C", "ping -n 601 127.0.0.1 >NUL"]+ } else {+ vec![+ "/bin/sh",+ "-c",+ "parent=$PPID; while kill -0 \"$parent\" 2>/dev/null; do sleep 1; done",+ ]+ };+ let process_env = if cfg!(windows) {+ serde_json::json!({ "PATH": std::env::var("PATH")? })+ } else {+ serde_json::json!({})+ };let initialize_id = server.send_request("initialize",@@ -112,9 +134,9 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res"process/start",serde_json::json!({"processId": "proc-serial-read",- "argv": ["/bin/sh", "-c", "parent=$PPID; while kill -0 \"$parent\" 2>/dev/null; do sleep 1; done"],+ "argv": process_argv,"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,- "env": {},+ "env": process_env,"tty": false,"pipeStdin": false,"arg0": null@@ -149,9 +171,9 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res"process/start",serde_json::json!({"processId": "proc-serial-queued",- "argv": ["/bin/sh", "-c", "parent=$PPID; while kill -0 \"$parent\" 2>/dev/null; do sleep 1; done"],+ "argv": process_argv,"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,- "env": {},+ "env": process_env,"tty": false,"pipeStdin": false,"arg0": null@@ -159,18 +181,25 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res).await?;- let JSONRPCMessage::Response(JSONRPCResponse { id, .. }) = server.next_event().await? else {+ let response = server+ .wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))+ .await?;+ let JSONRPCMessage::Response(JSONRPCResponse { id, .. }) = response else {panic!("expected the blocked process/read to finish before the queued process/start");};assert_eq!(id, read_id);- let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = server.next_event().await?- else {+ let response = server+ .wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))+ .await?;+ let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = response else {panic!("expected the queued environment/info response after process/read");};assert_eq!(id, queued_environment_info_id);let _: EnvironmentInfo = serde_json::from_value(result)?;- let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = server.next_event().await?- else {+ let response = server+ .wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))+ .await?;+ let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = response else {panic!("expected the queued process/start response after process/read");};assert_eq!(id, queued_start_id);@@ -182,6 +211,203 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res});+ for process_id in ["proc-serial-read", "proc-serial-queued"] {+ let terminate_id = server+ .send_request(+ "process/terminate",+ serde_json::json!({ "processId": process_id }),+ )+ .await?;+ server+ .wait_for_event(|event| {+ matches!(+ event,+ JSONRPCMessage::Response(JSONRPCResponse { id, .. }) if id == &terminate_id+ )+ })+ .await?;+ }++ server.shutdown().await?;+ Ok(())+}++/// A long read cannot block health checks; saturated ordinary work cannot block health checks or cleanup.+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn exec_server_keeps_control_requests_live_during_long_reads_and_queued_requests()+-> anyhow::Result<()> {+ let mut server = exec_server_with_env(+ std::iter::empty::<(&str, &str)>(),+ &["--concurrent-requests", "32"],+ )+ .await?;+ let process_argv = if cfg!(windows) {+ vec!["cmd.exe", "/D", "/C", "ping -n 601 127.0.0.1 >NUL"]+ } else {+ vec![+ "/bin/sh",+ "-c",+ "parent=$PPID; while kill -0 \"$parent\" 2>/dev/null; do sleep 1; done",+ ]+ };+ let process_env = if cfg!(windows) {+ serde_json::json!({ "PATH": std::env::var("PATH")? })+ } else {+ serde_json::json!({})+ };+ let initialize_id = server+ .send_request(+ "initialize",+ serde_json::to_value(InitializeParams {+ client_name: "exec-server-test".to_string(),+ resume_session_id: None,+ })?,+ )+ .await?;+ assert!(matches!(+ server.next_event().await?,+ JSONRPCMessage::Response(JSONRPCResponse { id, .. }) if id == initialize_id+ ));+ server+ .send_notification("initialized", serde_json::json!({}))+ .await?;++ let process_start_id = server+ .send_request(+ "process/start",+ serde_json::json!({+ "processId": "proc-capacity",+ "argv": process_argv,+ "cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,+ "env": process_env,+ "tty": false,+ "pipeStdin": false,+ "arg0": null+ }),+ )+ .await?;+ assert!(matches!(+ server.next_event().await?,+ JSONRPCMessage::Response(JSONRPCResponse { id, .. }) if id == process_start_id+ ));++ let read_params = serde_json::json!({+ "processId": "proc-capacity",+ "afterSeq": null,+ "maxBytes": null,+ "waitMs": 600_000+ });+ server+ .send_request("process/read", read_params.clone())+ .await?;+ let concurrent_start_id = server+ .send_request(+ "process/start",+ serde_json::json!({+ "processId": "proc-concurrent",+ "argv": process_argv,+ "cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,+ "env": process_env,+ "tty": false,+ "pipeStdin": false,+ "arg0": null+ }),+ )+ .await?;+ let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = server.next_event().await?+ else {+ panic!("expected process/start to finish before the pending process/read");+ };+ assert_eq!(id, concurrent_start_id);+ assert_eq!(+ serde_json::from_value::<ExecResponse>(result)?,+ ExecResponse {+ process_id: ProcessId::from("proc-concurrent"),+ sandbox_type: Some(ProcessSandboxType::None),+ }+ );+ for _ in 1..32 {+ server+ .send_request("process/read", read_params.clone())+ .await?;+ }++ let queued_read_id = server.send_request("process/read", read_params).await?;++ let environment_info_id = server+ .send_request("environment/info", serde_json::json!({}))+ .await?;+ let response = server+ .wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))+ .await?;+ let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = response else {+ panic!("expected environment/info response at regular request capacity");+ };+ assert_eq!(id, environment_info_id);+ let _: EnvironmentInfo = serde_json::from_value(result)?;++ let environment_status_id = server+ .send_request("environment/status", serde_json::json!({}))+ .await?;+ let response = server+ .wait_for_event(|event| matches!(event, JSONRPCMessage::Response(_)))+ .await?;+ let JSONRPCMessage::Response(JSONRPCResponse { id, result }) = response else {+ panic!("expected environment/status response at regular request capacity");+ };+ assert_eq!(id, environment_status_id);+ assert_eq!(+ serde_json::from_value::<EnvironmentStatus>(result)?,+ EnvironmentStatus {+ status: EnvironmentStatusKind::Ready,+ }+ );++ let terminate_id = server+ .send_request(+ "process/terminate",+ serde_json::json!({ "processId": "proc-capacity" }),+ )+ .await?;+ let mut terminate_response = None;+ let mut queued_read_completed = false;+ while terminate_response.is_none() || !queued_read_completed {+ match server.next_event().await? {+ JSONRPCMessage::Response(JSONRPCResponse { id, result }) if id == terminate_id => {+ terminate_response = Some(serde_json::from_value::<TerminateResponse>(result)?);+ }+ JSONRPCMessage::Response(JSONRPCResponse { id, result }) if id == queued_read_id => {+ let _: ReadResponse = serde_json::from_value(result)?;+ queued_read_completed = true;+ }+ JSONRPCMessage::Error(error) => {+ anyhow::bail!("unexpected error while waiting for queued requests: {error:?}");+ }+ JSONRPCMessage::Request(_)+ | JSONRPCMessage::Response(_)+ | JSONRPCMessage::Notification(_) => {}+ }+ }+ assert_eq!(+ terminate_response,+ Some(TerminateResponse { running: true })+ );++ let terminate_id = server+ .send_request(+ "process/terminate",+ serde_json::json!({ "processId": "proc-concurrent" }),+ )+ .await?;+ server+ .wait_for_event(|event| {+ matches!(+ event,+ JSONRPCMessage::Response(JSONRPCResponse { id, .. }) if id == &terminate_id+ )+ })+ .await?;+server.shutdown().await?;Ok(())}@@ -189,6 +415,20 @@ async fn exec_server_runs_ordinary_requests_serially_by_default() -> anyhow::Res#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn exec_server_defaults_omitted_pipe_stdin_to_closed_stdin() -> anyhow::Result<()> {let mut server = exec_server().await?;+ let process_argv = if cfg!(windows) {+ vec!["cmd.exe", "/D", "/C", "ping -n 2 127.0.0.1 >NUL"]+ } else {+ vec![+ "/bin/sh",+ "-c",+ "sleep 0.3; if IFS= read -r line; then printf 'read:%s\\n' \"$line\"; else printf 'eof\\n'; fi",+ ]+ };+ let process_env = if cfg!(windows) {+ serde_json::json!({ "PATH": std::env::var("PATH")? })+ } else {+ serde_json::json!({})+ };let initialize_id = server.send_request("initialize",@@ -216,13 +456,9 @@ async fn exec_server_defaults_omitted_pipe_stdin_to_closed_stdin() -> anyhow::Re"process/start",serde_json::json!({"processId": "proc-default-stdin",- "argv": [- "/bin/sh",- "-c",- "sleep 0.3; if IFS= read -r line; then printf 'read:%s\\n' \"$line\"; else printf 'eof\\n'; fi"- ],+ "argv": process_argv,"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,- "env": {},+ "env": process_env,"tty": false,"arg0": null}),@@ -284,6 +520,26 @@ async fn exec_server_defaults_omitted_pipe_stdin_to_closed_stdin() -> anyhow::Re#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn exec_server_dedupes_retried_process_write_ids() -> anyhow::Result<()> {let mut server = exec_server().await?;+ let process_argv = if cfg!(windows) {+ vec![+ "powershell.exe",+ "-NoProfile",+ "-NonInteractive",+ "-Command",+ "[Console]::Out.WriteLine('line:' + [Console]::In.ReadLine()); [Console]::Out.WriteLine('line:' + [Console]::In.ReadLine())",+ ]+ } else {+ vec![+ "/bin/sh",+ "-c",+ "IFS= read -r first; printf 'line:%s\\n' \"$first\"; IFS= read -r second; printf 'line:%s\\n' \"$second\"",+ ]+ };+ let process_env = if cfg!(windows) {+ serde_json::to_value(std::env::vars().collect::<HashMap<_, _>>())?+ } else {+ serde_json::json!({})+ };let initialize_id = server.send_request("initialize",@@ -311,13 +567,9 @@ async fn exec_server_dedupes_retried_process_write_ids() -> anyhow::Result<()> {"process/start",serde_json::json!({"processId": "proc-write-id",- "argv": [- "/bin/sh",- "-c",- "IFS= read -r first; printf 'line:%s\\n' \"$first\"; IFS= read -r second; printf 'line:%s\\n' \"$second\""- ],+ "argv": process_argv,"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,- "env": {},+ "env": process_env,"tty": false,"pipeStdin": true,"arg0": null@@ -401,13 +653,16 @@ async fn exec_server_dedupes_retried_process_write_ids() -> anyhow::Result<()> {.flat_map(|chunk| chunk.chunk.into_inner()),);after_seq = Some(read_response.next_seq.saturating_sub(1));- if read_response.closed || output.ends_with(b"line:second\n") {+ if read_response.closed+ || output.ends_with(b"line:second\n")+ || output.ends_with(b"line:second\r\n")+ {break;}}assert_eq!(- String::from_utf8(output)?,+ String::from_utf8(output)?.replace("\r\n", "\n"),"line:first\nline:second\n".to_string());@@ -418,6 +673,16 @@ async fn exec_server_dedupes_retried_process_write_ids() -> anyhow::Result<()> {#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn exec_server_resumes_detached_session_without_killing_processes() -> anyhow::Result<()> {let mut server = exec_server().await?;+ let process_argv = if cfg!(windows) {+ vec!["cmd.exe", "/D", "/C", "ping -n 6 127.0.0.1 >NUL"]+ } else {+ vec!["/bin/sh", "-c", "sleep 5"]+ };+ let process_env = if cfg!(windows) {+ serde_json::json!({ "PATH": std::env::var("PATH")? })+ } else {+ serde_json::json!({})+ };let initialize_id = server.send_request("initialize",@@ -449,9 +714,9 @@ async fn exec_server_resumes_detached_session_without_killing_processes() -> any"process/start",serde_json::json!({"processId": "proc-resume",- "argv": ["/bin/sh", "-c", "sleep 5"],+ "argv": process_argv,"cwd": PathUri::from_host_native_path(std::env::current_dir()?)?,- "env": {},+ "env": process_env,"tty": false,"pipeStdin": false,"arg0": null