langtrace-python-sdk 3.8.6__py3-none-any.whl → 3.8.8__py3-none-any.whl

langtrace_python_sdk/instrumentation/__init__.py

@@ -22,6 +22,7 @@ from .litellm import LiteLLMInstrumentation
 from .llamaindex import LlamaindexInstrumentation
 from .milvus import MilvusInstrumentation
 from .mistral import MistralInstrumentation
+from .neo4j_graphrag import Neo4jGraphRAGInstrumentation
 from .ollama import OllamaInstrumentor
 from .openai import OpenAIInstrumentation
 from .openai_agents import OpenAIAgentsInstrumentation
@@ -59,6 +60,7 @@ __all__ = [
     "AWSBedrockInstrumentation",
     "CerebrasInstrumentation",
     "MilvusInstrumentation",
+    "Neo4jGraphRAGInstrumentation",
     "GoogleGenaiInstrumentation",
     "CrewaiToolsInstrumentation",
     "GraphlitInstrumentation",

langtrace_python_sdk/instrumentation/neo4j_graphrag/__init__.py

@@ -0,0 +1,3 @@
+from .instrumentation import Neo4jGraphRAGInstrumentation
+
+__all__ = ["Neo4jGraphRAGInstrumentation"]

langtrace_python_sdk/instrumentation/neo4j_graphrag/instrumentation.py

@@ -0,0 +1,62 @@
+"""
+Copyright (c) 2025 Scale3 Labs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from typing import Collection
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry import trace
+from wrapt import wrap_function_wrapper as _W
+from importlib.metadata import version as v
+from .patch import patch_graphrag_search, patch_kg_pipeline_run, \
+patch_kg_pipeline_run, patch_retriever_search
+
+
+class Neo4jGraphRAGInstrumentation(BaseInstrumentor):
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["neo4j-graphrag>=1.6.0"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = trace.get_tracer(__name__, "", tracer_provider)
+        graphrag_version = v("neo4j-graphrag")
+        
+        try:
+            # instrument kg builder
+            _W(
+                "neo4j_graphrag.experimental.pipeline.kg_builder",
+                "SimpleKGPipeline.run_async",
+                patch_kg_pipeline_run("run_async", graphrag_version, tracer),
+            )
+            
+            # Instrument GraphRAG
+            _W(
+                "neo4j_graphrag.generation.graphrag",
+                "GraphRAG.search",
+                patch_graphrag_search("search", graphrag_version, tracer),
+            )
+            
+            # Instrument retrievers
+            _W(
+                "neo4j_graphrag.retrievers.vector",
+                "VectorRetriever.get_search_results",
+                patch_retriever_search("vector_search", graphrag_version, tracer),
+            )
+            
+        except Exception as e:
+            print(f"Failed to instrument Neo4j GraphRAG: {e}")
+
+    def _uninstrument(self, **kwargs):
+        pass

langtrace_python_sdk/instrumentation/neo4j_graphrag/patch.py

@@ -0,0 +1,229 @@
+"""
+Copyright (c) 2025 Scale3 Labs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import json
+
+from importlib_metadata import version as v
+from langtrace.trace_attributes import FrameworkSpanAttributes
+from opentelemetry import baggage
+from opentelemetry.trace import Span, SpanKind, Tracer
+from opentelemetry.trace.status import Status, StatusCode
+
+from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
+from langtrace_python_sdk.constants.instrumentation.common import (
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, SERVICE_PROVIDERS)
+from langtrace_python_sdk.utils.llm import set_span_attributes
+from langtrace_python_sdk.utils.misc import serialize_args, serialize_kwargs
+
+
+def patch_kg_pipeline_run(operation_name: str, version: str, tracer: Tracer):
+    
+    async def async_traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS.get("NEO4J_GRAPHRAG", "neo4j_graphrag")
+        extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
+
+        span_attributes = {
+            "langtrace.sdk.name": "langtrace-python-sdk",
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": v(LANGTRACE_SDK_NAME),
+            "neo4j.pipeline.type": "SimpleKGPipeline",
+            **(extra_attributes if extra_attributes is not None else {}),
+        }
+
+        if len(args) > 0:
+            span_attributes["neo4j.pipeline.inputs"] = serialize_args(*args)
+        if kwargs:
+            span_attributes["neo4j.pipeline.kwargs"] = serialize_kwargs(**kwargs)
+
+        file_path = kwargs.get("file_path", args[0] if len(args) > 0 else None)
+        text = kwargs.get("text", args[1] if len(args) > 1 else None)
+        if file_path:
+            span_attributes["neo4j.pipeline.file_path"] = file_path
+        if text:
+            span_attributes["neo4j.pipeline.text_length"] = len(text)
+
+        if hasattr(instance, "runner") and hasattr(instance.runner, "config"):
+            config = instance.runner.config
+            if config:
+                span_attributes["neo4j.pipeline.from_pdf"] = getattr(config, "from_pdf", None)
+                span_attributes["neo4j.pipeline.perform_entity_resolution"] = getattr(config, "perform_entity_resolution", None)
+
+        attributes = FrameworkSpanAttributes(**span_attributes)
+
+        with tracer.start_as_current_span(
+            name=f"neo4j.pipeline.{operation_name}",
+            kind=SpanKind.CLIENT,
+        ) as span:
+            try:
+                set_span_attributes(span, attributes)
+
+                result = await wrapped(*args, **kwargs)
+
+                if result:
+                    try:
+                        if hasattr(result, "to_dict"):
+                            result_dict = result.to_dict()
+                            span.set_attribute("neo4j.pipeline.result", json.dumps(result_dict))
+                        elif hasattr(result, "model_dump"):
+                            result_dict = result.model_dump()
+                            span.set_attribute("neo4j.pipeline.result", json.dumps(result_dict))
+                    except Exception as e:
+                        span.set_attribute("neo4j.pipeline.result_error", str(e))
+                
+                span.set_status(Status(StatusCode.OK))
+                return result
+
+            except Exception as err:
+                span.record_exception(err)
+                span.set_status(Status(StatusCode.ERROR, str(err)))
+                raise
+
+    return async_traced_method
+
+
+def patch_graphrag_search(operation_name: str, version: str, tracer: Tracer):
+    
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS.get("NEO4J_GRAPHRAG", "neo4j_graphrag")
+        extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
+        
+        # Basic attributes
+        span_attributes = {
+            "langtrace.sdk.name": "langtrace-python-sdk",
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": v(LANGTRACE_SDK_NAME),
+            "neo4j_graphrag.operation": operation_name,
+            **(extra_attributes if extra_attributes is not None else {}),
+        }
+
+        query_text = kwargs.get("query_text", args[0] if len(args) > 0 else None)
+        if query_text:
+            span_attributes["neo4j_graphrag.query_text"] = query_text
+
+        retriever_config = kwargs.get("retriever_config", None)
+        if retriever_config:
+            span_attributes["neo4j_graphrag.retriever_config"] = json.dumps(retriever_config)
+
+        if hasattr(instance, "retriever"):
+            span_attributes["neo4j_graphrag.retriever_type"] = instance.retriever.__class__.__name__
+
+        if hasattr(instance, "llm"):
+            span_attributes["neo4j_graphrag.llm_type"] = instance.llm.__class__.__name__
+
+        attributes = FrameworkSpanAttributes(**span_attributes)
+
+        with tracer.start_as_current_span(
+            name=f"neo4j_graphrag.{operation_name}",
+            kind=SpanKind.CLIENT,
+        ) as span:
+            try:
+                set_span_attributes(span, attributes)
+
+                result = wrapped(*args, **kwargs)
+                
+                if result and hasattr(result, "answer"):
+                    span.set_attribute("neo4j_graphrag.answer", result.answer)
+
+                    if hasattr(result, "retriever_result") and result.retriever_result:
+                        try:
+                            retriever_items = len(result.retriever_result.items)
+                            span.set_attribute("neo4j_graphrag.context_items", retriever_items)
+                        except Exception:
+                            pass
+                
+                span.set_status(Status(StatusCode.OK))
+                return result
+
+            except Exception as err:
+                span.record_exception(err)
+                span.set_status(Status(StatusCode.ERROR, str(err)))
+                raise
+
+    return traced_method
+
+
+def patch_retriever_search(operation_name: str, version: str, tracer: Tracer):
+    
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS.get("NEO4J_GRAPHRAG", "neo4j_graphrag")
+        extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
+        
+        # Basic attributes
+        span_attributes = {
+            "langtrace.sdk.name": "langtrace-python-sdk",
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": v(LANGTRACE_SDK_NAME),
+            "neo4j.retriever.operation": operation_name,
+            "neo4j.retriever.type": instance.__class__.__name__,
+            **(extra_attributes if extra_attributes is not None else {}),
+        }
+
+        query_text = kwargs.get("query_text", args[0] if len(args) > 0 else None)
+        if query_text:
+            span_attributes["neo4j.retriever.query_text"] = query_text
+
+        if hasattr(instance, "__class__") and hasattr(instance.__class__, "__name__"):
+            retriever_type = instance.__class__.__name__
+
+            if retriever_type == "VectorRetriever" and hasattr(instance, "index_name"):
+                span_attributes["neo4j.vector_retriever.index_name"] = instance.index_name
+
+            if retriever_type == "KnowledgeGraphRetriever" and hasattr(instance, "cypher_query"):
+                span_attributes["neo4j.kg_retriever.cypher_query"] = instance.cypher_query
+
+        for param in ["top_k", "similarity_threshold"]:
+            if param in kwargs:
+                span_attributes[f"neo4j.retriever.{param}"] = kwargs[param]
+            elif hasattr(instance, param):
+                span_attributes[f"neo4j.retriever.{param}"] = getattr(instance, param)
+
+        attributes = FrameworkSpanAttributes(**span_attributes)
+
+        with tracer.start_as_current_span(
+            name=f"neo4j.retriever.{operation_name}",
+            kind=SpanKind.CLIENT,
+        ) as span:
+            try:
+                set_span_attributes(span, attributes)
+
+                result = wrapped(*args, **kwargs)
+
+                if result:
+                    if hasattr(result, "items") and isinstance(result.items, list):
+                        span.set_attribute("neo4j.retriever.items_count", len(result.items))
+
+                        try:
+                            item_ids = [item.id for item in result.items[:5] if hasattr(item, "id")]
+                            if item_ids:
+                                span.set_attribute("neo4j.retriever.item_ids", json.dumps(item_ids))
+                        except Exception:
+                            pass
+                
+                span.set_status(Status(StatusCode.OK))
+                return result
+
+            except Exception as err:
+                span.record_exception(err)
+                span.set_status(Status(StatusCode.ERROR, str(err)))
+                raise
+
+    return traced_method

langtrace_python_sdk/instrumentation/openai/instrumentation.py

@@ -24,6 +24,8 @@ from langtrace_python_sdk.instrumentation.openai.patch import (
     async_embeddings_create,
     async_images_generate,
     chat_completions_create,
+    openai_responses_create,
+    async_openai_responses_create,
     embeddings_create,
     images_edit,
     images_generate,
@@ -32,7 +34,7 @@ from langtrace_python_sdk.instrumentation.openai.patch import (
 logging.basicConfig(level=logging.FATAL)
 
 
-class OpenAIInstrumentation(BaseInstrumentor): # type: ignore
+class OpenAIInstrumentation(BaseInstrumentor):  # type: ignore
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return ["openai >= 0.27.0", "trace-attributes >= 4.0.5"]
@@ -54,6 +56,18 @@ class OpenAIInstrumentation(BaseInstrumentor): # type: ignore
             async_chat_completions_create(version, tracer),
         )
 
+        wrap_function_wrapper(
+            "openai.resources.responses",
+            "AsyncResponses.create",
+            async_openai_responses_create(version, tracer),
+        )
+
+        wrap_function_wrapper(
+            "openai.resources.responses",
+            "Responses.create",
+            openai_responses_create(version, tracer),
+        )
+
         wrap_function_wrapper(
             "openai.resources.images",
             "Images.generate",

langtrace_python_sdk/instrumentation/openai/patch.py

@@ -7,27 +7,121 @@ from opentelemetry.trace import Span, SpanKind, Tracer
 from opentelemetry.trace.propagation import set_span_in_context
 from opentelemetry.trace.status import Status, StatusCode
 
-from langtrace_python_sdk.constants.instrumentation.common import \
-    SERVICE_PROVIDERS
+from langtrace_python_sdk.constants.instrumentation.common import SERVICE_PROVIDERS
 from langtrace_python_sdk.constants.instrumentation.openai import APIS
 from langtrace_python_sdk.instrumentation.openai.types import (
-    ChatCompletionsCreateKwargs, ContentItem, EmbeddingsCreateKwargs,
-    ImagesEditKwargs, ImagesGenerateKwargs, ResultType)
+    ChatCompletionsCreateKwargs,
+    ContentItem,
+    EmbeddingsCreateKwargs,
+    ImagesEditKwargs,
+    ImagesGenerateKwargs,
+    ResultType,
+)
 from langtrace_python_sdk.types import NOT_GIVEN
 from langtrace_python_sdk.utils import set_span_attribute
-from langtrace_python_sdk.utils.llm import (StreamWrapper,
-                                            calculate_prompt_tokens,
-                                            get_base_url, get_extra_attributes,
-                                            get_langtrace_attributes,
-                                            get_llm_request_attributes,
-                                            get_llm_url, get_span_name,
-                                            get_tool_calls, is_streaming,
-                                            set_event_completion,
-                                            set_span_attributes,
-                                            set_usage_attributes)
+from langtrace_python_sdk.utils.llm import (
+    StreamWrapper,
+    calculate_prompt_tokens,
+    get_base_url,
+    get_extra_attributes,
+    get_langtrace_attributes,
+    get_llm_request_attributes,
+    get_llm_url,
+    get_span_name,
+    get_tool_calls,
+    is_streaming,
+    set_event_completion,
+    set_span_attributes,
+    set_usage_attributes,
+)
 from langtrace_python_sdk.utils.silently_fail import silently_fail
 
 
+def async_openai_responses_create(version: str, tracer: Tracer) -> Callable:
+    """Wrap the `create` method of the `openai.AsyncResponse.create` class to trace it."""
+
+    async def traced_method(
+        wrapped: Callable, instance: Any, args: List[Any], kwargs: Dict[str, Any]
+    ):
+        input_value = kwargs.get("input")
+        prompt = (
+            input_value[0]
+            if isinstance(input_value, list)
+            else [{"role": "user", "content": input_value}]
+        )
+        service_provider = SERVICE_PROVIDERS["OPENAI"]
+        span_attributes = {
+            "instructions": kwargs.get("instructions"),
+            **get_langtrace_attributes(version, service_provider, vendor_type="llm"),
+            **get_llm_request_attributes(
+                kwargs,
+                operation_name="openai.responses.create",
+                prompts=prompt,
+            ),
+        }
+        with tracer.start_as_current_span(
+            name="openai.responses.create",
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        ) as span:
+            try:
+                set_span_attributes(span, span_attributes)
+
+                response = await wrapped(*args, **kwargs)
+                _set_openai_agentic_response_attributes(span, response)
+
+                return response
+            except Exception as err:
+                span.record_exception(err)
+                raise
+
+    return traced_method
+
+
+def openai_responses_create(version: str, tracer: Tracer) -> Callable:
+    """Wrap the `create` method of the `openai.responses.create` class to trace it."""
+
+    def traced_method(
+        wrapped: Callable, instance: Any, args: List[Any], kwargs: Dict[str, Any]
+    ):
+        input_value = kwargs.get("input")
+        prompt = (
+            input_value[0]
+            if isinstance(input_value, list)
+            else [{"role": "user", "content": input_value}]
+        )
+        service_provider = SERVICE_PROVIDERS["OPENAI"]
+        span_attributes = {
+            "instructions": kwargs.get("instructions"),
+            **get_langtrace_attributes(version, service_provider, vendor_type="llm"),
+            **get_llm_request_attributes(
+                kwargs,
+                operation_name="openai.responses.create",
+                prompts=prompt,
+            ),
+        }
+        with tracer.start_as_current_span(
+            name="openai.responses.create",
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+            end_on_exit=False,
+        ) as span:
+            try:
+                set_span_attributes(span, span_attributes)
+
+                response = wrapped(*args, **kwargs)
+                if is_streaming(kwargs) and span.is_recording():
+                    return StreamWrapper(response, span)
+                else:
+                    _set_openai_agentic_response_attributes(span, response)
+                return response
+            except Exception as err:
+                span.record_exception(err)
+                raise
+
+    return traced_method
+
+
 def filter_valid_attributes(attributes):
     """Filter attributes where value is not None, not an empty string, and not openai.NOT_GIVEN."""
     return {
@@ -634,6 +728,21 @@ def extract_content(choice: Any) -> Union[str, List[Dict[str, Any]], Dict[str, A
         return ""
 
 
+def _set_openai_agentic_response_attributes(span: Span, response) -> None:
+    set_span_attribute(span, SpanAttributes.LLM_RESPONSE_ID, response.id)
+    set_span_attribute(span, SpanAttributes.LLM_RESPONSE_MODEL, response.model)
+    set_event_completion(span, [{"role": "assistant", "content": response.output_text}])
+    set_usage_attributes(
+        span,
+        {
+            "input_tokens": response.usage.input_tokens,
+            "output_tokens": response.usage.output_tokens,
+            "total_tokens": response.usage.total_tokens,
+            "cached_tokens": response.usage.input_tokens_details["cached_tokens"],
+        },
+    )
+
+
 @silently_fail
 def _set_input_attributes(
     span: Span, kwargs: ChatCompletionsCreateKwargs, attributes: LLMSpanAttributes
@@ -707,5 +816,9 @@ def _set_response_attributes(span: Span, result: ResultType) -> None:
             set_span_attribute(
                 span,
                 "gen_ai.usage.cached_tokens",
-                result.usage.prompt_tokens_details.cached_tokens if result.usage.prompt_tokens_details else 0,
+                (
+                    result.usage.prompt_tokens_details.cached_tokens
+                    if result.usage.prompt_tokens_details
+                    else 0
+                ),
             )

langtrace_python_sdk/langtrace.py

@@ -48,8 +48,8 @@ from langtrace_python_sdk.instrumentation import (
     GeminiInstrumentation, GoogleGenaiInstrumentation, GraphlitInstrumentation,
     GroqInstrumentation, LangchainCommunityInstrumentation,
     LangchainCoreInstrumentation, LangchainInstrumentation,
-    LanggraphInstrumentation, LiteLLMInstrumentation,
-    LlamaindexInstrumentation, MilvusInstrumentation, MistralInstrumentation,
+    LanggraphInstrumentation, LiteLLMInstrumentation, LlamaindexInstrumentation,
+    MilvusInstrumentation, MistralInstrumentation, Neo4jGraphRAGInstrumentation,
     OllamaInstrumentor, OpenAIAgentsInstrumentation, OpenAIInstrumentation,
     PhiDataInstrumentation, PineconeInstrumentation, PyMongoInstrumentation,
     QdrantInstrumentation, VertexAIInstrumentation, WeaviateInstrumentation)
@@ -284,6 +284,7 @@ def init(
         "phidata": PhiDataInstrumentation(),
         "agno": AgnoInstrumentation(),
         "mistralai": MistralInstrumentation(),
+        "neo4j-graphrag": Neo4jGraphRAGInstrumentation(),
         "boto3": AWSBedrockInstrumentation(),
         "autogen": AutogenInstrumentation(),
         "pymongo": PyMongoInstrumentation(),

langtrace_python_sdk/utils/llm.py

@@ -96,22 +96,22 @@ def calculate_price_from_usage(model, usage):
 
 def convert_mistral_messages_to_serializable(mistral_messages):
     serializable_messages = []
-    
+
     try:
         for message in mistral_messages:
             serializable_message = {"role": message.role}
-        
+
             # Handle content
             if hasattr(message, "content"):
                 serializable_message["content"] = message.content
-            
+
             # Handle tool_calls
             if hasattr(message, "tool_calls") and message.tool_calls is not None:
                 serializable_tool_calls = []
-                
+
                 for tool_call in message.tool_calls:
                     serializable_tool_call = {}
-                    
+
                     # Handle id, type, and index
                     if hasattr(tool_call, "id"):
                         serializable_tool_call["id"] = tool_call.id
@@ -119,111 +119,117 @@ def convert_mistral_messages_to_serializable(mistral_messages):
                         serializable_tool_call["type"] = tool_call.type
                     if hasattr(tool_call, "index"):
                         serializable_tool_call["index"] = tool_call.index
-                    
+
                     # Handle function
                     if hasattr(tool_call, "function"):
                         function_call = tool_call.function
                         serializable_function = {}
-                        
+
                         if hasattr(function_call, "name"):
                             serializable_function["name"] = function_call.name
                         if hasattr(function_call, "arguments"):
                             serializable_function["arguments"] = function_call.arguments
-                        
+
                         serializable_tool_call["function"] = serializable_function
-                    
+
                     serializable_tool_calls.append(serializable_tool_call)
-                
+
                 serializable_message["tool_calls"] = serializable_tool_calls
-            
+
             # Handle tool_call_id for tool messages
             if hasattr(message, "tool_call_id"):
                 serializable_message["tool_call_id"] = message.tool_call_id
-            
+
             serializable_messages.append(serializable_message)
     except Exception as e:
         pass
-    
+
     return serializable_messages
 
 
 def convert_gemini_messages_to_serializable(formatted_messages, system_message=None):
     """
     Converts Gemini-formatted messages back to a JSON serializable format.
-    
+
     Args:
         formatted_messages: The formatted messages from Gemini.
         system_message (str, optional): System message content.
-        
+
     Returns:
         List[dict]: JSON serializable list of message dictionaries.
     """
     serializable_messages = []
-    
+
     try:
         # Add system message if present
         if system_message:
-            serializable_messages.append({
-                "role": "system",
-                "content": system_message
-            })
-        
+            serializable_messages.append({"role": "system", "content": system_message})
+
         for message_item in formatted_messages:
             # Handle the case where the item is a dict with 'role' and 'content' keys
-            if isinstance(message_item, dict) and 'role' in message_item and 'content' in message_item:
-                role = message_item['role']
-                content_value = message_item['content']
-                
+            if (
+                isinstance(message_item, dict)
+                and "role" in message_item
+                and "content" in message_item
+            ):
+                role = message_item["role"]
+                content_value = message_item["content"]
+
                 # Initialize our serializable message
                 serializable_message = {"role": role}
-                
+
                 # If content is a list of Content objects
                 if isinstance(content_value, list) and len(content_value) > 0:
                     for content_obj in content_value:
                         # Process each Content object
-                        if hasattr(content_obj, 'parts') and hasattr(content_obj, 'role'):
+                        if hasattr(content_obj, "parts") and hasattr(
+                            content_obj, "role"
+                        ):
                             parts = content_obj.parts
-                            
+
                             # Extract text from parts
                             text_parts = []
                             for part in parts:
-                                if hasattr(part, 'text') and part.text:
+                                if hasattr(part, "text") and part.text:
                                     text_parts.append(part.text)
-                            
+
                             if text_parts:
                                 serializable_message["content"] = " ".join(text_parts)
-                            
+
                             # Here you can add additional processing for other part types
                             # like function_call, function_response, inline_data, etc.
                             # Similar to the previous implementation
-                
+
                 # If content is a string or already a primitive type
-                elif isinstance(content_value, (str, int, float, bool)) or content_value is None:
+                elif (
+                    isinstance(content_value, (str, int, float, bool))
+                    or content_value is None
+                ):
                     serializable_message["content"] = content_value
-                
+
                 # Add the processed message to our list
                 serializable_messages.append(serializable_message)
-            
+
             # Handle the case where the item is a Content object directly
-            elif hasattr(message_item, 'role') and hasattr(message_item, 'parts'):
+            elif hasattr(message_item, "role") and hasattr(message_item, "parts"):
                 # This is the case from the previous implementation
                 # Process a Content object directly
                 serializable_message = {"role": message_item.role}
-                
+
                 parts = message_item.parts
                 text_parts = []
-                
+
                 for part in parts:
-                    if hasattr(part, 'text') and part.text:
+                    if hasattr(part, "text") and part.text:
                         text_parts.append(part.text)
-                
+
                 if text_parts:
                     serializable_message["content"] = " ".join(text_parts)
-                
+
                 serializable_messages.append(serializable_message)
     except Exception as e:
         pass
-    
+
     return serializable_messages
 
 
@@ -253,7 +259,7 @@ def get_llm_request_attributes(kwargs, prompts=None, model=None, operation_name=
         or kwargs.get("top_k", None)
         or kwargs.get("top_n", None)
     )
-    
+
     try:
         prompts = json.dumps(prompts) if prompts else None
     except Exception as e:
@@ -261,9 +267,13 @@ def get_llm_request_attributes(kwargs, prompts=None, model=None, operation_name=
             # check model
             if kwargs.get("model") is not None:
                 if kwargs.get("model").startswith("gemini"):
-                    prompts = json.dumps(convert_gemini_messages_to_serializable(prompts))
+                    prompts = json.dumps(
+                        convert_gemini_messages_to_serializable(prompts)
+                    )
                 elif kwargs.get("model").startswith("mistral"):
-                    prompts = json.dumps(convert_mistral_messages_to_serializable(prompts))
+                    prompts = json.dumps(
+                        convert_mistral_messages_to_serializable(prompts)
+                    )
                 else:
                     prompts = "[]"
             else:
@@ -427,6 +437,7 @@ class StreamWrapper:
                 "".join(self.result_content), response_model
             )
         if self._span_started:
+            print("SPAAN", self.span)
             set_span_attribute(
                 self.span,
                 SpanAttributes.LLM_RESPONSE_MODEL,
@@ -570,6 +581,9 @@ class StreamWrapper:
             and not hasattr(chunk.delta, "message")
         ):
             content = [chunk.delta.text] if hasattr(chunk.delta, "text") else []
+        # OpenAI Responses API
+        if hasattr(chunk, "type") and chunk.type == "response.completed":
+            content = [chunk.response.output_text]
 
         if isinstance(chunk, dict):
             if "message" in chunk:
@@ -579,7 +593,11 @@ class StreamWrapper:
             self.result_content.append(content[0])
 
     def set_usage_attributes(self, chunk):
-
+        # Responses API OpenAI
+        if hasattr(chunk, "type") and chunk.type == "response.completed":
+            usage = chunk.response.usage
+            self.completion_tokens = usage.output_tokens
+            self.prompt_tokens = usage.input_tokens
         # Anthropic & OpenAI
         if hasattr(chunk, "type") and chunk.type == "message_start":
             if hasattr(chunk.message, "usage") and chunk.message.usage is not None:
@@ -630,6 +648,7 @@ class StreamWrapper:
             and chunk.data.choices is not None
         ):
             chunk = chunk.data
+
         self.set_response_model(chunk=chunk)
         self.build_streaming_response(chunk=chunk)
         self.set_usage_attributes(chunk=chunk)

langtrace_python_sdk/version.py

@@ -1 +1 @@
-__version__ = "3.8.6"
+__version__ = "3.8.8"

{langtrace_python_sdk-3.8.6.dist-info → langtrace_python_sdk-3.8.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langtrace-python-sdk
-Version: 3.8.6
+Version: 3.8.8
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>

{langtrace_python_sdk-3.8.6.dist-info → langtrace_python_sdk-3.8.8.dist-info}/RECORD

@@ -115,8 +115,8 @@ examples/vertexai_example/main.py,sha256=gndId5X5ksD-ycxnAWMdEqIDbLc3kz5Vt8vm4YP
 examples/weaviate_example/__init__.py,sha256=8JMDBsRSEV10HfTd-YC7xb4txBjD3la56snk-Bbg2Kw,618
 examples/weaviate_example/query_text.py,sha256=wPHQTc_58kPoKTZMygVjTj-2ZcdrIuaausJfMxNQnQc,127162
 langtrace_python_sdk/__init__.py,sha256=VZM6i71NR7pBQK6XvJWRelknuTYUhqwqE7PlicKa5Wg,1166
-langtrace_python_sdk/langtrace.py,sha256=T-DsDrwWaL4gAUK1lkTRRpmvoO7F2WtO5hQZdyrVAxE,13791
-langtrace_python_sdk/version.py,sha256=L1_tSVoK2Iu6e_MbZl4Kogu3ops-t44WVGFD8F6BeAc,22
+langtrace_python_sdk/langtrace.py,sha256=4nhcy9_T3h4m5T5Blyrvs0BJcKzPWMtkIyEDSbba8P8,13879
+langtrace_python_sdk/version.py,sha256=3SjfTmtUQqjDdaQC3uiCoISksstrQ1Sqj4ASUtoUrzs,22
 langtrace_python_sdk/constants/__init__.py,sha256=3CNYkWMdd1DrkGqzLUgNZXjdAlM6UFMlf_F-odAToyc,146
 langtrace_python_sdk/constants/exporter/langtrace_exporter.py,sha256=EVCrouYCpY98f0KSaKr4PzNxPULTZZO6dSA_crEOyJU,106
 langtrace_python_sdk/constants/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -141,7 +141,7 @@ langtrace_python_sdk/constants/instrumentation/weaviate.py,sha256=gtv-JBxvNGClEM
 langtrace_python_sdk/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/extensions/langtrace_exporter.py,sha256=ckd8dMmY6h2oxE04p1JFLwUB5PSJX_Cy4eDFEM6aj4Y,6605
 langtrace_python_sdk/extensions/langtrace_filesystem.py,sha256=34fZutG28EJ66l67OvTGsydAH3ZpXgikdE7hVLqBpG4,7863
-langtrace_python_sdk/instrumentation/__init__.py,sha256=DC96oELorZedDf5zooQ6HGi-dmieXwUephgeB_LzfaU,2559
+langtrace_python_sdk/instrumentation/__init__.py,sha256=lw53EsTTtOK-dMhImudipmbVhZqORylt4hO5A7Mv8Uo,2652
 langtrace_python_sdk/instrumentation/agno/__init__.py,sha256=95fn4oA-CHB0mxc6KnVB20KSbXGl_ZZr9n99EEaXzrY,91
 langtrace_python_sdk/instrumentation/agno/instrumentation.py,sha256=XUnfvqpp13IgdF03xGKasq7kGjeaN1sXLIwCf-Nt_Nc,2667
 langtrace_python_sdk/instrumentation/agno/patch.py,sha256=qCUxCkzU9cYu_d8BzLgj_Ss97qib07tRVYpYDiNnNMs,16876
@@ -218,12 +218,15 @@ langtrace_python_sdk/instrumentation/milvus/patch.py,sha256=0yY5aQz0x7hpQZ8U-0qf
 langtrace_python_sdk/instrumentation/mistral/__init__.py,sha256=mkGALBQvq0jSfwDl6TU09SFwnVs6O4zkUi-yVmd3SNg,90
 langtrace_python_sdk/instrumentation/mistral/instrumentation.py,sha256=qtCkHCSOaiicUChbmTID4lcK1rbeW8oRSbpda2ogbgM,2328
 langtrace_python_sdk/instrumentation/mistral/patch.py,sha256=5EzqMeIEcMUH8P-l9-ijpRNWSc6mYwe9Gz0VY4PLrS0,6559
+langtrace_python_sdk/instrumentation/neo4j_graphrag/__init__.py,sha256=K-Qpfh-kn2EPxnYZ_oubLZNqAUO9Cx7mnMrJu_ms3UU,102
+langtrace_python_sdk/instrumentation/neo4j_graphrag/instrumentation.py,sha256=FLnddPSozuu5puqYD_FnXLMFet8YToVdWP-cY5QZrvM,2216
+langtrace_python_sdk/instrumentation/neo4j_graphrag/patch.py,sha256=4c7NKcTJeYsbi5V4aSsuPzTiFoBqtlcXmYx2bMlE7qg,9713
 langtrace_python_sdk/instrumentation/ollama/__init__.py,sha256=g2zJsXnDHinXPzTc-WxDeTtHmr9gmAj3K6l_00kP8c8,82
 langtrace_python_sdk/instrumentation/ollama/instrumentation.py,sha256=jdsvkqUJAAUNLVPtAkn_rG26HXetVQXWtjn4a6eWZro,2029
 langtrace_python_sdk/instrumentation/ollama/patch.py,sha256=w99r9wCCVDdJnZQEezYE2lW_iNFEtrldt9vq3ISAsag,5375
 langtrace_python_sdk/instrumentation/openai/__init__.py,sha256=VPHRNCQEdkizIVP2d0Uw_a7t8XOTSTprEIB8oboJFbs,95
-langtrace_python_sdk/instrumentation/openai/instrumentation.py,sha256=PZxI0qfoud1VsKGmJu49YDp0Z9z9TzCR8qxR3uznOMA,2810
-langtrace_python_sdk/instrumentation/openai/patch.py,sha256=mRE150sHGL2dq4oOKTYWek1vup7HuRW_sqP6nNOd3N8,27862
+langtrace_python_sdk/instrumentation/openai/instrumentation.py,sha256=kvbRr5DrcP23ka4mLZpwr7W0ZxeTGHilkOlc_h5V5s8,3226
+langtrace_python_sdk/instrumentation/openai/patch.py,sha256=I_Gzp8ULbOQzlG9PltrembOiBvfp0FQHDRwR5q5tmZg,31358
 langtrace_python_sdk/instrumentation/openai/types.py,sha256=aVkoa7tmAbYfyOhnyMrDaVjQuwhmRNLMthlNtKMtWX8,4311
 langtrace_python_sdk/instrumentation/openai_agents/__init__.py,sha256=ElRfFIQYXD2-eRyL3fZnjIsDJLTrDolh5cZHPnZv0q8,107
 langtrace_python_sdk/instrumentation/openai_agents/instrumentation.py,sha256=6M4FHXfem7pazrNgsimebrEfMb2FxI8lHrdEMbVf75Y,1860
@@ -249,7 +252,7 @@ langtrace_python_sdk/instrumentation/weaviate/patch.py,sha256=Lqixz32uAvDA2VLU3z
 langtrace_python_sdk/types/__init__.py,sha256=SJSJzkgPjGGTVJXUZ_FyR3p9DJ5kWGx7iAnJfY4ZYHU,4669
 langtrace_python_sdk/utils/__init__.py,sha256=VVDOG-QLd59ZvSHp0avjof0sbxlZ1QQOf0KoOF7ofhQ,3310
 langtrace_python_sdk/utils/langtrace_sampler.py,sha256=BupNndHbU9IL_wGleKetz8FdcveqHMBVz1bfKTTW80w,1753
-langtrace_python_sdk/utils/llm.py,sha256=giJU33LvMPaRjPAjUwBCehgHj_ei1HwM7gLJSVWYLnI,23238
+langtrace_python_sdk/utils/llm.py,sha256=UGfCfOcQ6NiGKsA1_aJt9Pt7yi4iGKq26TJQroOwktg,23463
 langtrace_python_sdk/utils/misc.py,sha256=LaQr5LOmZMiuwVdjYh7aIu6o2C_Xb1wgpQGNOVmRzfE,1918
 langtrace_python_sdk/utils/prompt_registry.py,sha256=n5dQMVLBw8aJZY8Utvf67bncc25ELf6AH9BYw8_hSzo,2619
 langtrace_python_sdk/utils/sdk_version_checker.py,sha256=F-VVVH7Fmhr5LcY0IIe-34zIi5RQcx26uuxFpPzZesM,1782
@@ -300,8 +303,8 @@ tests/pinecone/cassettes/test_query.yaml,sha256=b5v9G3ssUy00oG63PlFUR3JErF2Js-5A
 tests/pinecone/cassettes/test_upsert.yaml,sha256=neWmQ1v3d03V8WoLl8FoFeeCYImb8pxlJBWnFd_lITU,38607
 tests/qdrant/conftest.py,sha256=9n0uHxxIjWk9fbYc4bx-uP8lSAgLBVx-cV9UjnsyCHM,381
 tests/qdrant/test_qdrant.py,sha256=pzjAjVY2kmsmGfrI2Gs2xrolfuaNHz7l1fqGQCjp5_o,3353
-langtrace_python_sdk-3.8.6.dist-info/METADATA,sha256=4oUaxQYAGDXx_tRBdNnMja_qs0XOH-KOTYSwWizKc4g,15844
-langtrace_python_sdk-3.8.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langtrace_python_sdk-3.8.6.dist-info/entry_points.txt,sha256=1_b9-qvf2fE7uQNZcbUei9vLpFZBbbh9LrtGw95ssAo,70
-langtrace_python_sdk-3.8.6.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-langtrace_python_sdk-3.8.6.dist-info/RECORD,,
+langtrace_python_sdk-3.8.8.dist-info/METADATA,sha256=deElB8UvrgQqY6ZaOFhY7bKQnvXEinTTrnNkgz4b04o,15844
+langtrace_python_sdk-3.8.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langtrace_python_sdk-3.8.8.dist-info/entry_points.txt,sha256=1_b9-qvf2fE7uQNZcbUei9vLpFZBbbh9LrtGw95ssAo,70
+langtrace_python_sdk-3.8.8.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+langtrace_python_sdk-3.8.8.dist-info/RECORD,,