fix(llm): separate provider metadata from streaming handler metadata

Split accumulated_metadata into streaming_handler_metadata (wrapped structure
for StreamingHandler) and accumulated_provider_metadata (flat dict matching
non-streaming path). Fixes schema parity for llm_response_metadata_var.

Follow-up: streaming_handler_metadata still uses the wrapped structure from
_extract_chunk_metadata ({"provider_metadata": ..., "usage": ...}). If output
rails or streaming consumers need raw provider metadata, that function should
be revisited.

Author: Pouyanpi

nemoguardrails/actions/llm/utils.py

@@ -98,7 +98,8 @@ async def _stream_llm_call(
     llm_params: Optional[dict] = None,
 ) -> LLMResponse:
     handler.stop = stop or []
-    accumulated_metadata: Dict[str, Any] = {}
+    streaming_handler_metadata: Dict[str, Any] = {}
+    accumulated_provider_metadata: Dict[str, Any] = {}
     accumulated_reasoning: List[str] = []
     tool_calls = None
     model_name: Optional[str] = None
@@ -122,14 +123,16 @@ async def _stream_llm_call(
                 request_id = chunk.request_id
             if chunk.usage:
                 usage = chunk.usage
+            if chunk.provider_metadata:
+                accumulated_provider_metadata.update(chunk.provider_metadata)
 
             chunk_metadata = _extract_chunk_metadata(chunk)
             if chunk_metadata:
-                accumulated_metadata.update(chunk_metadata)
+                streaming_handler_metadata.update(chunk_metadata)
 
             await handler.push_chunk(content, chunk_metadata)
 
-        llm_response_metadata_var.set(accumulated_metadata or None)
+        llm_response_metadata_var.set(accumulated_provider_metadata or None)
 
         await handler.finish()
 
@@ -160,7 +163,7 @@ async def _stream_llm_call(
             finish_reason=finish_reason,
             request_id=request_id,
             usage=usage,
-            provider_metadata=accumulated_metadata if accumulated_metadata else None,
+            provider_metadata=accumulated_provider_metadata or None,
         )
 
     except Exception as e:

tests/test_actions_llm_utils.py

@@ -25,7 +25,13 @@
     _update_token_stats_from_chunk,
     llm_call,
 )
-from nemoguardrails.context import llm_call_info_var, llm_stats_var, reasoning_trace_var, tool_calls_var
+from nemoguardrails.context import (
+    llm_call_info_var,
+    llm_response_metadata_var,
+    llm_stats_var,
+    reasoning_trace_var,
+    tool_calls_var,
+)
 from nemoguardrails.exceptions import LLMCallException
 from nemoguardrails.integrations.langchain.llm_adapter import (
     LangChainLLMAdapter,
@@ -572,3 +578,62 @@ async def test_request_id_accumulated(self):
         result = await _stream_llm_call(model, "test", StreamingHandler(), stop=None)
 
         assert result.request_id == "req-123"
+
+    @pytest.mark.asyncio
+    async def test_clears_tool_calls_var_when_none(self):
+        tool_calls_var.set([{"id": "stale", "type": "function", "function": {"name": "old", "arguments": {}}}])
+
+        model = _make_chunk_model(
+            [
+                LLMResponseChunk(delta_content="no tools here", finish_reason="stop"),
+            ]
+        )
+
+        await _stream_llm_call(model, "test", StreamingHandler(), stop=None)
+
+        assert tool_calls_var.get() is None
+
+    @pytest.mark.asyncio
+    async def test_clears_reasoning_var_when_none(self):
+        reasoning_trace_var.set("stale reasoning")
+
+        model = _make_chunk_model(
+            [
+                LLMResponseChunk(delta_content="no reasoning", finish_reason="stop"),
+            ]
+        )
+
+        await _stream_llm_call(model, "test", StreamingHandler(), stop=None)
+
+        assert reasoning_trace_var.get() is None
+
+    @pytest.mark.asyncio
+    async def test_provider_metadata_stored_flat(self):
+        model = _make_chunk_model(
+            [
+                LLMResponseChunk(
+                    delta_content="hi",
+                    provider_metadata={"system_fingerprint": "fp_abc"},
+                    finish_reason="stop",
+                ),
+            ]
+        )
+
+        await _stream_llm_call(model, "test", StreamingHandler(), stop=None)
+
+        metadata = llm_response_metadata_var.get()
+        assert metadata == {"system_fingerprint": "fp_abc"}
+
+    @pytest.mark.asyncio
+    async def test_clears_metadata_var_when_none(self):
+        llm_response_metadata_var.set({"stale": True})
+
+        model = _make_chunk_model(
+            [
+                LLMResponseChunk(delta_content="no metadata", finish_reason="stop"),
+            ]
+        )
+
+        await _stream_llm_call(model, "test", StreamingHandler(), stop=None)
+
+        assert llm_response_metadata_var.get() is None