agentshim 0.3.0__tar.gz → 0.3.1__tar.gz

{agentshim-0.3.0 → agentshim-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentshim
-Version: 0.3.0
+Version: 0.3.1
 Summary: Provider-agnostic coding-agent CLI shims
 Requires-Python: >=3.10
 Requires-Dist: litellm>=1.0.0

{agentshim-0.3.0 → agentshim-0.3.1}/agentshim/claude/agent.py

@@ -53,6 +53,10 @@ class ClaudeGenerationSession(CLIGenerationSession):
     def _handle_event(self, event: ClaudeEvent):
         """Handle a single parsed Claude event."""
         if isinstance(event, MultiEvent):
+            if event.usage and self.event_handler is not None:
+                on_usage = getattr(self.event_handler, "on_usage", None)
+                if on_usage is not None:
+                    on_usage(event.usage)
             for sub_event in event.events:
                 self._handle_event(sub_event)
             return
@@ -105,6 +109,9 @@ class ClaudeGenerationSession(CLIGenerationSession):
 
         elif isinstance(event, ResultEvent):
             self.final_result = event.result
+            self.final_usage = event.usage
+            self.total_cost_usd = event.total_cost_usd
+            self.duration_ms = event.duration_ms
             # Anthropic reports cache_creation + cache_read as disjoint
             # from input_tokens; fold them into input_tokens to match the
             # crucible invariant (cached ⊆ input).

{agentshim-0.3.0 → agentshim-0.3.1}/agentshim/claude/events.py

@@ -36,7 +36,8 @@ class ClaudeEvent(ABC):
                             parameters=block.get("input"),
                         )
                     )
-            return MultiEvent(events) if events else None
+            usage = message.get("usage")
+            return MultiEvent(events, usage=usage) if events else None
         if event_type == "user":
             message = data.get("message", {})
             content_blocks = message.get("content", [])
@@ -53,6 +54,7 @@ class ClaudeEvent(ABC):
                 num_turns=data.get("num_turns"),
                 usage=data.get("usage"),
                 total_cost_usd=data.get("total_cost_usd"),
+                duration_ms=data.get("duration_ms"),
             )
 
         return None
@@ -61,8 +63,13 @@ class ClaudeEvent(ABC):
 class MultiEvent(ClaudeEvent):
     """Container for multiple events from a single message."""
 
-    def __init__(self, events: list[ClaudeEvent]):
+    def __init__(
+        self,
+        events: list[ClaudeEvent],
+        usage: dict[str, Any] | None = None,
+    ):
         self.events = events
+        self.usage = usage
 
     def render(self, log_prefix: str) -> str | None:
         # MultiEvent doesn't render itself; events are handled individually
@@ -138,11 +145,13 @@ class ResultEvent(ClaudeEvent):
         num_turns: int | None = None,
         usage: dict[str, Any] | None = None,
         total_cost_usd: float | None = None,
+        duration_ms: int | None = None,
     ):
         self.result = result
         self.num_turns = num_turns
         self.usage = usage
         self.total_cost_usd = total_cost_usd
+        self.duration_ms = duration_ms
 
     def render(self, log_prefix: str) -> str | None:
         # Result events are silent (result is captured separately)

{agentshim-0.3.0 → agentshim-0.3.1}/agentshim/cli_agent.py

@@ -56,6 +56,11 @@ class CLIGenerationSession:
         # Providers populate this during event handling; stays at the
         # empty default if the session crashes before any terminal event.
         self.usage: ProviderUsage = ProviderUsage()
+        # Final provider-reported accounting snapshot, when the CLI exposes
+        # one on a terminal event.
+        self.final_usage: dict[str, Any] | None = None
+        self.total_cost_usd: float | None = None
+        self.duration_ms: int | None = None
         # Provider session id captured from the event stream (set by subclasses
         # that parse JSON events). ``None`` if the underlying CLI did not emit
         # an id during this run.

{agentshim-0.3.0 → agentshim-0.3.1}/agentshim/codex/agent.py

