mirror of
https://github.com/openai/codex.git
synced 2026-10-19 17:28:46 +00:00
Add a dual-WebSocket transport for code mode (#36812)
## Why Large nested-tool callbacks can occupy a WebSocket and delay unrelated session operations on the same code-mode connection. ## What changed - Negotiate the optional `dual-websocket-v1` capability and pair a second, token-scoped WebSocket with the control connection. - Route nested-tool callbacks and their results over the bulk socket while keeping session operations, notifications, and execution responses on the control socket. Reject messages sent on the wrong lane. - Preserve the single-connection transport when the capability is unavailable, and bound pairing, queued callbacks, and deferred cross-socket messages. - Defer callbacks that arrive before their execution-started response, and return delegate errors without disconnecting the connection. ## Testing Add protocol, transport, driver, and WebSocket integration coverage for capability negotiation, lane routing, pairing failures, out-of-order messages, and progress during large concurrent tool results. GitOrigin-RevId: fa4504653e7cbf3c4ec930ae57aa0a41345bad66
This commit is contained in:
Channing Conger
committed by
copyberry
copyberry
parent
b258c028fe
commit
60c722e075
@@ -27,6 +27,7 @@ tokio = { workspace = true, features = ["io-std", "io-util", "macros", "net", "p
|
||||
tokio-util = { workspace = true, features = ["rt"] }
|
||||
tracing = { workspace = true }
|
||||
tracing-subscriber = { workspace = true }
|
||||
uuid = { workspace = true, features = ["v4"] }
|
||||
|
||||
[dev-dependencies]
|
||||
codex-code-mode = { workspace = true }
|
||||
|
||||
@@ -12,6 +12,7 @@ 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::DUAL_WEBSOCKET_CAPABILITY;
|
||||
use codex_code_mode_protocol::host::EncodedFrame;
|
||||
use codex_code_mode_protocol::host::FramedReader;
|
||||
use codex_code_mode_protocol::host::FramedWriter;
|
||||
@@ -33,6 +34,7 @@ use tokio::sync::mpsc;
|
||||
use tokio::sync::oneshot;
|
||||
use tokio_util::sync::CancellationToken;
|
||||
use tokio_util::task::TaskTracker;
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::HostState;
|
||||
use super::MAX_ACTIVE_CELLS;
|
||||
@@ -41,8 +43,12 @@ use super::MAX_RECENT_REQUEST_IDS;
|
||||
use super::RequestKind;
|
||||
use super::RequestRegistry;
|
||||
use super::SeenSessionIds;
|
||||
use super::negotiate;
|
||||
use super::peer::HostPeer;
|
||||
use super::run;
|
||||
use super::transport::BulkConnectionRegistry;
|
||||
use super::transport::ConnectionReader;
|
||||
use super::transport::ConnectionWriter;
|
||||
|
||||
fn client_hello(
|
||||
versions: impl IntoIterator<Item = ProtocolVersion>,
|
||||
@@ -250,6 +256,107 @@ impl AsyncWrite for BlockingWriter {
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn failed_host_hello_removes_the_bulk_pairing_reservation() {
|
||||
let (host_reader, client_writer) = tokio::io::duplex(/*max_buf_size*/ 4096);
|
||||
let capability = Capability::new(DUAL_WEBSOCKET_CAPABILITY).expect("dual websocket capability");
|
||||
let hello = ClientToHost::ClientHello(
|
||||
ClientHello::new(
|
||||
SupportedProtocolVersions::try_new([ProtocolVersion::V1]).expect("supported versions"),
|
||||
CapabilitySet::empty(),
|
||||
CapabilitySet::try_new([capability]).expect("optional capabilities"),
|
||||
)
|
||||
.expect("client hello"),
|
||||
);
|
||||
FramedWriter::new(client_writer)
|
||||
.write(&hello)
|
||||
.await
|
||||
.expect("write client hello");
|
||||
|
||||
let bytes = Arc::new(Mutex::new(Vec::new()));
|
||||
let registry = BulkConnectionRegistry::default();
|
||||
let mut reader = ConnectionReader::from_reader(host_reader);
|
||||
let mut writer = ConnectionWriter::from_writer(FailingHandshakeWriter {
|
||||
bytes: Arc::clone(&bytes),
|
||||
});
|
||||
let result = negotiate(&mut reader, &mut writer, Some(®istry)).await;
|
||||
assert!(result.is_err());
|
||||
|
||||
let message = EncodedFrame::decode_framed::<HostToClient>(
|
||||
&bytes.lock().unwrap_or_else(PoisonError::into_inner),
|
||||
)
|
||||
.expect("decode failed host hello");
|
||||
let HostToClient::HostHello(hello) = message else {
|
||||
panic!("expected a host hello");
|
||||
};
|
||||
let token = hello
|
||||
.bulk_connection_token()
|
||||
.expect("dual websocket pairing token");
|
||||
let token = Uuid::parse_str(token).expect("UUID pairing token");
|
||||
assert!(registry.remove(token).is_none());
|
||||
}
|
||||
|
||||
struct FailingHandshakeWriter {
|
||||
bytes: Arc<Mutex<Vec<u8>>>,
|
||||
}
|
||||
|
||||
impl AsyncWrite for FailingHandshakeWriter {
|
||||
fn poll_write(
|
||||
self: Pin<&mut Self>,
|
||||
_cx: &mut Context<'_>,
|
||||
bytes: &[u8],
|
||||
) -> Poll<std::io::Result<usize>> {
|
||||
self.bytes
|
||||
.lock()
|
||||
.unwrap_or_else(PoisonError::into_inner)
|
||||
.extend_from_slice(bytes);
|
||||
Poll::Ready(Ok(bytes.len()))
|
||||
}
|
||||
|
||||
fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
|
||||
Poll::Ready(Err(std::io::Error::other("host hello write failed")))
|
||||
}
|
||||
|
||||
fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
|
||||
Poll::Ready(Ok(()))
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn optional_dual_websocket_capability_falls_back_to_a_single_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);
|
||||
let capability = Capability::new(DUAL_WEBSOCKET_CAPABILITY).expect("dual websocket capability");
|
||||
|
||||
writer
|
||||
.write(&ClientToHost::ClientHello(
|
||||
ClientHello::new(
|
||||
SupportedProtocolVersions::try_new([ProtocolVersion::V1])
|
||||
.expect("supported versions"),
|
||||
CapabilitySet::empty(),
|
||||
CapabilitySet::try_new([capability]).expect("optional capabilities"),
|
||||
)
|
||||
.expect("client hello"),
|
||||
))
|
||||
.await
|
||||
.expect("write hello");
|
||||
assert_eq!(
|
||||
reader.read::<HostToClient>().await.expect("host hello"),
|
||||
Some(HostToClient::HostHello(HostHello::new(
|
||||
ProtocolVersion::V1,
|
||||
CapabilitySet::empty(),
|
||||
)))
|
||||
);
|
||||
|
||||
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);
|
||||
@@ -395,7 +502,7 @@ async fn session_id_cannot_be_reused_after_shutdown() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn request_cancellation_tombstones_are_bounded() {
|
||||
fn request_history_is_bounded() {
|
||||
let mut requests = RequestRegistry::default();
|
||||
let duplicate = request_id(/*value*/ -1);
|
||||
requests
|
||||
@@ -411,10 +518,6 @@ fn request_cancellation_tombstones_are_bounded() {
|
||||
requests.cancel(id);
|
||||
requests.finish(id);
|
||||
}
|
||||
for value in 10_000..20_000 {
|
||||
requests.cancel(request_id(value));
|
||||
}
|
||||
|
||||
assert!(requests.active.is_empty());
|
||||
assert_eq!(requests.recent.len(), MAX_RECENT_REQUEST_IDS);
|
||||
assert_eq!(requests.recent_order.len(), MAX_RECENT_REQUEST_IDS);
|
||||
|
||||
@@ -10,18 +10,22 @@ use std::time::Duration;
|
||||
|
||||
use anyhow::Context;
|
||||
use anyhow::Result;
|
||||
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::DUAL_WEBSOCKET_CAPABILITY;
|
||||
use codex_code_mode_protocol::host::EncodedFrame;
|
||||
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::MAX_PENDING_DELEGATE_CALLS;
|
||||
use codex_code_mode_protocol::host::ProtocolVersion;
|
||||
use codex_code_mode_protocol::host::RequestId;
|
||||
use codex_code_mode_protocol::host::SessionId;
|
||||
use codex_code_mode_protocol::host::SupportedProtocolVersions;
|
||||
use codex_code_mode_protocol::host::TransportLane;
|
||||
use codex_code_mode_runtime::InProcessCodeModeSession;
|
||||
use tokio::io::AsyncRead;
|
||||
use tokio::io::AsyncWrite;
|
||||
@@ -32,6 +36,8 @@ use tokio_util::task::TaskTracker;
|
||||
|
||||
use self::delegate::RemoteDelegate;
|
||||
use self::peer::HostPeer;
|
||||
use self::transport::BulkConnectionRegistration;
|
||||
use self::transport::BulkConnectionRegistry;
|
||||
use self::transport::ConnectionReader;
|
||||
use self::transport::ConnectionWriter;
|
||||
|
||||
@@ -46,6 +52,14 @@ const MAX_ACTIVE_CELLS: usize = 128;
|
||||
const MAX_RECENT_REQUEST_IDS: usize = 4096;
|
||||
const MAX_RECENT_SESSION_IDS: usize = 4096;
|
||||
const SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
const OUTGOING_CHANNEL_CAPACITY: usize = 128;
|
||||
const BULK_PAIRING_TIMEOUT: Duration = Duration::from_secs(10);
|
||||
|
||||
enum NegotiatedConnection {
|
||||
Rejected,
|
||||
Single,
|
||||
Dual(BulkConnectionRegistration),
|
||||
}
|
||||
|
||||
struct HostLimits {
|
||||
request_permits: Arc<Semaphore>,
|
||||
@@ -81,6 +95,7 @@ where
|
||||
ConnectionReader::from_reader(reader),
|
||||
ConnectionWriter::from_writer(writer),
|
||||
Arc::new(HostLimits::new()),
|
||||
/*bulk_connections*/ None,
|
||||
)
|
||||
.await
|
||||
}
|
||||
@@ -89,13 +104,39 @@ async fn run_connection(
|
||||
mut reader: ConnectionReader,
|
||||
mut writer: ConnectionWriter,
|
||||
limits: Arc<HostLimits>,
|
||||
bulk_connections: Option<BulkConnectionRegistry>,
|
||||
) -> Result<()> {
|
||||
if !negotiate(&mut reader, &mut writer).await? {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let (outgoing_tx, mut outgoing_rx) = mpsc::channel::<EncodedFrame>(/*max_capacity*/ 128);
|
||||
let peer = Arc::new(HostPeer::new(outgoing_tx));
|
||||
let negotiated = negotiate(&mut reader, &mut writer, bulk_connections.as_ref()).await?;
|
||||
let bulk_connection = match negotiated {
|
||||
NegotiatedConnection::Rejected => return Ok(()),
|
||||
NegotiatedConnection::Single => None,
|
||||
NegotiatedConnection::Dual(mut registration) => {
|
||||
match tokio::time::timeout(BULK_PAIRING_TIMEOUT, registration.receive()).await {
|
||||
Ok(Ok(connection)) => Some(connection),
|
||||
Ok(Err(_)) => {
|
||||
anyhow::bail!("code-mode host bulk websocket pairing was abandoned");
|
||||
}
|
||||
Err(_) => {
|
||||
anyhow::bail!("timed out pairing code-mode host bulk websocket");
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
let (mut bulk_reader, bulk_writer) = match bulk_connection {
|
||||
Some(connection) => (Some(connection.reader), Some(connection.writer)),
|
||||
None => (None, None),
|
||||
};
|
||||
let (outgoing_tx, outgoing_rx) = mpsc::channel::<EncodedFrame>(OUTGOING_CHANNEL_CAPACITY);
|
||||
let (bulk_tx, bulk_rx) = if bulk_writer.is_some() {
|
||||
let (sender, receiver) = mpsc::channel::<EncodedFrame>(MAX_PENDING_DELEGATE_CALLS);
|
||||
(Some(sender), Some(receiver))
|
||||
} else {
|
||||
(None, None)
|
||||
};
|
||||
let peer = match bulk_tx {
|
||||
Some(sender) => Arc::new(HostPeer::new(outgoing_tx).with_bulk_sender(sender)),
|
||||
None => Arc::new(HostPeer::new(outgoing_tx)),
|
||||
};
|
||||
let state = Arc::new(HostState {
|
||||
sessions: Mutex::new(HashMap::new()),
|
||||
seen_session_ids: Mutex::new(SeenSessionIds::default()),
|
||||
@@ -108,25 +149,14 @@ async fn run_connection(
|
||||
});
|
||||
let writer_disconnected = peer.disconnection_token();
|
||||
let writer_task = tokio::spawn(async move {
|
||||
loop {
|
||||
tokio::select! {
|
||||
_ = writer_disconnected.cancelled() => return Ok::<(), anyhow::Error>(()),
|
||||
frame = outgoing_rx.recv() => {
|
||||
let Some(frame) = frame else {
|
||||
return Ok(());
|
||||
};
|
||||
let result = tokio::select! {
|
||||
_ = writer_disconnected.cancelled() => return Ok(()),
|
||||
result = writer.write_frame(frame) => result,
|
||||
};
|
||||
if let Err(err) = result {
|
||||
return Err(
|
||||
anyhow::Error::new(err)
|
||||
.context("failed to write code-mode host message")
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
if let (Some(bulk_writer), Some(bulk_rx)) = (bulk_writer, bulk_rx) {
|
||||
tokio::try_join!(
|
||||
drive_writer(writer, outgoing_rx, writer_disconnected.clone()),
|
||||
drive_writer(bulk_writer, bulk_rx, writer_disconnected)
|
||||
)?;
|
||||
Ok(())
|
||||
} else {
|
||||
drive_writer(writer, outgoing_rx, writer_disconnected).await
|
||||
}
|
||||
});
|
||||
let writer_peer = Arc::clone(&peer);
|
||||
@@ -147,14 +177,30 @@ async fn run_connection(
|
||||
|
||||
let input_result = async {
|
||||
loop {
|
||||
let message = tokio::select! {
|
||||
let (message, lane) = tokio::select! {
|
||||
// Session operations and shutdown must make progress even when bulk callbacks are ready.
|
||||
biased;
|
||||
_ = peer.disconnected() => break,
|
||||
message = reader.read() => message
|
||||
.context("failed to read code-mode client message")?,
|
||||
message = reader.read() => (
|
||||
message.context("failed to read code-mode client control message")?,
|
||||
TransportLane::Control,
|
||||
),
|
||||
message = async {
|
||||
match &mut bulk_reader {
|
||||
Some(reader) => reader.read().await,
|
||||
None => Ok(None),
|
||||
}
|
||||
}, if bulk_reader.is_some() => (
|
||||
message.context("failed to read code-mode client bulk message")?,
|
||||
TransportLane::Bulk,
|
||||
),
|
||||
};
|
||||
let Some(message) = message else {
|
||||
break;
|
||||
};
|
||||
if bulk_reader.is_some() && !message.allows_transport_lane(lane) {
|
||||
anyhow::bail!("code-mode client sent a message on the wrong websocket lane");
|
||||
}
|
||||
match message {
|
||||
ClientToHost::ClientHello(_) => {
|
||||
anyhow::bail!("received a second code-mode client hello");
|
||||
@@ -195,13 +241,40 @@ async fn run_connection(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn negotiate(reader: &mut ConnectionReader, writer: &mut ConnectionWriter) -> Result<bool> {
|
||||
async fn drive_writer(
|
||||
mut writer: ConnectionWriter,
|
||||
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(
|
||||
reader: &mut ConnectionReader,
|
||||
writer: &mut ConnectionWriter,
|
||||
bulk_connections: Option<&BulkConnectionRegistry>,
|
||||
) -> Result<NegotiatedConnection> {
|
||||
let Some(first_message) = reader
|
||||
.read()
|
||||
.await
|
||||
.context("failed to read code-mode client hello")?
|
||||
else {
|
||||
return Ok(false);
|
||||
return Ok(NegotiatedConnection::Rejected);
|
||||
};
|
||||
let ClientToHost::ClientHello(client_hello) = first_message else {
|
||||
writer
|
||||
@@ -212,7 +285,7 @@ async fn negotiate(reader: &mut ConnectionReader, writer: &mut ConnectionWriter)
|
||||
})
|
||||
.await
|
||||
.context("failed to reject invalid code-mode client hello")?;
|
||||
return Ok(false);
|
||||
return Ok(NegotiatedConnection::Rejected);
|
||||
};
|
||||
|
||||
let supported_versions = SupportedProtocolVersions::try_new([ProtocolVersion::V1])?;
|
||||
@@ -226,10 +299,26 @@ async fn negotiate(reader: &mut ConnectionReader, writer: &mut ConnectionWriter)
|
||||
})
|
||||
.await
|
||||
.context("failed to reject incompatible code-mode client")?;
|
||||
return Ok(false);
|
||||
return Ok(NegotiatedConnection::Rejected);
|
||||
}
|
||||
|
||||
let host_capabilities = CapabilitySet::empty();
|
||||
let dual_capability = Capability::new(DUAL_WEBSOCKET_CAPABILITY)?;
|
||||
let dual_requested = client_hello
|
||||
.required_capabilities()
|
||||
.contains(&dual_capability)
|
||||
|| client_hello
|
||||
.optional_capabilities()
|
||||
.contains(&dual_capability);
|
||||
let registration = if dual_requested {
|
||||
bulk_connections.and_then(BulkConnectionRegistry::reserve)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let host_capabilities = if registration.is_some() {
|
||||
CapabilitySet::try_new([dual_capability])?
|
||||
} else {
|
||||
CapabilitySet::empty()
|
||||
};
|
||||
if let Some(capability) = client_hello
|
||||
.required_capabilities()
|
||||
.iter()
|
||||
@@ -243,17 +332,26 @@ async fn negotiate(reader: &mut ConnectionReader, writer: &mut ConnectionWriter)
|
||||
})
|
||||
.await
|
||||
.context("failed to reject unsupported code-mode capability")?;
|
||||
return Ok(false);
|
||||
return Ok(NegotiatedConnection::Rejected);
|
||||
}
|
||||
|
||||
let (hello, negotiated) = if let Some(registration) = registration {
|
||||
(
|
||||
HostHello::new(ProtocolVersion::V1, host_capabilities)
|
||||
.with_bulk_connection_token(registration.token().to_string()),
|
||||
NegotiatedConnection::Dual(registration),
|
||||
)
|
||||
} else {
|
||||
(
|
||||
HostHello::new(ProtocolVersion::V1, host_capabilities),
|
||||
NegotiatedConnection::Single,
|
||||
)
|
||||
};
|
||||
writer
|
||||
.write(&HostToClient::HostHello(HostHello::new(
|
||||
ProtocolVersion::V1,
|
||||
host_capabilities,
|
||||
)))
|
||||
.write(&HostToClient::HostHello(hello))
|
||||
.await
|
||||
.context("failed to write code-mode host hello")?;
|
||||
Ok(true)
|
||||
Ok(negotiated)
|
||||
}
|
||||
|
||||
struct HostState {
|
||||
@@ -584,7 +682,7 @@ impl RequestRegistry {
|
||||
Ok(cancellation)
|
||||
}
|
||||
|
||||
fn cancel(&self, request_id: RequestId) {
|
||||
fn cancel(&mut self, request_id: RequestId) {
|
||||
if let Some(request) = self.active.get(&request_id)
|
||||
&& request.kind.is_cancellable()
|
||||
{
|
||||
|
||||
@@ -16,6 +16,7 @@ use codex_code_mode_protocol::host::HostToClient;
|
||||
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 codex_code_mode_protocol::host::TransportLane;
|
||||
use codex_code_mode_protocol::host::WireResult;
|
||||
use tokio::sync::Mutex;
|
||||
use tokio::sync::Notify;
|
||||
@@ -29,6 +30,7 @@ const CELL_MESSAGE_CAPACITY: usize = 128;
|
||||
|
||||
pub(super) struct HostPeer {
|
||||
outgoing_tx: mpsc::Sender<EncodedFrame>,
|
||||
bulk_tx: Option<mpsc::Sender<EncodedFrame>>,
|
||||
pending: Mutex<HashMap<DelegateRequestId, PendingDelegate>>,
|
||||
delegate_permits: Arc<Semaphore>,
|
||||
cell_routes: StdMutex<HashMap<(SessionId, CellId), CellRoute>>,
|
||||
@@ -62,6 +64,7 @@ impl HostPeer {
|
||||
pub(super) fn new(outgoing_tx: mpsc::Sender<EncodedFrame>) -> Self {
|
||||
Self {
|
||||
outgoing_tx,
|
||||
bulk_tx: None,
|
||||
pending: Mutex::new(HashMap::new()),
|
||||
delegate_permits: Arc::new(Semaphore::new(MAX_PENDING_DELEGATE_CALLS)),
|
||||
cell_routes: StdMutex::new(HashMap::new()),
|
||||
@@ -72,10 +75,16 @@ impl HostPeer {
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn with_bulk_sender(mut self, bulk_tx: mpsc::Sender<EncodedFrame>) -> Self {
|
||||
self.bulk_tx = Some(bulk_tx);
|
||||
self
|
||||
}
|
||||
|
||||
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)
|
||||
let lane = message.transport_lane();
|
||||
self.send_frame(frame, lane)
|
||||
}
|
||||
|
||||
pub(super) fn respond(
|
||||
@@ -389,8 +398,12 @@ impl HostPeer {
|
||||
});
|
||||
}
|
||||
|
||||
fn send_frame(&self, frame: EncodedFrame) -> Result<(), PeerSendError> {
|
||||
match self.outgoing_tx.try_send(frame) {
|
||||
fn send_frame(&self, frame: EncodedFrame, lane: TransportLane) -> Result<(), PeerSendError> {
|
||||
let sender = match lane {
|
||||
TransportLane::Control => &self.outgoing_tx,
|
||||
TransportLane::Bulk => self.bulk_tx.as_ref().unwrap_or(&self.outgoing_tx),
|
||||
};
|
||||
match sender.try_send(frame) {
|
||||
Ok(()) => Ok(()),
|
||||
Err(mpsc::error::TrySendError::Full(_)) => {
|
||||
self.disconnect();
|
||||
|
||||
@@ -1,13 +1,17 @@
|
||||
use std::collections::HashMap;
|
||||
use std::io;
|
||||
use std::io::Write as _;
|
||||
use std::net::SocketAddr;
|
||||
use std::sync::Arc;
|
||||
use std::sync::Mutex;
|
||||
use std::sync::PoisonError;
|
||||
|
||||
use anyhow::Context;
|
||||
use anyhow::Result;
|
||||
use axum::Router;
|
||||
use axum::body::Body;
|
||||
use axum::extract::ConnectInfo;
|
||||
use axum::extract::Path;
|
||||
use axum::extract::State;
|
||||
use axum::extract::ws::Message;
|
||||
use axum::extract::ws::WebSocket;
|
||||
@@ -34,15 +38,19 @@ use futures::stream::SplitStream;
|
||||
use tokio::io::AsyncRead;
|
||||
use tokio::io::AsyncWrite;
|
||||
use tokio::net::TcpListener;
|
||||
use tokio::sync::oneshot;
|
||||
use tracing::info;
|
||||
use tracing::warn;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::HostLimits;
|
||||
use crate::MAX_IN_FLIGHT_REQUESTS;
|
||||
|
||||
/// The default transport retains the standalone host's original stdio behavior.
|
||||
pub const DEFAULT_LISTEN_URL: &str = "stdio";
|
||||
|
||||
const MAX_WEBSOCKET_FRAME_BYTES: usize = MAX_FRAME_BYTES + std::mem::size_of::<u32>();
|
||||
const MAX_PENDING_BULK_CONNECTIONS: usize = MAX_IN_FLIGHT_REQUESTS;
|
||||
|
||||
type BoxedReader = Box<dyn AsyncRead + Send + Unpin>;
|
||||
type BoxedWriter = Box<dyn AsyncWrite + Send + Unpin>;
|
||||
@@ -66,6 +74,64 @@ pub(crate) enum ConnectionWriter {
|
||||
#[derive(Clone)]
|
||||
struct WebSocketListenerState {
|
||||
limits: Arc<HostLimits>,
|
||||
bulk_connections: BulkConnectionRegistry,
|
||||
}
|
||||
|
||||
pub(crate) struct BulkConnection {
|
||||
pub(crate) reader: ConnectionReader,
|
||||
pub(crate) writer: ConnectionWriter,
|
||||
}
|
||||
|
||||
#[derive(Clone, Default)]
|
||||
pub(crate) struct BulkConnectionRegistry {
|
||||
pending: Arc<Mutex<HashMap<Uuid, oneshot::Sender<BulkConnection>>>>,
|
||||
}
|
||||
|
||||
pub(crate) struct BulkConnectionRegistration {
|
||||
registry: BulkConnectionRegistry,
|
||||
token: Uuid,
|
||||
receiver: oneshot::Receiver<BulkConnection>,
|
||||
}
|
||||
|
||||
impl BulkConnectionRegistry {
|
||||
pub(crate) fn reserve(&self) -> Option<BulkConnectionRegistration> {
|
||||
let mut pending = self.pending.lock().unwrap_or_else(PoisonError::into_inner);
|
||||
if pending.len() >= MAX_PENDING_BULK_CONNECTIONS {
|
||||
return None;
|
||||
}
|
||||
|
||||
let token = Uuid::new_v4();
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
pending.insert(token, sender);
|
||||
Some(BulkConnectionRegistration {
|
||||
registry: self.clone(),
|
||||
token,
|
||||
receiver,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn remove(&self, token: Uuid) -> Option<oneshot::Sender<BulkConnection>> {
|
||||
self.pending
|
||||
.lock()
|
||||
.unwrap_or_else(PoisonError::into_inner)
|
||||
.remove(&token)
|
||||
}
|
||||
}
|
||||
|
||||
impl BulkConnectionRegistration {
|
||||
pub(crate) fn token(&self) -> Uuid {
|
||||
self.token
|
||||
}
|
||||
|
||||
pub(crate) async fn receive(&mut self) -> Result<BulkConnection, oneshot::error::RecvError> {
|
||||
(&mut self.receiver).await
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for BulkConnectionRegistration {
|
||||
fn drop(&mut self) {
|
||||
self.registry.remove(self.token);
|
||||
}
|
||||
}
|
||||
|
||||
impl ConnectionReader {
|
||||
@@ -165,6 +231,7 @@ async fn run_websocket_listener(bind_address: SocketAddr) -> Result<()> {
|
||||
.context("failed to read code-mode host websocket listen address")?;
|
||||
let state = WebSocketListenerState {
|
||||
limits: Arc::new(HostLimits::new()),
|
||||
bulk_connections: BulkConnectionRegistry::default(),
|
||||
};
|
||||
info!("codex-code-mode-host listening on ws://{local_addr}");
|
||||
println!("ws://{local_addr}");
|
||||
@@ -174,6 +241,7 @@ async fn run_websocket_listener(bind_address: SocketAddr) -> Result<()> {
|
||||
|
||||
let router = Router::new()
|
||||
.route("/", any(websocket_upgrade_handler))
|
||||
.route("/bulk/{token}", any(bulk_websocket_upgrade_handler))
|
||||
.route("/readyz", get(readiness_handler))
|
||||
.layer(middleware::from_fn(reject_requests_with_origin_header))
|
||||
.with_state(state);
|
||||
@@ -220,6 +288,7 @@ async fn websocket_upgrade_handler(
|
||||
ConnectionReader::WebSocket(reader),
|
||||
ConnectionWriter::WebSocket(writer),
|
||||
state.limits,
|
||||
Some(state.bulk_connections),
|
||||
)
|
||||
.await
|
||||
{
|
||||
@@ -228,6 +297,38 @@ async fn websocket_upgrade_handler(
|
||||
})
|
||||
}
|
||||
|
||||
async fn bulk_websocket_upgrade_handler(
|
||||
websocket: WebSocketUpgrade,
|
||||
Path(token): Path<String>,
|
||||
ConnectInfo(peer_addr): ConnectInfo<SocketAddr>,
|
||||
State(state): State<WebSocketListenerState>,
|
||||
) -> Response {
|
||||
let Ok(token) = Uuid::parse_str(&token) else {
|
||||
return StatusCode::NOT_FOUND.into_response();
|
||||
};
|
||||
let Some(pending) = state.bulk_connections.remove(token) else {
|
||||
return StatusCode::NOT_FOUND.into_response();
|
||||
};
|
||||
|
||||
websocket
|
||||
.max_frame_size(MAX_WEBSOCKET_FRAME_BYTES)
|
||||
.max_message_size(MAX_WEBSOCKET_FRAME_BYTES)
|
||||
.on_upgrade(move |stream| async move {
|
||||
info!(%peer_addr, "code-mode host bulk websocket client connected");
|
||||
let (writer, reader) = stream.split();
|
||||
if pending
|
||||
.send(BulkConnection {
|
||||
reader: ConnectionReader::WebSocket(reader),
|
||||
writer: ConnectionWriter::WebSocket(writer),
|
||||
})
|
||||
.is_err()
|
||||
{
|
||||
warn!(%peer_addr, "code-mode host bulk websocket pairing expired");
|
||||
}
|
||||
})
|
||||
.into_response()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "transport_tests.rs"]
|
||||
mod tests;
|
||||
|
||||
@@ -2,9 +2,34 @@ use std::net::SocketAddr;
|
||||
|
||||
use pretty_assertions::assert_eq;
|
||||
|
||||
use super::BulkConnectionRegistry;
|
||||
use super::ListenTransport;
|
||||
use super::MAX_PENDING_BULK_CONNECTIONS;
|
||||
use super::parse_listen_url;
|
||||
|
||||
#[test]
|
||||
fn bulk_connection_registration_cleans_up_when_dropped() {
|
||||
let registry = BulkConnectionRegistry::default();
|
||||
let registration = registry.reserve().expect("bulk connection registration");
|
||||
let token = registration.token();
|
||||
|
||||
drop(registration);
|
||||
|
||||
assert!(registry.remove(token).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_connection_registrations_are_bounded_and_released() {
|
||||
let registry = BulkConnectionRegistry::default();
|
||||
let mut registrations = (0..MAX_PENDING_BULK_CONNECTIONS)
|
||||
.map(|_| registry.reserve().expect("bulk connection registration"))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
assert!(registry.reserve().is_none());
|
||||
drop(registrations.pop());
|
||||
assert!(registry.reserve().is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_listen_url_accepts_stdio_transports() {
|
||||
assert_eq!(
|
||||
|
||||
@@ -1,12 +1,27 @@
|
||||
use std::process::Stdio;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use anyhow::Context;
|
||||
use anyhow::Result;
|
||||
use codex_code_mode::CellId;
|
||||
use codex_code_mode::CodeModeNestedToolCall;
|
||||
use codex_code_mode::CodeModeSessionDelegate;
|
||||
use codex_code_mode::CodeModeSessionProvider;
|
||||
use codex_code_mode::CodeModeToolKind;
|
||||
use codex_code_mode::ExecuteRequest;
|
||||
use codex_code_mode::FunctionCallOutputContentItem;
|
||||
use codex_code_mode::NoopCodeModeSessionDelegate;
|
||||
use codex_code_mode::NotificationFuture;
|
||||
use codex_code_mode::RuntimeResponse;
|
||||
use codex_code_mode::ToolDefinition;
|
||||
use codex_code_mode::ToolInvocationFuture;
|
||||
use codex_code_mode::WebSocketCodeModeSessionProvider;
|
||||
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::DUAL_WEBSOCKET_CAPABILITY;
|
||||
use codex_code_mode_protocol::host::DelegateRequest;
|
||||
use codex_code_mode_protocol::host::DelegateResponse;
|
||||
use codex_code_mode_protocol::host::EncodedFrame;
|
||||
@@ -26,6 +41,8 @@ use codex_code_mode_protocol::host::WireRuntimeResponse;
|
||||
use codex_code_mode_protocol::host::WireToolDefinition;
|
||||
use codex_code_mode_protocol::host::WireToolKind;
|
||||
use codex_code_mode_protocol::host::WireToolName;
|
||||
use codex_code_mode_protocol::host::WireWaitRequest;
|
||||
use codex_protocol::ToolName;
|
||||
use futures::SinkExt;
|
||||
use futures::StreamExt;
|
||||
use pretty_assertions::assert_eq;
|
||||
@@ -37,6 +54,7 @@ use tokio::io::BufReader;
|
||||
use tokio::net::TcpStream;
|
||||
use tokio::process::Child;
|
||||
use tokio::process::Command;
|
||||
use tokio::sync::Semaphore;
|
||||
use tokio::time::timeout;
|
||||
use tokio_tungstenite::MaybeTlsStream;
|
||||
use tokio_tungstenite::WebSocketStream;
|
||||
@@ -49,6 +67,8 @@ use tokio_tungstenite::tungstenite::http::HeaderValue;
|
||||
use tokio_tungstenite::tungstenite::http::StatusCode;
|
||||
use tokio_tungstenite::tungstenite::http::header::ORIGIN;
|
||||
use tokio_tungstenite::tungstenite::protocol::WebSocketConfig;
|
||||
use tokio_util::sync::CancellationToken;
|
||||
use uuid::Uuid;
|
||||
|
||||
const TEST_TIMEOUT: Duration = Duration::from_secs(10);
|
||||
const MAX_WEBSOCKET_FRAME_BYTES: usize = MAX_FRAME_BYTES + std::mem::size_of::<u32>();
|
||||
@@ -62,6 +82,43 @@ struct HostClient {
|
||||
websocket: WebSocketStream<MaybeTlsStream<TcpStream>>,
|
||||
}
|
||||
|
||||
struct LargeToolResultDelegate {
|
||||
started: Semaphore,
|
||||
release: Semaphore,
|
||||
}
|
||||
|
||||
impl CodeModeSessionDelegate for LargeToolResultDelegate {
|
||||
fn invoke_tool<'a>(
|
||||
&'a self,
|
||||
invocation: CodeModeNestedToolCall,
|
||||
_cancellation_token: CancellationToken,
|
||||
) -> ToolInvocationFuture<'a> {
|
||||
Box::pin(async move {
|
||||
assert_eq!(invocation.tool_name, ToolName::plain("large"));
|
||||
self.started.add_permits(1);
|
||||
let permit = self
|
||||
.release
|
||||
.acquire()
|
||||
.await
|
||||
.map_err(|_| "large tool release closed".to_string())?;
|
||||
permit.forget();
|
||||
Ok(json!({ "value": "x".repeat(8 * 1024 * 1024) }))
|
||||
})
|
||||
}
|
||||
|
||||
fn notify<'a>(
|
||||
&'a self,
|
||||
_call_id: String,
|
||||
_cell_id: CellId,
|
||||
_text: String,
|
||||
_cancellation_token: CancellationToken,
|
||||
) -> NotificationFuture<'a> {
|
||||
Box::pin(async { Ok(()) })
|
||||
}
|
||||
|
||||
fn cell_closed(&self, _cell_id: &CellId) {}
|
||||
}
|
||||
|
||||
impl HostHarness {
|
||||
async fn start() -> Result<Self> {
|
||||
let host_program = codex_utils_cargo_bin::cargo_bin("codex-code-mode-host")?;
|
||||
@@ -166,6 +223,34 @@ impl HostClient {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn negotiate_dual(&mut self, websocket_url: &str) -> Result<HostClient> {
|
||||
let capability = Capability::new(DUAL_WEBSOCKET_CAPABILITY)?;
|
||||
let hello = ClientHello::new(
|
||||
SupportedProtocolVersions::try_new([ProtocolVersion::V1])?,
|
||||
CapabilitySet::empty(),
|
||||
CapabilitySet::try_new([capability.clone()])?,
|
||||
)?;
|
||||
self.send(&ClientToHost::ClientHello(hello)).await?;
|
||||
let HostToClient::HostHello(hello) = self.read().await? else {
|
||||
anyhow::bail!("expected code-mode host hello");
|
||||
};
|
||||
assert!(hello.capabilities().contains(&capability));
|
||||
let token = hello
|
||||
.bulk_connection_token()
|
||||
.context("dual websocket handshake omitted its pairing token")?;
|
||||
let bulk_url = format!("{}/bulk/{token}", websocket_url.trim_end_matches('/'));
|
||||
let config = WebSocketConfig::default()
|
||||
.max_frame_size(Some(MAX_WEBSOCKET_FRAME_BYTES))
|
||||
.max_message_size(Some(MAX_WEBSOCKET_FRAME_BYTES));
|
||||
let (websocket, _) = timeout(
|
||||
TEST_TIMEOUT,
|
||||
connect_async_with_config(bulk_url, Some(config), /*disable_nagle*/ false),
|
||||
)
|
||||
.await
|
||||
.context("timed out connecting to code-mode host bulk websocket")??;
|
||||
Ok(HostClient { websocket })
|
||||
}
|
||||
|
||||
async fn open_session(&mut self, session_id: SessionId) -> Result<()> {
|
||||
let id = RequestId::new(/*value*/ 1);
|
||||
self.send(&ClientToHost::Request {
|
||||
@@ -317,6 +402,418 @@ async fn websocket_listener_executes_cells_and_forwards_tool_callbacks() -> Resu
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn production_websocket_client_runs_nested_tools_while_other_sessions_progress() -> Result<()>
|
||||
{
|
||||
let host = HostHarness::start().await?;
|
||||
let provider = WebSocketCodeModeSessionProvider::new(host.websocket_url.clone());
|
||||
let delegate = Arc::new(LargeToolResultDelegate {
|
||||
started: Semaphore::new(/*permits*/ 0),
|
||||
release: Semaphore::new(/*permits*/ 0),
|
||||
});
|
||||
let slow_session = provider
|
||||
.create_session(delegate.clone())
|
||||
.await
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
let fast_session = provider
|
||||
.create_session(Arc::new(NoopCodeModeSessionDelegate))
|
||||
.await
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
|
||||
let slow_cell = slow_session
|
||||
.execute(ExecuteRequest {
|
||||
tool_call_id: "large-tool".to_string(),
|
||||
enabled_tools: vec![ToolDefinition {
|
||||
name: "large".to_string(),
|
||||
tool_name: ToolName::plain("large"),
|
||||
description: String::new(),
|
||||
kind: CodeModeToolKind::Function,
|
||||
input_schema: None,
|
||||
output_schema: None,
|
||||
}],
|
||||
source: r#"const result = await tools.large({ value: "request" }); text(String(result.value.length));"#
|
||||
.to_string(),
|
||||
yield_time_ms: Some(20_000),
|
||||
max_output_tokens: Some(1_000),
|
||||
})
|
||||
.await
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
let started = timeout(TEST_TIMEOUT, delegate.started.acquire())
|
||||
.await
|
||||
.context("large tool callback did not start")??;
|
||||
started.forget();
|
||||
|
||||
let fast_response = timeout(TEST_TIMEOUT, async {
|
||||
fast_session
|
||||
.execute(ExecuteRequest {
|
||||
tool_call_id: "fast-before-transfer".to_string(),
|
||||
enabled_tools: Vec::new(),
|
||||
source: r#"text("fast-before");"#.to_string(),
|
||||
yield_time_ms: Some(5_000),
|
||||
max_output_tokens: Some(1_000),
|
||||
})
|
||||
.await
|
||||
.map_err(anyhow::Error::msg)?
|
||||
.initial_response()
|
||||
.await
|
||||
.map_err(anyhow::Error::msg)
|
||||
})
|
||||
.await
|
||||
.context("unrelated execution was blocked by the pending tool callback")??;
|
||||
assert_eq!(
|
||||
fast_response,
|
||||
RuntimeResponse::Result {
|
||||
cell_id: CellId::new("1".to_string()),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "fast-before".to_string(),
|
||||
}],
|
||||
error_text: None,
|
||||
}
|
||||
);
|
||||
|
||||
delegate.release.add_permits(1);
|
||||
let slow_response = async {
|
||||
timeout(TEST_TIMEOUT, slow_cell.initial_response())
|
||||
.await
|
||||
.context("large tool result did not finish")?
|
||||
.map_err(anyhow::Error::msg)
|
||||
};
|
||||
let concurrent_response = async {
|
||||
timeout(TEST_TIMEOUT, async {
|
||||
fast_session
|
||||
.execute(ExecuteRequest {
|
||||
tool_call_id: "fast-during-transfer".to_string(),
|
||||
enabled_tools: Vec::new(),
|
||||
source: r#"text("fast-during");"#.to_string(),
|
||||
yield_time_ms: Some(5_000),
|
||||
max_output_tokens: Some(1_000),
|
||||
})
|
||||
.await
|
||||
.map_err(anyhow::Error::msg)?
|
||||
.initial_response()
|
||||
.await
|
||||
.map_err(anyhow::Error::msg)
|
||||
})
|
||||
.await
|
||||
.context("unrelated execution was blocked by the large tool transfer")?
|
||||
};
|
||||
tokio::pin!(slow_response);
|
||||
tokio::pin!(concurrent_response);
|
||||
let concurrent_response = tokio::select! {
|
||||
response = &mut concurrent_response => response?,
|
||||
response = &mut slow_response => {
|
||||
response?;
|
||||
anyhow::bail!("large tool result completed before the unrelated control response");
|
||||
}
|
||||
};
|
||||
let slow_response = slow_response.await?;
|
||||
assert_eq!(
|
||||
slow_response,
|
||||
RuntimeResponse::Result {
|
||||
cell_id: CellId::new("1".to_string()),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "8388608".to_string(),
|
||||
}],
|
||||
error_text: None,
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
concurrent_response,
|
||||
RuntimeResponse::Result {
|
||||
cell_id: CellId::new("2".to_string()),
|
||||
content_items: vec![FunctionCallOutputContentItem::InputText {
|
||||
text: "fast-during".to_string(),
|
||||
}],
|
||||
error_text: None,
|
||||
}
|
||||
);
|
||||
|
||||
slow_session.shutdown().await.map_err(anyhow::Error::msg)?;
|
||||
fast_session.shutdown().await.map_err(anyhow::Error::msg)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn websocket_dual_connections_route_notifications_and_tool_callbacks_to_separate_lanes()
|
||||
-> Result<()> {
|
||||
let host = HostHarness::start().await?;
|
||||
let mut control = host.connect().await?;
|
||||
let mut bulk = control.negotiate_dual(&host.websocket_url).await?;
|
||||
let session_id = SessionId::new("dual-websocket-session")?;
|
||||
control.open_session(session_id.clone()).await?;
|
||||
|
||||
let execute_id = RequestId::new(/*value*/ 2);
|
||||
control
|
||||
.send(&ClientToHost::Request {
|
||||
id: execute_id,
|
||||
request: HostRequest::Execute {
|
||||
session_id: session_id.clone(),
|
||||
request: WireExecuteRequest {
|
||||
tool_call_id: "dual-websocket-call".to_string(),
|
||||
enabled_tools: vec![WireToolDefinition {
|
||||
name: "echo".to_string(),
|
||||
tool_name: WireToolName {
|
||||
name: "echo".to_string(),
|
||||
namespace: None,
|
||||
},
|
||||
description: String::new(),
|
||||
kind: WireToolKind::Function,
|
||||
input_schema: None,
|
||||
output_schema: None,
|
||||
}],
|
||||
source: r#"notify("important"); const result = await tools.echo({ value: "ping" }); text(result.value);"#
|
||||
.to_string(),
|
||||
yield_time_ms: Some(5_000),
|
||||
max_output_tokens: Some(1_000),
|
||||
},
|
||||
},
|
||||
})
|
||||
.await?;
|
||||
|
||||
let started = control.read().await?;
|
||||
let HostToClient::Response {
|
||||
id,
|
||||
result:
|
||||
WireResult::Ok {
|
||||
value: HostResponse::ExecutionStarted { cell_id },
|
||||
},
|
||||
} = started
|
||||
else {
|
||||
anyhow::bail!("expected execution-started response on control lane, got {started:?}");
|
||||
};
|
||||
assert_eq!(id, execute_id);
|
||||
|
||||
let notification = control.read().await?;
|
||||
let HostToClient::DelegateRequest {
|
||||
id: notification_id,
|
||||
..
|
||||
} = ¬ification
|
||||
else {
|
||||
anyhow::bail!("expected notification on control lane, got {notification:?}");
|
||||
};
|
||||
let notification_id = *notification_id;
|
||||
assert_eq!(
|
||||
notification,
|
||||
HostToClient::DelegateRequest {
|
||||
id: notification_id,
|
||||
session_id: session_id.clone(),
|
||||
request: DelegateRequest::Notify {
|
||||
call_id: "dual-websocket-call".to_string(),
|
||||
cell_id: cell_id.clone(),
|
||||
text: "important".to_string(),
|
||||
},
|
||||
}
|
||||
);
|
||||
control
|
||||
.send(&ClientToHost::DelegateResponse {
|
||||
id: notification_id,
|
||||
result: WireResult::Ok {
|
||||
value: DelegateResponse::NotificationDelivered,
|
||||
},
|
||||
})
|
||||
.await?;
|
||||
|
||||
let callback = bulk.read().await?;
|
||||
let HostToClient::DelegateRequest {
|
||||
id: delegate_id,
|
||||
session_id: callback_session_id,
|
||||
request: DelegateRequest::InvokeTool { invocation },
|
||||
} = callback
|
||||
else {
|
||||
anyhow::bail!("expected tool callback on bulk lane, got {callback:?}");
|
||||
};
|
||||
assert_eq!(callback_session_id, session_id);
|
||||
assert_eq!(invocation.input, Some(json!({ "value": "ping" })));
|
||||
|
||||
bulk.send(&ClientToHost::DelegateResponse {
|
||||
id: delegate_id,
|
||||
result: WireResult::Ok {
|
||||
value: DelegateResponse::ToolResult {
|
||||
result: json!({ "value": "pong" }),
|
||||
},
|
||||
},
|
||||
})
|
||||
.await?;
|
||||
|
||||
assert_eq!(
|
||||
control.read().await?,
|
||||
HostToClient::InitialResponse {
|
||||
id: execute_id,
|
||||
result: WireResult::Ok {
|
||||
value: WireRuntimeResponse::Result {
|
||||
cell_id: cell_id.clone(),
|
||||
content_items: vec![WireContentItem::InputText {
|
||||
text: "pong".to_string(),
|
||||
}],
|
||||
error_text: None,
|
||||
},
|
||||
},
|
||||
}
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
control.read().await?,
|
||||
HostToClient::CellClosed {
|
||||
session_id: session_id.clone(),
|
||||
cell_id,
|
||||
}
|
||||
);
|
||||
|
||||
let shutdown_id = RequestId::new(/*value*/ 3);
|
||||
control
|
||||
.send(&ClientToHost::Request {
|
||||
id: shutdown_id,
|
||||
request: HostRequest::ShutdownSession {
|
||||
session_id: session_id.clone(),
|
||||
},
|
||||
})
|
||||
.await?;
|
||||
assert_eq!(
|
||||
control.read().await?,
|
||||
HostToClient::Response {
|
||||
id: shutdown_id,
|
||||
result: WireResult::Ok {
|
||||
value: HostResponse::SessionClosed { session_id },
|
||||
},
|
||||
}
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn websocket_control_operations_bypass_an_incomplete_bulk_frame() -> Result<()> {
|
||||
let host = HostHarness::start().await?;
|
||||
let mut control = host.connect().await?;
|
||||
let mut bulk = control.negotiate_dual(&host.websocket_url).await?;
|
||||
let session_id = SessionId::new("bulk-priority-session")?;
|
||||
control.open_session(session_id.clone()).await?;
|
||||
|
||||
let bulk_message = ClientToHost::DelegateResponse {
|
||||
id: codex_code_mode_protocol::host::DelegateRequestId::new(/*value*/ 999),
|
||||
result: WireResult::Ok {
|
||||
value: DelegateResponse::ToolResult {
|
||||
result: json!({ "image": "x".repeat(1024 * 1024) }),
|
||||
},
|
||||
},
|
||||
};
|
||||
let payload = EncodedFrame::encode(&bulk_message)?.into_framed_bytes();
|
||||
let mask = [0x13_u8, 0x37, 0xc0, 0xde];
|
||||
let mut partial_frame = vec![0x82_u8, 0xff];
|
||||
partial_frame.extend_from_slice(&(payload.len() as u64).to_be_bytes());
|
||||
partial_frame.extend_from_slice(&mask);
|
||||
partial_frame.extend(
|
||||
payload[..64 * 1024]
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(index, byte)| byte ^ mask[index % mask.len()]),
|
||||
);
|
||||
bulk.websocket
|
||||
.get_mut()
|
||||
.write_all(&partial_frame)
|
||||
.await
|
||||
.context("failed to start the intentionally incomplete bulk frame")?;
|
||||
|
||||
let request_id = RequestId::new(/*value*/ 42);
|
||||
control
|
||||
.send(&ClientToHost::Request {
|
||||
id: request_id,
|
||||
request: HostRequest::Wait {
|
||||
session_id: session_id.clone(),
|
||||
request: WireWaitRequest {
|
||||
cell_id: codex_code_mode_protocol::host::WireCellId::new("missing-cell"),
|
||||
yield_time_ms: 10,
|
||||
},
|
||||
},
|
||||
})
|
||||
.await?;
|
||||
let response = timeout(TEST_TIMEOUT, control.read())
|
||||
.await
|
||||
.context("control wait was blocked behind the incomplete bulk frame")??;
|
||||
assert!(matches!(
|
||||
response,
|
||||
HostToClient::Response {
|
||||
id,
|
||||
result: WireResult::Ok {
|
||||
value: HostResponse::WaitCompleted { .. },
|
||||
},
|
||||
} if id == request_id
|
||||
));
|
||||
|
||||
let execute_id = RequestId::new(/*value*/ 43);
|
||||
control
|
||||
.send(&ClientToHost::Request {
|
||||
id: execute_id,
|
||||
request: HostRequest::Execute {
|
||||
session_id,
|
||||
request: WireExecuteRequest {
|
||||
tool_call_id: "control-execute".to_string(),
|
||||
enabled_tools: Vec::new(),
|
||||
source: r#"text("fast");"#.to_string(),
|
||||
yield_time_ms: Some(5_000),
|
||||
max_output_tokens: Some(1_000),
|
||||
},
|
||||
},
|
||||
})
|
||||
.await?;
|
||||
for _ in 0..2 {
|
||||
let response = timeout(TEST_TIMEOUT, control.read())
|
||||
.await
|
||||
.context("control execute was blocked behind the incomplete bulk frame")??;
|
||||
assert!(matches!(
|
||||
response,
|
||||
HostToClient::Response { id, .. } | HostToClient::InitialResponse { id, .. }
|
||||
if id == execute_id
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn websocket_bulk_lane_rejects_control_messages() -> Result<()> {
|
||||
let host = HostHarness::start().await?;
|
||||
let mut control = host.connect().await?;
|
||||
let mut bulk = control.negotiate_dual(&host.websocket_url).await?;
|
||||
let session_id = SessionId::new("wrong-lane-session")?;
|
||||
control.open_session(session_id.clone()).await?;
|
||||
|
||||
bulk.send(&ClientToHost::Request {
|
||||
id: RequestId::new(/*value*/ 42),
|
||||
request: HostRequest::Wait {
|
||||
session_id,
|
||||
request: WireWaitRequest {
|
||||
cell_id: codex_code_mode_protocol::host::WireCellId::new("missing-cell"),
|
||||
yield_time_ms: 10,
|
||||
},
|
||||
},
|
||||
})
|
||||
.await?;
|
||||
|
||||
let result = timeout(TEST_TIMEOUT, control.websocket.next())
|
||||
.await
|
||||
.context("wrong-lane control message did not disconnect the paired sockets")?;
|
||||
assert!(
|
||||
matches!(result, None | Some(Ok(Message::Close(_))) | Some(Err(_))),
|
||||
"wrong-lane message unexpectedly returned {result:?}"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn websocket_bulk_pairing_rejects_unknown_tokens() -> Result<()> {
|
||||
let host = HostHarness::start().await?;
|
||||
let unknown_token = Uuid::new_v4();
|
||||
let url = format!("{}/bulk/{unknown_token}", host.websocket_url);
|
||||
let error = match connect_async(url).await {
|
||||
Ok(_) => anyhow::bail!("unknown bulk pairing token should be rejected"),
|
||||
Err(error) => error,
|
||||
};
|
||||
let WebSocketError::Http(response) = error else {
|
||||
anyhow::bail!("bulk pairing failed unexpectedly: {error}");
|
||||
};
|
||||
assert_eq!(response.status(), StatusCode::NOT_FOUND);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn websocket_listener_accepts_frames_larger_than_default_websocket_limit() -> Result<()> {
|
||||
let host = HostHarness::start().await?;
|
||||
|
||||
Reference in New Issue
Block a user