langfuse-haystack 2.0.0__tar.gz → 2.0.1__tar.gz

{langfuse_haystack-2.0.0 → langfuse_haystack-2.0.1}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [integrations/langfuse-v2.0.0] - 2025-05-27
+
+### 🌀 Miscellaneous
+
+- Add Langfuse pins (#1837)
+
 ## [integrations/langfuse-v1.1.2] - 2025-05-16
 
 ### 🌀 Miscellaneous

{langfuse_haystack-2.0.0 → langfuse_haystack-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfuse-haystack
-Version: 2.0.0
+Version: 2.0.1
 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-2.0.0 → langfuse_haystack-2.0.1}/src/haystack_integrations/tracing/langfuse/tracer.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import contextlib
+import json
 import os
 from abc import ABC, abstractmethod
 from collections import Counter
@@ -45,6 +46,7 @@ _SUPPORTED_CHAT_GENERATORS = [
     "HuggingFaceLocalChatGenerator",
     "CohereChatGenerator",
     "OllamaChatGenerator",
+    "GoogleGenAIChatGenerator",
 ]
 _ALL_SUPPORTED_GENERATORS = _SUPPORTED_GENERATORS + _SUPPORTED_CHAT_GENERATORS
 
@@ -64,6 +66,61 @@ _COMPONENT_INPUT_KEY = "haystack.component.input"
 tracing_context_var: ContextVar[Dict[Any, Any]] = ContextVar("tracing_context")
 
 
+def _to_openai_dict_format(chat_message: ChatMessage) -> Dict[str, Any]:
+    """
+    Convert a ChatMessage to the dictionary format expected by OpenAI's chat completion API.
+
+    Note: We already have such a method in Haystack's ChatMessage class.
+    However, the original method doesn't tolerate None values for ids of ToolCall and ToolCallResult.
+    Some generators, like GoogleGenAIChatGenerator, return None values for ids of ToolCall and ToolCallResult.
+    To seamlessly support these generators, we use this, Langfuse local, version of the method.
+
+    :param chat_message: The ChatMessage instance to convert.
+    :return: Dictionary in OpenAI Chat API format.
+    """
+    text_contents = chat_message.texts
+    tool_calls = chat_message.tool_calls
+    tool_call_results = chat_message.tool_call_results
+
+    if not text_contents and not tool_calls and not tool_call_results:
+        message = "A `ChatMessage` must contain at least one `TextContent`, `ToolCall`, or `ToolCallResult`."
+        logger.error(message)
+        raise ValueError(message)
+    if len(text_contents) + len(tool_call_results) > 1:
+        message = "A `ChatMessage` can only contain one `TextContent` or one `ToolCallResult`."
+        logger.error(message)
+        raise ValueError(message)
+
+    openai_msg: Dict[str, Any] = {"role": chat_message._role.value}
+
+    # Add name field if present
+    if chat_message._name is not None:
+        openai_msg["name"] = chat_message._name
+
+    if tool_call_results:
+        result = tool_call_results[0]
+        openai_msg["content"] = result.result
+        openai_msg["tool_call_id"] = result.origin.id
+        # OpenAI does not provide a way to communicate errors in tool invocations, so we ignore the error field
+        return openai_msg
+
+    if text_contents:
+        openai_msg["content"] = text_contents[0]
+    if tool_calls:
+        openai_tool_calls = []
+        for tc in tool_calls:
+            openai_tool_calls.append(
+                {
+                    "id": tc.id,
+                    "type": "function",
+                    # We disable ensure_ascii so special chars like emojis are not converted
+                    "function": {"name": tc.tool_name, "arguments": json.dumps(tc.arguments, ensure_ascii=False)},
+                }
+            )
+        openai_msg["tool_calls"] = openai_tool_calls
+    return openai_msg
+
+
 class LangfuseSpan(Span):
     """
     Internal class representing a bridge between the Haystack span tracing API and Langfuse.
@@ -101,7 +158,7 @@ class LangfuseSpan(Span):
             return
         if key.endswith(".input"):
             if "messages" in value:
-                messages = [m.to_openai_dict_format() for m in value["messages"]]
+                messages = [_to_openai_dict_format(m) for m in value["messages"]]
                 self._span.update(input=messages)
             else:
                 coerced_value = tracing_utils.coerce_tag_value(value)
@@ -109,7 +166,7 @@ class LangfuseSpan(Span):
         elif key.endswith(".output"):
             if "replies" in value:
                 if all(isinstance(r, ChatMessage) for r in value["replies"]):
-                    replies = [m.to_openai_dict_format() for m in value["replies"]]
+                    replies = [_to_openai_dict_format(m) for m in value["replies"]]
                 else:
                     replies = value["replies"]
                 self._span.update(output=replies)