@@ -15,6 +15,7 @@ from ..usage import ProviderUsage, TokenUsage
 from .events import (
     CodexEvent,
     ErrorEvent,
+    LifecycleEvent,
     TextEvent,
     ThreadStartedEvent,
     ToolResultEvent,
@@ -38,21 +39,28 @@ class CodexGenerationSession(CLIGenerationSession):
         self._accumulated_tokens = TokenUsage()
 
     def _process_stdout(self, line: str) -> None:
-        if not line:
+        if not line.strip():
             return
         try:
             data = json.loads(line)
         except json.JSONDecodeError:
-            self.stdout_lines.append(line.rstrip())
-            if not self.silent:
+            stripped = line.rstrip()
+            self.stdout_lines.append(stripped)
+            if self.event_handler and stripped:
+                self.event_handler.on_thinking(stripped)
+            elif not self.silent:
                 if self._at_line_start:
                     self._log_raw(f"{self.log_prefix} ")
-                self._log_raw(line.rstrip() + "\n")
+                self._log_raw(stripped + "\n")
                 self._at_line_start = True
             return
 
         event = CodexEvent.from_dict(data)
         if event is None:
+            stripped = line.rstrip()
+            if self.event_handler and stripped:
+                self.event_handler.on_thinking(stripped)
+            self.stdout_lines.append(stripped)
             return
         self._handle_event(event)
 
@@ -65,6 +73,13 @@ class CodexGenerationSession(CLIGenerationSession):
         if isinstance(event, ThreadStartedEvent):
             if self.session_id is None and event.thread_id:
                 self.session_id = event.thread_id
+            if self.event_handler and event.thread_id:
+                self.event_handler.on_thinking(f"[codex thread {event.thread_id} started]")
+            return
+
+        if isinstance(event, LifecycleEvent):
+            if self.event_handler and event.event_type == "turn.started":
+                self.event_handler.on_thinking("[codex turn started]")
             return
 
         if isinstance(event, TextEvent):
@@ -76,12 +91,12 @@ class CodexGenerationSession(CLIGenerationSession):
             return
 
         if isinstance(event, ToolUseEvent):
-            if event.tool_id:
+            if event.tool_name == "execute" and event.tool_id:
                 self.tool_map[event.tool_id] = event.tool_name
                 self.tool_start_times[event.tool_id] = time.time()
                 self.tool_args[event.tool_id] = event.parameters
-                if self.event_handler:
-                    self.event_handler.on_tool_call(event.tool_name, event.parameters)
+            if self.event_handler:
+                self.event_handler.on_tool_call(event.tool_name, event.parameters)
             return
 
         if isinstance(event, TurnCompletedEvent):
@@ -96,16 +111,48 @@ class CodexGenerationSession(CLIGenerationSession):
                 total_cost_usd=None,
                 provider="codex",
             )
+            normalized_usage = {
+                "input_tokens": event.input_tokens,
+                "output_tokens": event.output_tokens,
+                "cache_read_input_tokens": event.cached_input_tokens,
+                "cache_creation_input_tokens": 0,
+            }
+            if event.has_usage:
+                self.final_usage = normalized_usage
+            if self.event_handler is not None and event.has_usage:
+                on_usage = getattr(self.event_handler, "on_usage", None)
+                if on_usage is not None:
+                    on_usage(normalized_usage)
+                self.event_handler.on_thinking(
+                    f"[codex turn complete: in={normalized_usage['input_tokens']} "
+                    f"cached={normalized_usage['cache_read_input_tokens']} "
+                    f"out={normalized_usage['output_tokens']}]"
+                )
+            elif self.event_handler is not None:
+                self.event_handler.on_thinking("[codex turn complete]")
             return
 
         if isinstance(event, ToolResultEvent):
             if not event.tool_id:
-                return
-            event.tool_name_resolved = self.tool_map.get(event.tool_id, "Tool")
+                if event.tool_name is None:
+                    return
+                event.tool_name_resolved = event.tool_name
+                args = event.parameters or {}
+                duration = None
+                if self.event_handler:
+                    self.event_handler.on_tool_call(event.tool_name, args)
+            else:
+                event.tool_name_resolved = self.tool_map.get(
+                    event.tool_id,
+                    event.tool_name or "Tool",
+                )
+
+                start_time = self.tool_start_times.get(event.tool_id)
+                duration = time.time() - start_time if start_time else None
+                args = self.tool_args.get(event.tool_id, event.parameters or {})
 
