fix(langchain-agents): a reported zero token count is not a missing one

extract_llm_usage read the llm_output fallback with `or`, so a genuine 0 was
skipped in favour of the next key. With both counts at zero the bag came back all
None, lang_chain_span_usage read that as the provider having said nothing, and
the run went unreported: a turn that completed and cost nothing became
indistinguishable from one that never reported, which is the distinction the
reported flag exists to preserve.

Now keyed on presence rather than truthiness.

Three tests: a zero prompt count survives, both-zero still counts as reported,
and a genuinely absent count is still absent.

Found by Bugbot on #35.

Author: apucacao

packages/langchain-agents/src/launchdarkly_ai_langchain_agents/spans.py

@@ -247,15 +247,29 @@ def extract_llm_usage(output: Any) -> dict[str, Any]:
     llm_output = _get(output, "llm_output") or {}
     token_usage = llm_output.get("token_usage") or llm_output.get("usage")
     if token_usage:
+        # `or` would read a real 0 as missing, and with both counts at zero the bag came back all
+        # None, which lang_chain_span_usage reports as "the provider said nothing". A turn that
+        # completed and reported zero is not the same as a turn that reported nothing: only the
+        # second may leave the root without usage attributes.
         return {
-            "input_tokens": token_usage.get("prompt_tokens")
-            or token_usage.get("input_tokens"),
-            "output_tokens": token_usage.get("completion_tokens")
-            or token_usage.get("output_tokens"),
+            "input_tokens": _first_present(
+                token_usage, "prompt_tokens", "input_tokens"
+            ),
+            "output_tokens": _first_present(
+                token_usage, "completion_tokens", "output_tokens"
+            ),
         }
     return {}
 
 
+def _first_present(bag: dict[str, Any], *keys: str) -> Any:
+    """The first key actually present, so a reported 0 is kept rather than skipped."""
+    for key in keys:
+        if key in bag:
+            return bag[key]
+    return None
+
+
 def to_tool_definitions(config_tools: dict[str, Any]) -> list[ToolDefinitionInput]:
     """The catalog handed to the agent, so a ``chat`` span reports what the model could call."""
     return [

packages/langchain-agents/tests/test_handler.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 from collections.abc import AsyncIterator
+from types import SimpleNamespace
 from typing import Any, ClassVar
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -1679,3 +1680,41 @@ def _get_type(self) -> str:
             bundle.abandon_open_spans(set())
 
         assert recorder.named("chat ")[0].ended == 1
+
+
+class TestZeroTokensAreStillReported:
+    """A reported 0 is not a missing count.
+
+    `extract_llm_usage` read the llm_output fallback with `or`, so a genuine 0 was skipped. With both
+    counts at zero the bag came back all None, `lang_chain_span_usage` read that as "the provider
+    said nothing", and the run went unreported: a turn that completed and cost nothing became
+    indistinguishable from one that never reported.
+    """
+
+    def test_a_zero_prompt_count_survives(self) -> None:
+        from launchdarkly_ai_langchain_agents.spans import extract_llm_usage
+
+        result = SimpleNamespace(
+            generations=[],
+            llm_output={"token_usage": {"prompt_tokens": 0, "completion_tokens": 7}},
+        )
+        assert extract_llm_usage(result) == {"input_tokens": 0, "output_tokens": 7}
+
+    def test_both_zero_still_counts_as_reported(self) -> None:
+        from launchdarkly_ai_langchain_agents.spans import extract_llm_usage
+        from launchdarkly_ai_server import lang_chain_span_usage
+
+        result = SimpleNamespace(
+            generations=[],
+            llm_output={"token_usage": {"prompt_tokens": 0, "completion_tokens": 0}},
+        )
+        raw = extract_llm_usage(result)
+        assert raw == {"input_tokens": 0, "output_tokens": 0}
+        # The distinction that matters downstream: this is a reported turn, not an absent one.
+        assert lang_chain_span_usage(raw) is not None
+
+    def test_an_absent_count_is_still_none(self) -> None:
+        from launchdarkly_ai_langchain_agents.spans import extract_llm_usage
+
+        result = SimpleNamespace(generations=[], llm_output={"token_usage": {}})
+        assert extract_llm_usage(result) == {}