Support negotiated server-side truncation in Code Mode clients (#58125)

## Why

Host-side truncation can bound Code Mode output before it crosses the transport, including script errors that would otherwise exceed the frame limit.

## What changed

- Negotiate server-side output truncation for stdio and gRPC sessions, with client-side fallback for older hosts.
- Forward output budgets for execution, waiting, and termination when server-side truncation is selected. Avoid truncating host-formatted output or appending script errors a second time.
- Preserve the negotiated mode across reconnects and reject hosts that cannot maintain it.

## Testing

Add transport and integration coverage for output budgets, oversized script errors, reconnect compatibility, and preservation of output-limit notices with a zero-token budget.

GitOrigin-RevId: 2075101e4845eca64f45491c27a3b326788645c8
This commit is contained in:
Sean Huang
2026-10-29 16:57:12 +00:00
committed by copyberry
parent 3062f7aa4a
commit 09db085f94
21 changed files with 751 additions and 154 deletions
+53 -4
View File
@@ -10,9 +10,11 @@ use std::sync::atomic::Ordering;
use std::time::Duration;
use codex_code_mode_protocol::CellId;
use codex_code_mode_protocol::CodeModeOutputTruncation;
use codex_code_mode_protocol::CodeModeSession;
use codex_code_mode_protocol::CodeModeSessionCellExecutionLimits;
use codex_code_mode_protocol::CodeModeSessionDelegate;
use codex_code_mode_protocol::CodeModeSessionOptions;
use codex_code_mode_protocol::CodeModeSessionProvider;
use codex_code_mode_protocol::CodeModeSessionProviderFuture;
use codex_code_mode_protocol::CodeModeSessionResultFuture;
@@ -129,9 +131,12 @@ impl GrpcCodeModeSessionProvider {
#[tracing::instrument(name = "code_mode.grpc.open_binding", level = "info", skip_all)]
async fn open_binding(
&self,
limits: CodeModeSessionCellExecutionLimits,
options: &CodeModeSessionOptions,
pinned_mode: Option<CodeModeOutputTruncation>,
) -> Result<Arc<GrpcCodeModeSession>, String> {
let mut client = deadline::startup("transport connection", self.transport.client()).await?;
let requested_mode = pinned_mode.unwrap_or(options.output_truncation);
let limits = &options.cell_execution_limits;
let limits = grpc::SessionCellExecutionLimits {
max_yield_time_ms: limits.max_yield_time_ms,
max_heap_size_bytes: limits
@@ -149,7 +154,12 @@ impl GrpcCodeModeSessionProvider {
loop {
let mut request = tonic::Request::new(grpc::OpenSessionRequest {
cell_execution_limits,
output_truncation: None,
output_truncation: match requested_mode {
CodeModeOutputTruncation::Client => None,
CodeModeOutputTruncation::Server => {
Some(grpc::OutputTruncation::Server.into())
}
},
});
inject_span_traceparent(&mut request, &open_session_span);
let result = async {
@@ -197,9 +207,33 @@ impl GrpcCodeModeSessionProvider {
return Err("gRPC code-mode session lease omitted its opening event".to_string());
};
validate_identifier(&opened.session_id, "session ID")?;
let host_mode =
grpc::OutputTruncation::try_from(opened.output_truncation.unwrap_or_default())
.map_err(|_| "gRPC code-mode host returned an unknown output truncation mode")?;
let output_truncation = match host_mode {
grpc::OutputTruncation::Unspecified | grpc::OutputTruncation::Client => {
CodeModeOutputTruncation::Client
}
grpc::OutputTruncation::Server => CodeModeOutputTruncation::Server,
};
if output_truncation == CodeModeOutputTruncation::Server
&& requested_mode == CodeModeOutputTruncation::Client
{
return Err(format!(
"gRPC code-mode host selected {output_truncation:?} output truncation, requested {requested_mode:?}"
));
}
if pinned_mode.is_some_and(|previous| previous != output_truncation) {
// Dropping the opening lease releases this incompatible session before subscribing.
return Err(
"gRPC code-mode host changed the session output truncation mode on reconnect"
.to_string(),
);
}
let inner = Arc::new(SessionInner {
id: opened.session_id,
output_truncation,
client,
route,
runtime: tokio::runtime::Handle::current(),
@@ -259,9 +293,19 @@ impl CodeModeSessionProvider for GrpcCodeModeSessionProvider {
fn create_session_with_limits<'a>(
&'a self,
limits: CodeModeSessionCellExecutionLimits,
) -> CodeModeSessionProviderFuture<'a> {
self.create_session_with_options(CodeModeSessionOptions {
cell_execution_limits: limits,
..CodeModeSessionOptions::default()
})
}
fn create_session_with_options<'a>(
&'a self,
options: CodeModeSessionOptions,
) -> CodeModeSessionProviderFuture<'a> {
Box::pin(async move {
let session = Arc::new(reconnect::ReconnectableSession::new(self.clone(), limits));
let session = Arc::new(reconnect::ReconnectableSession::new(self.clone(), options));
session.initialize().await?;
Ok(session as _)
})
@@ -290,6 +334,10 @@ impl Drop for OpeningSession {
}
impl CodeModeSession for GrpcCodeModeSession {
fn output_truncation(&self) -> CodeModeOutputTruncation {
self.inner.output_truncation
}
fn execute<'a>(
&'a self,
request: ExecuteRequest,
@@ -311,7 +359,7 @@ impl CodeModeSession for GrpcCodeModeSession {
&'a self,
request: TerminateRequest,
) -> CodeModeSessionResultFuture<'a, WaitOutcome> {
Box::pin(self.inner.terminate(request.cell_id))
Box::pin(self.inner.terminate(request))
}
fn shutdown<'a>(&'a self) -> CodeModeSessionResultFuture<'a, ()> {
@@ -327,6 +375,7 @@ impl Drop for GrpcCodeModeSession {
pub(super) struct SessionInner {
pub(super) id: String,
output_truncation: CodeModeOutputTruncation,
pub(super) client: GrpcClient,
// Affinity belongs to the session: parents and children may share a transport
// while being admitted to different hosts. The token is opaque to Codex.