-            start_time = self.tool_start_times.get(event.tool_id)
-            duration = time.time() - start_time if start_time else None
-            args = self.tool_args.get(event.tool_id, {})
+                if event.tool_id not in self.tool_map and self.event_handler and event.tool_name:
+                    self.event_handler.on_tool_call(event.tool_name, args)
 
             self.recorder.add_tool_call(
                 tool=event.tool_name_resolved,
@@ -140,8 +187,20 @@ class CodexGenerationSession(CLIGenerationSession):
         if isinstance(event, ErrorEvent):
             self.stdout_lines.append(event.message)
 
+    def _process_stderr(self, line: str) -> None:
+        line_stripped = line.rstrip("\n")
+        self.stderr_lines.append(line)
+        if self.event_handler and line_stripped:
+            self.event_handler.on_thinking(f"[codex stderr] {line_stripped}")
+        elif not self.silent:
+            self.logger.bind(stderr=True).info(f"[STDERR] {line_stripped}")
+
     def run(self, prompt: str) -> str:
-        super().run(prompt)
+        started = time.monotonic()
+        try:
+            super().run(prompt)
+        finally:
+            self.duration_ms = int((time.monotonic() - started) * 1000)
         if self.final_result:
             return self.final_result
         return "\n".join(self.stdout_lines)

{agentshim-0.3.0 → agentshim-0.3.1}/agentshim/codex/events.py

@@ -27,13 +27,7 @@ class CodexEvent(ABC):
             return LifecycleEvent(event_type)
 
         if event_type == "turn.completed":
-            usage_raw = data.get("usage")
-            usage = cast("dict[str, Any]", usage_raw) if isinstance(usage_raw, dict) else {}
-            return TurnCompletedEvent(
-                input_tokens=int(usage.get("input_tokens") or 0),
-                cached_input_tokens=int(usage.get("cached_input_tokens") or 0),
-                output_tokens=int(usage.get("output_tokens") or 0),
-            )
+            return TurnCompletedEvent.from_usage_payload(data.get("usage"))
 
         if event_type in ("item.started", "item.completed"):
             item_raw = data.get("item")
@@ -52,7 +46,15 @@ class CodexEvent(ABC):
                 text_raw = item.get("text", "")
                 return TextEvent(text=text_raw if isinstance(text_raw, str) else "")
 
+            if item_type == "reasoning":
+                if not completed:
+                    return None
+                text_raw = item.get("text", "")
+                return TextEvent(text=text_raw if isinstance(text_raw, str) else "")
+
             if item_type == "command_execution":
+                command_raw = item.get("command", "")
+                command = command_raw if isinstance(command_raw, str) else ""
                 exit_code_raw = item.get("exit_code")
                 exit_code = exit_code_raw if isinstance(exit_code_raw, int) else None
                 status_raw = item.get("status")
@@ -63,23 +65,22 @@ class CodexEvent(ABC):
                         output=item.get("aggregated_output", ""),
                         exit_code=exit_code,
                         status=status,
+                        tool_name="execute",
+                        parameters={"command": command},
                     )
-                command_raw = item.get("command", "")
-                command = command_raw if isinstance(command_raw, str) else ""
                 return ToolUseEvent(
                     tool_id=item_id,
-                    tool_name="shell",
+                    tool_name="execute",
                     parameters={"command": command},
                 )
 
             status_raw = item.get("status")
             status = status_raw if isinstance(status_raw, str) else None
             if completed:
-                return ToolResultEvent(
+                return ToolUseEvent(
                     tool_id=item_id,
-                    output=_summarize_item(item),
-                    exit_code=None,
-                    status=status,
+                    tool_name=item_type or "item",
+                    parameters=_item_parameters(item),
                 )
             return ToolUseEvent(
                 tool_id=item_id,
@@ -171,6 +172,8 @@ class ToolResultEvent(CodexEvent):
         tool_id: str | None,
         exit_code: int | None = None,
         status: str | None = None,
+        tool_name: str | None = None,
+        parameters: Any = None,
     ):
         if isinstance(output, list):
             items = cast("list[Any]", output)
@@ -180,7 +183,9 @@ class ToolResultEvent(CodexEvent):
         self.tool_id = tool_id
         self.exit_code = exit_code
         self.status = status
-        self.tool_name_resolved: str = "Tool"
+        self.tool_name = tool_name
+        self.parameters = parameters
+        self.tool_name_resolved: str = tool_name or "Tool"
 
     def render(self, log_prefix: str) -> str:
         if not self.output:
@@ -197,10 +202,27 @@ class TurnCompletedEvent(CodexEvent):
         input_tokens: int = 0,
         cached_input_tokens: int = 0,
         output_tokens: int = 0,
+        usage: dict[str, Any] | None = None,
     ):
         self.input_tokens = input_tokens
         self.cached_input_tokens = cached_input_tokens
         self.output_tokens = output_tokens
+        self.usage = usage
+
+    @classmethod
+    def from_usage_payload(cls, usage_raw: Any) -> TurnCompletedEvent:
+        usage = cast("dict[str, Any]", usage_raw) if isinstance(usage_raw, dict) else None
+        usage_dict = usage or {}
+        return cls(
+            input_tokens=int(usage_dict.get("input_tokens") or 0),
+            cached_input_tokens=int(usage_dict.get("cached_input_tokens") or 0),
+            output_tokens=int(usage_dict.get("output_tokens") or 0),
+            usage=usage,
+        )
+
+    @property
+    def has_usage(self) -> bool:
+        return self.usage is not None
 
     def render(self, log_prefix: str) -> str | None:
         return None

