codexcw 0.3.0__tar.gz → 0.4.0__tar.gz

{codexcw-0.3.0 → codexcw-0.4.0}/Cargo.lock

@@ -22,7 +22,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "codexcw"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -35,7 +35,7 @@ dependencies = [
 
 [[package]]
 name = "codexcw-node"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "codexcw",
  "napi",
@@ -47,7 +47,7 @@ dependencies = [
 
 [[package]]
 name = "codexcw-py"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "codexcw",
  "pyo3",

{codexcw-0.3.0 → codexcw-0.4.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/codexcw", "bindings/python"]
 
 [workspace.package]
-version = "0.3.0"
+version = "0.4.0"
 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.3.0" }
+codexcw = { path = "crates/codexcw", version = "0.4.0" }
 tokio = { version = "1", default-features = false, features = [
   "process",
   "io-util",

{codexcw-0.3.0 → codexcw-0.4.0}/PKG-INFO

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

{codexcw-0.3.0 → codexcw-0.4.0}/bindings/python/src/lib.rs

@@ -122,6 +122,12 @@ pub struct PyItem {
     raw: String,
     #[pyo3(get)]
     changes: Vec<PyFileChange>,
+    #[pyo3(get)]
+    tool: String,
+    #[pyo3(get)]
+    sender_thread_id: String,
+    #[pyo3(get)]
+    receiver_thread_ids: Vec<String>,
 }
 
 /// One decoded agent event.
@@ -628,6 +634,9 @@ fn to_py_item(item: &Item) -> PyItem {
                 kind: c.kind.clone(),
             })
             .collect(),
+        tool: item.tool.clone(),
+        sender_thread_id: item.sender_thread_id.clone(),
+        receiver_thread_ids: item.receiver_thread_ids.clone(),
     }
 }
 

{codexcw-0.3.0 → codexcw-0.4.0}/bindings/python/uv.lock

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

{codexcw-0.3.0 → codexcw-0.4.0}/crates/codexcw/src/claude.rs

@@ -341,6 +341,11 @@ impl ClaudeDecoder {
                     item.changes[0].kind = kind;
                 }
             }
+            if item.kind == ItemKind::CollabToolCall {
+                if let Some(agent_id) = collab_agent_id(wire.tool_use_result.as_deref()) {
+                    item.receiver_thread_ids = vec![agent_id];
+                }
+            }
             events.push(item_completed(&base, item));
         }
         if events.is_empty() {
@@ -403,21 +408,48 @@ impl ClaudeDecoder {
 }
 
 fn result_usage(wire: &WireEvent) -> Usage {
+    // result.usage covers the root agent only; modelUsage and the cost also
+    // cover subagents. The full-run total comes from modelUsage when Claude
+    // reports it.
+    let mut total_tokens = wire.usage.input_tokens
+        + wire.usage.cache_creation_input_tokens
+        + wire.usage.cache_read_input_tokens
+        + wire.usage.output_tokens;
+    if !wire.model_usage.is_empty() {
+        total_tokens = wire
+            .model_usage
+            .values()
+            .map(|usage| {
+                usage.input_tokens
+                    + usage.cache_creation_input_tokens
+                    + usage.cache_read_input_tokens
+                    + usage.output_tokens
+            })
+            .sum();
+    }
+
     Usage {
         input_tokens: wire.usage.input_tokens,
         cache_creation_input_tokens: wire.usage.cache_creation_input_tokens,
         cached_input_tokens: wire.usage.cache_read_input_tokens,
         output_tokens: wire.usage.output_tokens,
-        total_tokens: wire.usage.input_tokens
-            + wire.usage.cache_creation_input_tokens
-            + wire.usage.cache_read_input_tokens
-            + wire.usage.output_tokens,
+        total_tokens,
         total_cost_usd: wire.total_cost_usd,
         model_usage: wire.model_usage.clone(),
         reasoning_output_tokens: 0,
     }
 }
 
+fn collab_agent_id(tool_use_result: Option<&RawValue>) -> Option<String> {
+    #[derive(serde::Deserialize)]
+    struct Wire {
+        #[serde(rename = "agentId", default)]
+        agent_id: String,
+    }
+    let wire: Wire = serde_json::from_str(tool_use_result?.get()).ok()?;
+    (!wire.agent_id.is_empty()).then_some(wire.agent_id)
+}
+
 fn tool_item(block: &WireBlock, raw_block: &str) -> Item {
     let input: WireToolInput = block
         .input
@@ -455,7 +487,12 @@ fn tool_item(block: &WireBlock, raw_block: &str) -> Item {
             }];
         }
         "WebSearch" => item.kind = ItemKind::WebSearch,
