codexcw 0.2.0__tar.gz → 0.2.2__tar.gz

{codexcw-0.2.0 → codexcw-0.2.2}/Cargo.lock

@@ -22,7 +22,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "codexcw"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "serde",
  "serde_json",
@@ -35,7 +35,7 @@ dependencies = [
 
 [[package]]
 name = "codexcw-node"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "codexcw",
  "napi",
@@ -47,7 +47,7 @@ dependencies = [
 
 [[package]]
 name = "codexcw-py"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "codexcw",
  "pyo3",
@@ -238,9 +238,9 @@ dependencies = [
 
 [[package]]
 name = "napi"
-version = "3.9.3"
+version = "3.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbd9f9295f3ff5921e78a71222c3361a8216f7760b1a99a6ad4e8441de18bbb9"
+checksum = "0c71997d6f7ad4a756966e452426848ac27d3b37a295302d63afbbcce0270f93"
 dependencies = [
  "bitflags",
  "ctor",
@@ -260,9 +260,9 @@ checksum = "c9c366d2c8c60b86fa632df75f745509b52f9128f91a6bad4c796e44abb505e1"
 
 [[package]]
 name = "napi-derive"
-version = "3.5.6"
+version = "3.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b3f766e04667e6da0e181e2da4f85475d5a6513b7cf6a80bea184e224a5b42"
+checksum = "6730ee4e7b335eac6d7cf10fc2525d92743bd4713a13cb2e6667f0e97322d7c3"
 dependencies = [
  "convert_case",
  "ctor",
@@ -274,9 +274,9 @@ dependencies = [
 
 [[package]]
 name = "napi-derive-backend"
-version = "5.0.4"
+version = "5.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d5af30503edf933ce7377cf6d4c877a62b0f1107ea05585f1b5e430e88d5baf"
+checksum = "db5ccc18b1b16d1049dcbd3e1a21fdfbf3ce720b8944979c5e1a76d4e30d9f9f"
 dependencies = [
  "convert_case",
  "proc-macro2",

{codexcw-0.2.0 → codexcw-0.2.2}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/codexcw", "bindings/python"]
 
 [workspace.package]
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 rust-version = "1.90"
 license = "CC0-1.0"
@@ -12,7 +12,7 @@ homepage = "https://github.com/c3-oss/codexcw"
 authors = ["c3-oss"]
 
 [workspace.dependencies]
-codexcw = { path = "crates/codexcw", version = "0.2.0" }
+codexcw = { path = "crates/codexcw", version = "0.2.2" }
 tokio = { version = "1", default-features = false, features = [
   "process",
   "io-util",

{codexcw-0.2.0 → codexcw-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codexcw
-Version: 0.2.0
+Version: 0.2.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: POSIX

{codexcw-0.2.0 → codexcw-0.2.2}/bindings/python/src/lib.rs

@@ -420,12 +420,12 @@ struct AccountUsageReqData {
 }
 
 impl AccountUsageReqData {
-    fn into_core(self) -> CoreAccountUsageRequest {
-        CoreAccountUsageRequest {
+    fn into_core(self) -> Result<CoreAccountUsageRequest, PyError> {
+        Ok(CoreAccountUsageRequest {
             executable: self.executable,
             env: self.env.unwrap_or_default().into_iter().collect(),
-            timeout: self.timeout.map(Duration::from_secs_f64),
-        }
+            timeout: self.timeout.map(parse_account_usage_timeout).transpose()?,
+        })
     }
 }
 
@@ -467,6 +467,15 @@ fn invalid_request(message: String) -> PyError {
     }
 }
 
+fn parse_account_usage_timeout(timeout: f64) -> Result<Duration, PyError> {
+    Duration::try_from_secs_f64(timeout).map_err(|_| {
+        invalid_request(
+            "account usage timeout must be finite, non-negative, and within the supported duration range"
+                .to_string(),
+        )
+    })
+}
+
 fn to_py_usage(usage: &Usage) -> PyUsage {
     PyUsage {
         input_tokens: usage.input_tokens,
@@ -691,7 +700,15 @@ fn to_py_account_usage(usage: &CoreAccountUsage) -> PyAccountUsage {
 #[pyfunction]
 #[pyo3(signature = (req=None))]
 fn get_account_usage(py: Python<'_>, req: Option<AccountUsageReqData>) -> PyAccountUsageOutcome {
-    let core_req = req.map(AccountUsageReqData::into_core).unwrap_or_default();
+    let core_req = match req.map(AccountUsageReqData::into_core).transpose() {
+        Ok(req) => req.unwrap_or_default(),
+        Err(error) => {
+            return PyAccountUsageOutcome {
+                result: None,
+                error: Some(error),
+            };
+        }
+    };
     let result = py.detach(|| runtime().block_on(core_get_account_usage(core_req)));
     match result {
         Ok(usage) => PyAccountUsageOutcome {
@@ -818,6 +835,9 @@ impl Session {
 struct LiveGroup {
     core: codexcw::Group,
     stream: Mutex<ReceiverStream<codexcw::RunEvent>>,
+    indices: Vec<usize>,
+    conversion_errors: Vec<(usize, PyError)>,
+    total: usize,
 }
 
 /// A batch of running `codex exec` processes.
@@ -827,12 +847,20 @@ pub struct Group {
 }
 
 impl Group {
-    fn from_core(mut core: codexcw::Group) -> Self {
+    fn from_core(
+        mut core: codexcw::Group,
+        indices: Vec<usize>,
+        conversion_errors: Vec<(usize, PyError)>,
+        total: usize,
+    ) -> Self {
         let stream = core.events();
         Group {
             inner: LiveGroup {
                 core,
                 stream: Mutex::new(stream),
+                indices,
+                conversion_errors,
+                total,
             },
         }
     }
@@ -851,7 +879,7 @@ impl Group {
         });
         run_event.map(|re| PyRunEvent {
             run_id: re.run_id,
-            index: re.index as u32,
+            index: self.inner.indices[re.index] as u32,
             event: to_py_event(&re.event),
         })
     }
@@ -867,14 +895,27 @@ impl Group {
             Ok(results) => results,
             Err(group_error) => group_error.results,
         });
-        results
+        let mut mapped: Vec<Option<PyGroupResult>> = vec![None; self.inner.total];
+        for (index, error) in &self.inner.conversion_errors {
+            mapped[*index] = Some(PyGroupResult {
+                index: *index as u32,
+                run_id: String::new(),
+                result: None,
+                error: Some(error.clone()),
+            });
+        }
+        for result in results {
+            let index = self.inner.indices[result.index];
+            mapped[index] = Some(PyGroupResult {
+                index: index as u32,
+                run_id: result.run_id,
+                result: result.result.as_ref().map(to_py_result),
+                error: result.error.as_ref().map(to_py_error),
+            });
+        }
+        mapped
             .into_iter()
-            .map(|r| PyGroupResult {
-                index: r.index as u32,
-                run_id: r.run_id,
-                result: r.result.as_ref().map(to_py_result),
-                error: r.error.as_ref().map(to_py_error),
-            })
+            .map(|result| result.expect("group result missing"))
             .collect()
     }
 
@@ -998,10 +1039,19 @@ impl Runner {
         max_concurrent: Option<u32>,
         event_buffer: Option<u32>,
     ) -> Group {
-        let core_reqs: Vec<Request> = reqs
-            .into_iter()
-            .map(|r| r.into_core().unwrap_or_default())
-            .collect();
+        let total = reqs.len();
+        let mut core_reqs = Vec::with_capacity(reqs.len());
+        let mut indices = Vec::with_capacity(reqs.len());
+        let mut conversion_errors = Vec::new();
+        for (index, req) in reqs.into_iter().enumerate() {
+            match req.into_core() {
+                Ok(request) => {
+                    core_reqs.push(request);
+                    indices.push(index);
+                }
+                Err(error) => conversion_errors.push((index, error)),
+            }
+        }
         let mut many = ManyOptions::default();
         if let Some(n) = max_concurrent {
             many.max_concurrent = n as usize;
@@ -1011,7 +1061,7 @@ impl Runner {
         }
         let runner = self.core.clone();
         let core_group = py.detach(move || runtime().block_on(runner.run_many(core_reqs, many)));
-        Group::from_core(core_group)
+        Group::from_core(core_group, indices, conversion_errors, total)
     }
 }
 

{codexcw-0.2.0 → codexcw-0.2.2}/bindings/python/tests/test_smoke.py

@@ -148,6 +148,38 @@ def test_run_many_collects_results(tmp_path):
         assert result.result.final_message == "Oi."
 
 
+def test_run_many_preserves_request_conversion_errors(tmp_path):
+    runner, _, _ = _runner_with_capture(tmp_path)
+
+    group = runner.run_many(
+        [
+            Request(prompt="bad sandbox", sandbox="bogus"),
+            Request(prompt="valid"),
+            Request(prompt="bad approval", approval="bogus"),
+        ]
+    )
+
+    event_indices = [run_event.index for run_event in group.events()]
+    results = group.wait()
+
+    assert [result.index for result in results] == [0, 1, 2]
+    assert event_indices
+    assert set(event_indices) == {1}
+
+    assert isinstance(results[0].error, CodexcwError)
+    assert results[0].error.kind == "invalidRequest"
+    assert "unknown sandbox mode: bogus" in str(results[0].error)
+    assert results[0].result is None
+
+    assert results[1].error is None
+    assert results[1].result.final_message == "Oi."
+
+    assert isinstance(results[2].error, CodexcwError)
+    assert results[2].error.kind == "invalidRequest"
+    assert "unknown approval policy: bogus" in str(results[2].error)
+    assert results[2].result is None
+
+
 def test_get_account_usage_reads_limits(tmp_path):
     fake = _usage_fake(tmp_path)
     args_file = tmp_path / "usage-args.txt"
@@ -214,6 +246,18 @@ done
     assert "timeout" in str(excinfo.value)
 
 
+@pytest.mark.parametrize(
+    "timeout",
+    [-1.0, float("nan"), float("inf"), float("-inf"), sys.float_info.max],
+)
+def test_get_account_usage_rejects_invalid_timeout(timeout):
+    with pytest.raises(CodexcwError) as excinfo:
+        get_account_usage(AccountUsageRequest(timeout=timeout))
+
+    assert excinfo.value.kind == "invalidRequest"
+    assert "account usage timeout must be finite, non-negative" in str(excinfo.value)
+
+
 async def test_async_run_and_stream(tmp_path):
     args_file = tmp_path / "args.txt"
     stdin_file = tmp_path / "stdin.txt"
@@ -251,6 +295,18 @@ async def test_async_get_account_usage(tmp_path):
     assert usage.token_usage.daily_usage_buckets[0].tokens == "42"
 
 
+@pytest.mark.parametrize(
+    "timeout",
+    [-1.0, float("nan"), float("inf"), float("-inf"), sys.float_info.max],
+)
+async def test_async_get_account_usage_rejects_invalid_timeout(timeout):
+    with pytest.raises(CodexcwError) as excinfo:
+        await codexcw.aio.get_account_usage(AccountUsageRequest(timeout=timeout))
+
+    assert excinfo.value.kind == "invalidRequest"
+    assert "account usage timeout must be finite, non-negative" in str(excinfo.value)
+
+
 @pytest.mark.skipif(
     os.environ.get("CODEXCW_LIVE_CODEX") != "1",
     reason="set CODEXCW_LIVE_CODEX=1 to run against the real codex executable",

{codexcw-0.2.0 → codexcw-0.2.2}/bindings/python/uv.lock

@@ -17,7 +17,7 @@ wheels = [
 
 [[package]]
 name = "codexcw"
-version = "0.2.0"
+version = "0.2.2"
 source = { editable = "." }
 
 [package.optional-dependencies]

{codexcw-0.2.0 → codexcw-0.2.2}/crates/codexcw/src/group.rs

@@ -106,10 +106,13 @@ impl Runner {
     pub async fn run_many(&self, reqs: Vec<Request>, opts: ManyOptions) -> Group {
         let event_buffer = opts.event_buffer.unwrap_or(self.event_buffer()).max(1);
         let max_concurrent = opts.max_concurrent.max(1);
+        let (event_tx, event_rx) = mpsc::unbounded_channel();
         let (tx, rx) = mpsc::channel(event_buffer);
         let cancel = CancellationToken::new();
         let completion = Arc::new(Latch::new());
 
+        tokio::spawn(forward_events(event_rx, tx, cancel.clone()));
+
         let runner = self.clone();
         let task_cancel = cancel.clone();
         let task_completion = completion.clone();
@@ -120,7 +123,7 @@ impl Runner {
                 reqs,
                 max_concurrent,
                 run_opts,
-                tx,
+                event_tx,
                 task_cancel,
                 task_completion,
             )
@@ -140,7 +143,7 @@ async fn run_many_inner(
     reqs: Vec<Request>,
     max_concurrent: usize,
     run_opts: RunOptions,
-    tx: mpsc::Sender<RunEvent>,
+    event_tx: mpsc::UnboundedSender<RunEvent>,
     cancel: CancellationToken,
     completion: Arc<Latch<Vec<GroupResult>>>,
 ) {
@@ -166,17 +169,17 @@ async fn run_many_inner(
             .await
             .expect("semaphore closed");
         let runner = runner.clone();
-        let tx = tx.clone();
+        let event_tx = event_tx.clone();
         let cancel = cancel.clone();
         let run_opts = run_opts.clone();
         set.spawn(async move {
             let _permit = permit;
-            let result = run_one(runner, index, req, run_opts, tx, cancel).await;
+            let result = run_one(runner, index, req, run_opts, event_tx, cancel).await;
             (index, result)
         });
     }
 
-    drop(tx);
+    drop(event_tx);
 
     while let Some(joined) = set.join_next().await {
         if let Ok((index, result)) = joined {
@@ -200,12 +203,37 @@ async fn run_many_inner(
     completion.set(results);
 }
 
+async fn forward_events(
+    mut source: mpsc::UnboundedReceiver<RunEvent>,
+    destination: mpsc::Sender<RunEvent>,
+    cancel: CancellationToken,
+) {
+    loop {
+        let event = tokio::select! {
+            biased;
+            _ = cancel.cancelled() => break,
+            event = source.recv() => event,
+        };
+        let Some(event) = event else {
+            break;
+        };
+        let sent = tokio::select! {
+            biased;
+            _ = cancel.cancelled() => break,
+            sent = destination.send(event) => sent,
+        };
+        if sent.is_err() {
+            break;
+        }
+    }
+}
+
 async fn run_one(
     runner: Runner,
     index: usize,
     req: Request,
     run_opts: RunOptions,
-    tx: mpsc::Sender<RunEvent>,
+    event_tx: mpsc::UnboundedSender<RunEvent>,
     cancel: CancellationToken,
 ) -> GroupResult {
     let mut session = match runner.start_opts(req, run_opts).await {
@@ -232,13 +260,11 @@ async fn run_one(
             event = session.next_event() => {
                 match event {
                     Some(event) => {
-                        let _ = tx
-                            .send(RunEvent {
-                                run_id: run_id.clone(),
-                                index,
-                                event,
-                            })
-                            .await;
+                        let _ = event_tx.send(RunEvent {
+                            run_id: run_id.clone(),
+                            index,
+                            event,
+                        });
                     }
                     None => break,
                 }

{codexcw-0.2.0 → codexcw-0.2.2}/crates/codexcw/src/runner.rs

@@ -148,11 +148,14 @@ impl Runner {
         }
 
         let run_id = new_run_id();
+        let (event_tx, event_rx) = mpsc::unbounded_channel();
         let (tx, rx) = mpsc::channel(self.inner.event_buffer.max(1));
         let cancel = CancellationToken::new();
         let thread_id = Arc::new(Mutex::new(String::new()));
         let completion = Arc::new(Completion::new());
 
+        tokio::spawn(forward_events(event_rx, tx));
+
         let tail = Arc::new(TailBuffer::new(self.inner.stderr_limit));
         let stderr_task = tokio::spawn(drain_stderr(stderr, tail.clone()));
 
@@ -161,7 +164,7 @@ impl Runner {
             stdout,
             stderr_task,
             tail,
-            tx,
+            event_tx,
             cancel: cancel.clone(),
             completion: completion.clone(),
             handler: opts.handler,
@@ -289,7 +292,7 @@ struct CollectCtx {
     stdout: ChildStdout,
     stderr_task: tokio::task::JoinHandle<()>,
     tail: Arc<TailBuffer>,
-    tx: mpsc::Sender<Event>,
+    event_tx: mpsc::UnboundedSender<Event>,
     cancel: CancellationToken,
     completion: Arc<Completion>,
     handler: Option<Handler>,
@@ -309,13 +312,24 @@ pub(crate) async fn drain_stderr(mut stderr: ChildStderr, tail: Arc<TailBuffer>)
     }
 }
 
+async fn forward_events(
+    mut source: mpsc::UnboundedReceiver<Event>,
+    destination: mpsc::Sender<Event>,
+) {
+    while let Some(event) = source.recv().await {
+        if destination.send(event).await.is_err() {
+            break;
+        }
+    }
+}
+
 async fn collect(ctx: CollectCtx) {
     let CollectCtx {
         mut child,
         stdout,
         stderr_task,
         tail,
-        tx,
+        event_tx,
         cancel,
         completion,
         handler,
@@ -406,18 +420,7 @@ async fn collect(ctx: CollectCtx) {
         last_event = Some(event.clone());
         events.push(event.clone());
 
-        tokio::select! {
-            biased;
-            _ = cancel.cancelled() => {
-                if run_err.is_none() {
-                    run_err = Some(Error::Cancelled);
-                }
-                break;
-            }
-            send = tx.send(event.clone()) => {
-                let _ = send;
-            }
-        }
+        let _ = event_tx.send(event.clone());
 
         if let Some(handler) = &handler {
             if let Err(message) = handler(event.clone()).await {
@@ -459,7 +462,6 @@ async fn collect(ctx: CollectCtx) {
         report,
         error: run_err,
     });
-    drop(tx);
 }
 
 fn classify_process_error(

{codexcw-0.2.0 → codexcw-0.2.2}/crates/codexcw/tests/runner_it.rs

@@ -7,6 +7,7 @@ mod common;
 
 use codexcw::{handler, Error, EventKind, EventPayload, ManyOptions, Request, RunOptions, Runner};
 use common::{read_args, write_fake_codex};
+use tokio::time::{timeout, Duration};
 
 fn runner_for(fake: &common::FakeCodex) -> Runner {
     Runner::builder()
@@ -308,3 +309,242 @@ printf '%s\n' '{"type":"turn.completed","usage":{"input_tokens":1,"output_tokens
         .expect("second result");
     assert!(matches!(failed.error, Some(Error::PromptRequired)));
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn session_wait_completes_when_event_buffer_fills() {
+    let fake = write_fake_codex(
+        r#"record_args "$@"
+cat >/dev/null
+printf '%s\n' '{"type":"thread.started","thread_id":"thread-buffer"}'
+printf '%s\n' '{"type":"turn.started"}'
+printf '%s\n' '{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"done"}}'
+printf '%s\n' '{"type":"turn.completed","usage":{"input_tokens":1,"output_tokens":1}}'
+"#,
+    );
+    let runner = Runner::builder()
+        .executable(fake.executable())
+        .event_buffer(1)
+        .build();
+    let mut session = runner
+        .start(Request::new("buffer"))
+        .await
+        .expect("session starts");
+
+    let result = timeout(Duration::from_secs(5), session.wait())
+        .await
+        .expect("wait must not depend on event consumption")
+        .expect("run succeeds");
+
+    assert_eq!(result.events.len(), 4);
+    assert_eq!(result.final_message, "done");
+
+    let mut streamed = Vec::new();
+    while let Some(event) = session.next_event().await {
+        streamed.push(event.kind);
+    }
+    assert_eq!(
+        streamed,
+        [
+            EventKind::ThreadStarted,
+            EventKind::TurnStarted,
+            EventKind::ItemCompleted,
+            EventKind::TurnCompleted,
+        ]
+    );
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn session_wait_handles_claude_shaped_events_without_consumption() {
+    let fake = write_fake_codex(
+        r#"record_args "$@"
+cat >/dev/null
+printf '%s\n' '{"type":"system","subtype":"init","session_id":"session-buffer"}'
+printf '%s\n' '{"type":"rate_limit_event","session_id":"session-buffer"}'
+printf '%s\n' '{"type":"result","subtype":"success","result":"done","session_id":"session-buffer"}'
+"#,
+    );
+    let runner = Runner::builder()
+        .executable(fake.executable())
+        .event_buffer(1)
+        .build();
+    let session = runner
+        .start(Request::new("buffer"))
+        .await
+        .expect("session starts");
+
+    let result = timeout(Duration::from_secs(5), session.wait())
+        .await
+        .expect("wait must not depend on event shape")
+        .expect("run succeeds");
+    let kinds: Vec<&str> = result
+        .events
+        .iter()
+        .map(|event| event.kind.as_str())
+        .collect();
+
+    assert_eq!(kinds, ["system", "rate_limit_event", "result"]);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn group_wait_completes_when_event_buffer_fills() {
+    let fake = write_fake_codex(
+        r#"record_args "$@"
+cat >/dev/null
+printf '%s\n' '{"type":"thread.started","thread_id":"thread-group-buffer"}'
+printf '%s\n' '{"type":"turn.started"}'
+printf '%s\n' '{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"done"}}'
+printf '%s\n' '{"type":"turn.completed","usage":{"input_tokens":1,"output_tokens":1}}'
+"#,
+    );
+    let mut group = runner_for(&fake)
+        .run_many(
+            vec![Request::new("a"), Request::new("b")],
+            ManyOptions {
+                max_concurrent: 2,
+                event_buffer: Some(1),
+                ..Default::default()
+            },
+        )
+        .await;
+
+    let results = timeout(Duration::from_secs(5), group.wait())
+        .await
+        .expect("group wait must not depend on event consumption")
+        .expect("group succeeds");
+
+    assert_eq!(results.len(), 2);
+    assert!(results.iter().all(|result| result
+        .result
+        .as_ref()
+        .is_some_and(|report| report.events.len() == 4)));
+
+    let mut event_count = 0;
+    while group.next_event().await.is_some() {
+        event_count += 1;
+    }
+    assert_eq!(event_count, 8);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn group_cancel_releases_forwarding_blocked_by_backpressure() {
+    let fake = write_fake_codex(
+        r#"record_args "$@"
+cat >/dev/null
+printf '%s\n' '{"type":"thread.started","thread_id":"thread-group-cancel"}'
+printf '%s\n' '{"type":"turn.started"}'
+printf '%s\n' '{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"working"}}'
+mkfifo "$CODEXCW_WAIT_FIFO"
+read -r _ < "$CODEXCW_WAIT_FIFO"
+"#,
+    );
+    let wait_fifo = fake.stdin_file.with_file_name("wait.fifo");
+    let runner = Runner::builder()
+        .executable(fake.executable())
+        .env("CODEXCW_WAIT_FIFO", wait_fifo.to_str().unwrap())
+        .build();
+    let mut group = runner
+        .run_many(
+            vec![Request::new("cancel")],
+            ManyOptions {
+                event_buffer: Some(1),
+                ..Default::default()
+            },
+        )
+        .await;
+
+    timeout(Duration::from_secs(5), group.next_event())
+        .await
+        .expect("first event must arrive")
+        .expect("event stream remains open");
+    tokio::time::sleep(Duration::from_millis(100)).await;
+    group.cancel();
+
+    let error = timeout(Duration::from_secs(5), group.wait())
+        .await
+        .expect("cancelled group must finish under backpressure")
+        .expect_err("group is cancelled");
+    assert!(matches!(error.results[0].error, Some(Error::Cancelled)));
+
+    let mut remaining = 0;
+    loop {
+        match timeout(Duration::from_secs(2), group.next_event()).await {
+            Ok(Some(_)) => remaining += 1,
+            Ok(None) => break,
+            Err(_) => panic!("cancelled forwarder must close the event stream"),
+        }
+    }
+    assert!(
+        remaining <= 1,
+        "cancelled forwarder delivered {remaining} queued events"
+    );
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn event_stream_preserves_order_with_small_buffer() {
+    let fake = write_fake_codex(
+        r#"record_args "$@"
+cat >/dev/null
+printf '%s\n' '{"type":"thread.started","thread_id":"thread-order"}'
+printf '%s\n' '{"type":"turn.started"}'
+printf '%s\n' '{"type":"item.started","item":{"id":"item_0","type":"agent_message"}}'
+printf '%s\n' '{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"done"}}'
+printf '%s\n' '{"type":"turn.completed","usage":{"input_tokens":1,"output_tokens":1}}'
+"#,
+    );
+    let runner = Runner::builder()
+        .executable(fake.executable())
+        .event_buffer(1)
+        .build();
+    let mut session = runner
+        .start(Request::new("order"))
+        .await
+        .expect("session starts");
+    let mut kinds = Vec::new();
+
+    while let Some(event) = session.next_event().await {
+        kinds.push(event.kind);
+    }
+    session.wait().await.expect("run succeeds");
+
+    assert_eq!(
+        kinds,
+        [
+            EventKind::ThreadStarted,
+            EventKind::TurnStarted,
+            EventKind::ItemStarted,
+            EventKind::ItemCompleted,
+            EventKind::TurnCompleted,
+        ]
+    );
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn session_wait_handles_large_event_burst_without_consumption() {
+    let fake = write_fake_codex(
+        r#"record_args "$@"
+cat >/dev/null
+i=0
+while [ "$i" -lt 4096 ]; do
+  printf '{"type":"burst.%s"}\n' "$i"
+  i=$((i + 1))
+done
+"#,
+    );
+    let runner = Runner::builder()
+        .executable(fake.executable())
+        .event_buffer(1)
+        .build();
+    let session = runner
+        .start(Request::new("burst"))
+        .await
+        .expect("session starts");
+
+    let result = timeout(Duration::from_secs(5), session.wait())
+        .await
+        .expect("large burst must not block completion")
+        .expect("run succeeds");
+
+    assert_eq!(result.events.len(), 4096);
+    assert_eq!(result.events[0].kind.as_str(), "burst.0");
+    assert_eq!(result.events[4095].kind.as_str(), "burst.4095");
+}

{codexcw-0.2.0 → codexcw-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "codexcw"
-version = "0.2.0"
+version = "0.2.2"
 description = "Run the Codex CLI non-interactively from Python, backed by a Rust core."
 readme = "README.md"
 requires-python = ">=3.9"