Skip to content

Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.

fix(agent-chat): count Claude's live output tokens as they stream

rubenluetke10-beep089b20a9acad
diff --git a/jarvis/agent_chat/runner_cli.py b/jarvis/agent_chat/runner_cli.py
index ae8493af52..9a032f535e 100644
--- a/jarvis/agent_chat/runner_cli.py
+++ b/jarvis/agent_chat/runner_cli.py
@@ -1299,6 +1299,10 @@ class _ClaudeState:
thinking_announced: set[str] = field(default_factory=set)
#: Per-message usage as the CLI reports it — summed into the live counter.
usage_by_message: dict[str, dict[str, int]] = field(default_factory=dict)
+ #: Characters streamed per message so far; a live floor for its output.
+ stream_chars: dict[str, int] = field(default_factory=dict)
+ #: The usage totals last sent, so an unchanged count sends nothing.
+ usage_sent: dict[str, int] = field(default_factory=dict)
emitted_tool_ids: set[str] = field(default_factory=set)
emitted_text: bool = False
status: str = "done"
@@ -1313,6 +1317,62 @@ class _ClaudeState:
last_tool_error: str | None = None
+#: Streamed characters per estimated output token (English and code average).
+_CHARS_PER_TOKEN: Final = 4
+#: A streamed estimate is sent once it has grown by this many output tokens,
+#: so a long answer does not send one counter update per text fragment.
+_LIVE_OUTPUT_STEP: Final = 20
+
+
+def _claude_merge_usage(st: _ClaudeState, mid: str, usage: dict[str, Any]) -> bool:
+ """Fold one usage report of message ``mid`` in; True when it changed.
+
+ A message's first report is the ``message_start`` snapshot: the input side
+ is final, ``output_tokens`` a placeholder that only becomes true at the
+ message's end (``message_delta``). Keep the largest value seen so a
+ placeholder can never walk a real count back down (BUG-173).
+ """
+ counted = {
+ k: int(usage[k]) for k in _CLAUDE_USAGE_KEYS if isinstance(usage.get(k), int | float)
+ }
+ previous = st.usage_by_message.get(mid)
+ if previous:
+ counted = {k: max(counted.get(k, 0), previous.get(k, 0)) for k in (*counted, *previous)}
+ if not counted or counted == previous:
+ return False
+ st.usage_by_message[mid] = counted
+ return True
+
+
+def _claude_usage_totals(st: _ClaudeState) -> dict[str, int]:
+ """The turn so far: reported usage, with streamed text as a floor for output."""
+ totals: dict[str, int] = {}
+ streamed_only = (m for m in st.stream_chars if m not in st.usage_by_message)
+ for mid in (*st.usage_by_message, *streamed_only):
+ per_message = dict(st.usage_by_message.get(mid, {}))
+ estimate = st.stream_chars.get(mid, 0) // _CHARS_PER_TOKEN
+ if estimate > per_message.get("output_tokens", 0):
+ per_message["output_tokens"] = estimate
+ for k, v in per_message.items():
+ totals[k] = totals.get(k, 0) + v
+ return totals
+
+
+def _claude_usage_event(st: _ClaudeState, *, min_output_step: int = 0) -> dict[str, Any] | None:
+ """A ``usage_delta`` when the totals moved (by ``min_output_step`` output tokens)."""
+ totals = _claude_usage_totals(st)
+ if not totals or totals == st.usage_sent:
+ return None
+ grown = totals.get("output_tokens", 0) - st.usage_sent.get("output_tokens", 0)
+ only_output_moved = {k: v for k, v in totals.items() if k != "output_tokens"} == {
+ k: v for k, v in st.usage_sent.items() if k != "output_tokens"
+ }
+ if min_output_step and only_output_moved and grown < min_output_step:
+ return None
+ st.usage_sent = totals
+ return make_event("usage_delta", {"turn_id": st.turn_id, "usage": totals})
+
+
def _claude_request_summary(tool_name: str, tool_input: dict[str, Any]) -> str:
for key in ("command", "file_path", "path", "pattern", "url", "query", "description"):
val = tool_input.get(key)
@@ -1428,6 +1488,26 @@ def translate_claude_line(obj: dict[str, Any], st: _ClaudeState) -> list[dict[st
{"turn_id": st.turn_id, "message_id": mid, "text": delta["thinking"]},
)
)
+ # Count what streams as it streams: text, a tool call's input and
+ # readable thinking are all output. The CLI reports a message's
+ # true output count only once the message ends, so between those
+ # reports the counter would otherwise sit on the start-of-message
+ # placeholder ("Working 28s · 39 tokens" on a turn that ended at
+ # 11k). The estimate never overrides a real report.
+ streamed = delta.get("text") or delta.get("partial_json") or delta.get("thinking")
+ if isinstance(streamed, str) and streamed:
+ st.stream_chars[mid] = st.stream_chars.get(mid, 0) + len(streamed)
+ event = _claude_usage_event(st, min_output_step=_LIVE_OUTPUT_STEP)
+ if event is not None:
+ out.append(event)
+ elif et == "message_delta":
+ # The end of a message: its usage carries the true output count.
+ usage_end = ev.get("usage")
+ mid = st.current_message_id
+ if mid and isinstance(usage_end, dict) and _claude_merge_usage(st, mid, usage_end):
+ event = _claude_usage_event(st)
+ if event is not None:
+ out.append(event)
return out
if kind == "assistant":
@@ -1435,33 +1515,10 @@ def translate_claude_line(obj: dict[str, Any], st: _ClaudeState) -> list[dict[st
mid = str(message.get("id") or st.current_message_id or uuid.uuid4().hex)
st.current_message_id = mid
usage_now = message.get("usage")
- if isinstance(usage_now, dict):
- counted = {
- k: int(usage_now[k])
- for k in _CLAUDE_USAGE_KEYS
- if isinstance(usage_now.get(k), int | float)
- }
- # A message's first usage report is the ``message_start`` snapshot:
- # the input side is already final, ``output_tokens`` is a placeholder
- # that only becomes true later. Keep the largest value seen so a
- # placeholder can never walk a real count back down (BUG-173).
- previous = st.usage_by_message.get(mid)
- if previous:
- counted = {
- k: max(counted.get(k, 0), previous.get(k, 0)) for k in (*counted, *previous)
- }
- if counted and counted != previous:
- st.usage_by_message[mid] = counted
- totals: dict[str, int] = {}
- for per_message in st.usage_by_message.values():
- for k, v in per_message.items():
- totals[k] = totals.get(k, 0) + v
- out.append(
- make_event(
- "usage_delta",
- {"turn_id": st.turn_id, "usage": totals},
- )
- )
+ if isinstance(usage_now, dict) and _claude_merge_usage(st, mid, usage_now):
+ event = _claude_usage_event(st)
+ if event is not None:
+ out.append(event)
content = message.get("content") or []
if not isinstance(content, list):
content = [{"type": "text", "text": str(content)}]
diff --git a/tests/unit/agent_chat/test_agent_chat_core.py b/tests/unit/agent_chat/test_agent_chat_core.py
index c90d557bd4..6ee20bbd7c 100644
--- a/tests/unit/agent_chat/test_agent_chat_core.py
+++ b/tests/unit/agent_chat/test_agent_chat_core.py
@@ -635,3 +635,64 @@ def test_cli_seat_retirement_follows_the_surface_capability(tmp_path, monkeypatc
# The IDE's chat is untouched.
assert store.get_session(kept.session_id).provider == "claude-api"
assert store.get_session(kept.session_id).model == "claude-opus-5"
+
+
+def test_claude_live_usage_follows_the_stream_and_the_message_end():
+ """The live counter tracks real output, not the start-of-message placeholder.
+
+ Claude Code reports a message's true ``output_tokens`` only in the
+ ``message_delta`` that ends it; every ``assistant`` snapshot before that
+ carries a placeholder. The counter read "Working 28s · 39 tokens" on a
+ turn that ended at 11k. Streamed text and tool input now count as they
+ arrive, and the message end sets the real number.
+ """
+ st = _ClaudeState(turn_id="t")
+ lines = [
+ {"type": "stream_event", "event": {"type": "message_start", "message": {"id": "m1"}}},
+ {
+ "type": "assistant",
+ "message": {
+ "id": "m1",
+ "content": [],
+ "usage": {"input_tokens": 3, "output_tokens": 2},
+ },
+ },
+ {
+ "type": "stream_event",
+ "event": {
+ "type": "content_block_delta",
+ "index": 0,
+ "delta": {"type": "input_json_delta", "partial_json": "x" * 400},
+ },
+ },
+ {
+ "type": "stream_event",
+ "event": {"type": "message_delta", "delta": {}, "usage": {"output_tokens": 180}},
+ },
+ {"type": "stream_event", "event": {"type": "message_start", "message": {"id": "m2"}}},
+ {
+ "type": "stream_event",
+ "event": {
+ "type": "content_block_delta",
+ "index": 0,
+ "delta": {"type": "text_delta", "text": "y" * 200},
+ },
+ },
+ ]
+ events = [ev for obj in lines for ev in translate_claude_line(obj, st)]
+ usage = [ev["payload"]["usage"] for ev in events if ev["kind"] == "usage_delta"]
+ output = [u["output_tokens"] for u in usage]
+ # Placeholder, then the streamed tool input (400 chars ≈ 100 tokens), then
+ # the message's real count, then the next message streaming on top.
+ assert output == [2, 100, 180, 230]
+ # A few streamed characters do not send an update of their own.
+ quiet = _ClaudeState(turn_id="q")
+ tiny = {
+ "type": "stream_event",
+ "event": {
+ "type": "content_block_delta",
+ "index": 0,
+ "delta": {"type": "text_delta", "text": "hi"},
+ },
+ }
+ assert [ev for ev in translate_claude_line(tiny, quiet) if ev["kind"] == "usage_delta"] == []