langfuse-haystack 5.1.0__tar.gz → 5.2.0__tar.gz

{langfuse_haystack-5.1.0 → langfuse_haystack-5.2.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [integrations/langfuse-v5.1.0] - 2026-07-08
+
+### 🐛 Bug Fixes
+
+- *(langfuse)* Stop relying on `haystack.utils.base_serialization` helpers (#3563)
+
+### 📚 Documentation
+
+- Replace old haystack core imports with haystack_integrations paths (#3545)
+
+### 🧪 Testing
+
+- Trust test modules under Haystack 3.0's deserialization allowlist (#3537)
+
+### 🧹 Chores
+
+- Improve consistency of integrations folder structure (#3430)
+
+
 ## [integrations/langfuse-v5.0.2] - 2026-06-01
 
 ### 🐛 Bug Fixes

{langfuse_haystack-5.1.0 → langfuse_haystack-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfuse-haystack
-Version: 5.1.0
+Version: 5.2.0
 Summary: Langfuse integration for Haystack
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues

{langfuse_haystack-5.1.0 → langfuse_haystack-5.2.0}/src/haystack_integrations/tracing/langfuse/tracer.py

@@ -345,10 +345,13 @@ class DefaultSpanHandler(SpanHandler):
         # special case for ToolInvoker (to update the span name to be: `original_component_name - [tool_names]`)
         if component_type == "ToolInvoker":
             tool_names: list[str] = []
+            tool_calls_input: list[dict[str, Any]] = []
             messages = span.get_data().get(_COMPONENT_INPUT_KEY, {}).get("messages", [])
             for message in messages:
                 if isinstance(message, ChatMessage) and message.tool_calls:
-                    tool_names.extend(call.tool_name for call in message.tool_calls)
+                    for call in message.tool_calls:
+                        tool_names.append(call.tool_name)
+                        tool_calls_input.append({"tool_name": call.tool_name, "arguments": call.arguments})
 
             if tool_names:
                 # Fallback to "ToolInvoker" if we can't retrieve component name
@@ -357,6 +360,30 @@ class DefaultSpanHandler(SpanHandler):
                 formatted_names = [f"{name} (x{count})" if count > 1 else name for name, count in tool_counts.items()]
                 span.raw_span().update(name=f"{tool_invoker_name} - {sorted(formatted_names)}")
 
+            if tool_calls_input and proxy_tracer.is_content_tracing_enabled:
+                # Replace the noisy full message history with just the tool call arguments
+                span.raw_span().update(input=tool_calls_input)
+
+                output_messages = span.get_data().get(_COMPONENT_OUTPUT_KEY, {}).get("tool_messages", [])
+                tool_results: list[dict[str, Any]] = []
+                for message in output_messages:
+                    if isinstance(message, ChatMessage) and message.tool_call_results:
+                        for tcr in message.tool_call_results:
+                            origin = tcr.origin
+                            # Keys `name`, `arguments` and `id` let Langfuse detect these as tool
+                            # calls at ingestion and populate the Tool Call Name filter in the UI.
+                            tool_results.append(
+                                {
+                                    "id": origin.id if origin else None,
+                                    "name": origin.tool_name if origin else None,
+                                    "arguments": origin.arguments if origin else None,
+                                    "result": tcr.result,
+                                    "error": tcr.error,
+                                }
+                            )
+                if tool_results:
+                    span.raw_span().update(output=tool_results)
+
         if component_type and component_type.endswith("ChatGenerator"):
             replies = span.get_data().get(_COMPONENT_OUTPUT_KEY, {}).get("replies")
             if replies:

{langfuse_haystack-5.1.0 → langfuse_haystack-5.2.0}/tests/test_tracer.py

@@ -748,6 +748,79 @@ class TestLangfuseTracer:
         assert "search_tool (x2)" in updated_name, f"Expected 'search_tool (x2)' in {updated_name}"
         assert "weather_tool" in updated_name, f"Expected 'weather_tool' in {updated_name}"
 
+    def test_handle_tool_invoker_input_output_with_content_tracing(self):
+        """
+        Test that ToolInvoker spans replace the noisy full-message input with just tool call
+        arguments, and populate output with tool results, when content tracing is enabled.
+        """
+        mock_span = Mock()
+        mock_span.raw_span.return_value = mock_span
+
+        tool_call = ToolCall(id="call_123", tool_name="search_tool", arguments={"query": "RAG pipelines"})
+
+        span_data = {
+            "haystack.component.name": "tool_invoker",
+            "haystack.component.type": "ToolInvoker",
+            "haystack.component.input": {
+                "messages": [
+                    ChatMessage.from_user("what is RAG?"),
+                    ChatMessage.from_assistant(text="Calling search", tool_calls=[tool_call]),
+                ]
+            },
+            "haystack.component.output": {
+                "tool_messages": [ChatMessage.from_tool("RAG stands for Retrieval-Augmented Generation", tool_call)]
+            },
+        }
+        mock_span.get_data.return_value = span_data
+
+        handler = DefaultSpanHandler()
+        with patch("haystack_integrations.tracing.langfuse.tracer.proxy_tracer.is_content_tracing_enabled", True):
+            handler.handle(mock_span, component_type="ToolInvoker")
+
+        update_calls = {k: v for call in mock_span.update.call_args_list for k, v in call[1].items()}
+
+        # input should be just the tool call arguments, not the full message list
+        assert update_calls["input"] == [{"tool_name": "search_tool", "arguments": {"query": "RAG pipelines"}}]
+        # output carries id/name/arguments so Langfuse detects the tool call and populates its filter
+        assert update_calls["output"] == [
+            {
+                "id": "call_123",
+                "name": "search_tool",
+                "arguments": {"query": "RAG pipelines"},
+                "result": "RAG stands for Retrieval-Augmented Generation",
+                "error": False,
+            }
+        ]
+
+    def test_handle_tool_invoker_no_content_tracing(self):
+        """
+        Test that ToolInvoker input/output is NOT updated when content tracing is disabled.
+        The span name update (tool names) should still happen.
+        """
+        mock_span = Mock()
+        mock_span.raw_span.return_value = mock_span
+
+        tool_call = ToolCall(tool_name="weather_tool", arguments={"location": "Tokyo"})
+
+        span_data = {
+            "haystack.component.name": "tool_invoker",
+            "haystack.component.type": "ToolInvoker",
+            "haystack.component.input": {"messages": [ChatMessage.from_assistant(text="", tool_calls=[tool_call])]},
+            "haystack.component.output": {"tool_messages": [ChatMessage.from_tool("Sunny, 28°C", tool_call)]},
+        }
+        mock_span.get_data.return_value = span_data
+
+        handler = DefaultSpanHandler()
+        with patch("haystack_integrations.tracing.langfuse.tracer.proxy_tracer.is_content_tracing_enabled", False):
+            handler.handle(mock_span, component_type="ToolInvoker")
+
+        update_kwargs_keys = {k for call in mock_span.update.call_args_list for k in call[1]}
+        # name should still be updated
+        assert "name" in update_kwargs_keys
+        # input and output must NOT be set when content tracing is off
+        assert "input" not in update_kwargs_keys
+        assert "output" not in update_kwargs_keys
+
     def test_trace_generation_invalid_start_time(self):
         with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client"):
             tracer = LangfuseTracer(tracer=MockLangfuseClient(), name="Haystack", public=False)