diff --git a/codex-cli/scripts/README.md b/codex-cli/scripts/README.md
new file mode 100644
index 0000000000..21e4f3e883
--- /dev/null
+++ b/codex-cli/scripts/README.md
@@ -0,0 +1,9 @@
+# npm releases
+
+Run the following:
+
+To build the 0.2.x or later version of the npm module, which runs the Rust version of the CLI, build it as follows:
+
+```bash
+./codex-cli/scripts/stage_rust_release.py --release-version 0.6.0
+```
diff --git a/codex-cli/scripts/stage_release.sh b/codex-cli/scripts/stage_release.sh
index 29b9f76783..cd32ade6f9 100755
--- a/codex-cli/scripts/stage_release.sh
+++ b/codex-cli/scripts/stage_release.sh
@@ -4,10 +4,7 @@
# -----------------------------------------------------------------------------
# Stages an npm release for @openai/codex.
#
-# The script used to accept a single optional positional argument that indicated
-# the temporary directory in which to stage the package. We now support a
-# flag-based interface so that we can extend the command with further options
-# without breaking the call-site contract.
+# Usage:
#
# --tmp
: Use instead of a freshly created temp directory.
# --native : Bundle the pre-built Rust CLI binaries for Linux alongside
@@ -141,7 +138,8 @@ popd >/dev/null
echo "Staged version $VERSION for release in $TMPDIR"
if [[ "$INCLUDE_NATIVE" -eq 1 ]]; then
- echo "Test Rust:"
+ echo "Verify the CLI:"
+ echo " node ${TMPDIR}/bin/codex.js --version"
echo " node ${TMPDIR}/bin/codex.js --help"
else
echo "Test Node:"
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock
index 2909c2c594..e59dbfa255 100644
--- a/codex-rs/Cargo.lock
+++ b/codex-rs/Cargo.lock
@@ -250,6 +250,28 @@ dependencies = [
"pin-project-lite",
]
+[[package]]
+name = "async-stream"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
+]
+
[[package]]
name = "async-trait"
version = "0.1.88"
@@ -654,6 +676,7 @@ dependencies = [
"thiserror 2.0.12",
"time",
"tokio",
+ "tokio-test",
"tokio-util",
"toml 0.9.1",
"tracing",
@@ -787,6 +810,7 @@ dependencies = [
"color-eyre",
"crossterm",
"image",
+ "insta",
"lazy_static",
"mcp-types",
"path-clean",
@@ -871,6 +895,18 @@ dependencies = [
"crossbeam-utils",
]
+[[package]]
+name = "console"
+version = "0.15.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "windows-sys 0.59.0",
+]
+
[[package]]
name = "convert_case"
version = "0.6.0"
@@ -1230,6 +1266,12 @@ dependencies = [
"log",
]
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
[[package]]
name = "encoding_rs"
version = "0.8.35"
@@ -2110,6 +2152,17 @@ version = "2.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
+[[package]]
+name = "insta"
+version = "1.43.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "154934ea70c58054b556dd430b99a98c2a7ff5309ac9891597e339b5c28f4371"
+dependencies = [
+ "console",
+ "once_cell",
+ "similar",
+]
+
[[package]]
name = "instability"
version = "0.3.7"
@@ -4486,6 +4539,30 @@ dependencies = [
"tokio",
]
+[[package]]
+name = "tokio-stream"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-test"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2468baabc3311435b55dd935f702f42cd1b8abb7e754fb7dfb16bd36aa88f9f7"
+dependencies = [
+ "async-stream",
+ "bytes",
+ "futures-core",
+ "tokio",
+ "tokio-stream",
+]
+
[[package]]
name = "tokio-util"
version = "0.7.15"
diff --git a/codex-rs/core/Cargo.toml b/codex-rs/core/Cargo.toml
index 22636102c9..c55d7d395d 100644
--- a/codex-rs/core/Cargo.toml
+++ b/codex-rs/core/Cargo.toml
@@ -64,4 +64,5 @@ maplit = "1.0.2"
predicates = "3"
pretty_assertions = "1.4.1"
tempfile = "3"
+tokio-test = "0.4"
wiremock = "0.6"
diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rs
index bd2eeb9457..2fa182cf7f 100644
--- a/codex-rs/core/src/client.rs
+++ b/codex-rs/core/src/client.rs
@@ -391,3 +391,241 @@ async fn stream_from_fixture(path: impl AsRef) -> Result {
tokio::spawn(process_sse(stream, tx_event));
Ok(ResponseStream { rx_event })
}
+
+#[cfg(test)]
+mod tests {
+ #![allow(clippy::expect_used, clippy::unwrap_used)]
+
+ use super::*;
+ use serde_json::json;
+ use tokio::sync::mpsc;
+ use tokio_test::io::Builder as IoBuilder;
+ use tokio_util::io::ReaderStream;
+
+ // ────────────────────────────
+ // Helpers
+ // ────────────────────────────
+
+ /// Runs the SSE parser on pre-chunked byte slices and returns every event
+ /// (including any final `Err` from a stream-closure check).
+ async fn collect_events(chunks: &[&[u8]]) -> Vec> {
+ let mut builder = IoBuilder::new();
+ for chunk in chunks {
+ builder.read(chunk);
+ }
+
+ let reader = builder.build();
+ let stream = ReaderStream::new(reader).map_err(CodexErr::Io);
+ let (tx, mut rx) = mpsc::channel::>(16);
+ tokio::spawn(process_sse(stream, tx));
+
+ let mut events = Vec::new();
+ while let Some(ev) = rx.recv().await {
+ events.push(ev);
+ }
+ events
+ }
+
+ /// Builds an in-memory SSE stream from JSON fixtures and returns only the
+ /// successfully parsed events (panics on internal channel errors).
+ async fn run_sse(events: Vec) -> Vec {
+ let mut body = String::new();
+ for e in events {
+ let kind = e
+ .get("type")
+ .and_then(|v| v.as_str())
+ .expect("fixture event missing type");
+ if e.as_object().map(|o| o.len() == 1).unwrap_or(false) {
+ body.push_str(&format!("event: {kind}\n\n"));
+ } else {
+ body.push_str(&format!("event: {kind}\ndata: {e}\n\n"));
+ }
+ }
+
+ let (tx, mut rx) = mpsc::channel::>(8);
+ let stream = ReaderStream::new(std::io::Cursor::new(body)).map_err(CodexErr::Io);
+ tokio::spawn(process_sse(stream, tx));
+
+ let mut out = Vec::new();
+ while let Some(ev) = rx.recv().await {
+ out.push(ev.expect("channel closed"));
+ }
+ out
+ }
+
+ // ────────────────────────────
+ // Tests from `implement-test-for-responses-api-sse-parser`
+ // ────────────────────────────
+
+ #[tokio::test]
+ async fn parses_items_and_completed() {
+ let item1 = json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "message",
+ "role": "assistant",
+ "content": [{"type": "output_text", "text": "Hello"}]
+ }
+ })
+ .to_string();
+
+ let item2 = json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "message",
+ "role": "assistant",
+ "content": [{"type": "output_text", "text": "World"}]
+ }
+ })
+ .to_string();
+
+ let completed = json!({
+ "type": "response.completed",
+ "response": { "id": "resp1" }
+ })
+ .to_string();
+
+ let sse1 = format!("event: response.output_item.done\ndata: {item1}\n\n");
+ let sse2 = format!("event: response.output_item.done\ndata: {item2}\n\n");
+ let sse3 = format!("event: response.completed\ndata: {completed}\n\n");
+
+ let events = collect_events(&[sse1.as_bytes(), sse2.as_bytes(), sse3.as_bytes()]).await;
+
+ assert_eq!(events.len(), 3);
+
+ matches!(
+ &events[0],
+ Ok(ResponseEvent::OutputItemDone(ResponseItem::Message { role, .. }))
+ if role == "assistant"
+ );
+
+ matches!(
+ &events[1],
+ Ok(ResponseEvent::OutputItemDone(ResponseItem::Message { role, .. }))
+ if role == "assistant"
+ );
+
+ match &events[2] {
+ Ok(ResponseEvent::Completed {
+ response_id,
+ token_usage,
+ }) => {
+ assert_eq!(response_id, "resp1");
+ assert!(token_usage.is_none());
+ }
+ other => panic!("unexpected third event: {other:?}"),
+ }
+ }
+
+ #[tokio::test]
+ async fn error_when_missing_completed() {
+ let item1 = json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "message",
+ "role": "assistant",
+ "content": [{"type": "output_text", "text": "Hello"}]
+ }
+ })
+ .to_string();
+
+ let sse1 = format!("event: response.output_item.done\ndata: {item1}\n\n");
+
+ let events = collect_events(&[sse1.as_bytes()]).await;
+
+ assert_eq!(events.len(), 2);
+
+ matches!(events[0], Ok(ResponseEvent::OutputItemDone(_)));
+
+ match &events[1] {
+ Err(CodexErr::Stream(msg)) => {
+ assert_eq!(msg, "stream closed before response.completed")
+ }
+ other => panic!("unexpected second event: {other:?}"),
+ }
+ }
+
+ // ────────────────────────────
+ // Table-driven test from `main`
+ // ────────────────────────────
+
+ /// Verifies that the adapter produces the right `ResponseEvent` for a
+ /// variety of incoming `type` values.
+ #[tokio::test]
+ async fn table_driven_event_kinds() {
+ struct TestCase {
+ name: &'static str,
+ event: serde_json::Value,
+ expect_first: fn(&ResponseEvent) -> bool,
+ expected_len: usize,
+ }
+
+ fn is_created(ev: &ResponseEvent) -> bool {
+ matches!(ev, ResponseEvent::Created)
+ }
+ fn is_output(ev: &ResponseEvent) -> bool {
+ matches!(ev, ResponseEvent::OutputItemDone(_))
+ }
+ fn is_completed(ev: &ResponseEvent) -> bool {
+ matches!(ev, ResponseEvent::Completed { .. })
+ }
+
+ let completed = json!({
+ "type": "response.completed",
+ "response": {
+ "id": "c",
+ "usage": {
+ "input_tokens": 0,
+ "input_tokens_details": null,
+ "output_tokens": 0,
+ "output_tokens_details": null,
+ "total_tokens": 0
+ },
+ "output": []
+ }
+ });
+
+ let cases = vec![
+ TestCase {
+ name: "created",
+ event: json!({"type": "response.created", "response": {}}),
+ expect_first: is_created,
+ expected_len: 2,
+ },
+ TestCase {
+ name: "output_item.done",
+ event: json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "message",
+ "role": "assistant",
+ "content": [
+ {"type": "output_text", "text": "hi"}
+ ]
+ }
+ }),
+ expect_first: is_output,
+ expected_len: 2,
+ },
+ TestCase {
+ name: "unknown",
+ event: json!({"type": "response.new_tool_event"}),
+ expect_first: is_completed,
+ expected_len: 1,
+ },
+ ];
+
+ for case in cases {
+ let mut evs = vec![case.event];
+ evs.push(completed.clone());
+
+ let out = run_sse(evs).await;
+ assert_eq!(out.len(), case.expected_len, "case {}", case.name);
+ assert!(
+ (case.expect_first)(&out[0]),
+ "first event mismatch in case {}",
+ case.name
+ );
+ }
+ }
+}
diff --git a/codex-rs/core/tests/cli_responses_fixture.sse b/codex-rs/core/tests/cli_responses_fixture.sse
new file mode 100644
index 0000000000..d297ebafb2
--- /dev/null
+++ b/codex-rs/core/tests/cli_responses_fixture.sse
@@ -0,0 +1,8 @@
+event: response.created
+data: {"type":"response.created","response":{"id":"resp1"}}
+
+event: response.output_item.done
+data: {"type":"response.output_item.done","item":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"fixture hello"}]}}
+
+event: response.completed
+data: {"type":"response.completed","response":{"id":"resp1","output":[]}}
diff --git a/codex-rs/core/tests/cli_stream.rs b/codex-rs/core/tests/cli_stream.rs
new file mode 100644
index 0000000000..df3fedfd48
--- /dev/null
+++ b/codex-rs/core/tests/cli_stream.rs
@@ -0,0 +1,119 @@
+#![expect(clippy::unwrap_used)]
+
+use assert_cmd::Command as AssertCommand;
+use codex_core::exec::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
+use tempfile::TempDir;
+use wiremock::Mock;
+use wiremock::MockServer;
+use wiremock::ResponseTemplate;
+use wiremock::matchers::method;
+use wiremock::matchers::path;
+
+/// Tests streaming chat completions through the CLI using a mock server.
+/// This test:
+/// 1. Sets up a mock server that simulates OpenAI's chat completions API
+/// 2. Configures codex to use this mock server via a custom provider
+/// 3. Sends a simple "hello?" prompt and verifies the streamed response
+/// 4. Ensures the response is received exactly once and contains "hi"
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn chat_mode_stream_cli() {
+ if std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
+ println!(
+ "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
+ );
+ return;
+ }
+
+ let server = MockServer::start().await;
+ let sse = concat!(
+ "data: {\"choices\":[{\"delta\":{\"content\":\"hi\"}}]}\n\n",
+ "data: {\"choices\":[{\"delta\":{}}]}\n\n",
+ "data: [DONE]\n\n"
+ );
+ Mock::given(method("POST"))
+ .and(path("/v1/chat/completions"))
+ .respond_with(
+ ResponseTemplate::new(200)
+ .insert_header("content-type", "text/event-stream")
+ .set_body_raw(sse, "text/event-stream"),
+ )
+ .expect(1)
+ .mount(&server)
+ .await;
+
+ let home = TempDir::new().unwrap();
+ let provider_override = format!(
+ "model_providers.mock={{ name = \"mock\", base_url = \"{}/v1\", env_key = \"PATH\", wire_api = \"chat\" }}",
+ server.uri()
+ );
+ let mut cmd = AssertCommand::new("cargo");
+ cmd.arg("run")
+ .arg("-p")
+ .arg("codex-cli")
+ .arg("--quiet")
+ .arg("--")
+ .arg("exec")
+ .arg("--skip-git-repo-check")
+ .arg("-c")
+ .arg(&provider_override)
+ .arg("-c")
+ .arg("model_provider=\"mock\"")
+ .arg("-C")
+ .arg(env!("CARGO_MANIFEST_DIR"))
+ .arg("hello?");
+ cmd.env("CODEX_HOME", home.path())
+ .env("OPENAI_API_KEY", "dummy")
+ .env("OPENAI_BASE_URL", format!("{}/v1", server.uri()));
+
+ let output = cmd.output().unwrap();
+ println!("Status: {}", output.status);
+ println!("Stdout:\n{}", String::from_utf8_lossy(&output.stdout));
+ println!("Stderr:\n{}", String::from_utf8_lossy(&output.stderr));
+ assert!(output.status.success());
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ assert!(stdout.contains("hi"));
+ assert_eq!(stdout.matches("hi").count(), 1);
+
+ server.verify().await;
+}
+
+/// Tests streaming responses through the CLI using a local SSE fixture file.
+/// This test:
+/// 1. Uses a pre-recorded SSE response fixture instead of a live server
+/// 2. Configures codex to read from this fixture via CODEX_RS_SSE_FIXTURE env var
+/// 3. Sends a "hello?" prompt and verifies the response
+/// 4. Ensures the fixture content is correctly streamed through the CLI
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn responses_api_stream_cli() {
+ if std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
+ println!(
+ "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
+ );
+ return;
+ }
+
+ let fixture =
+ std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/cli_responses_fixture.sse");
+
+ let home = TempDir::new().unwrap();
+ let mut cmd = AssertCommand::new("cargo");
+ cmd.arg("run")
+ .arg("-p")
+ .arg("codex-cli")
+ .arg("--quiet")
+ .arg("--")
+ .arg("exec")
+ .arg("--skip-git-repo-check")
+ .arg("-C")
+ .arg(env!("CARGO_MANIFEST_DIR"))
+ .arg("hello?");
+ cmd.env("CODEX_HOME", home.path())
+ .env("OPENAI_API_KEY", "dummy")
+ .env("CODEX_RS_SSE_FIXTURE", fixture)
+ .env("OPENAI_BASE_URL", "http://unused.local");
+
+ let output = cmd.output().unwrap();
+ assert!(output.status.success());
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ assert!(stdout.contains("fixture hello"));
+}
diff --git a/codex-rs/core/tests/fixtures/completed_template.json b/codex-rs/core/tests/fixtures/completed_template.json
new file mode 100644
index 0000000000..1774dc5e84
--- /dev/null
+++ b/codex-rs/core/tests/fixtures/completed_template.json
@@ -0,0 +1,16 @@
+[
+ {
+ "type": "response.completed",
+ "response": {
+ "id": "__ID__",
+ "usage": {
+ "input_tokens": 0,
+ "input_tokens_details": null,
+ "output_tokens": 0,
+ "output_tokens_details": null,
+ "total_tokens": 0
+ },
+ "output": []
+ }
+ }
+]
diff --git a/codex-rs/core/tests/fixtures/incomplete_sse.json b/codex-rs/core/tests/fixtures/incomplete_sse.json
new file mode 100644
index 0000000000..2876bbfd29
--- /dev/null
+++ b/codex-rs/core/tests/fixtures/incomplete_sse.json
@@ -0,0 +1,3 @@
+[
+ {"type": "response.output_item.done"}
+]
diff --git a/codex-rs/core/tests/previous_response_id.rs b/codex-rs/core/tests/previous_response_id.rs
index 10d6e8bf6a..e64271a0ff 100644
--- a/codex-rs/core/tests/previous_response_id.rs
+++ b/codex-rs/core/tests/previous_response_id.rs
@@ -11,6 +11,7 @@ mod test_support;
use serde_json::Value;
use tempfile::TempDir;
use test_support::load_default_config_for_test;
+use test_support::load_sse_fixture_with_id;
use tokio::time::timeout;
use wiremock::Match;
use wiremock::Mock;
@@ -42,12 +43,9 @@ impl Match for HasPrevId {
}
}
-/// Build minimal SSE stream with completed marker.
+/// Build minimal SSE stream with completed marker using the JSON fixture.
fn sse_completed(id: &str) -> String {
- format!(
- "event: response.completed\n\
-data: {{\"type\":\"response.completed\",\"response\":{{\"id\":\"{id}\",\"output\":[]}}}}\n\n\n"
- )
+ load_sse_fixture_with_id("tests/fixtures/completed_template.json", id)
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
diff --git a/codex-rs/core/tests/stream_no_completed.rs b/codex-rs/core/tests/stream_no_completed.rs
index ece34ba299..da2736aa77 100644
--- a/codex-rs/core/tests/stream_no_completed.rs
+++ b/codex-rs/core/tests/stream_no_completed.rs
@@ -12,6 +12,8 @@ use codex_core::protocol::Op;
mod test_support;
use tempfile::TempDir;
use test_support::load_default_config_for_test;
+use test_support::load_sse_fixture;
+use test_support::load_sse_fixture_with_id;
use tokio::time::timeout;
use wiremock::Mock;
use wiremock::MockServer;
@@ -22,15 +24,11 @@ use wiremock::matchers::method;
use wiremock::matchers::path;
fn sse_incomplete() -> String {
- // Only a single line; missing the completed event.
- "event: response.output_item.done\n\n".to_string()
+ load_sse_fixture("tests/fixtures/incomplete_sse.json")
}
fn sse_completed(id: &str) -> String {
- format!(
- "event: response.completed\n\
-data: {{\"type\":\"response.completed\",\"response\":{{\"id\":\"{id}\",\"output\":[]}}}}\n\n\n"
- )
+ load_sse_fixture_with_id("tests/fixtures/completed_template.json", id)
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
diff --git a/codex-rs/core/tests/test_support.rs b/codex-rs/core/tests/test_support.rs
index 532e3986d0..7d1e3a7fef 100644
--- a/codex-rs/core/tests/test_support.rs
+++ b/codex-rs/core/tests/test_support.rs
@@ -21,3 +21,58 @@ pub fn load_default_config_for_test(codex_home: &TempDir) -> Config {
)
.expect("defaults for test should always succeed")
}
+
+/// Builds an SSE stream body from a JSON fixture.
+///
+/// The fixture must contain an array of objects where each object represents a
+/// single SSE event with at least a `type` field matching the `event:` value.
+/// Additional fields become the JSON payload for the `data:` line. An object
+/// with only a `type` field results in an event with no `data:` section. This
+/// makes it trivial to extend the fixtures as OpenAI adds new event kinds or
+/// fields.
+#[allow(dead_code)]
+pub fn load_sse_fixture(path: impl AsRef) -> String {
+ let events: Vec =
+ serde_json::from_reader(std::fs::File::open(path).expect("read fixture"))
+ .expect("parse JSON fixture");
+ events
+ .into_iter()
+ .map(|e| {
+ let kind = e
+ .get("type")
+ .and_then(|v| v.as_str())
+ .expect("fixture event missing type");
+ if e.as_object().map(|o| o.len() == 1).unwrap_or(false) {
+ format!("event: {kind}\n\n")
+ } else {
+ format!("event: {kind}\ndata: {e}\n\n")
+ }
+ })
+ .collect()
+}
+
+/// Same as [`load_sse_fixture`], but replaces the placeholder `__ID__` in the
+/// fixture template with the supplied identifier before parsing. This lets a
+/// single JSON template be reused by multiple tests that each need a unique
+/// `response_id`.
+#[allow(dead_code)]
+pub fn load_sse_fixture_with_id(path: impl AsRef, id: &str) -> String {
+ let raw = std::fs::read_to_string(path).expect("read fixture template");
+ let replaced = raw.replace("__ID__", id);
+ let events: Vec =
+ serde_json::from_str(&replaced).expect("parse JSON fixture");
+ events
+ .into_iter()
+ .map(|e| {
+ let kind = e
+ .get("type")
+ .and_then(|v| v.as_str())
+ .expect("fixture event missing type");
+ if e.as_object().map(|o| o.len() == 1).unwrap_or(false) {
+ format!("event: {kind}\n\n")
+ } else {
+ format!("event: {kind}\ndata: {e}\n\n")
+ }
+ })
+ .collect()
+}
diff --git a/codex-rs/mcp-server/src/codex_tool_runner.rs b/codex-rs/mcp-server/src/codex_tool_runner.rs
index 796a119e5c..7c3b02fe5e 100644
--- a/codex-rs/mcp-server/src/codex_tool_runner.rs
+++ b/codex-rs/mcp-server/src/codex_tool_runner.rs
@@ -9,6 +9,7 @@ use codex_core::protocol::Event;
use codex_core::protocol::EventMsg;
use codex_core::protocol::InputItem;
use codex_core::protocol::Op;
+use codex_core::protocol::Submission;
use codex_core::protocol::TaskCompleteEvent;
use mcp_types::CallToolResult;
use mcp_types::CallToolResultContent;
@@ -66,14 +67,24 @@ pub async fn run_codex_tool_session(
.send(codex_event_to_notification(&first_event))
.await;
- if let Err(e) = codex
- .submit(Op::UserInput {
+ // Use the original MCP request ID as the `sub_id` for the Codex submission so that
+ // any events emitted for this tool-call can be correlated with the
+ // originating `tools/call` request.
+ let sub_id = match &id {
+ RequestId::String(s) => s.clone(),
+ RequestId::Integer(n) => n.to_string(),
+ };
+
+ let submission = Submission {
+ id: sub_id,
+ op: Op::UserInput {
items: vec![InputItem::Text {
text: initial_prompt.clone(),
}],
- })
- .await
- {
+ },
+ };
+
+ if let Err(e) = codex.submit_with_id(submission).await {
tracing::error!("Failed to submit initial prompt: {e}");
}
diff --git a/codex-rs/tui/Cargo.toml b/codex-rs/tui/Cargo.toml
index 151222a1d3..74aedfa353 100644
--- a/codex-rs/tui/Cargo.toml
+++ b/codex-rs/tui/Cargo.toml
@@ -61,4 +61,5 @@ unicode-segmentation = "1.12.0"
uuid = "1"
[dev-dependencies]
+insta = "1.43.1"
pretty_assertions = "1"
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs
index 4b8b9b7812..e1dde8332d 100644
--- a/codex-rs/tui/src/app.rs
+++ b/codex-rs/tui/src/app.rs
@@ -98,21 +98,7 @@ impl<'a> App<'a> {
scroll_event_helper.scroll_down();
}
crossterm::event::Event::Paste(pasted) => {
- use crossterm::event::KeyModifiers;
-
- for ch in pasted.chars() {
- let key_event = match ch {
- '\n' | '\r' => {
- // Represent newline as so that the bottom
- // pane treats it as a literal newline instead of a submit
- // action (submission is only triggered on Enter *without*
- // any modifiers).
- KeyEvent::new(KeyCode::Enter, KeyModifiers::SHIFT)
- }
- _ => KeyEvent::new(KeyCode::Char(ch), KeyModifiers::empty()),
- };
- app_event_tx.send(AppEvent::KeyEvent(key_event));
- }
+ app_event_tx.send(AppEvent::Paste(pasted));
}
_ => {
// Ignore any other events.
@@ -223,6 +209,9 @@ impl<'a> App<'a> {
AppEvent::Scroll(scroll_delta) => {
self.dispatch_scroll_event(scroll_delta);
}
+ AppEvent::Paste(text) => {
+ self.dispatch_paste_event(text);
+ }
AppEvent::CodexEvent(event) => {
self.dispatch_codex_event(event);
}
@@ -343,6 +332,13 @@ impl<'a> App<'a> {
}
}
+ fn dispatch_paste_event(&mut self, pasted: String) {
+ match &mut self.app_state {
+ AppState::Chat { widget } => widget.handle_paste(pasted),
+ AppState::Login { .. } | AppState::GitWarning { .. } => {}
+ }
+ }
+
fn dispatch_scroll_event(&mut self, scroll_delta: i32) {
match &mut self.app_state {
AppState::Chat { widget } => widget.handle_scroll_delta(scroll_delta),
diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs
index dd89b85331..fd6b2479ee 100644
--- a/codex-rs/tui/src/app_event.rs
+++ b/codex-rs/tui/src/app_event.rs
@@ -12,6 +12,9 @@ pub(crate) enum AppEvent {
KeyEvent(KeyEvent),
+ /// Text pasted from the terminal clipboard.
+ Paste(String),
+
/// Scroll event with a value representing the "scroll delta" as the net
/// scroll up/down events within a short time window.
Scroll(i32),
diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rs
index 29bf74c810..e89187d165 100644
--- a/codex-rs/tui/src/bottom_pane/chat_composer.rs
+++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs
@@ -28,6 +28,9 @@ const MIN_TEXTAREA_ROWS: usize = 1;
const BORDER_LINES: u16 = 2;
const BASE_PLACEHOLDER_TEXT: &str = "send a message";
+/// If the pasted content exceeds this number of characters, replace it with a
+/// placeholder in the UI.
+const LARGE_PASTE_CHAR_THRESHOLD: usize = 1000;
/// Result returned when the user interacts with the text area.
pub enum InputResult {
@@ -43,6 +46,7 @@ pub(crate) struct ChatComposer<'a> {
ctrl_c_quit_hint: bool,
dismissed_file_popup_token: Option,
current_file_query: Option,
+ pending_pastes: Vec<(String, String)>,
}
/// Popup state – at most one can be visible at any time.
@@ -66,6 +70,7 @@ impl ChatComposer<'_> {
ctrl_c_quit_hint: false,
dismissed_file_popup_token: None,
current_file_query: None,
+ pending_pastes: Vec::new(),
};
this.update_border(has_input_focus);
this
@@ -126,6 +131,20 @@ impl ChatComposer<'_> {
self.update_border(has_focus);
}
+ pub fn handle_paste(&mut self, pasted: String) -> bool {
+ let char_count = pasted.chars().count();
+ if char_count > LARGE_PASTE_CHAR_THRESHOLD {
+ let placeholder = format!("[Pasted Content {char_count} chars]");
+ self.textarea.insert_str(&placeholder);
+ self.pending_pastes.push((placeholder, pasted));
+ } else {
+ self.textarea.insert_str(&pasted);
+ }
+ self.sync_command_popup();
+ self.sync_file_search_popup();
+ true
+ }
+
/// Integrate results from an asynchronous file search.
pub(crate) fn on_file_search_result(&mut self, query: String, matches: Vec) {
// Only apply if user is still editing a token starting with `query`.
@@ -414,10 +433,18 @@ impl ChatComposer<'_> {
alt: false,
ctrl: false,
} => {
- let text = self.textarea.lines().join("\n");
+ let mut text = self.textarea.lines().join("\n");
self.textarea.select_all();
self.textarea.cut();
+ // Replace all pending pastes in the text
+ for (placeholder, actual) in &self.pending_pastes {
+ if text.contains(placeholder) {
+ text = text.replace(placeholder, actual);
+ }
+ }
+ self.pending_pastes.clear();
+
if text.is_empty() {
(InputResult::None, true)
} else {
@@ -443,10 +470,71 @@ impl ChatComposer<'_> {
/// Handle generic Input events that modify the textarea content.
fn handle_input_basic(&mut self, input: Input) -> (InputResult, bool) {
+ // Special handling for backspace on placeholders
+ if let Input {
+ key: Key::Backspace,
+ ..
+ } = input
+ {
+ if self.try_remove_placeholder_at_cursor() {
+ return (InputResult::None, true);
+ }
+ }
+
+ // Normal input handling
self.textarea.input(input);
+ let text_after = self.textarea.lines().join("\n");
+
+ // Check if any placeholders were removed and remove their corresponding pending pastes
+ self.pending_pastes
+ .retain(|(placeholder, _)| text_after.contains(placeholder));
+
(InputResult::None, true)
}
+ /// Attempts to remove a placeholder if the cursor is at the end of one.
+ /// Returns true if a placeholder was removed.
+ fn try_remove_placeholder_at_cursor(&mut self) -> bool {
+ let (row, col) = self.textarea.cursor();
+ let line = self
+ .textarea
+ .lines()
+ .get(row)
+ .map(|s| s.as_str())
+ .unwrap_or("");
+
+ // Find any placeholder that ends at the cursor position
+ let placeholder_to_remove = self.pending_pastes.iter().find_map(|(ph, _)| {
+ if col < ph.len() {
+ return None;
+ }
+ let potential_ph_start = col - ph.len();
+ if line[potential_ph_start..col] == *ph {
+ Some(ph.clone())
+ } else {
+ None
+ }
+ });
+
+ if let Some(placeholder) = placeholder_to_remove {
+ // Remove the entire placeholder from the text
+ let placeholder_len = placeholder.len();
+ for _ in 0..placeholder_len {
+ self.textarea.input(Input {
+ key: Key::Backspace,
+ ctrl: false,
+ alt: false,
+ shift: false,
+ });
+ }
+ // Remove from pending pastes
+ self.pending_pastes.retain(|(ph, _)| ph != &placeholder);
+ true
+ } else {
+ false
+ }
+ }
+
/// Synchronize `self.command_popup` with the current text in the
/// textarea. This must be called after every modification that can change
/// the text so the popup is shown/updated/hidden as appropriate.
@@ -624,7 +712,10 @@ impl WidgetRef for &ChatComposer<'_> {
#[cfg(test)]
mod tests {
+ use crate::bottom_pane::AppEventSender;
use crate::bottom_pane::ChatComposer;
+ use crate::bottom_pane::InputResult;
+ use crate::bottom_pane::chat_composer::LARGE_PASTE_CHAR_THRESHOLD;
use tui_textarea::TextArea;
#[test]
@@ -770,4 +861,324 @@ mod tests {
);
}
}
+
+ #[test]
+ fn handle_paste_small_inserts_text() {
+ use crossterm::event::KeyCode;
+ use crossterm::event::KeyEvent;
+ use crossterm::event::KeyModifiers;
+
+ let (tx, _rx) = std::sync::mpsc::channel();
+ let sender = AppEventSender::new(tx);
+ let mut composer = ChatComposer::new(true, sender);
+
+ let needs_redraw = composer.handle_paste("hello".to_string());
+ assert!(needs_redraw);
+ assert_eq!(composer.textarea.lines(), ["hello"]);
+ assert!(composer.pending_pastes.is_empty());
+
+ let (result, _) =
+ composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
+ match result {
+ InputResult::Submitted(text) => assert_eq!(text, "hello"),
+ _ => panic!("expected Submitted"),
+ }
+ }
+
+ #[test]
+ fn handle_paste_large_uses_placeholder_and_replaces_on_submit() {
+ use crossterm::event::KeyCode;
+ use crossterm::event::KeyEvent;
+ use crossterm::event::KeyModifiers;
+
+ let (tx, _rx) = std::sync::mpsc::channel();
+ let sender = AppEventSender::new(tx);
+ let mut composer = ChatComposer::new(true, sender);
+
+ let large = "x".repeat(LARGE_PASTE_CHAR_THRESHOLD + 10);
+ let needs_redraw = composer.handle_paste(large.clone());
+ assert!(needs_redraw);
+ let placeholder = format!("[Pasted Content {} chars]", large.chars().count());
+ assert_eq!(composer.textarea.lines(), [placeholder.as_str()]);
+ assert_eq!(composer.pending_pastes.len(), 1);
+ assert_eq!(composer.pending_pastes[0].0, placeholder);
+ assert_eq!(composer.pending_pastes[0].1, large);
+
+ let (result, _) =
+ composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
+ match result {
+ InputResult::Submitted(text) => assert_eq!(text, large),
+ _ => panic!("expected Submitted"),
+ }
+ assert!(composer.pending_pastes.is_empty());
+ }
+
+ #[test]
+ fn edit_clears_pending_paste() {
+ use crossterm::event::KeyCode;
+ use crossterm::event::KeyEvent;
+ use crossterm::event::KeyModifiers;
+
+ let large = "y".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1);
+ let (tx, _rx) = std::sync::mpsc::channel();
+ let sender = AppEventSender::new(tx);
+ let mut composer = ChatComposer::new(true, sender);
+
+ composer.handle_paste(large);
+ assert_eq!(composer.pending_pastes.len(), 1);
+
+ // Any edit that removes the placeholder should clear pending_paste
+ composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
+ assert!(composer.pending_pastes.is_empty());
+ }
+
+ #[test]
+ fn ui_snapshots() {
+ use crossterm::event::KeyCode;
+ use crossterm::event::KeyEvent;
+ use crossterm::event::KeyModifiers;
+ use insta::assert_snapshot;
+ use ratatui::Terminal;
+ use ratatui::backend::TestBackend;
+
+ let (tx, _rx) = std::sync::mpsc::channel();
+ let sender = AppEventSender::new(tx);
+ let mut terminal = match Terminal::new(TestBackend::new(100, 10)) {
+ Ok(t) => t,
+ Err(e) => panic!("Failed to create terminal: {e}"),
+ };
+
+ let test_cases = vec![
+ ("empty", None),
+ ("small", Some("short".to_string())),
+ ("large", Some("z".repeat(LARGE_PASTE_CHAR_THRESHOLD + 5))),
+ ("multiple_pastes", None),
+ ("backspace_after_pastes", None),
+ ];
+
+ for (name, input) in test_cases {
+ // Create a fresh composer for each test case
+ let mut composer = ChatComposer::new(true, sender.clone());
+
+ if let Some(text) = input {
+ composer.handle_paste(text);
+ } else if name == "multiple_pastes" {
+ // First large paste
+ composer.handle_paste("x".repeat(LARGE_PASTE_CHAR_THRESHOLD + 3));
+ // Second large paste
+ composer.handle_paste("y".repeat(LARGE_PASTE_CHAR_THRESHOLD + 7));
+ // Small paste
+ composer.handle_paste(" another short paste".to_string());
+ } else if name == "backspace_after_pastes" {
+ // Three large pastes
+ composer.handle_paste("a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 2));
+ composer.handle_paste("b".repeat(LARGE_PASTE_CHAR_THRESHOLD + 4));
+ composer.handle_paste("c".repeat(LARGE_PASTE_CHAR_THRESHOLD + 6));
+ // Move cursor to end and press backspace
+ composer.textarea.move_cursor(tui_textarea::CursorMove::End);
+ composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
+ }
+
+ terminal
+ .draw(|f| f.render_widget_ref(&composer, f.area()))
+ .unwrap_or_else(|e| panic!("Failed to draw {name} composer: {e}"));
+
+ assert_snapshot!(name, terminal.backend());
+ }
+ }
+
+ #[test]
+ fn test_multiple_pastes_submission() {
+ use crossterm::event::KeyCode;
+ use crossterm::event::KeyEvent;
+ use crossterm::event::KeyModifiers;
+
+ let (tx, _rx) = std::sync::mpsc::channel();
+ let sender = AppEventSender::new(tx);
+ let mut composer = ChatComposer::new(true, sender);
+
+ // Define test cases: (paste content, is_large)
+ let test_cases = [
+ ("x".repeat(LARGE_PASTE_CHAR_THRESHOLD + 3), true),
+ (" and ".to_string(), false),
+ ("y".repeat(LARGE_PASTE_CHAR_THRESHOLD + 7), true),
+ ];
+
+ // Expected states after each paste
+ let mut expected_text = String::new();
+ let mut expected_pending_count = 0;
+
+ // Apply all pastes and build expected state
+ let states: Vec<_> = test_cases
+ .iter()
+ .map(|(content, is_large)| {
+ composer.handle_paste(content.clone());
+ if *is_large {
+ let placeholder = format!("[Pasted Content {} chars]", content.chars().count());
+ expected_text.push_str(&placeholder);
+ expected_pending_count += 1;
+ } else {
+ expected_text.push_str(content);
+ }
+ (expected_text.clone(), expected_pending_count)
+ })
+ .collect();
+
+ // Verify all intermediate states were correct
+ assert_eq!(
+ states,
+ vec![
+ (
+ format!("[Pasted Content {} chars]", test_cases[0].0.chars().count()),
+ 1
+ ),
+ (
+ format!(
+ "[Pasted Content {} chars] and ",
+ test_cases[0].0.chars().count()
+ ),
+ 1
+ ),
+ (
+ format!(
+ "[Pasted Content {} chars] and [Pasted Content {} chars]",
+ test_cases[0].0.chars().count(),
+ test_cases[2].0.chars().count()
+ ),
+ 2
+ ),
+ ]
+ );
+
+ // Submit and verify final expansion
+ let (result, _) =
+ composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
+ if let InputResult::Submitted(text) = result {
+ assert_eq!(text, format!("{} and {}", test_cases[0].0, test_cases[2].0));
+ } else {
+ panic!("expected Submitted");
+ }
+ }
+
+ #[test]
+ fn test_placeholder_deletion() {
+ use crossterm::event::KeyCode;
+ use crossterm::event::KeyEvent;
+ use crossterm::event::KeyModifiers;
+
+ let (tx, _rx) = std::sync::mpsc::channel();
+ let sender = AppEventSender::new(tx);
+ let mut composer = ChatComposer::new(true, sender);
+
+ // Define test cases: (content, is_large)
+ let test_cases = [
+ ("a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 5), true),
+ (" and ".to_string(), false),
+ ("b".repeat(LARGE_PASTE_CHAR_THRESHOLD + 6), true),
+ ];
+
+ // Apply all pastes
+ let mut current_pos = 0;
+ let states: Vec<_> = test_cases
+ .iter()
+ .map(|(content, is_large)| {
+ composer.handle_paste(content.clone());
+ if *is_large {
+ let placeholder = format!("[Pasted Content {} chars]", content.chars().count());
+ current_pos += placeholder.len();
+ } else {
+ current_pos += content.len();
+ }
+ (
+ composer.textarea.lines().join("\n"),
+ composer.pending_pastes.len(),
+ current_pos,
+ )
+ })
+ .collect();
+
+ // Delete placeholders one by one and collect states
+ let mut deletion_states = vec![];
+
+ // First deletion
+ composer
+ .textarea
+ .move_cursor(tui_textarea::CursorMove::Jump(0, states[0].2 as u16));
+ composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
+ deletion_states.push((
+ composer.textarea.lines().join("\n"),
+ composer.pending_pastes.len(),
+ ));
+
+ // Second deletion
+ composer
+ .textarea
+ .move_cursor(tui_textarea::CursorMove::Jump(
+ 0,
+ composer.textarea.lines().join("\n").len() as u16,
+ ));
+ composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
+ deletion_states.push((
+ composer.textarea.lines().join("\n"),
+ composer.pending_pastes.len(),
+ ));
+
+ // Verify all states
+ assert_eq!(
+ deletion_states,
+ vec![
+ (" and [Pasted Content 1006 chars]".to_string(), 1),
+ (" and ".to_string(), 0),
+ ]
+ );
+ }
+
+ #[test]
+ fn test_partial_placeholder_deletion() {
+ use crossterm::event::KeyCode;
+ use crossterm::event::KeyEvent;
+ use crossterm::event::KeyModifiers;
+
+ let (tx, _rx) = std::sync::mpsc::channel();
+ let sender = AppEventSender::new(tx);
+ let mut composer = ChatComposer::new(true, sender);
+
+ // Define test cases: (cursor_position_from_end, expected_pending_count)
+ let test_cases = [
+ 5, // Delete from middle - should clear tracking
+ 0, // Delete from end - should clear tracking
+ ];
+
+ let paste = "x".repeat(LARGE_PASTE_CHAR_THRESHOLD + 4);
+ let placeholder = format!("[Pasted Content {} chars]", paste.chars().count());
+
+ let states: Vec<_> = test_cases
+ .into_iter()
+ .map(|pos_from_end| {
+ composer.handle_paste(paste.clone());
+ composer
+ .textarea
+ .move_cursor(tui_textarea::CursorMove::Jump(
+ 0,
+ (placeholder.len() - pos_from_end) as u16,
+ ));
+ composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
+ let result = (
+ composer.textarea.lines().join("\n").contains(&placeholder),
+ composer.pending_pastes.len(),
+ );
+ composer.textarea.select_all();
+ composer.textarea.cut();
+ result
+ })
+ .collect();
+
+ assert_eq!(
+ states,
+ vec![
+ (false, 0), // After deleting from middle
+ (false, 0), // After deleting from end
+ ]
+ );
+ }
}
diff --git a/codex-rs/tui/src/bottom_pane/mod.rs b/codex-rs/tui/src/bottom_pane/mod.rs
index 96f5c70285..350492b3e9 100644
--- a/codex-rs/tui/src/bottom_pane/mod.rs
+++ b/codex-rs/tui/src/bottom_pane/mod.rs
@@ -82,6 +82,15 @@ impl BottomPane<'_> {
}
}
+ pub fn handle_paste(&mut self, pasted: String) {
+ if self.active_view.is_none() {
+ let needs_redraw = self.composer.handle_paste(pasted);
+ if needs_redraw {
+ self.request_redraw();
+ }
+ }
+ }
+
/// Update the status indicator text (only when the `StatusIndicatorView` is
/// active).
pub(crate) fn update_status_text(&mut self, text: String) {
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__backspace_after_pastes.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__backspace_after_pastes.snap
new file mode 100644
index 0000000000..fa604c862b
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__backspace_after_pastes.snap
@@ -0,0 +1,14 @@
+---
+source: tui/src/bottom_pane/chat_composer.rs
+expression: terminal.backend()
+---
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮"
+"│[Pasted Content 1002 chars][Pasted Content 1004 chars] │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"╰───────────────────────────────────────────────Enter to send | Ctrl+D to quit | Ctrl+J for newline╯"
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__empty.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__empty.snap
new file mode 100644
index 0000000000..a89076d8aa
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__empty.snap
@@ -0,0 +1,14 @@
+---
+source: tui/src/bottom_pane/chat_composer.rs
+expression: terminal.backend()
+---
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮"
+"│ send a message │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"╰───────────────────────────────────────────────Enter to send | Ctrl+D to quit | Ctrl+J for newline╯"
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__large.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__large.snap
new file mode 100644
index 0000000000..39a62da400
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__large.snap
@@ -0,0 +1,14 @@
+---
+source: tui/src/bottom_pane/chat_composer.rs
+expression: terminal.backend()
+---
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮"
+"│[Pasted Content 1005 chars] │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"╰───────────────────────────────────────────────Enter to send | Ctrl+D to quit | Ctrl+J for newline╯"
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__multiple_pastes.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__multiple_pastes.snap
new file mode 100644
index 0000000000..cd94095431
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__multiple_pastes.snap
@@ -0,0 +1,14 @@
+---
+source: tui/src/bottom_pane/chat_composer.rs
+expression: terminal.backend()
+---
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮"
+"│[Pasted Content 1003 chars][Pasted Content 1007 chars] another short paste │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"╰───────────────────────────────────────────────Enter to send | Ctrl+D to quit | Ctrl+J for newline╯"
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__small.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__small.snap
new file mode 100644
index 0000000000..e6b55e36d8
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__small.snap
@@ -0,0 +1,14 @@
+---
+source: tui/src/bottom_pane/chat_composer.rs
+expression: terminal.backend()
+---
+"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮"
+"│short │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"│ │"
+"╰───────────────────────────────────────────────Enter to send | Ctrl+D to quit | Ctrl+J for newline╯"
diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs
index 0b623132b5..865e339763 100644
--- a/codex-rs/tui/src/chatwidget.rs
+++ b/codex-rs/tui/src/chatwidget.rs
@@ -174,6 +174,12 @@ impl ChatWidget<'_> {
}
}
+ pub(crate) fn handle_paste(&mut self, text: String) {
+ if matches!(self.input_focus, InputFocus::BottomPane) {
+ self.bottom_pane.handle_paste(text);
+ }
+ }
+
fn submit_user_message(&mut self, user_message: UserMessage) {
let UserMessage { text, image_paths } = user_message;
let mut items: Vec = Vec::new();