-        "Task" => item.kind = ItemKind::CollabToolCall,
+        // "Task" is the legacy name of the subagent tool; current Claude
+        // Code CLIs call it "Agent".
+        "Task" | "Agent" => {
+            item.kind = ItemKind::CollabToolCall;
+            item.tool = block.name.clone();
+        }
         "TodoWrite" => item.kind = ItemKind::PlanUpdate,
         name if name.starts_with("mcp__") => item.kind = ItemKind::McpToolCall,
         _ => item.kind = ItemKind::ToolCall,
@@ -716,11 +753,65 @@ mod tests {
             .unwrap();
         let task = started[0].item_started().unwrap();
         assert_eq!(task.kind, ItemKind::CollabToolCall);
+        assert_eq!(task.tool, "Task");
         assert!(task.raw.contains("subagent_type"));
         let todo = started[1].item_started().unwrap();
         assert_eq!(todo.kind, ItemKind::PlanUpdate);
     }
 
+    #[test]
+    fn agent_tool_maps_to_collab_with_receiver_id() {
+        // Current Claude Code CLIs call the subagent tool "Agent"; "Task" is
+        // the legacy name. This mirrors a real 2.1.x payload.
+        let mut decoder = ClaudeDecoder::default();
+        let started = decoder
+            .decode(
+                br#"{"type":"assistant","message":{"id":"msg_1","content":[{"type":"tool_use","id":"toolu_1","name":"Agent","input":{"subagent_type":"Explore","prompt":"reply SUBAGENT_CHILD_OK"}}]},"session_id":"s"}"#,
+                "run-x",
+                "s",
+                SystemTime::UNIX_EPOCH,
+            )
+            .unwrap();
+        let item = started[0].item_started().unwrap();
+        assert_eq!(item.kind, ItemKind::CollabToolCall);
+        assert_eq!(item.tool, "Agent");
+
+        let completed = decoder
+            .decode(
+                br#"{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"toolu_1","content":[{"type":"text","text":"SUBAGENT_CHILD_OK"}]}]},"tool_use_result":{"status":"completed","agentType":"Explore","agentId":"agent-123","resolvedModel":"claude-sonnet-5","totalTokens":12460},"session_id":"s"}"#,
+                "run-x",
+                "s",
+                SystemTime::UNIX_EPOCH,
+            )
+            .unwrap();
+        let item = completed[0].item_completed().unwrap();
+        assert_eq!(item.kind, ItemKind::CollabToolCall);
+        assert_eq!(item.tool, "Agent");
+        assert_eq!(item.status, "completed");
+        assert_eq!(item.receiver_thread_ids, vec!["agent-123".to_string()]);
+        assert_eq!(item.aggregated_output, "SUBAGENT_CHILD_OK");
+    }
+
+    #[test]
+    fn result_total_tokens_come_from_model_usage_when_present() {
+        let mut decoder = ClaudeDecoder::default();
+        let events = decoder
+            .decode(
+                br#"{"type":"result","is_error":false,"result":"ok","session_id":"s","total_cost_usd":0.5,"usage":{"input_tokens":100,"cache_creation_input_tokens":200,"cache_read_input_tokens":300,"output_tokens":50},"modelUsage":{"claude-sonnet-5":{"inputTokens":100,"outputTokens":50,"cacheReadInputTokens":300,"cacheCreationInputTokens":200},"claude-haiku-4-5-20251001":{"inputTokens":8000,"outputTokens":460,"cacheReadInputTokens":3000,"cacheCreationInputTokens":1000}}}"#,
+                "run-x",
+                "s",
+                SystemTime::UNIX_EPOCH,
+            )
+            .unwrap();
+        let EventPayload::TurnCompleted { usage } = &events.last().unwrap().payload else {
+            panic!("expected turn.completed");
+        };
+        assert_eq!(usage.input_tokens, 100);
+        // The root result.usage sums to 650; the subagent's 12460 tokens only
+        // appear in modelUsage, and the full-run total must include them.
+        assert_eq!(usage.total_tokens, 650 + 12460);
+    }
+
     #[test]
     fn bash_failure_extracts_exit_code() {
         let mut decoder = ClaudeDecoder::default();

{codexcw-0.3.0 → codexcw-0.4.0}/crates/codexcw/src/decoder.rs

@@ -46,6 +46,12 @@ struct WireItem {
     exit_code: Option<i32>,
     #[serde(default)]
     changes: Vec<FileChange>,
+    #[serde(default)]
+    tool: String,
+    #[serde(default)]
+    sender_thread_id: String,
+    #[serde(default)]
+    receiver_thread_ids: Vec<String>,
 }
 
 /// Decodes one JSONL line into an [`Event`].
@@ -83,10 +89,12 @@ pub(crate) fn decode_event(
             }
         }
         EventKind::TurnStarted => EventPayload::TurnStarted,
