Skip to content

Commit a006551

Browse files
Bound buffered HTTP response bodies
1 parent 1369f2e commit a006551

4 files changed

Lines changed: 154 additions & 13 deletions

File tree

‎packages/codex/patches/0063-buffered-responses.patch‎

Lines changed: 93 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -35,10 +35,19 @@ index 77b3054aeeca459f33b679e3165f12652eaeaf53..e846ffec067f08a72319286f2e2ac5c6
3535
pub(crate) mod search;
3636
mod session;
3737
diff --git a/codex-rs/codex-api/src/endpoint/responses.rs b/codex-rs/codex-api/src/endpoint/responses.rs
38-
index 9c41a802eadd57cf20ffc733121921d8d3ba9d08..138935533403f2ae8f37a1be689139d854c6b2bd 100644
38+
index 9c41a802eadd57cf20ffc733121921d8d3ba9d08..40ff37082281faf6356163819a10b87259f57609 100644
3939
--- a/codex-rs/codex-api/src/endpoint/responses.rs
4040
+++ b/codex-rs/codex-api/src/endpoint/responses.rs
41-
@@ -72,28 +72,75 @@ impl<T: HttpTransport> ResponsesClient<T> {
41+
@@ -23,6 +23,8 @@ use std::sync::Arc;
42+
use std::sync::OnceLock;
43+
use tracing::instrument;
44+
45+
+const MAX_JSON_RESPONSE_BODY_BYTES: usize = 64 * 1024 * 1024;
46+
+
47+
pub struct ResponsesClient<T: HttpTransport> {
48+
session: EndpointSession<T>,
49+
sse_telemetry: Option<Arc<dyn SseTelemetry>>,
50+
@@ -72,28 +74,76 @@ impl<T: HttpTransport> ResponsesClient<T> {
4251
request: ResponsesApiRequest,
4352
options: ResponsesOptions,
4453
) -> Result<ResponseStream, ApiError> {
@@ -90,6 +99,7 @@ index 9c41a802eadd57cf20ffc733121921d8d3ba9d08..138935533403f2ae8f37a1be689139d8
9099
+ options.extra_headers,
91100
+ options.compression,
92101
+ "application/json",
102+
+ Some(MAX_JSON_RESPONSE_BODY_BYTES),
93103
+ )
94104
+ .await?;
95105
+ Ok(super::responses_json::response_stream(
@@ -130,12 +140,12 @@ index 9c41a802eadd57cf20ffc733121921d8d3ba9d08..138935533403f2ae8f37a1be689139d8
130140
}
131141

132142
#[instrument(
133-
@@ -127,33 +174,41 @@ impl<T: HttpTransport> ResponsesClient<T> {
143+
@@ -127,33 +177,43 @@ impl<T: HttpTransport> ResponsesClient<T> {
134144
compression: Compression,
135145
turn_state: Option<Arc<OnceLock<String>>>,
136146
) -> Result<ResponseStream, ApiError> {
137147
+ let stream_response = self
138-
+ .send_encoded(body, extra_headers, compression, "text/event-stream")
148+
+ .send_encoded(body, extra_headers, compression, "text/event-stream", None)
139149
+ .await?;
140150
+
141151
+ Ok(spawn_response_stream(
@@ -151,6 +161,7 @@ index 9c41a802eadd57cf20ffc733121921d8d3ba9d08..138935533403f2ae8f37a1be689139d8
151161
+ extra_headers: HeaderMap,
152162
+ compression: Compression,
153163
+ accept: &'static str,
164+
+ response_body_limit_bytes: Option<usize>,
154165
+ ) -> Result<codex_client::StreamResponse, ApiError> {
155166
let request_compression = match compression {
156167
Compression::None => RequestCompression::None,
@@ -173,6 +184,7 @@ index 9c41a802eadd57cf20ffc733121921d8d3ba9d08..138935533403f2ae8f37a1be689139d8
173184
+ req.headers
174185
+ .insert(http::header::ACCEPT, HeaderValue::from_static(accept));
175186
req.compression = request_compression;
187+
+ req.response_body_limit_bytes = response_body_limit_bytes;
176188
},
177189
)
178190
- .await?;
@@ -188,10 +200,10 @@ index 9c41a802eadd57cf20ffc733121921d8d3ba9d08..138935533403f2ae8f37a1be689139d8
188200
}
189201
diff --git a/codex-rs/codex-api/src/endpoint/responses_json.rs b/codex-rs/codex-api/src/endpoint/responses_json.rs
190202
new file mode 100644
191-
index 0000000000000000000000000000000000000000..5d544f8c6ceb711d7d635583e82194782711dd1b
203+
index 0000000000000000000000000000000000000000..ddc82fd350c2ce6644c87bbbe463263bb1b9af73
192204
--- /dev/null
193205
+++ b/codex-rs/codex-api/src/endpoint/responses_json.rs
194-
@@ -0,0 +1,209 @@
206+
@@ -0,0 +1,210 @@
195207
+//! Lazy buffered Responses ingress. The caller's mapper owns and polls the body.
196208
+use crate::api_rate_limits::parse_api_rate_limits;
197209
+use crate::common::ResponseEvent;
@@ -258,7 +270,8 @@ index 0000000000000000000000000000000000000000..5d544f8c6ceb711d7d635583e8219478
258270
+ break;
259271
+ };
260272
+ let chunk = next.map_err(|error| match error {
261-
+ error @ codex_client::TransportError::Policy(_) => ApiError::Transport(error),
273+
+ error @ (codex_client::TransportError::Policy(_)
274+
+ | codex_client::TransportError::ResponseTooLarge { .. }) => ApiError::Transport(error),
262275
+ error => ApiError::Stream(error.to_string()),
263276
+ })?;
264277
+ body.extend_from_slice(&chunk);
@@ -403,10 +416,10 @@ index 0000000000000000000000000000000000000000..5d544f8c6ceb711d7d635583e8219478
403416
+mod tests;
404417
diff --git a/codex-rs/codex-api/src/endpoint/responses_json_tests.rs b/codex-rs/codex-api/src/endpoint/responses_json_tests.rs
405418
new file mode 100644
406-
index 0000000000000000000000000000000000000000..18c7ee66b62939ab32f3a2070e34d566d920da2f
419+
index 0000000000000000000000000000000000000000..4540f42840de808bd4a29c3e7b1834cb33743def
407420
--- /dev/null
408421
+++ b/codex-rs/codex-api/src/endpoint/responses_json_tests.rs
409-
@@ -0,0 +1,522 @@
422+
@@ -0,0 +1,547 @@
410423
+use super::*;
411424
+use bytes::Bytes;
412425
+use codex_client::TransportError;
@@ -741,6 +754,31 @@ index 0000000000000000000000000000000000000000..18c7ee66b62939ab32f3a2070e34d566
741754
+ }
742755
+}
743756
+
757+
+#[tokio::test]
758+
+async fn body_size_error_retains_its_nonretryable_transport_classification() {
759+
+ let (_, events) = response_stream(
760+
+ StreamResponse {
761+
+ status: StatusCode::OK,
762+
+ headers: HeaderMap::new(),
763+
+ bytes: Box::pin(futures::stream::iter([Err(
764+
+ TransportError::ResponseTooLarge {
765+
+ max_bytes: 64 * 1024 * 1024,
766+
+ },
767+
+ )])),
768+
+ },
769+
+ Duration::from_secs(5),
770+
+ None,
771+
+ );
772+
+ let events: Events = events.collect().await;
773+
+ assert!(default_header_reset(events.first()));
774+
+ assert!(matches!(
775+
+ &events[1..],
776+
+ [Err(ApiError::Transport(
777+
+ TransportError::ResponseTooLarge { .. }
778+
+ ))]
779+
+ ));
780+
+}
781+
+
744782
+#[derive(Default)]
745783
+struct SyntheticAuth;
746784
+impl crate::AuthProvider for SyntheticAuth {
@@ -967,6 +1005,52 @@ index 30bc97b1157daf506f6962f0cddf5fb66bb32532..5b862aa2b6a85c69cf7945b1ee497cfa
9671005
/// Read only safe typed facts; malformed or missing counters stay unknown.
9681006
pub(crate) fn response_observation(
9691007
&self,
1008+
diff --git a/codex-rs/codex-api/tests/clients.rs b/codex-rs/codex-api/tests/clients.rs
1009+
index b17da453440ad49cb8e495ea72f21081b99a4ea2..7c529fd838218fae4c404d10d631e40748c25cf7 100644
1010+
--- a/codex-rs/codex-api/tests/clients.rs
1011+
+++ b/codex-rs/codex-api/tests/clients.rs
1012+
@@ -303,6 +303,41 @@ async fn responses_client_uses_responses_path() -> Result<()> {
1013+
1014+
let requests = state.take_stream_requests();
1015+
assert_path_ends_with(&requests, "/responses");
1016+
+ assert_eq!(requests[0].response_body_limit_bytes, None);
1017+
+ Ok(())
1018+
+}
1019+
+
1020+
+#[tokio::test]
1021+
+async fn responses_client_bounds_json_response_bodies() -> Result<()> {
1022+
+ let state = RecordingState::default();
1023+
+ let transport = RecordingTransport::new(state.clone());
1024+
+ let client = ResponsesClient::new(transport, provider("openai"), Arc::new(NoAuth));
1025+
+ let request = ResponsesApiRequest {
1026+
+ model: "gpt-test".into(),
1027+
+ input: Vec::new(),
1028+
+ tools: None,
1029+
+ tool_choice: "auto".into(),
1030+
+ parallel_tool_calls: false,
1031+
+ reasoning: None,
1032+
+ store: false,
1033+
+ stream: true,
1034+
+ stream_options: None,
1035+
+ include: Vec::new(),
1036+
+ service_tier: None,
1037+
+ prompt_cache_key: None,
1038+
+ text: None,
1039+
+ client_metadata: None,
1040+
+ access_programs: None,
1041+
+ };
1042+
+ let _stream = client
1043+
+ .json_request(request, ResponsesOptions::default())
1044+
+ .await?;
1045+
+ let requests = state.take_stream_requests();
1046+
+ assert_eq!(requests.len(), 1);
1047+
+ assert_eq!(
1048+
+ requests[0].response_body_limit_bytes,
1049+
+ Some(64 * 1024 * 1024)
1050+
+ );
1051+
Ok(())
1052+
}
1053+
9701054
diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rs
9711055
index 0c5537ebaa01a0286d574cf9f4b720a18232a611..81391ca070ff4ec0574028c86d0a1e05744007dd 100644
9721056
--- a/codex-rs/core/src/client.rs

‎packages/codex/patches/series.json‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -278,8 +278,8 @@
278278
},
279279
{
280280
"path": "0063-buffered-responses.patch",
281-
"sha256": "5dcd738fe5348ce488252365ac4b5698304fa2673313d73fc6eae41c9366752f"
281+
"sha256": "4a4c1fbce6938bb0d131c40436cf7511c297096e2feac915e0ea39b527d1aefc"
282282
}
283283
],
284-
"result_tree": "62bd1293e0b3b0d4418ed5b98f8e581dd028a152"
284+
"result_tree": "f3307c99e669b1913f691f70d39f6755fa2f3ba7"
285285
}

‎packages/codex/src/_agents_codex/agent.py‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -155,7 +155,8 @@ class NativeProvider:
155155
Set ``response_mode="buffered"`` to request complete JSON responses from an
156156
endpoint that supports nonstreaming Responses. Model output events become
157157
available after the full response arrives, without token-level progress.
158-
Each model response is buffered separately. Tool calls start after that
158+
Each HTTP response body is limited to 64 MiB; larger responses fail without
159+
retry. Each model response is buffered separately. Tool calls start after that
159160
response completes; events remain available while tools execute.
160161
Successful output uses the normal Session history and tool processing.
161162
Provider failures deliver no partial output; validated response metadata

‎packages/codex/tests/test_buffered_responses.py‎

Lines changed: 57 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,7 @@
4343
@dataclass
4444
class JSONPeer(HTTPPeer):
4545
json_replies: deque[dict[str, Any] | bytes] = field(default_factory=deque)
46+
response_headers: dict[str, str] = field(default_factory=dict)
4647
body_gate: asyncio.Event | None = None
4748
body_entered: asyncio.Event = field(default_factory=asyncio.Event)
4849

@@ -59,7 +60,9 @@ async def handle(self, request: web.Request) -> web.StreamResponse:
5960
assert self.json_replies, "Unexpected buffered model request"
6061
value = self.json_replies.popleft()
6162
data = value if isinstance(value, bytes) else json.dumps(value, ensure_ascii=False).encode()
62-
response = web.StreamResponse(headers={"Content-Type": "application/json"})
63+
response = web.StreamResponse(
64+
headers={"Content-Type": "application/json", **self.response_headers}
65+
)
6366
await response.prepare(request)
6467
gate = self.body_gate
6568
try:
@@ -246,6 +249,59 @@ async def test_buffered_runs_keep_fresh_histories_and_provider_cleanup() -> None
246249
await disconnected(peer.transports)
247250

248251

252+
async def test_buffered_custom_tool_input_executes_once() -> None:
253+
seen: list[str] = []
254+
255+
@function_tool
256+
async def capture(value: str) -> str:
257+
seen.append(value)
258+
return value
259+
260+
code = 'text(await tools.capture({value: "exact-once"}));'
261+
response = json_response("", "code-response", "unused-item")
262+
response["output"] = [
263+
{"type": "custom_tool_call", "name": "exec", "call_id": "code-once", "input": code}
264+
]
265+
async with timeout(30), json_peer() as peer:
266+
peer.json_replies.extend([response, json_response("done", "done-response", "done-item")])
267+
async with provider(peer) as owner:
268+
agent = Agent(
269+
model="gpt-5.2",
270+
instructions="Use capture through code.",
271+
tools=[capture],
272+
provider=owner,
273+
programmatic_tool_calling=True,
274+
)
275+
result = await agent.run("Capture the value once.")
276+
assert result.final_output == "done"
277+
assert seen == ["exact-once"]
278+
assert len(peer.requests) == 2
279+
calls = [
280+
item for item in peer.requests[1]["input"] if item["type"] == "custom_tool_call"
281+
]
282+
assert [(call["call_id"], call["input"]) for call in calls] == [("code-once", code)]
283+
output = tool_output(peer.requests[1], "code-once", "custom_tool_call_output")
284+
assert output.count("exact-once") == 1
285+
await disconnected(peer.transports)
286+
287+
288+
@pytest.mark.parametrize("content_length", [False, True], ids=["chunked", "declared"])
289+
async def test_buffered_body_limit_rejects_oversize_without_retry(content_length: bool) -> None:
290+
limit = 64 * 1024 * 1024
291+
body = json.dumps(json_response("oversized", "large-response", "large-item")).encode()
292+
body += b" " * limit
293+
async with timeout(30), json_peer() as peer:
294+
peer.json_replies.append(body)
295+
if content_length:
296+
peer.response_headers["Content-Length"] = str(len(body))
297+
async with provider(peer) as owner:
298+
agent = Agent(model="gpt-5.2", instructions="Answer.", provider=owner)
299+
with pytest.raises(NativeError, match=f"response body exceeds the {limit} byte limit"):
300+
await agent.run("Reject the oversized response.")
301+
assert len(peer.requests) == 1
302+
await disconnected(peer.transports)
303+
304+
249305
@pytest.mark.parametrize(
250306
"mode", [None, "streaming", "buffered"], ids=["default", "streaming", "buffered"]
251307
)

0 commit comments

Comments
 (0)