{agentshim-0.3.0 → agentshim-0.3.1}/agentshim/events.py

@@ -22,3 +22,7 @@ class AgentEventHandler(Protocol):
     ) -> None:
         """Handle tool execution result."""
         ...
+
+    def on_usage(self, usage: dict[str, Any]) -> None:
+        """Handle a per-turn usage update from the underlying CLI."""
+        ...

{agentshim-0.3.0 → agentshim-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentshim"
-version = "0.3.0"
+version = "0.3.1"
 description = "Provider-agnostic coding-agent CLI shims"
 readme = "README.md"
 requires-python = ">=3.10"

{agentshim-0.3.0 → agentshim-0.3.1}/tests/unit/test_agent_cli_claude.py

@@ -135,6 +135,19 @@ class TestClaudeGenerationSession:
         session._process_stdout(line)
         assert session.final_result == "all done"
 
+    def test_result_event_captures_final_usage_cost_and_duration(self):
+        session = self._make_session()
+        line = (
+            '{"type":"result","result":"done",'
+            '"usage":{"input_tokens":7000,"output_tokens":120},'
+            '"total_cost_usd":0.0456,"duration_ms":12345}\n'
+        )
+        session._process_stdout(line)
+        assert session.final_result == "done"
+        assert session.final_usage == {"input_tokens": 7000, "output_tokens": 120}
+        assert session.total_cost_usd == 0.0456
+        assert session.duration_ms == 12345
+
     def test_process_stdout_handles_non_json(self):
         session = self._make_session()
         session._process_stdout("some plain text\n")
@@ -162,6 +175,59 @@ class TestClaudeGenerationSession:
         session._process_stdout(line)
         handler.on_tool_call.assert_called_once_with("Read", {"path": "/tmp"})
 
+    def test_assistant_usage_forwarded_to_event_handler(self):
+        handler = MagicMock()
+        session = self._make_session(event_handler=handler)
+        line = (
+            '{"type":"assistant","message":{"content":'
+            '[{"type":"text","text":"ok"}],'
+            '"usage":{"input_tokens":14000,"output_tokens":50,'
+            '"cache_creation_input_tokens":0,"cache_read_input_tokens":0}}}\n'
+        )
+        session._process_stdout(line)
+        handler.on_usage.assert_called_once_with(
+            {
+                "input_tokens": 14000,
+                "output_tokens": 50,
+                "cache_creation_input_tokens": 0,
+                "cache_read_input_tokens": 0,
+            }
+        )
+
+    def test_assistant_without_usage_does_not_call_on_usage(self):
+        handler = MagicMock()
+        session = self._make_session(event_handler=handler)
+        line = (
+            '{"type":"assistant","message":{"content":'
+            '[{"type":"text","text":"ok"}]}}\n'
+        )
+        session._process_stdout(line)
+        handler.on_usage.assert_not_called()
+
+    def test_legacy_event_handler_without_on_usage_still_works(self):
+        class LegacyHandler:
+            def __init__(self):
+                self.text_calls = []
+
+            def on_thinking(self, text):
+                self.text_calls.append(text)
+
+            def on_tool_call(self, tool, args=None):
+                pass
+
+            def on_tool_result(self, tool, stdout="", stderr="", exit_code=None, duration=None):
+                pass
+
+        handler = LegacyHandler()
+        session = self._make_session(event_handler=handler)
+        line = (
+            '{"type":"assistant","message":{"content":'
+            '[{"type":"text","text":"hi"}],'
+            '"usage":{"input_tokens":500,"output_tokens":10}}}\n'
+        )
+        session._process_stdout(line)
+        assert handler.text_calls == ["hi"]
+
     def test_create_session_returns_claude_session(self, agent):
         session = agent._create_session(cmd=["claude", "-p"])
         assert isinstance(session, ClaudeGenerationSession)

agentshim-0.3.1/tests/unit/test_agent_cli_codex.py

@@ -0,0 +1,243 @@
+import json
+from unittest.mock import MagicMock
+
+import pytest
+
+from agentshim.cli_agent import CLICodingAgent
+from agentshim.codex import CodexCodingAgent, CodexGenerationSession
+from agentshim.mcp_config import HttpMcpServer, StdioMcpServer
+
+
+@pytest.fixture
+def mock_binaries(monkeypatch):
+    """Mock binary discovery and CLI check."""
+    monkeypatch.setattr(
+        "agentshim.cli_agent.shutil.which",
+        lambda cmd, path=None: f"/usr/local/bin/{cmd}",
+    )
+    monkeypatch.setattr(CLICodingAgent, "_check_cli", lambda self: None)
+
+
+@pytest.fixture
+def agent(mock_binaries):
+    return CodexCodingAgent(model="test-model")
+
+
+class TestCodexCommandConstruction:
+    def test_command_base_flags(self, agent):
+        cmd = agent._get_command("test")
+        assert "exec" in cmd
+        assert "--dangerously-bypass-approvals-and-sandbox" in cmd
+        assert "--json" in cmd
+        assert cmd[-1] == "-"
+
+    def test_command_omits_mcp_when_no_servers(self, agent):
+        cmd = agent._get_command("test")
+        assert "-c" not in cmd
+        assert cmd[-1] == "-"
+
+    def test_mcp_http_server(self, mock_binaries):
+        servers = [HttpMcpServer(name="srv", url="http://localhost:9000/sse")]
+        agent = CodexCodingAgent(mcp_servers=servers)
+        cmd = agent._get_command("test")
+        assert "-c" in cmd
+        idx = cmd.index("-c")
+        assert cmd[idx + 1] == 'mcp_servers.srv.url="http://localhost:9000/sse"'
+
+    def test_mcp_stdio_server(self, mock_binaries):
+        servers = [StdioMcpServer(name="tool", command="npx", args=["-y", "pkg"])]
+        agent = CodexCodingAgent(mcp_servers=servers)
+        cmd = agent._get_command("test")
+        c_values = [cmd[i + 1] for i, v in enumerate(cmd) if v == "-c"]
+        assert 'mcp_servers.tool.command="npx"' in c_values
+        assert 'mcp_servers.tool.args=["-y", "pkg"]' in c_values
+
+    def test_mcp_stdio_server_with_env(self, mock_binaries):
+        servers = [StdioMcpServer(name="t", command="cmd", env={"K1": "v1", "K2": "v2"})]
+        agent = CodexCodingAgent(mcp_servers=servers)
+        cmd = agent._get_command("test")
+        c_values = [cmd[i + 1] for i, v in enumerate(cmd) if v == "-c"]
+        assert 'mcp_servers.t.env.K1="v1"' in c_values
+        assert 'mcp_servers.t.env.K2="v2"' in c_values
+
+    def test_mcp_multiple_servers(self, mock_binaries):
+        servers = [
+            HttpMcpServer(name="a", url="http://a"),
+            StdioMcpServer(name="b", command="cmd"),
+        ]
+        agent = CodexCodingAgent(mcp_servers=servers)
+        cmd = agent._get_command("test")
+        c_values = [cmd[i + 1] for i, v in enumerate(cmd) if v == "-c"]
+        assert 'mcp_servers.a.url="http://a"' in c_values
+        assert 'mcp_servers.b.command="cmd"' in c_values
+
+
+def _session(event_handler=None) -> CodexGenerationSession:
+    session = CodexGenerationSession(
+        binary_name="codex",
+        env={},
+        log_prefix="[Codex]",
+        cmd=["codex", "exec", "--json", "-"],
+        logger=MagicMock(),
+        silent=True,
+        event_handler=event_handler,
+    )
+    return session
+
+
+class TestCodexGenerationSession:
+    def test_thread_started_captures_session_id_and_emits_marker(self):
+        handler = MagicMock()
+        session = _session(event_handler=handler)
+        session._process_stdout(json.dumps({"type": "thread.started", "thread_id": "t-1"}))
+        assert session.session_id == "t-1"
+        handler.on_thinking.assert_called_once_with("[codex thread t-1 started]")
+
+    def test_turn_started_emits_marker(self):
+        handler = MagicMock()
+        session = _session(event_handler=handler)
+        session._process_stdout(json.dumps({"type": "turn.started"}))
+        handler.on_thinking.assert_called_once_with("[codex turn started]")
+
+    def test_turn_completed_forwards_normalized_usage(self):
+        handler = MagicMock()
+        session = _session(event_handler=handler)
+        session._process_stdout(
+            json.dumps(
+                {
+                    "type": "turn.completed",
+                    "usage": {
+                        "input_tokens": 1200,
+                        "cached_input_tokens": 800,
+                        "output_tokens": 150,
+                    },
+                }
+            )
+        )
+        handler.on_usage.assert_called_once_with(
+            {
+                "input_tokens": 1200,
+                "output_tokens": 150,
+                "cache_read_input_tokens": 800,
+                "cache_creation_input_tokens": 0,
+            }
+        )
+        assert session.final_usage == {
+            "input_tokens": 1200,
+            "output_tokens": 150,
+            "cache_read_input_tokens": 800,
+            "cache_creation_input_tokens": 0,
+        }
+        thinking_calls = [call.args[0] for call in handler.on_thinking.call_args_list]
+        assert any("turn complete" in text for text in thinking_calls)
+
+    def test_turn_completed_without_usage_does_not_call_on_usage(self):
+        handler = MagicMock()
+        session = _session(event_handler=handler)
+        session._process_stdout(json.dumps({"type": "turn.completed"}))
+        handler.on_usage.assert_not_called()
+        assert session.final_usage is None
+        handler.on_thinking.assert_called_once_with("[codex turn complete]")
+
+    def test_legacy_event_handler_without_on_usage_still_works(self):
+        class LegacyHandler:
+            def on_thinking(self, text):
+                pass
+
+            def on_tool_call(self, tool, args=None):
+                pass
+
+            def on_tool_result(self, tool, stdout="", stderr="", exit_code=None, duration=None):
+                pass
+
+        session = _session(event_handler=LegacyHandler())
+        session._process_stdout(
+            json.dumps(
+                {
+                    "type": "turn.completed",
+                    "usage": {
+                        "input_tokens": 10,
+                        "cached_input_tokens": 2,
+                        "output_tokens": 3,
+                    },
+                }
+            )
+        )
+
+    def test_reasoning_completed_is_forwarded_as_thinking(self):
+        handler = MagicMock()
+        session = _session(event_handler=handler)
+        session._process_stdout(
+            json.dumps(
+                {
+                    "type": "item.completed",
+                    "item": {"id": "r1", "type": "reasoning", "text": "I should grep for X"},
+                }
+            )
+        )
+        handler.on_thinking.assert_called_once_with("I should grep for X")
+
+    def test_command_execution_completed_without_started_event_emits_call_and_result(self):
+        handler = MagicMock()
+        session = _session(event_handler=handler)
+        session._process_stdout(
+            json.dumps(
+                {
+                    "type": "item.completed",
+                    "item": {
+                        "type": "command_execution",
+                        "command": "ls -la",
+                        "aggregated_output": "file.txt\n",
+                    },
+                }
+            )
+        )
+        handler.on_tool_call.assert_called_once_with("execute", {"command": "ls -la"})
+        handler.on_tool_result.assert_called_once_with(
+            tool="execute",
+            stdout="file.txt\n",
+            exit_code=None,
+            duration=None,
+        )
+
+    def test_unknown_item_completed_surfaces_tool_call_with_full_payload(self):
+        handler = MagicMock()
+        session = _session(event_handler=handler)
+        session._process_stdout(
+            json.dumps(
+                {
+                    "type": "item.completed",
+                    "item": {
+                        "id": "fc1",
+                        "type": "file_change",
+                        "path": "engine.py",
+                        "kind": "update",
+                    },
+                }
+            )
+        )
+        handler.on_tool_call.assert_called_once_with(
+            "file_change",
+            {"path": "engine.py", "kind": "update"},
+        )
+
+    def test_non_json_stdout_line_is_forwarded_to_event_handler(self):
+        handler = MagicMock()
+        session = _session(event_handler=handler)
+        session._process_stdout("starting codex 1.2.3\n")
+        handler.on_thinking.assert_called_once_with("starting codex 1.2.3")
+        assert session.stdout_lines == ["starting codex 1.2.3"]
+
+    def test_unknown_json_event_is_forwarded_raw(self):
+        handler = MagicMock()
+        session = _session(event_handler=handler)
+        raw = json.dumps({"type": "item.updated", "item": {"type": "reasoning", "delta": "thinking..."}})
+        session._process_stdout(raw)
+        handler.on_thinking.assert_called_once_with(raw)
+
+    def test_stderr_is_forwarded_to_event_handler(self):
+        handler = MagicMock()
+        session = _session(event_handler=handler)
+        session._process_stderr("panic: index out of bounds\n")
+        handler.on_thinking.assert_called_once_with("[codex stderr] panic: index out of bounds")
+        assert session.stderr_lines == ["panic: index out of bounds\n"]

{agentshim-0.3.0 → agentshim-0.3.1}/tests/unit/test_agent_cli_event_parsing.py

@@ -77,6 +77,37 @@ class TestClaudeEventFromDict:
         assert isinstance(event.events[0], TextEvent)
         assert isinstance(event.events[1], ToolUseEvent)
 
+    def test_assistant_event_captures_usage(self):
+        data = {
+            "type": "assistant",
+            "message": {
+                "content": [{"type": "text", "text": "hi"}],
+                "usage": {
+                    "input_tokens": 1234,
+                    "output_tokens": 56,
+                    "cache_creation_input_tokens": 100,
+                    "cache_read_input_tokens": 7,
+                },
+            },
+        }
+        event = ClaudeEvent.from_dict(data)
+        assert isinstance(event, MultiEvent)
+        assert event.usage == {
+            "input_tokens": 1234,
+            "output_tokens": 56,
+            "cache_creation_input_tokens": 100,
+            "cache_read_input_tokens": 7,
+        }
+
+    def test_assistant_event_missing_usage_is_none(self):
+        data = {
+            "type": "assistant",
+            "message": {"content": [{"type": "text", "text": "hi"}]},
+        }
+        event = ClaudeEvent.from_dict(data)
+        assert isinstance(event, MultiEvent)
+        assert event.usage is None
+
     def test_user_tool_result_event(self):
         data = {
             "type": "user",
@@ -337,6 +368,18 @@ class TestCodexEventFromDict:
         }
         assert CodexEvent.from_dict(data) is None
 
+    def test_reasoning_completed_is_text(self):
+        from agentshim.codex_events import CodexEvent
+        from agentshim.codex_events import TextEvent as CodexTextEvent
+
+        data = {
+            "type": "item.completed",
+            "item": {"id": "r1", "type": "reasoning", "text": "planning"},
+        }
+        event = CodexEvent.from_dict(data)
+        assert isinstance(event, CodexTextEvent)
+        assert event.text == "planning"
+
     def test_command_execution_started_is_tool_use(self):
         from agentshim.codex_events import CodexEvent
         from agentshim.codex_events import ToolUseEvent as CodexToolUseEvent
@@ -353,7 +396,7 @@ class TestCodexEventFromDict:
         event = CodexEvent.from_dict(data)
         assert isinstance(event, CodexToolUseEvent)
         assert event.tool_id == "item_1"
-        assert event.tool_name == "shell"
+        assert event.tool_name == "execute"
         assert event.parameters == {"command": "/bin/bash -lc ls"}
 
     def test_command_execution_completed_is_tool_result(self):
@@ -378,17 +421,32 @@ class TestCodexEventFromDict:
         assert event.exit_code == 0
         assert event.status == "completed"
 
-    def test_generic_item_types_become_tool_events(self):
+    def test_generic_item_started_reasoning_is_skipped(self):
         from agentshim.codex_events import CodexEvent
-        from agentshim.codex_events import ToolUseEvent as CodexToolUseEvent
 
         data = {
             "type": "item.started",
             "item": {"id": "r1", "type": "reasoning", "summary": "planning"},
         }
+        assert CodexEvent.from_dict(data) is None
+
+    def test_generic_item_completed_becomes_tool_use_with_full_payload(self):
+        from agentshim.codex_events import CodexEvent
+        from agentshim.codex_events import ToolUseEvent as CodexToolUseEvent
+
+        data = {
+            "type": "item.completed",
+            "item": {
+                "id": "fc1",
+                "type": "file_change",
+                "path": "engine.py",
+                "kind": "update",
+            },
+        }
         event = CodexEvent.from_dict(data)
         assert isinstance(event, CodexToolUseEvent)
-        assert event.tool_name == "reasoning"
+        assert event.tool_name == "file_change"
+        assert event.parameters == {"path": "engine.py", "kind": "update"}
 
     def test_turn_failed_is_error(self):
         from agentshim.codex_events import CodexEvent, ErrorEvent

{agentshim-0.3.0 → agentshim-0.3.1}/tests/unit/test_cli_agent_usage.py

@@ -78,12 +78,30 @@ class TestClaudeSessionUsage:
         assert session.usage.tokens.turns == 4
         # Invariant: cached ⊆ input
         assert session.usage.tokens.cached_input_tokens <= session.usage.tokens.input_tokens
+        assert session.final_usage == {
+            "input_tokens": 100,
+            "output_tokens": 40,
+            "cache_creation_input_tokens": 30,
+            "cache_read_input_tokens": 20,
+        }
+        assert session.total_cost_usd == 0.5
+
+    def test_result_event_populates_duration_ms(self):
+        session = _make_session(ClaudeGenerationSession)
+        event = ClaudeResultEvent(
+            result="done",
+            duration_ms=18431,
+        )
+        session._handle_event(event)
+        assert session.duration_ms == 18431
 
     def test_result_event_without_usage_degrades_to_zero(self):
         session = _make_session(ClaudeGenerationSession)
         session._handle_event(ClaudeResultEvent(result="done"))
         assert session.usage.provider == "claude"
         assert session.usage.tokens == TokenUsage()
+        assert session.final_usage is None
+        assert session.total_cost_usd is None
 
 
 class TestCodexSessionUsage:
@@ -98,6 +116,25 @@ class TestCodexSessionUsage:
         assert session.usage.tokens.cached_input_tokens == 40
         assert session.usage.tokens.turns == 2
 
+    def test_turn_completed_populates_final_usage(self):
+        session = _make_session(CodexGenerationSession)
+        session._handle_event(
+            TurnCompletedEvent(
+                input_tokens=100,
+                cached_input_tokens=10,
+                output_tokens=50,
+                usage={"input_tokens": 100, "cached_input_tokens": 10, "output_tokens": 50},
+            )
+        )
+
+        assert session.final_usage == {
+            "input_tokens": 100,
+            "output_tokens": 50,
+            "cache_read_input_tokens": 10,
+            "cache_creation_input_tokens": 0,
+        }
+        assert session.total_cost_usd is None
+
 
 class TestOpencodeSessionUsage:
     def test_step_finish_events_accumulate_with_cache_and_reasoning(self):

{agentshim-0.3.0 → agentshim-0.3.1}/uv.lock

@@ -4,7 +4,7 @@ requires-python = ">=3.10"
 
 [[package]]
 name = "agentshim"
-version = "0.3.0"
+version = "0.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "litellm" },

agentshim-0.3.0/tests/unit/test_agent_cli_codex.py

@@ -1,69 +0,0 @@
-import pytest
-
-from agentshim.cli_agent import CLICodingAgent
-from agentshim.codex import CodexCodingAgent
-from agentshim.mcp_config import HttpMcpServer, StdioMcpServer
-
-
-@pytest.fixture
-def mock_binaries(monkeypatch):
-    """Mock binary discovery and CLI check."""
-    monkeypatch.setattr(
-        "agentshim.cli_agent.shutil.which",
-        lambda cmd, path=None: f"/usr/local/bin/{cmd}",
-    )
-    monkeypatch.setattr(CLICodingAgent, "_check_cli", lambda self: None)
-
-
-@pytest.fixture
-def agent(mock_binaries):
-    return CodexCodingAgent(model="test-model")
-
-
-class TestCodexCommandConstruction:
-    def test_command_base_flags(self, agent):
-        cmd = agent._get_command("test")
-        assert "exec" in cmd
-        assert "--dangerously-bypass-approvals-and-sandbox" in cmd
-        assert "--json" in cmd
-        assert cmd[-1] == "-"
-
-    def test_command_omits_mcp_when_no_servers(self, agent):
-        cmd = agent._get_command("test")
-        assert "-c" not in cmd
-        assert cmd[-1] == "-"
-
-    def test_mcp_http_server(self, mock_binaries):
-        servers = [HttpMcpServer(name="srv", url="http://localhost:9000/sse")]
-        agent = CodexCodingAgent(mcp_servers=servers)
-        cmd = agent._get_command("test")
-        assert "-c" in cmd
-        idx = cmd.index("-c")
-        assert cmd[idx + 1] == 'mcp_servers.srv.url="http://localhost:9000/sse"'
-
-    def test_mcp_stdio_server(self, mock_binaries):
-        servers = [StdioMcpServer(name="tool", command="npx", args=["-y", "pkg"])]
-        agent = CodexCodingAgent(mcp_servers=servers)
-        cmd = agent._get_command("test")
-        c_values = [cmd[i + 1] for i, v in enumerate(cmd) if v == "-c"]
-        assert 'mcp_servers.tool.command="npx"' in c_values
-        assert 'mcp_servers.tool.args=["-y", "pkg"]' in c_values
-
-    def test_mcp_stdio_server_with_env(self, mock_binaries):
-        servers = [StdioMcpServer(name="t", command="cmd", env={"K1": "v1", "K2": "v2"})]
-        agent = CodexCodingAgent(mcp_servers=servers)
-        cmd = agent._get_command("test")
-        c_values = [cmd[i + 1] for i, v in enumerate(cmd) if v == "-c"]
-        assert 'mcp_servers.t.env.K1="v1"' in c_values
-        assert 'mcp_servers.t.env.K2="v2"' in c_values
-
-    def test_mcp_multiple_servers(self, mock_binaries):
-        servers = [
-            HttpMcpServer(name="a", url="http://a"),
-            StdioMcpServer(name="b", command="cmd"),
-        ]
-        agent = CodexCodingAgent(mcp_servers=servers)
-        cmd = agent._get_command("test")
-        c_values = [cmd[i + 1] for i, v in enumerate(cmd) if v == "-c"]
-        assert 'mcp_servers.a.url="http://a"' in c_values
-        assert 'mcp_servers.b.command="cmd"' in c_values