Use gRPC for all code-mode host connections (#62476)

## What changed

Remove the legacy framed stdio protocol and its client and server.
Local Codex launches the standalone host with `--listen grpc+stdio://`,
which is also the host's default. The `stdio` and `stdio://` aliases
now select gRPC over stdio. The `features.code_mode_host_grpc` setting
is deprecated and ignored.

Carry execution trace context into gRPC tool callbacks and
notifications. Reject oversized execute requests before sending them
so an encoding failure does not appear as a connection reset.

## Testing

Exercise gRPC callback cancellation, trace context across overlapping
yielded cells, and isolation of tool preload failures between sessions.
Check that both values of the deprecated feature setting are ignored.

GitOrigin-RevId: f5faff3901dc60958627f677f50cfad834291b69
This commit is contained in:
Channing Conger
2026-11-19 09:37:29 +00:00
committed by copyberry
parent 083bf59b6b
commit 336dc645fb
62 changed files with 489 additions and 11082 deletions
-85
View File
@@ -1,85 +0,0 @@
use std::sync::Arc;
use codex_code_mode_protocol::CellId;
use codex_code_mode_protocol::CodeModeNestedToolCall;
use codex_code_mode_protocol::CodeModeSessionDelegate;
use codex_code_mode_protocol::NotificationFuture;
use codex_code_mode_protocol::ToolInvocationFuture;
use codex_code_mode_protocol::host::DelegateRequest;
use codex_code_mode_protocol::host::DelegateResponse;
use codex_code_mode_protocol::host::SessionId;
use tokio_util::sync::CancellationToken;
use crate::peer::HostPeer;
pub(super) struct RemoteDelegate {
session_id: SessionId,
peer: Arc<HostPeer>,
}
impl RemoteDelegate {
pub(super) fn new(session_id: SessionId, peer: Arc<HostPeer>) -> Self {
Self { session_id, peer }
}
}
impl CodeModeSessionDelegate for RemoteDelegate {
fn invoke_tool<'a>(
&'a self,
invocation: CodeModeNestedToolCall,
cancellation_token: CancellationToken,
) -> ToolInvocationFuture<'a> {
Box::pin(async move {
match self
.peer
.call(
self.session_id.clone(),
DelegateRequest::InvokeTool {
invocation: invocation.into(),
},
cancellation_token,
)
.await?
{
DelegateResponse::ToolResult { result } => Ok(result),
DelegateResponse::NotificationDelivered => {
Err("code-mode client returned an invalid tool result".to_string())
}
}
})
}
fn notify<'a>(
&'a self,
call_id: String,
cell_id: CellId,
text: String,
cancellation_token: CancellationToken,
) -> NotificationFuture<'a> {
Box::pin(async move {
match self
.peer
.call(
self.session_id.clone(),
DelegateRequest::Notify {
call_id,
cell_id: cell_id.into(),
text,
},
cancellation_token,
)
.await?
{
DelegateResponse::NotificationDelivered => Ok(()),
DelegateResponse::ToolResult { .. } => {
Err("code-mode client returned an invalid notification result".to_string())
}
}
})
}
fn cell_closed(&self, cell_id: &CellId) {
self.peer
.close_cell(self.session_id.clone(), cell_id.clone());
}
}
+1 -1
View File
@@ -71,7 +71,7 @@ fn trace_context_from_request<T>(request: &Request<T>) -> Option<W3cTraceContext
#[derive(Clone)]
pub struct GrpcCodeModeHost {
state: Arc<GrpcHostState>,
pub(super) tool_preloads: &'static [ToolPreload],
tool_preloads: &'static [ToolPreload],
process_metrics: Option<Arc<crate::process_metrics::ProcessMetrics>>,
}
@@ -2,6 +2,7 @@ use super::GrpcCodeModeHost;
use super::GrpcStream;
use codex_code_mode_protocol::grpc as proto;
use codex_code_mode_protocol::grpc::code_mode_host_server::CodeModeHost;
use codex_code_mode_runtime::ToolPreload;
use futures::FutureExt;
use futures::StreamExt;
use pretty_assertions::assert_eq;
@@ -156,6 +157,58 @@ fn only_text(items: &[proto::ContentItem]) -> &str {
&text.text
}
#[tokio::test]
async fn preload_errors_preserve_other_sessions_on_the_host() {
let host = GrpcCodeModeHost::new().with_tool_preloads(&[
ToolPreload {
tool: "first",
tool_name: "first",
tool_namespace: None,
source: "const shared = 1;",
},
ToolPreload {
tool: "second",
tool_name: "second",
tool_namespace: None,
source: "const shared = 2;",
},
]);
let (broken, _broken_lease) = open_session(&host).await;
let (healthy, _healthy_lease) = open_session(&host).await;
let mut request = execute_request(&broken, "broken", "text('never runs')");
request.enabled_tools = vec![tool("first"), tool("second")];
for (mut request, expected_content, expected_error) in [
(
request,
Vec::new(),
Some("failed to execute tool preload #2 for `second`".to_string()),
),
(
execute_request(&healthy, "healthy", "text('still alive')"),
vec![proto::ContentItem {
item: Some(proto::content_item::Item::Text(proto::TextContent {
text: "still alive".to_string(),
})),
}],
None,
),
] {
request.yield_time_ms = Some(60_000);
let (_, mut events) = execute_events(&host, request).await;
let event = events.next().await.unwrap().unwrap();
let Some(proto::execute_event::Event::Outcome(outcome)) = event.event else {
panic!("expected cell outcome");
};
let Some(proto::execution_outcome::Outcome::Completed(completed)) = outcome.outcome else {
panic!("expected cell completion");
};
assert_eq!(
(outcome.content_items, completed.error_text),
(expected_content, expected_error)
);
}
}
#[tokio::test]
async fn execute_stream_starts_immediately_and_wait_preserves_missing_cells() {
let host = GrpcCodeModeHost::new();
-992
View File
@@ -1,992 +0,0 @@
use std::collections::HashMap;
use std::pin::Pin;
use std::process::Stdio;
use std::sync::Arc;
use std::sync::Mutex;
use std::sync::PoisonError;
use std::sync::atomic::AtomicBool;
use std::task::Context;
use std::task::Poll;
use std::time::Duration;
use std::time::Instant;
use codex_code_mode_protocol::CodeModeSessionOptions;
use codex_code_mode_protocol::CodeModeToolKind;
use codex_code_mode_protocol::TerminateRequest;
use codex_code_mode_protocol::ToolDefinition;
use codex_code_mode_protocol::host::BOUNDED_OUTPUT_CAPABILITY;
use codex_code_mode_protocol::host::Capability;
use codex_code_mode_protocol::host::CapabilitySet;
use codex_code_mode_protocol::host::ClientHello;
use codex_code_mode_protocol::host::ClientToHost;
use codex_code_mode_protocol::host::EncodedFrame;
use codex_code_mode_protocol::host::FramedReader;
use codex_code_mode_protocol::host::FramedWriter;
use codex_code_mode_protocol::host::HandshakeRejectReason;
use codex_code_mode_protocol::host::HostHello;
use codex_code_mode_protocol::host::HostRequest;
use codex_code_mode_protocol::host::HostResponse;
use codex_code_mode_protocol::host::HostToClient;
use codex_code_mode_protocol::host::LARGE_DELEGATE_CAPACITY_CAPABILITY;
use codex_code_mode_protocol::host::MAX_PENDING_DELEGATE_CALLS;
use codex_code_mode_protocol::host::ProtocolVersion;
use codex_code_mode_protocol::host::RequestId;
use codex_code_mode_protocol::host::SESSION_RESOURCE_LIMITS_CAPABILITY;
use codex_code_mode_protocol::host::SessionId;
use codex_code_mode_protocol::host::SupportedProtocolVersions;
use codex_code_mode_protocol::host::TOOL_CATALOG_CAPABILITY;
use codex_code_mode_protocol::host::WireContentItem;
use codex_code_mode_protocol::host::WireExecuteRequest;
use codex_code_mode_protocol::host::WireOutputTruncation;
use codex_code_mode_protocol::host::WireResult;
use codex_code_mode_protocol::host::WireRuntimeResponse;
use codex_code_mode_protocol::host::WireWaitOutcome;
use codex_code_mode_protocol::host::WireWaitRequest;
use codex_code_mode_runtime::ToolPreload;
use codex_protocol::ToolName;
use pretty_assertions::assert_eq;
use tokio::io::AsyncBufReadExt;
use tokio::io::AsyncRead;
use tokio::io::AsyncWrite;
use tokio::io::BufReader;
use tokio::sync::Semaphore;
use tokio::sync::mpsc;
use tokio::sync::oneshot;
use tokio_util::sync::CancellationToken;
use tokio_util::task::TaskTracker;
use super::HostLimits;
use super::HostState;
use super::MAX_IN_FLIGHT_REQUESTS;
use super::MAX_RECENT_REQUEST_IDS;
use super::RequestKind;
use super::RequestRegistry;
use super::SeenSessionIds;
use super::peer::HostPeer;
use super::run;
fn client_hello(
versions: impl IntoIterator<Item = ProtocolVersion>,
required_capabilities: CapabilitySet,
) -> ClientToHost {
ClientToHost::ClientHello(
ClientHello::new(
SupportedProtocolVersions::try_new(versions).expect("supported versions"),
required_capabilities,
CapabilitySet::empty(),
)
.expect("client hello"),
)
}
fn session_id(value: &str) -> SessionId {
SessionId::new(value).expect("session ID")
}
fn request_id(value: i64) -> RequestId {
RequestId::new(value)
}
async fn decode_frame(frame: EncodedFrame) -> HostToClient {
let (reader, writer) = tokio::io::duplex(/*max_buf_size*/ 4096);
let writer = tokio::spawn(async move {
FramedWriter::new(writer)
.write_frame(&frame)
.await
.expect("write encoded frame");
});
let message = FramedReader::new(reader)
.read()
.await
.expect("read encoded frame")
.expect("encoded frame message");
writer.await.expect("frame writer task");
message
}
fn execute_request(source: &str) -> WireExecuteRequest {
WireExecuteRequest {
catalog_revision: None,
tool_call_id: "call-1".to_string(),
enabled_tools: Vec::new(),
source: source.to_string(),
yield_time_ms: Some(60_000),
max_output_tokens: Some(1_000),
}
}
async fn next_response(reader: &mut FramedReader<impl AsyncRead + Unpin>) -> HostToClient {
loop {
match reader
.read()
.await
.expect("host response")
.expect("host connected")
{
HostToClient::CellClosed { .. } => {}
message => return message,
}
}
}
#[tokio::test]
async fn handshake_and_multiple_session_lifecycles_are_ordered() {
let (host_stream, client_stream) = tokio::io::duplex(/*max_buf_size*/ 4096);
let (host_reader, host_writer) = tokio::io::split(host_stream);
let (client_reader, client_writer) = tokio::io::split(client_stream);
let host = tokio::spawn(run(host_reader, host_writer, &[]));
let mut reader = FramedReader::new(client_reader);
let mut writer = FramedWriter::new(client_writer);
writer
.write(&client_hello([ProtocolVersion::V1], CapabilitySet::empty()))
.await
.expect("write hello");
assert_eq!(
reader.read::<HostToClient>().await.expect("read hello"),
Some(HostToClient::HostHello(HostHello::new(
ProtocolVersion::V1,
CapabilitySet::empty(),
)))
);
for (request_id, id) in [
(request_id(/*value*/ 1), "session-1"),
(request_id(/*value*/ 2), "session-2"),
] {
writer
.write(&ClientToHost::Request {
id: request_id,
request: HostRequest::OpenSession {
session_id: session_id(id),
cell_execution_limits: None,
output_truncation: None,
},
})
.await
.expect("open session");
assert_eq!(
reader.read::<HostToClient>().await.expect("session ready"),
Some(HostToClient::Response {
id: request_id,
result: WireResult::Ok {
value: HostResponse::SessionReady {
session_id: session_id(id),
},
},
})
);
}
for (request_id, id) in [
(request_id(/*value*/ 3), "session-1"),
(request_id(/*value*/ 4), "session-2"),
] {
writer
.write(&ClientToHost::Request {
id: request_id,
request: HostRequest::ShutdownSession {
session_id: session_id(id),
},
})
.await
.expect("shutdown session");
assert_eq!(
reader.read::<HostToClient>().await.expect("session closed"),
Some(HostToClient::Response {
id: request_id,
result: WireResult::Ok {
value: HostResponse::SessionClosed {
session_id: session_id(id),
},
},
})
);
}
drop(writer);
drop(reader);
host.await.expect("host task").expect("host connection");
}
const PRELOAD_STDIO_CHILD: &str = "CODE_MODE_HOST_PRELOAD_STDIO_CHILD";
#[tokio::test]
#[ignore = "stdio subprocess for preload_errors_preserve_other_sessions_on_the_connection"]
async fn preload_stdio_child() {
if std::env::var_os(PRELOAD_STDIO_CHILD).is_none() {
return;
}
super::run_stdio_with_tool_preloads(&[
ToolPreload {
tool: "first",
tool_name: "first",
tool_namespace: None,
source: "const shared = 1;",
},
ToolPreload {
tool: "second",
tool_name: "second",
tool_namespace: None,
source: "const shared = 2;",
},
])
.await
.expect("stdio host");
}
#[tokio::test]
async fn preload_errors_preserve_other_sessions_on_the_connection() {
let mut command =
codex_utils_process::background_command(std::env::current_exe().expect("test executable"));
command
.args([
"--quiet",
"--exact",
"tests::preload_stdio_child",
"--ignored",
"--nocapture",
])
.env(PRELOAD_STDIO_CHILD, "1")
.stdin(Stdio::piped())
.stdout(Stdio::piped());
let mut child = tokio::process::Command::from(command)
.kill_on_drop(/*kill_on_drop*/ true)
.spawn()
.expect("spawn stdio host");
let mut stdout = BufReader::new(child.stdout.take().expect("host stdout"));
// libtest emits its banner before entering the child; subsequent bytes must be frames.
let mut banner = String::new();
for _ in 0..2 {
banner.clear();
stdout.read_line(&mut banner).await.expect("libtest banner");
if banner.trim() == "running 1 test" {
break;
}
}
assert_eq!(banner.trim(), "running 1 test");
let mut reader = FramedReader::new(stdout);
let mut writer = FramedWriter::new(child.stdin.take().expect("host stdin"));
writer
.write(&client_hello([ProtocolVersion::V1], CapabilitySet::empty()))
.await
.expect("hello");
assert!(matches!(
reader.read::<HostToClient>().await.expect("host hello"),
Some(HostToClient::HostHello(_))
));
for (id, name) in [(1, "broken"), (2, "healthy")] {
writer
.write(&ClientToHost::Request {
id: request_id(id),
request: HostRequest::OpenSession {
session_id: session_id(name),
cell_execution_limits: None,
output_truncation: None,
},
})
.await
.expect("open session");
assert!(matches!(
next_response(&mut reader).await,
HostToClient::Response {
id: actual_id,
result: WireResult::Ok { value: HostResponse::SessionReady { .. } },
} if actual_id == request_id(id)
));
}
let mut broken = execute_request("text('never runs')");
broken.enabled_tools = ["first", "second"]
.into_iter()
.map(|name| {
ToolDefinition {
name: name.to_string(),
tool_name: ToolName::plain(name),
description: String::new(),
kind: CodeModeToolKind::Function,
input_schema: None,
input_schema_max_bytes: None,
output_schema: None,
}
.into()
})
.collect();
for (id, name, request, expected_content, expected_error) in [
(
3,
"broken",
broken,
Vec::new(),
Some("failed to execute tool preload #2 for `second`".to_string()),
),
(
4,
"healthy",
execute_request("text('still alive')"),
vec![WireContentItem::InputText {
text: "still alive".to_string(),
}],
None,
),
] {
writer
.write(&ClientToHost::Request {
id: request_id(id),
request: HostRequest::Execute {
session_id: session_id(name),
request,
},
})
.await
.expect("execute");
assert!(matches!(
next_response(&mut reader).await,
HostToClient::Response {
id: actual_id,
result: WireResult::Ok { value: HostResponse::ExecutionStarted { .. } },
} if actual_id == request_id(id)
));
let HostToClient::InitialResponse {
id: actual_id,
result:
WireResult::Ok {
value:
WireRuntimeResponse::Result {
content_items,
error_text,
..
},
},
} = next_response(&mut reader).await
else {
panic!("expected framed cell result");
};
assert_eq!(actual_id, request_id(id));
assert_eq!(
(content_items, error_text),
(expected_content, expected_error)
);
}
drop(writer);
assert!(child.wait().await.expect("host exit").success());
}
#[tokio::test]
async fn disconnect_cancels_a_backpressured_host_writer() {
let (host_reader, client_writer) = tokio::io::duplex(/*max_buf_size*/ 4096);
let (blocked_tx, blocked_rx) = oneshot::channel();
let host = tokio::spawn(run(
host_reader,
BlockingWriter {
blocked_tx: Some(blocked_tx),
handshake_flushed: false,
},
&[],
));
let mut writer = FramedWriter::new(client_writer);
writer
.write(&client_hello([ProtocolVersion::V1], CapabilitySet::empty()))
.await
.expect("write client hello");
writer
.write(&ClientToHost::Request {
id: request_id(/*value*/ 1),
request: HostRequest::OpenSession {
session_id: session_id("backpressured-session"),
cell_execution_limits: None,
output_truncation: None,
},
})
.await
.expect("write session-open request");
tokio::time::timeout(Duration::from_secs(1), blocked_rx)
.await
.expect("host writer should reach backpressure")
.expect("host writer should report backpressure");
writer
.write(&client_hello([ProtocolVersion::V1], CapabilitySet::empty()))
.await
.expect("write invalid second client hello");
let error = tokio::time::timeout(Duration::from_secs(1), host)
.await
.expect("disconnect should cancel the backpressured writer")
.expect("host task should finish")
.expect_err("a second client hello should fail the connection");
assert_eq!(
error.to_string(),
"received a second code-mode client hello"
);
}
struct BlockingWriter {
blocked_tx: Option<oneshot::Sender<()>>,
handshake_flushed: bool,
}
impl AsyncWrite for BlockingWriter {
fn poll_write(
mut self: Pin<&mut Self>,
_cx: &mut Context<'_>,
bytes: &[u8],
) -> Poll<std::io::Result<usize>> {
if self.handshake_flushed {
if let Some(blocked_tx) = self.blocked_tx.take() {
let _ = blocked_tx.send(());
}
Poll::Pending
} else {
Poll::Ready(Ok(bytes.len()))
}
}
fn poll_flush(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
self.handshake_flushed = true;
Poll::Ready(Ok(()))
}
fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Poll::Ready(Ok(()))
}
}
#[tokio::test]
async fn supported_capabilities_are_negotiated_when_optional_or_required() {
for capability in [
TOOL_CATALOG_CAPABILITY,
SESSION_RESOURCE_LIMITS_CAPABILITY,
BOUNDED_OUTPUT_CAPABILITY,
LARGE_DELEGATE_CAPACITY_CAPABILITY,
] {
let capability = Capability::new(capability).expect("supported capability");
let host_capabilities =
CapabilitySet::try_new([capability.clone()]).expect("host capabilities");
for (required, optional) in [
(
CapabilitySet::empty(),
CapabilitySet::try_new([capability]).expect("optional capabilities"),
),
(host_capabilities.clone(), CapabilitySet::empty()),
] {
let (host_stream, client_stream) = tokio::io::duplex(/*max_buf_size*/ 1024);
let (host_reader, host_writer) = tokio::io::split(host_stream);
let (client_reader, client_writer) = tokio::io::split(client_stream);
let host = tokio::spawn(run(host_reader, host_writer, &[]));
let mut reader = FramedReader::new(client_reader);
let mut writer = FramedWriter::new(client_writer);
writer
.write(&ClientToHost::ClientHello(
ClientHello::new(
SupportedProtocolVersions::try_new([ProtocolVersion::V1])
.expect("supported versions"),
required,
optional,
)
.expect("client hello"),
))
.await
.expect("write hello");
assert_eq!(
reader.read::<HostToClient>().await.expect("host hello"),
Some(HostToClient::HostHello(HostHello::new(
ProtocolVersion::V1,
host_capabilities.clone(),
)))
);
drop(writer);
drop(reader);
host.await.expect("host task").expect("host connection");
}
}
}
#[tokio::test]
async fn output_selection_is_per_session() {
let (host_stream, client_stream) = tokio::io::duplex(/*max_buf_size*/ 4096);
let (host_reader, host_writer) = tokio::io::split(host_stream);
let (client_reader, client_writer) = tokio::io::split(client_stream);
let host = tokio::spawn(run(host_reader, host_writer, &[]));
let mut reader = FramedReader::new(client_reader);
let mut writer = FramedWriter::new(client_writer);
writer
.write(&client_hello([ProtocolVersion::V1], CapabilitySet::empty()))
.await
.expect("write hello");
assert_eq!(
reader.read::<HostToClient>().await.expect("host hello"),
Some(HostToClient::HostHello(HostHello::new(
ProtocolVersion::V1,
CapabilitySet::empty(),
)))
);
for (id, name, output_truncation) in [
(1, "client", None),
(2, "server", Some(WireOutputTruncation::Server)),
] {
writer
.write(&ClientToHost::Request {
id: request_id(id),
request: HostRequest::OpenSession {
session_id: session_id(name),
cell_execution_limits: None,
output_truncation,
},
})
.await
.expect("open session");
assert_eq!(
reader.read::<HostToClient>().await.expect("session ready"),
Some(HostToClient::Response {
id: request_id(id),
result: WireResult::Ok {
value: HostResponse::SessionReady {
session_id: session_id(name),
},
},
})
);
}
for (id, name, expected_text, expected_wait) in [
(
3,
"client",
"0123456789012345678901234567890123456789",
"01234567890123456789012345678901234567890123456789012345678901234567890123456789",
),
(
4,
"server",
"Warning: truncated output (original token count: 10)\nTotal output lines: 1\n\n0123456789…5 tokens truncated…0123456789",
"Warning: truncated output (original token count: 20)\nTotal output lines: 1\n\n01234567890123…13 tokens truncated…67890123456789",
),
] {
let mut request = execute_request(
"text('0123456789'.repeat(4)); yield_control(); text('0123456789'.repeat(8));",
);
request.max_output_tokens = Some(5);
writer
.write(&ClientToHost::Request {
id: request_id(id),
request: HostRequest::Execute {
session_id: session_id(name),
request,
},
})
.await
.expect("execute");
// Admission is sent before start_cell can send its initial result.
assert!(matches!(
next_response(&mut reader).await,
HostToClient::Response {
id: actual_id,
result: WireResult::Ok { value: HostResponse::ExecutionStarted { .. } },
} if actual_id == request_id(id)
));
let HostToClient::InitialResponse {
id: actual_id,
result:
WireResult::Ok {
value:
WireRuntimeResponse::Yielded {
cell_id,
content_items,
..
},
},
} = next_response(&mut reader).await
else {
panic!("expected initial yield");
};
assert_eq!(actual_id, request_id(id));
assert_eq!(
content_items,
vec![WireContentItem::InputText {
text: expected_text.to_string()
}]
);
writer
.write(&ClientToHost::Request {
id: request_id(id + 2),
request: HostRequest::Wait {
session_id: session_id(name),
request: WireWaitRequest {
cell_id,
yield_time_ms: 60_000,
},
// A supplied budget only affects Server mode and belongs
// to this observation, not the preceding exec.
max_output_tokens: Some(7),
},
})
.await
.expect("wait");
let HostToClient::Response {
id: actual_id,
result:
WireResult::Ok {
value:
HostResponse::WaitCompleted {
outcome:
WireWaitOutcome::LiveCell(WireRuntimeResponse::Result {
content_items,
error_text,
..
}),
},
},
} = next_response(&mut reader).await
else {
panic!("expected final wait");
};
assert_eq!(actual_id, request_id(id + 2));
assert_eq!(error_text, None);
assert_eq!(
content_items,
vec![WireContentItem::InputText {
text: expected_wait.to_string()
}]
);
}
drop(writer);
drop(reader);
host.await.expect("host task").expect("host connection");
}
#[tokio::test]
async fn incompatible_or_invalid_handshake_is_rejected() {
let (host_stream, client_stream) = tokio::io::duplex(/*max_buf_size*/ 1024);
let (host_reader, host_writer) = tokio::io::split(host_stream);
let (client_reader, client_writer) = tokio::io::split(client_stream);
let host = tokio::spawn(run(host_reader, host_writer, &[]));
let mut reader = FramedReader::new(client_reader);
let mut writer = FramedWriter::new(client_writer);
let version_two = ProtocolVersion::new(/*value*/ 2).expect("protocol version");
writer
.write(&client_hello([version_two], CapabilitySet::empty()))
.await
.expect("write hello");
assert_eq!(
reader.read::<HostToClient>().await.expect("rejection"),
Some(HostToClient::HandshakeRejected {
reason: HandshakeRejectReason::NoCompatibleVersion {
supported_versions: SupportedProtocolVersions::try_new([ProtocolVersion::V1])
.expect("host versions"),
},
})
);
host.await.expect("host task").expect("host connection");
let (host_stream, client_stream) = tokio::io::duplex(/*max_buf_size*/ 1024);
let (host_reader, host_writer) = tokio::io::split(host_stream);
let (client_reader, client_writer) = tokio::io::split(client_stream);
let host = tokio::spawn(run(host_reader, host_writer, &[]));
let mut reader = FramedReader::new(client_reader);
let mut writer = FramedWriter::new(client_writer);
writer
.write(&ClientToHost::Request {
id: request_id(/*value*/ 1),
request: HostRequest::OpenSession {
session_id: session_id("session-1"),
cell_execution_limits: None,
output_truncation: None,
},
})
.await
.expect("write invalid first message");
assert_eq!(
reader.read::<HostToClient>().await.expect("rejection"),
Some(HostToClient::HandshakeRejected {
reason: HandshakeRejectReason::InvalidHello {
message: "first message must be connection/hello".to_string(),
},
})
);
host.await.expect("host task").expect("host connection");
}
#[tokio::test]
async fn unsupported_required_capability_is_rejected() {
let (host_stream, client_stream) = tokio::io::duplex(/*max_buf_size*/ 1024);
let (host_reader, host_writer) = tokio::io::split(host_stream);
let (client_reader, client_writer) = tokio::io::split(client_stream);
let host = tokio::spawn(run(host_reader, host_writer, &[]));
let mut reader = FramedReader::new(client_reader);
let mut writer = FramedWriter::new(client_writer);
let capability = Capability::new("required").expect("capability");
writer
.write(&client_hello(
[ProtocolVersion::V1],
CapabilitySet::try_new([capability.clone()]).expect("capabilities"),
))
.await
.expect("write hello");
assert_eq!(
reader.read::<HostToClient>().await.expect("rejection"),
Some(HostToClient::HandshakeRejected {
reason: HandshakeRejectReason::MissingRequiredCapability { capability },
})
);
host.await.expect("host task").expect("host connection");
}
#[tokio::test]
async fn session_id_cannot_be_reused_after_shutdown() {
let (host_stream, client_stream) = tokio::io::duplex(/*max_buf_size*/ 2048);
let (host_reader, host_writer) = tokio::io::split(host_stream);
let (client_reader, client_writer) = tokio::io::split(client_stream);
let host = tokio::spawn(run(host_reader, host_writer, &[]));
let mut reader = FramedReader::new(client_reader);
let mut writer = FramedWriter::new(client_writer);
writer
.write(&client_hello([ProtocolVersion::V1], CapabilitySet::empty()))
.await
.expect("write hello");
reader
.read::<HostToClient>()
.await
.expect("read hello")
.expect("host hello");
let id = session_id("session-1");
for (request_id, request) in [
(
request_id(/*value*/ 1),
HostRequest::OpenSession {
session_id: id.clone(),
cell_execution_limits: None,
output_truncation: None,
},
),
(
request_id(/*value*/ 2),
HostRequest::ShutdownSession {
session_id: id.clone(),
},
),
] {
writer
.write(&ClientToHost::Request {
id: request_id,
request,
})
.await
.expect("session request");
reader
.read::<HostToClient>()
.await
.expect("session response")
.expect("session response message");
}
writer
.write(&ClientToHost::Request {
id: request_id(/*value*/ 3),
request: HostRequest::OpenSession {
session_id: id,
cell_execution_limits: None,
output_truncation: None,
},
})
.await
.expect("reuse session ID");
assert_eq!(
reader.read::<HostToClient>().await.expect("reuse response"),
Some(HostToClient::Response {
id: request_id(/*value*/ 3),
result: WireResult::Err {
message: "code-mode session ID `session-1` was reused".to_string(),
},
})
);
drop(writer);
drop(reader);
host.await.expect("host task").expect("host connection");
}
#[test]
fn request_history_is_bounded() {
let mut requests = RequestRegistry::default();
let duplicate = request_id(/*value*/ -1);
requests
.start(duplicate, RequestKind::OpenSession)
.expect("start duplicate probe");
assert!(requests.start(duplicate, RequestKind::OpenSession).is_err());
requests.finish(duplicate);
for value in 1..=MAX_RECENT_REQUEST_IDS as i64 + 100 {
let id = request_id(value);
requests
.start(id, RequestKind::Wait)
.expect("start request");
requests.cancel(id);
requests.finish(id);
}
assert!(requests.active.is_empty());
assert_eq!(requests.recent.len(), MAX_RECENT_REQUEST_IDS);
assert_eq!(requests.recent_order.len(), MAX_RECENT_REQUEST_IDS);
}
#[tokio::test]
async fn request_task_panic_disconnects_host() {
let (outgoing_tx, _outgoing_rx) = mpsc::channel(/*max_capacity*/ 1);
let peer = Arc::new(HostPeer::new(outgoing_tx, MAX_PENDING_DELEGATE_CALLS));
let state = HostState {
sessions: Mutex::new(HashMap::new()),
tool_preloads: &[],
limits: Arc::new(HostLimits::new()),
seen_session_ids: Mutex::new(SeenSessionIds::default()),
requests: Mutex::new(RequestRegistry::default()),
request_tasks: TaskTracker::new(),
closing: AtomicBool::new(false),
peer: Arc::clone(&peer),
};
let task = state.request_tasks.spawn(async {
panic!("request panic probe");
});
state.supervise_request_task(task);
tokio::time::timeout(Duration::from_secs(1), peer.disconnected())
.await
.expect("request panic should disconnect host");
assert!(
peer.failure()
.expect("request failure")
.contains("request task failed")
);
}
#[tokio::test]
async fn execute_request_id_remains_active_until_initial_response() {
let (outgoing_tx, mut outgoing_rx) = mpsc::channel(/*max_capacity*/ 4);
let peer = Arc::new(HostPeer::new(outgoing_tx, MAX_PENDING_DELEGATE_CALLS));
let state = Arc::new(HostState {
sessions: Mutex::new(HashMap::new()),
tool_preloads: &[],
limits: Arc::new(HostLimits::new()),
seen_session_ids: Mutex::new(SeenSessionIds::default()),
requests: Mutex::new(RequestRegistry::default()),
request_tasks: TaskTracker::new(),
closing: AtomicBool::new(false),
peer,
});
let session_id = session_id("session-1");
state
.open_session(session_id.clone(), CodeModeSessionOptions::default())
.expect("open session");
let request_id = request_id(/*value*/ 1);
state
.spawn_request(
request_id,
HostRequest::Execute {
session_id: session_id.clone(),
request: execute_request("await new Promise(() => {});"),
},
)
.expect("spawn execute request");
let started = decode_frame(outgoing_rx.recv().await.expect("execution started frame")).await;
let HostToClient::Response {
id,
result:
WireResult::Ok {
value: HostResponse::ExecutionStarted { cell_id },
},
} = started
else {
panic!("expected execution started response");
};
assert_eq!(id, request_id);
assert!(
state
.requests
.lock()
.unwrap_or_else(PoisonError::into_inner)
.active
.contains_key(&request_id)
);
state
.session(&session_id)
.expect("session")
.terminate(TerminateRequest {
cell_id: cell_id.into(),
max_output_tokens: None,
})
.await
.expect("terminate cell");
state.disconnect().await;
}
#[tokio::test]
async fn active_cell_limit_rejects_execute_without_disconnecting() {
let (outgoing_tx, mut outgoing_rx) = mpsc::channel(/*max_capacity*/ 1);
let peer = Arc::new(HostPeer::new(outgoing_tx, MAX_PENDING_DELEGATE_CALLS));
let state = HostState {
sessions: Mutex::new(HashMap::new()),
tool_preloads: &[],
limits: Arc::new(HostLimits {
request_permits: Arc::new(Semaphore::new(MAX_IN_FLIGHT_REQUESTS)),
active_cell_permits: Arc::new(Semaphore::new(/*permits*/ 0)),
}),
seen_session_ids: Mutex::new(SeenSessionIds::default()),
requests: Mutex::new(RequestRegistry::default()),
request_tasks: TaskTracker::new(),
closing: AtomicBool::new(false),
peer: Arc::clone(&peer),
};
let session_id = session_id("session-1");
state
.open_session(session_id.clone(), CodeModeSessionOptions::default())
.expect("open session");
let request_id = request_id(/*value*/ 1);
state
.handle_request(
request_id,
HostRequest::Execute {
session_id,
request: execute_request("text(\"hello\");"),
},
CancellationToken::new(),
CancellationToken::new(),
Instant::now(),
)
.await;
assert_eq!(
decode_frame(outgoing_rx.recv().await.expect("execute response frame")).await,
HostToClient::Response {
id: request_id,
result: WireResult::Err {
message: "code-mode host has too many active cells".to_string(),
},
}
);
assert!(!peer.is_disconnected());
state.disconnect().await;
}
#[tokio::test]
async fn cell_forwarding_panic_disconnects_host() {
let (outgoing_tx, _outgoing_rx) = mpsc::channel(/*max_capacity*/ 1);
let peer = Arc::new(HostPeer::new(outgoing_tx, MAX_PENDING_DELEGATE_CALLS));
peer.spawn_critical("cell forwarding", async {
panic!("cell forwarding panic probe");
});
tokio::time::timeout(Duration::from_secs(1), peer.disconnected())
.await
.expect("cell panic should disconnect host");
assert!(
peer.failure()
.expect("cell failure")
.contains("cell forwarding task failed")
);
}
+4 -741
View File
@@ -1,68 +1,22 @@
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::VecDeque;
use std::sync::Arc;
use std::sync::Mutex;
use std::sync::PoisonError;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use std::time::Duration;
use std::time::Instant;
//! Runs the gRPC code-mode host over stdio or TCP.
use std::sync::Arc;
use anyhow::Context;
use anyhow::Result;
use codex_code_mode_protocol::CodeModeOutputTruncation;
use codex_code_mode_protocol::CodeModeSessionCellExecutionLimits;
use codex_code_mode_protocol::CodeModeSessionOptions;
use codex_code_mode_protocol::TerminateRequest;
use codex_code_mode_protocol::WaitRequest;
use codex_code_mode_protocol::host::BOUNDED_OUTPUT_CAPABILITY;
use codex_code_mode_protocol::host::Capability;
use codex_code_mode_protocol::host::CapabilitySet;
use codex_code_mode_protocol::host::ClientToHost;
use codex_code_mode_protocol::host::EncodedFrame;
use codex_code_mode_protocol::host::FramedReader;
use codex_code_mode_protocol::host::FramedWriter;
use codex_code_mode_protocol::host::HandshakeRejectReason;
use codex_code_mode_protocol::host::HostHello;
use codex_code_mode_protocol::host::HostRequest;
use codex_code_mode_protocol::host::HostResponse;
use codex_code_mode_protocol::host::HostToClient;
use codex_code_mode_protocol::host::LARGE_DELEGATE_CAPACITY_CAPABILITY;
use codex_code_mode_protocol::host::LEGACY_MAX_PENDING_DELEGATE_CALLS;
use codex_code_mode_protocol::host::MAX_PENDING_DELEGATE_CALLS;
use codex_code_mode_protocol::host::ProtocolVersion;
use codex_code_mode_protocol::host::RequestId;
use codex_code_mode_protocol::host::SESSION_RESOURCE_LIMITS_CAPABILITY;
use codex_code_mode_protocol::host::SessionId;
use codex_code_mode_protocol::host::SupportedProtocolVersions;
use codex_code_mode_protocol::host::TOOL_CATALOG_CAPABILITY;
use codex_code_mode_protocol::host::WireWaitOutcome;
use codex_code_mode_protocol::host::YIELD_OBSERVATION_CAPABILITY;
use codex_code_mode_runtime::InProcessCodeModeSession;
use codex_code_mode_runtime::ToolPreload;
use tokio::io::AsyncRead;
use tokio::io::AsyncWrite;
use tokio::sync::OwnedSemaphorePermit;
use tokio::sync::Semaphore;
use tokio::sync::TryAcquireError;
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;
use tokio_util::task::TaskTracker;
use self::delegate::RemoteDelegate;
use self::peer::HostPeer;
pub use self::grpc::GrpcCodeModeHost;
pub use self::process_metrics::CodeModeProcessMetricsCollector;
pub use self::transport::DEFAULT_LISTEN_URL;
pub use codex_code_mode_protocol::CodeModeProcessMetrics;
mod delegate;
mod grpc;
mod grpc_stdio;
mod grpc_transport;
mod peer;
mod process_metrics;
mod transport;
@@ -72,16 +26,9 @@ const MAX_ACTIVE_CELLS: usize = 2_048;
// Leave observation and control headroom during a full callback-completion burst.
const MAX_IN_FLIGHT_REQUESTS: usize = MAX_PENDING_DELEGATE_CALLS * 2;
const MAX_RECENT_REQUEST_IDS: usize = 4096;
const MAX_RECENT_SESSION_IDS: usize = 4096;
const SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(5);
// Allow a full callback-completion burst plus concurrent control messages.
const OUTGOING_CHANNEL_CAPACITY: usize = MAX_PENDING_DELEGATE_CALLS * 2;
enum NegotiatedConnection {
Rejected,
Accepted { max_pending_delegate_calls: usize },
}
struct HostLimits {
request_permits: Arc<Semaphore>,
active_cell_permits: Arc<Semaphore>,
@@ -104,7 +51,7 @@ impl HostLimits {
}
}
/// Runs the code-mode host on its configured stdio or gRPC transport.
/// Runs the code-mode host over gRPC on the configured endpoint.
pub async fn run_main(listen_url: &str) -> Result<()> {
run_main_with_tool_preloads(listen_url, &[]).await
}
@@ -128,7 +75,6 @@ pub async fn run_main_with_tool_preloads(
}
/// Runs with an optional gRPC metrics collector initialized before sandbox entry.
/// The legacy stdio transport remains unchanged.
pub async fn run_main_with_process_metrics(
listen_url: &str,
collector: CodeModeProcessMetricsCollector,
@@ -139,686 +85,3 @@ pub async fn run_main_with_process_metrics(
)
.await
}
/// Runs one code-mode host connection over the process standard streams.
pub async fn run_stdio() -> Result<()> {
run_stdio_with_tool_preloads(&[]).await
}
async fn run_stdio_with_tool_preloads(tool_preloads: &'static [ToolPreload]) -> Result<()> {
run(tokio::io::stdin(), tokio::io::stdout(), tool_preloads).await
}
/// Runs one code-mode host connection over an ordered input/output pair.
async fn run<R, W>(reader: R, writer: W, tool_preloads: &'static [ToolPreload]) -> Result<()>
where
R: AsyncRead + Send + Unpin + 'static,
W: AsyncWrite + Send + Unpin + 'static,
{
let mut reader = FramedReader::new(reader);
let mut writer = FramedWriter::new(writer);
let max_pending_delegate_calls = match negotiate(&mut reader, &mut writer).await? {
NegotiatedConnection::Rejected => return Ok(()),
NegotiatedConnection::Accepted {
max_pending_delegate_calls,
} => max_pending_delegate_calls,
};
let (outgoing_tx, outgoing_rx) = mpsc::channel::<EncodedFrame>(OUTGOING_CHANNEL_CAPACITY);
let peer = Arc::new(HostPeer::new(outgoing_tx, max_pending_delegate_calls));
let state = Arc::new(HostState {
sessions: Mutex::new(HashMap::new()),
tool_preloads,
limits: Arc::new(HostLimits::new()),
seen_session_ids: Mutex::new(SeenSessionIds::default()),
requests: Mutex::new(RequestRegistry::default()),
request_tasks: TaskTracker::new(),
closing: AtomicBool::new(false),
peer: Arc::clone(&peer),
});
let writer_disconnected = peer.disconnection_token();
let writer_task =
tokio::spawn(async move { drive_writer(writer, outgoing_rx, writer_disconnected).await });
let writer_peer = Arc::clone(&peer);
let writer_supervisor = tokio::spawn(async move {
match writer_task.await {
Ok(Ok(())) if !writer_peer.is_disconnected() => {
writer_peer.fail("code-mode writer task exited unexpectedly".to_string());
}
Ok(Ok(())) => {}
Ok(Err(err)) => {
writer_peer.fail(format!("code-mode writer task failed: {err:#}"));
}
Err(err) => {
writer_peer.fail(format!("code-mode writer task failed: {err}"));
}
}
});
let input_result = async {
loop {
let message = tokio::select! {
biased;
_ = peer.disconnected() => break,
message = reader.read() => message.context("failed to read code-mode client message")?,
};
let Some(message) = message else {
break;
};
match message {
ClientToHost::ClientHello(_) => {
anyhow::bail!("received a second code-mode client hello");
}
ClientToHost::Request { id, request } => {
state.spawn_request(id, request)?;
}
ClientToHost::CancelRequest { id } => {
state.cancel_request(id);
}
ClientToHost::YieldRequest { id } => {
state.yield_request(id);
}
ClientToHost::DelegateResponse { id, result } => {
peer.complete(id, result.into_result()).await;
}
}
}
Ok::<(), anyhow::Error>(())
}
.await;
peer.disconnect();
if tokio::time::timeout(SHUTDOWN_TIMEOUT, state.disconnect())
.await
.is_err()
{
peer.fail("timed out shutting down code-mode host state".to_string());
}
drop(state);
tokio::time::timeout(SHUTDOWN_TIMEOUT, writer_supervisor)
.await
.context("timed out supervising code-mode writer task")?
.context("code-mode writer supervisor task failed")?;
let failure = peer.failure();
drop(peer);
input_result?;
if let Some(failure) = failure {
anyhow::bail!(failure);
}
Ok(())
}
async fn drive_writer<W: AsyncWrite + Unpin>(
mut writer: FramedWriter<W>,
mut outgoing: mpsc::Receiver<EncodedFrame>,
disconnected: CancellationToken,
) -> Result<()> {
loop {
tokio::select! {
_ = disconnected.cancelled() => return Ok(()),
frame = outgoing.recv() => {
let Some(frame) = frame else {
return Ok(());
};
tokio::select! {
_ = disconnected.cancelled() => return Ok(()),
result = writer.write_frame(&frame) => {
result.context("failed to write code-mode host message")?;
}
}
}
}
}
}
async fn negotiate<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
reader: &mut FramedReader<R>,
writer: &mut FramedWriter<W>,
) -> Result<NegotiatedConnection> {
let Some(first_message) = reader
.read()
.await
.context("failed to read code-mode client hello")?
else {
return Ok(NegotiatedConnection::Rejected);
};
let ClientToHost::ClientHello(client_hello) = first_message else {
writer
.write(&HostToClient::HandshakeRejected {
reason: HandshakeRejectReason::InvalidHello {
message: "first message must be connection/hello".to_string(),
},
})
.await
.context("failed to reject invalid code-mode client hello")?;
return Ok(NegotiatedConnection::Rejected);
};
let supported_versions = SupportedProtocolVersions::try_new([ProtocolVersion::V1])?;
if !client_hello
.supported_versions()
.contains(ProtocolVersion::V1)
{
writer
.write(&HostToClient::HandshakeRejected {
reason: HandshakeRejectReason::NoCompatibleVersion { supported_versions },
})
.await
.context("failed to reject incompatible code-mode client")?;
return Ok(NegotiatedConnection::Rejected);
}
let host_capabilities = CapabilitySet::try_new(
[
SESSION_RESOURCE_LIMITS_CAPABILITY,
YIELD_OBSERVATION_CAPABILITY,
BOUNDED_OUTPUT_CAPABILITY,
LARGE_DELEGATE_CAPACITY_CAPABILITY,
TOOL_CATALOG_CAPABILITY,
]
.into_iter()
.map(Capability::new)
.collect::<Result<Vec<_>, _>>()?
.into_iter()
.filter(|capability| {
client_hello.required_capabilities().contains(capability)
|| client_hello.optional_capabilities().contains(capability)
}),
)?;
if let Some(capability) = client_hello
.required_capabilities()
.iter()
.find(|capability| !host_capabilities.contains(capability))
{
writer
.write(&HostToClient::HandshakeRejected {
reason: HandshakeRejectReason::MissingRequiredCapability {
capability: capability.clone(),
},
})
.await
.context("failed to reject unsupported code-mode capability")?;
return Ok(NegotiatedConnection::Rejected);
}
let max_pending_delegate_calls =
if host_capabilities.contains(&Capability::new(LARGE_DELEGATE_CAPACITY_CAPABILITY)?) {
MAX_PENDING_DELEGATE_CALLS
} else {
LEGACY_MAX_PENDING_DELEGATE_CALLS
};
let hello = HostHello::new(ProtocolVersion::V1, host_capabilities);
writer
.write(&HostToClient::HostHello(hello))
.await
.context("failed to write code-mode host hello")?;
Ok(NegotiatedConnection::Accepted {
max_pending_delegate_calls,
})
}
struct HostState {
sessions: Mutex<HashMap<SessionId, Arc<InProcessCodeModeSession>>>,
tool_preloads: &'static [ToolPreload],
limits: Arc<HostLimits>,
seen_session_ids: Mutex<SeenSessionIds>,
requests: Mutex<RequestRegistry>,
request_tasks: TaskTracker,
closing: AtomicBool,
peer: Arc<HostPeer>,
}
impl HostState {
fn spawn_request(
self: &Arc<Self>,
request_id: RequestId,
request: HostRequest,
) -> Result<(), anyhow::Error> {
// Include host admission and scheduling before the runtime observes the request.
let received_at = Instant::now();
let request_kind = RequestKind::from(&request);
let (cancellation, yield_signal) = self
.requests
.lock()
.unwrap_or_else(PoisonError::into_inner)
.start(request_id, request_kind)?;
let Ok(permit) = self.limits.request_permit() else {
self.respond(
request_id,
Err("code-mode host has too many in-flight requests".to_string()),
);
self.finish_request(request_id);
return Ok(());
};
let state = Arc::clone(self);
let request_task = self.request_tasks.spawn(async move {
let _permit = permit;
state
.handle_request(request_id, request, cancellation, yield_signal, received_at)
.await;
state.finish_request(request_id);
});
self.supervise_request_task(request_task);
Ok(())
}
fn supervise_request_task(&self, task: tokio::task::JoinHandle<()>) {
let peer = Arc::clone(&self.peer);
tokio::spawn(async move {
if let Err(err) = task.await {
peer.fail(format!("code-mode request task failed: {err}"));
}
});
}
#[tracing::instrument(
name = "code_mode_host.request",
level = "info",
skip_all,
fields(
otel.name = "code_mode_host.request",
request.kind = RequestKind::from(&request).as_str(),
request.id = ?request_id,
call_id = tracing::field::Empty,
)
)]
async fn handle_request(
&self,
request_id: RequestId,
request: HostRequest,
cancellation: CancellationToken,
yield_signal: CancellationToken,
received_at: Instant,
) {
if let HostRequest::Execute { request, .. } = &request {
tracing::Span::current().record("call_id", request.tool_call_id.as_str());
}
if self.closing.load(Ordering::Acquire) {
self.respond(
request_id,
Err("code-mode host is shutting down".to_string()),
);
return;
}
match request {
HostRequest::OpenSession {
session_id,
cell_execution_limits,
output_truncation,
} => {
let result = CodeModeSessionCellExecutionLimits::try_from(
cell_execution_limits.unwrap_or_default(),
)
.map_err(|error| format!("invalid code-mode session execution limits: {error}"))
.and_then(|limits| {
self.open_session(
session_id.clone(),
CodeModeSessionOptions {
cell_execution_limits: limits,
output_truncation: output_truncation
.map(CodeModeOutputTruncation::from)
.unwrap_or_default(),
..Default::default()
},
)
})
.map(|()| HostResponse::SessionReady { session_id });
self.respond(request_id, result);
}
HostRequest::Execute {
session_id,
request,
} => {
if cancellation.is_cancelled() {
self.respond(request_id, Err("code-mode request cancelled".to_string()));
return;
}
let catalog_revision = request.catalog_revision;
let request = match request.try_into() {
Ok(request) => request,
Err(err) => {
self.respond(
request_id,
Err(format!("invalid code-mode execute request: {err}")),
);
return;
}
};
let session = match self.session(&session_id) {
Ok(session) => session,
Err(err) => {
self.respond(request_id, Err(err));
return;
}
};
let Ok(active_cell_permit) = self.limits.cell_permit() else {
self.respond(
request_id,
Err("code-mode host has too many active cells".to_string()),
);
return;
};
let delegate = Arc::new(RemoteDelegate::new(
session_id.clone(),
Arc::clone(&self.peer),
));
let result = session
.execute_with_catalog(request, catalog_revision, delegate, Some(yield_signal))
.await;
match result {
Ok(started) => {
let cell_id = started.cell_id.clone();
self.respond(
request_id,
Ok(HostResponse::ExecutionStarted {
cell_id: cell_id.into(),
}),
);
let initial_response_sent = self.peer.start_cell(
session_id,
request_id,
started,
active_cell_permit,
received_at,
);
let _ = initial_response_sent.await;
}
Err(err) => self.respond(request_id, Err(err)),
}
}
HostRequest::Wait {
session_id,
request,
max_output_tokens,
} => {
let result = match self.session(&session_id) {
Ok(session) => {
tokio::select! {
biased;
_ = cancellation.cancelled() => {
Err("code-mode request cancelled".to_string())
}
result = session.wait(WaitRequest {
max_output_tokens,
..request.into()
}, Some(yield_signal)) => result.and_then(|outcome| {
let outcome = outcome.with_code_mode_host_duration(received_at.elapsed());
Ok(HostResponse::WaitCompleted {
outcome: WireWaitOutcome::try_from(outcome)
.map_err(|error| error.to_string())?,
})
}),
}
}
Err(err) => Err(err),
};
self.respond(request_id, result);
}
HostRequest::Terminate {
session_id,
cell_id,
max_output_tokens,
} => {
let result = match self.session(&session_id) {
Ok(session) => session
.terminate(TerminateRequest {
cell_id: cell_id.into(),
max_output_tokens,
})
.await
.and_then(|outcome| {
let outcome =
outcome.with_code_mode_host_duration(received_at.elapsed());
Ok(HostResponse::WaitCompleted {
outcome: WireWaitOutcome::try_from(outcome)
.map_err(|error| error.to_string())?,
})
}),
Err(err) => Err(err),
};
self.respond(request_id, result);
}
HostRequest::ShutdownSession { session_id } => {
let session = self
.sessions
.lock()
.unwrap_or_else(PoisonError::into_inner)
.remove(&session_id);
let result = match session {
Some(session) => match session.shutdown().await {
Ok(()) => {
self.peer.wait_for_session_cells(&session_id).await;
Ok(HostResponse::SessionClosed { session_id })
}
Err(err) => Err(err),
},
None => Err(format!("unknown code-mode session {session_id}")),
};
self.respond(request_id, result);
}
}
}
fn open_session(
&self,
session_id: SessionId,
options: CodeModeSessionOptions,
) -> Result<(), String> {
let mut sessions = self.sessions.lock().unwrap_or_else(PoisonError::into_inner);
if sessions.contains_key(&session_id) {
return Err(format!(
"code-mode session ID `{session_id}` is already open"
));
}
if self.closing.load(Ordering::Acquire) {
return Err("code-mode host is shutting down".to_string());
}
if !self
.seen_session_ids
.lock()
.unwrap_or_else(PoisonError::into_inner)
.remember(session_id.clone())
{
return Err(format!("code-mode session ID `{session_id}` was reused"));
}
let peer = Arc::downgrade(&self.peer);
let task_failure_handler = Arc::new(move |reason| {
if let Some(peer) = peer.upgrade() {
peer.fail(reason);
}
});
sessions.insert(
session_id,
Arc::new(InProcessCodeModeSession::with_options_and_tool_preloads(
options,
Some(task_failure_handler),
self.tool_preloads,
)),
);
Ok(())
}
fn session(&self, session_id: &SessionId) -> Result<Arc<InProcessCodeModeSession>, String> {
self.sessions
.lock()
.unwrap_or_else(PoisonError::into_inner)
.get(session_id)
.cloned()
.ok_or_else(|| format!("unknown code-mode session {session_id}"))
}
fn respond(&self, id: RequestId, result: Result<HostResponse, String>) {
self.peer.respond(id, result);
}
fn cancel_request(&self, request_id: RequestId) {
self.requests
.lock()
.unwrap_or_else(PoisonError::into_inner)
.cancel(request_id);
}
fn yield_request(&self, request_id: RequestId) {
self.requests
.lock()
.unwrap_or_else(PoisonError::into_inner)
.yield_observation(request_id);
}
fn finish_request(&self, request_id: RequestId) {
self.requests
.lock()
.unwrap_or_else(PoisonError::into_inner)
.finish(request_id);
}
async fn disconnect(&self) {
self.closing.store(true, Ordering::Release);
self.requests
.lock()
.unwrap_or_else(PoisonError::into_inner)
.cancel_all();
self.request_tasks.close();
self.request_tasks.wait().await;
let sessions = self
.sessions
.lock()
.unwrap_or_else(PoisonError::into_inner)
.drain()
.map(|(_, session)| session)
.collect::<Vec<_>>();
for session in sessions {
let _ = session.shutdown().await;
}
}
}
#[derive(Clone, Copy)]
enum RequestKind {
OpenSession,
Execute,
Wait,
Terminate,
ShutdownSession,
}
impl RequestKind {
fn from(request: &HostRequest) -> Self {
match request {
HostRequest::OpenSession { .. } => Self::OpenSession,
HostRequest::Execute { .. } => Self::Execute,
HostRequest::Wait { .. } => Self::Wait,
HostRequest::Terminate { .. } => Self::Terminate,
HostRequest::ShutdownSession { .. } => Self::ShutdownSession,
}
}
fn is_cancellable(self) -> bool {
matches!(self, Self::Execute | Self::Wait)
}
fn as_str(self) -> &'static str {
match self {
Self::OpenSession => "open_session",
Self::Execute => "execute",
Self::Wait => "wait",
Self::Terminate => "terminate",
Self::ShutdownSession => "shutdown_session",
}
}
}
struct ActiveRequest {
kind: RequestKind,
cancellation: CancellationToken,
yield_signal: CancellationToken,
}
#[derive(Default)]
struct RequestRegistry {
active: HashMap<RequestId, ActiveRequest>,
recent: HashSet<RequestId>,
recent_order: VecDeque<RequestId>,
}
impl RequestRegistry {
fn start(
&mut self,
request_id: RequestId,
kind: RequestKind,
) -> Result<(CancellationToken, CancellationToken), anyhow::Error> {
if self.active.contains_key(&request_id) || self.recent.contains(&request_id) {
anyhow::bail!("duplicate code-mode request ID {request_id:?}");
}
let cancellation = CancellationToken::new();
let yield_signal = CancellationToken::new();
self.active.insert(
request_id,
ActiveRequest {
kind,
cancellation: cancellation.clone(),
yield_signal: yield_signal.clone(),
},
);
Ok((cancellation, yield_signal))
}
fn cancel(&mut self, request_id: RequestId) {
if let Some(request) = self.active.get(&request_id)
&& request.kind.is_cancellable()
{
request.cancellation.cancel();
}
}
fn yield_observation(&self, request_id: RequestId) {
if let Some(request) = self.active.get(&request_id)
&& matches!(request.kind, RequestKind::Execute | RequestKind::Wait)
{
request.yield_signal.cancel();
}
}
fn finish(&mut self, request_id: RequestId) {
if self.active.remove(&request_id).is_none() {
return;
}
self.recent.insert(request_id);
self.recent_order.push_back(request_id);
while self.recent_order.len() > MAX_RECENT_REQUEST_IDS {
if let Some(expired) = self.recent_order.pop_front() {
self.recent.remove(&expired);
}
}
}
fn cancel_all(&self) {
for request in self.active.values() {
request.cancellation.cancel();
}
}
}
#[derive(Default)]
struct SeenSessionIds {
ids: HashSet<SessionId>,
order: VecDeque<SessionId>,
}
impl SeenSessionIds {
fn remember(&mut self, session_id: SessionId) -> bool {
if !self.ids.insert(session_id.clone()) {
return false;
}
self.order.push_back(session_id);
while self.order.len() > MAX_RECENT_SESSION_IDS {
if let Some(expired) = self.order.pop_front() {
self.ids.remove(&expired);
}
}
true
}
}
#[cfg(test)]
#[path = "host_tests.rs"]
mod tests;
+1 -1
View File
@@ -25,7 +25,7 @@ struct Cli {
)]
codex_ui_plugin_process: bool,
/// Transport endpoint: `stdio`, `stdio://`, `grpc+stdio://`, or `grpc://IP:PORT`.
/// gRPC endpoint: `grpc+stdio://` (aliases `stdio` and `stdio://`) or `grpc://IP:PORT`.
#[arg(
long,
value_name = "URL",
-566
View File
@@ -1,566 +0,0 @@
use std::collections::HashMap;
use std::collections::VecDeque;
use std::sync::Arc;
use std::sync::Mutex as StdMutex;
use std::sync::PoisonError;
use std::sync::atomic::AtomicI64;
use std::sync::atomic::Ordering;
use std::time::Instant;
use codex_code_mode_protocol::CellId;
use codex_code_mode_protocol::StartedCell;
use codex_code_mode_protocol::host::DelegateRequest;
use codex_code_mode_protocol::host::DelegateRequestId;
use codex_code_mode_protocol::host::DelegateResponse;
use codex_code_mode_protocol::host::EncodedFrame;
use codex_code_mode_protocol::host::HostToClient;
use codex_code_mode_protocol::host::RequestId;
use codex_code_mode_protocol::host::SessionId;
use codex_code_mode_protocol::host::WireResult;
use codex_code_mode_protocol::host::WireRuntimeResponse;
use tokio::sync::Mutex;
use tokio::sync::Notify;
use tokio::sync::OwnedSemaphorePermit;
use tokio::sync::Semaphore;
use tokio::sync::mpsc;
use tokio::sync::oneshot;
use tokio_util::sync::CancellationToken;
const CELL_MESSAGE_CAPACITY: usize = 128;
pub(super) struct HostPeer {
outgoing_tx: mpsc::Sender<EncodedFrame>,
pending: Mutex<HashMap<DelegateRequestId, PendingDelegate>>,
delegate_permits: Arc<Semaphore>,
cell_routes: StdMutex<HashMap<(SessionId, CellId), CellRoute>>,
cell_routes_changed: Notify,
next_request_id: AtomicI64,
disconnected: CancellationToken,
failure: StdMutex<Option<String>>,
}
struct PendingDelegate {
response_tx: oneshot::Sender<Result<DelegateResponse, String>>,
dispatched: bool,
_permit: OwnedSemaphorePermit,
}
enum CellRoute {
Pending(VecDeque<CellMessage>),
Active(mpsc::Sender<CellMessage>),
}
enum CellMessage {
Delegate {
id: DelegateRequestId,
request: DelegateRequest,
dispatched_tx: oneshot::Sender<Result<(), String>>,
},
Closed,
}
struct InitialRequest {
id: RequestId,
received_at: Instant,
}
impl HostPeer {
pub(super) fn new(
outgoing_tx: mpsc::Sender<EncodedFrame>,
max_pending_delegate_calls: usize,
) -> Self {
Self {
outgoing_tx,
pending: Mutex::new(HashMap::new()),
delegate_permits: Arc::new(Semaphore::new(max_pending_delegate_calls)),
cell_routes: StdMutex::new(HashMap::new()),
cell_routes_changed: Notify::new(),
next_request_id: AtomicI64::new(1),
disconnected: CancellationToken::new(),
failure: StdMutex::new(None),
}
}
pub(super) fn send(&self, message: HostToClient) -> Result<(), PeerSendError> {
let frame = EncodedFrame::encode(&message)
.map_err(|err| PeerSendError::Payload(err.to_string()))?;
self.send_frame(frame)
}
pub(super) fn respond(
&self,
id: RequestId,
result: Result<codex_code_mode_protocol::host::HostResponse, String>,
) {
let message = HostToClient::Response {
id,
result: WireResult::from_result(result),
};
if let Err(PeerSendError::Payload(err)) = self.send(message) {
let _ = self.send(HostToClient::Response {
id,
result: WireResult::Err {
message: format!("code-mode host response exceeds the IPC frame limit: {err}"),
},
});
}
}
fn initial_response(&self, id: RequestId, result: Result<WireRuntimeResponse, String>) {
let message = HostToClient::InitialResponse {
id,
result: WireResult::from_result(result),
};
if let Err(PeerSendError::Payload(err)) = self.send(message) {
let _ = self.send(HostToClient::InitialResponse {
id,
result: WireResult::Err {
message: format!(
"code-mode initial response exceeds the IPC frame limit: {err}"
),
},
});
}
}
pub(super) async fn call(
self: &Arc<Self>,
session_id: SessionId,
request: DelegateRequest,
cancellation_token: CancellationToken,
) -> Result<DelegateResponse, String> {
if self.disconnected.is_cancelled() {
return Err("code-mode client connection closed".to_string());
}
let Ok(permit) = Arc::clone(&self.delegate_permits).try_acquire_owned() else {
return Err("code-mode host has too many pending delegate calls".to_string());
};
let id = DelegateRequestId::new(self.next_request_id.fetch_add(1, Ordering::Relaxed));
let (response_tx, response_rx) = oneshot::channel();
self.pending.lock().await.insert(
id,
PendingDelegate {
response_tx,
dispatched: false,
_permit: permit,
},
);
let mut pending = PendingDelegateRequest::new(Arc::clone(self), id);
let cell_id = match &request {
DelegateRequest::InvokeTool { invocation } => invocation.cell_id.clone().into(),
DelegateRequest::Notify { cell_id, .. } => cell_id.clone().into(),
};
let (dispatched_tx, dispatched_rx) = oneshot::channel();
if let Err(err) = self.route_cell_message(
(session_id, cell_id),
CellMessage::Delegate {
id,
request,
dispatched_tx,
},
) {
self.pending.lock().await.remove(&id);
pending.disarm();
return Err(err);
}
let dispatched = tokio::select! {
dispatched = dispatched_rx => dispatched.map_err(|_| {
"code-mode cell route closed before dispatching delegate request".to_string()
})?,
_ = self.disconnected.cancelled() => {
self.pending.lock().await.remove(&id);
pending.disarm();
return Err("code-mode client connection closed".to_string());
}
};
if let Err(err) = dispatched {
self.pending.lock().await.remove(&id);
pending.disarm();
return Err(err);
}
tokio::select! {
response = response_rx => {
pending.disarm();
response.map_err(|_| {
"code-mode client closed before returning delegate output".to_string()
})?
}
_ = cancellation_token.cancelled() => {
if self.remove_pending(id).await.is_some() {
let _ = self.send(HostToClient::CancelDelegateRequest { id });
}
pending.disarm();
Err("code mode delegate request cancelled".to_string())
}
_ = self.disconnected.cancelled() => {
self.pending.lock().await.remove(&id);
pending.disarm();
Err("code-mode client connection closed".to_string())
}
}
}
pub(super) async fn complete(
&self,
id: DelegateRequestId,
response: Result<DelegateResponse, String>,
) {
if let Some(pending) = self.remove_pending(id).await {
let _ = pending.response_tx.send(response);
}
}
pub(super) fn start_cell(
self: &Arc<Self>,
session_id: SessionId,
request_id: RequestId,
started: StartedCell,
active_cell_permit: OwnedSemaphorePermit,
received_at: Instant,
) -> oneshot::Receiver<()> {
let (initial_response_sent_tx, initial_response_sent_rx) = oneshot::channel();
let key = (session_id, started.cell_id.clone());
let (messages_tx, messages_rx) = mpsc::channel(CELL_MESSAGE_CAPACITY);
let previous = self
.cell_routes
.lock()
.unwrap_or_else(PoisonError::into_inner)
.insert(key.clone(), CellRoute::Active(messages_tx.clone()));
match previous {
Some(CellRoute::Pending(messages)) => {
for message in messages {
if messages_tx.try_send(message).is_err() {
self.disconnect();
return initial_response_sent_rx;
}
}
}
Some(CellRoute::Active(_)) => {
self.disconnect();
return initial_response_sent_rx;
}
None => {}
}
let peer = Arc::clone(self);
self.spawn_critical("cell forwarding", async move {
drive_cell(
peer,
key,
InitialRequest {
id: request_id,
received_at,
},
started,
messages_rx,
initial_response_sent_tx,
active_cell_permit,
)
.await;
});
initial_response_sent_rx
}
pub(super) fn close_cell(&self, session_id: SessionId, cell_id: CellId) {
let _ = self.route_cell_message((session_id, cell_id), CellMessage::Closed);
}
pub(super) fn disconnect(&self) {
self.disconnected.cancel();
}
pub(super) fn fail(&self, reason: String) {
let mut failure = self.failure.lock().unwrap_or_else(PoisonError::into_inner);
if failure.is_none() {
*failure = Some(reason);
}
drop(failure);
self.disconnect();
}
pub(super) fn failure(&self) -> Option<String> {
self.failure
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone()
}
pub(super) fn is_disconnected(&self) -> bool {
self.disconnected.is_cancelled()
}
pub(super) async fn disconnected(&self) {
self.disconnected.cancelled().await;
}
pub(super) fn disconnection_token(&self) -> CancellationToken {
self.disconnected.clone()
}
pub(super) async fn wait_for_session_cells(&self, session_id: &SessionId) {
loop {
let changed = self.cell_routes_changed.notified();
if !self
.cell_routes
.lock()
.unwrap_or_else(PoisonError::into_inner)
.keys()
.any(|(route_session_id, _)| route_session_id == session_id)
{
return;
}
tokio::select! {
_ = changed => {}
_ = self.disconnected.cancelled() => return,
}
}
}
async fn send_delegate_if_pending(
&self,
id: DelegateRequestId,
session_id: SessionId,
request: DelegateRequest,
dispatched_tx: oneshot::Sender<Result<(), String>>,
) {
let result = {
let mut pending = self.pending.lock().await;
let Some(pending) = pending.get_mut(&id) else {
let _ = dispatched_tx.send(Err(
"code-mode delegate request was cancelled before dispatch".to_string(),
));
return;
};
match self.send(HostToClient::DelegateRequest {
id,
session_id,
request,
}) {
Ok(()) => {
pending.dispatched = true;
Ok(())
}
Err(err) => Err(err.to_string()),
}
};
let _ = dispatched_tx.send(result);
}
fn route_cell_message(
&self,
key: (SessionId, CellId),
message: CellMessage,
) -> Result<(), String> {
use std::collections::hash_map::Entry;
let result = match self
.cell_routes
.lock()
.unwrap_or_else(PoisonError::into_inner)
.entry(key)
{
Entry::Occupied(mut entry) => match entry.get_mut() {
CellRoute::Pending(messages) if messages.len() < CELL_MESSAGE_CAPACITY => {
messages.push_back(message);
Ok(())
}
CellRoute::Pending(_) => Err("code-mode cell message queue is full".to_string()),
CellRoute::Active(sender) => sender
.try_send(message)
.map_err(|_| "code-mode cell message queue is unavailable".to_string()),
},
Entry::Vacant(entry) => {
entry.insert(CellRoute::Pending(VecDeque::from([message])));
Ok(())
}
};
if result.is_err() {
self.disconnect();
}
result
}
async fn remove_pending(&self, id: DelegateRequestId) -> Option<PendingDelegate> {
self.pending.lock().await.remove(&id)
}
pub(super) fn spawn_critical<F>(self: &Arc<Self>, task_name: &'static str, future: F)
where
F: std::future::Future<Output = ()> + Send + 'static,
{
let task = tokio::spawn(future);
let peer = Arc::clone(self);
tokio::spawn(async move {
if let Err(err) = task.await {
peer.fail(format!("code-mode {task_name} task failed: {err}"));
}
});
}
fn send_frame(&self, frame: EncodedFrame) -> Result<(), PeerSendError> {
match self.outgoing_tx.try_send(frame) {
Ok(()) => Ok(()),
Err(mpsc::error::TrySendError::Full(_)) => {
self.disconnect();
Err(PeerSendError::Unavailable(
"code-mode host outgoing queue is full".to_string(),
))
}
Err(mpsc::error::TrySendError::Closed(_)) => {
self.disconnect();
Err(PeerSendError::Unavailable(
"code-mode client connection closed".to_string(),
))
}
}
}
}
async fn drive_cell(
peer: Arc<HostPeer>,
key: (SessionId, CellId),
request: InitialRequest,
started: StartedCell,
mut messages_rx: mpsc::Receiver<CellMessage>,
initial_response_sent_tx: oneshot::Sender<()>,
_active_cell_permit: OwnedSemaphorePermit,
) {
let mut initial_response_sent_tx = Some(initial_response_sent_tx);
let initial_response = started.initial_response();
tokio::pin!(initial_response);
let closed = loop {
tokio::select! {
biased;
result = &mut initial_response => {
// Freeze the request duration before response conversion or delivery.
let code_mode_host_duration = request.received_at.elapsed();
peer.initial_response(
request.id,
result.and_then(|response| {
let response = response.with_code_mode_host_duration(code_mode_host_duration);
WireRuntimeResponse::try_from(response).map_err(|error| error.to_string())
}),
);
if let Some(initial_response_sent_tx) = initial_response_sent_tx.take() {
let _ = initial_response_sent_tx.send(());
}
break false;
}
message = messages_rx.recv() => match message {
Some(CellMessage::Delegate {
id,
request,
dispatched_tx,
}) => {
peer.send_delegate_if_pending(id, key.0.clone(), request, dispatched_tx).await;
}
Some(CellMessage::Closed) | None => break true,
},
_ = peer.disconnected.cancelled() => {
peer.remove_cell_route(&key);
return;
}
}
};
if closed {
let result = initial_response.await;
let code_mode_host_duration = request.received_at.elapsed();
peer.initial_response(
request.id,
result.and_then(|response| {
let response = response.with_code_mode_host_duration(code_mode_host_duration);
WireRuntimeResponse::try_from(response).map_err(|error| error.to_string())
}),
);
if let Some(initial_response_sent_tx) = initial_response_sent_tx.take() {
let _ = initial_response_sent_tx.send(());
}
} else {
loop {
tokio::select! {
message = messages_rx.recv() => match message {
Some(CellMessage::Delegate {
id,
request,
dispatched_tx,
}) => {
peer.send_delegate_if_pending(id, key.0.clone(), request, dispatched_tx).await;
}
Some(CellMessage::Closed) | None => break,
},
_ = peer.disconnected.cancelled() => {
peer.remove_cell_route(&key);
return;
}
}
}
}
let _ = peer.send(HostToClient::CellClosed {
session_id: key.0.clone(),
cell_id: (&key.1).into(),
});
peer.remove_cell_route(&key);
}
impl HostPeer {
fn remove_cell_route(&self, key: &(SessionId, CellId)) {
let removed = self
.cell_routes
.lock()
.unwrap_or_else(PoisonError::into_inner)
.remove(key);
if removed.is_some() {
self.cell_routes_changed.notify_waiters();
}
}
}
pub(super) enum PeerSendError {
Payload(String),
Unavailable(String),
}
impl std::fmt::Display for PeerSendError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Payload(message) | Self::Unavailable(message) => formatter.write_str(message),
}
}
}
struct PendingDelegateRequest {
peer: Arc<HostPeer>,
id: Option<DelegateRequestId>,
}
impl PendingDelegateRequest {
fn new(peer: Arc<HostPeer>, id: DelegateRequestId) -> Self {
Self { peer, id: Some(id) }
}
fn disarm(&mut self) {
self.id = None;
}
}
impl Drop for PendingDelegateRequest {
fn drop(&mut self) {
let Some(id) = self.id.take() else {
return;
};
let peer = Arc::clone(&self.peer);
tokio::spawn(async move {
if let Some(pending) = peer.remove_pending(id).await
&& pending.dispatched
{
let _ = peer.send(HostToClient::CancelDelegateRequest { id });
}
});
}
}
#[cfg(test)]
#[path = "peer_tests.rs"]
mod tests;
-99
View File
@@ -1,99 +0,0 @@
use std::sync::Arc;
use std::time::Duration;
use std::time::Instant;
use codex_code_mode_protocol::CellId;
use codex_code_mode_protocol::RuntimeResponse;
use codex_code_mode_protocol::StartedCell;
use codex_code_mode_protocol::host::DelegateRequest;
use codex_code_mode_protocol::host::MAX_PENDING_DELEGATE_CALLS;
use codex_code_mode_protocol::host::RequestId;
use codex_code_mode_protocol::host::SessionId;
use pretty_assertions::assert_eq;
use tokio::sync::Semaphore;
use tokio::sync::mpsc;
use tokio::sync::oneshot;
use tokio::sync::oneshot::error::TryRecvError;
use tokio_util::sync::CancellationToken;
use super::HostPeer;
fn session_id(value: &str) -> SessionId {
SessionId::new(value).expect("session ID")
}
#[tokio::test]
async fn start_cell_reports_when_initial_response_is_enqueued() {
let (outgoing_tx, mut outgoing_rx) = mpsc::channel(/*max_capacity*/ 4);
let peer = Arc::new(HostPeer::new(outgoing_tx, MAX_PENDING_DELEGATE_CALLS));
let cell_id = CellId::new("cell-1".to_string());
let (response_tx, response_rx) = oneshot::channel();
let started = StartedCell::new(cell_id.clone(), response_rx);
let active_cell_permits = Arc::new(Semaphore::new(/*permits*/ 1));
let active_cell_permit = Arc::clone(&active_cell_permits)
.try_acquire_owned()
.expect("active cell permit");
let mut initial_response_sent = peer.start_cell(
session_id("session-1"),
RequestId::new(/*value*/ 1),
started,
active_cell_permit,
Instant::now(),
);
assert_eq!(initial_response_sent.try_recv(), Err(TryRecvError::Empty));
response_tx
.send(RuntimeResponse::Result {
code_mode_host_duration: None,
cell_id: cell_id.clone(),
content_items: Vec::new(),
result_buffered_for: Duration::ZERO,
error_text: None,
})
.expect("initial response receiver");
initial_response_sent
.await
.expect("initial response completion");
outgoing_rx.recv().await.expect("initial response frame");
assert_eq!(active_cell_permits.available_permits(), 0);
peer.close_cell(session_id("session-1"), cell_id);
let permit = tokio::time::timeout(
Duration::from_secs(1),
Arc::clone(&active_cell_permits).acquire_owned(),
)
.await
.expect("cell permit should be released")
.expect("cell permit semaphore should remain open");
drop(permit);
}
#[tokio::test]
async fn pending_delegate_limit_rejects_call_without_disconnecting() {
let (outgoing_tx, _outgoing_rx) = mpsc::channel(/*max_capacity*/ 1);
let peer = Arc::new(HostPeer::new(outgoing_tx, MAX_PENDING_DELEGATE_CALLS));
let permits = Arc::clone(&peer.delegate_permits)
.acquire_many_owned(MAX_PENDING_DELEGATE_CALLS as u32)
.await
.expect("delegate permits");
let result = peer
.call(
session_id("session-1"),
DelegateRequest::Notify {
call_id: "call-1".to_string(),
cell_id: CellId::new("cell-1".to_string()).into(),
text: "hello".to_string(),
},
CancellationToken::new(),
)
.await;
assert_eq!(
result,
Err("code-mode host has too many pending delegate calls".to_string())
);
assert!(!peer.is_disconnected());
drop(permits);
}
+2 -8
View File
@@ -5,19 +5,16 @@ use anyhow::Result;
use crate::grpc_transport;
/// The default transport retains the standalone host's original stdio behavior.
pub const DEFAULT_LISTEN_URL: &str = "stdio";
pub const DEFAULT_LISTEN_URL: &str = "grpc+stdio://";
#[derive(Debug, Clone, Eq, PartialEq)]
enum ListenTransport {
Stdio,
GrpcStdio,
Grpc(SocketAddr),
}
pub(crate) async fn run_transport(listen_url: &str, host: crate::GrpcCodeModeHost) -> Result<()> {
match parse_listen_url(listen_url)? {
ListenTransport::Stdio => crate::run_stdio_with_tool_preloads(host.tool_preloads).await,
ListenTransport::GrpcStdio => crate::grpc_stdio::run(host).await,
ListenTransport::Grpc(bind_address) => {
grpc_transport::run_tcp_listener(bind_address, host).await
@@ -26,12 +23,9 @@ pub(crate) async fn run_transport(listen_url: &str, host: crate::GrpcCodeModeHos
}
fn parse_listen_url(listen_url: &str) -> Result<ListenTransport> {
if listen_url == "grpc+stdio://" {
if matches!(listen_url, "grpc+stdio://" | "stdio" | "stdio://") {
return Ok(ListenTransport::GrpcStdio);
}
if matches!(listen_url, "stdio" | "stdio://") {
return Ok(ListenTransport::Stdio);
}
if let Some(socket_addr) = listen_url.strip_prefix("grpc://") {
return socket_addr
@@ -35,11 +35,11 @@ async fn grpc_listener_disables_nagle() {
fn parse_listen_url_accepts_stdio_transports() {
assert_eq!(
parse_listen_url("stdio").expect("stdio listen URL should parse"),
ListenTransport::Stdio
ListenTransport::GrpcStdio
);
assert_eq!(
parse_listen_url("stdio://").expect("stdio URL should parse"),
ListenTransport::Stdio
ListenTransport::GrpcStdio
);
assert_eq!(
parse_listen_url("grpc+stdio://").expect("gRPC stdio URL should parse"),