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.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
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.pyindex 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 = Falsestatus: 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 outif kind == "assistant":@@ -1435,33 +1515,10 @@ def translate_claude_line(obj: dict[str, Any], st: _ClaudeState) -> list[dict[stmid = str(message.get("id") or st.current_message_id or uuid.uuid4().hex)st.current_message_id = midusage_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.pyindex 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"] == []