-        EventKind::TurnCompleted => EventPayload::TurnCompleted { usage: wire.usage },
+        EventKind::TurnCompleted => EventPayload::TurnCompleted {
+            usage: normalize_codex_usage(wire.usage),
+        },
         EventKind::TurnFailed => EventPayload::TurnFailed {
             error: decode_event_error(wire.error.as_deref()),
-            usage: wire.usage,
+            usage: normalize_codex_usage(wire.usage),
         },
         EventKind::ItemStarted => EventPayload::ItemStarted(decode_item(wire.item.as_deref())?),
         EventKind::ItemCompleted => EventPayload::ItemCompleted(decode_item(wire.item.as_deref())?),
@@ -129,9 +137,22 @@ fn decode_item(raw: Option<&RawValue>) -> Result<Item, String> {
         aggregated_output: wire.aggregated_output,
         exit_code: wire.exit_code,
         changes: wire.changes,
+        tool: wire.tool,
+        sender_thread_id: wire.sender_thread_id,
+        receiver_thread_ids: wire.receiver_thread_ids,
     })
 }
 
+/// Derives the total when Codex omits `total_tokens`. `cached_input_tokens`
+/// is a subset of `input_tokens` on the codex wire, so the derived total is
+/// input plus output; an explicit total is preserved.
+fn normalize_codex_usage(mut usage: Usage) -> Usage {
+    if usage.total_tokens == 0 {
+        usage.total_tokens = usage.input_tokens + usage.output_tokens;
+    }
+    usage
+}
+
 fn decode_event_error(raw: Option<&RawValue>) -> ErrorPayload {
     let Some(raw) = raw else {
         return ErrorPayload::default();
@@ -216,6 +237,68 @@ mod tests {
         assert_eq!(item.kind, ItemKind::CollabToolCall);
         assert_eq!(item.status, "in_progress");
         assert!(item.raw.contains("\"tool\":\"wait\""));
+        assert_eq!(item.tool, "wait");
+        assert_eq!(item.sender_thread_id, "t-parent");
+        assert!(item.receiver_thread_ids.is_empty());
+    }
+
+    #[test]
+    fn collab_tool_call_exposes_receiver_thread_ids() {
+        let event = decode_event(
+            br#"{"type":"item.started","item":{"id":"i0","type":"collab_tool_call","tool":"spawn_agent","sender_thread_id":"t-parent","receiver_thread_ids":["t-child"],"agents_states":{},"status":"in_progress"}}"#,
+            "run-x",
+            "t-parent",
+            SystemTime::UNIX_EPOCH,
+        )
+        .unwrap();
+        let item = event.item_started().unwrap();
+        assert_eq!(item.tool, "spawn_agent");
+        assert_eq!(item.receiver_thread_ids, vec!["t-child".to_string()]);
+    }
+
+    #[test]
+    fn turn_completed_total_tokens_derived_when_omitted() {
+        // cached_input_tokens is a subset of input_tokens on the codex wire
+        // and must not be counted twice.
+        let event = decode_event(
+            br#"{"type":"turn.completed","usage":{"input_tokens":12966,"cached_input_tokens":8960,"output_tokens":6,"reasoning_output_tokens":0}}"#,
+            "run-x",
+            "t-1",
+            SystemTime::UNIX_EPOCH,
+        )
+        .unwrap();
+        let EventPayload::TurnCompleted { usage } = &event.payload else {
+            panic!("expected turn.completed");
+        };
+        assert_eq!(usage.total_tokens, 12972);
+
+        let explicit = decode_event(
+            br#"{"type":"turn.completed","usage":{"input_tokens":10,"output_tokens":3,"total_tokens":999}}"#,
+            "run-x",
+            "t-1",
+            SystemTime::UNIX_EPOCH,
+        )
+        .unwrap();
+        let EventPayload::TurnCompleted { usage } = &explicit.payload else {
+            panic!("expected turn.completed");
+        };
+        assert_eq!(usage.total_tokens, 999);
+    }
+
+    #[test]
+    fn turn_failed_total_tokens_derived_when_omitted() {
+        let event = decode_event(
+            br#"{"type":"turn.failed","error":{"message":"boom"},"usage":{"input_tokens":12966,"cached_input_tokens":8960,"output_tokens":6}}"#,
+            "run-x",
+            "t-1",
+            SystemTime::UNIX_EPOCH,
+        )
+        .unwrap();
+        let EventPayload::TurnFailed { error, usage } = &event.payload else {
+            panic!("expected turn.failed");
+        };
+        assert_eq!(error.message, "boom");
+        assert_eq!(usage.total_tokens, 12972);
     }
 
     #[test]

{codexcw-0.3.0 → codexcw-0.4.0}/crates/codexcw/src/event.rs

@@ -151,7 +151,9 @@ pub struct Usage {
     /// Number of reasoning output tokens.
     #[serde(default)]
     pub reasoning_output_tokens: i64,
-    /// Total tokens reported or calculated for the turn.
+    /// Total token count for the full run, subagents included. When the
+    /// agent omits an explicit total it is derived: input plus output tokens
+    /// for Codex, and the per-model sums when Claude reports model usage.
     #[serde(default)]
     pub total_tokens: i64,
     /// Total Claude API cost in US dollars.
@@ -226,6 +228,13 @@ pub struct Item {
     pub exit_code: Option<i32>,
     /// File edits for `file_change` items.
     pub changes: Vec<FileChange>,
+    /// Collab operation (`spawn_agent`, `wait`, ...) for `collab_tool_call`
+    /// items.
+    pub tool: String,
+    /// Thread that issued a `collab_tool_call` item.
+    pub sender_thread_id: String,
+    /// Agent threads targeted by a `collab_tool_call` item.
+    pub receiver_thread_ids: Vec<String>,
 }
 
 impl Default for ItemKind {

{codexcw-0.3.0 → codexcw-0.4.0}/pyproject.toml

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

{codexcw-0.3.0 → codexcw-0.4.0}/python/codexcw/_codexcw.pyi

@@ -37,6 +37,9 @@ class PyItem:
     exit_code: Optional[int]
     raw: str
     changes: List[PyFileChange]
+    tool: str
+    sender_thread_id: str
+    receiver_thread_ids: List[str]
 
 class PyEvent:
     type: str