langtrace-python-sdk 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

langtrace_python_sdk/instrumentation/openai/instrumentation.py

@@ -6,9 +6,12 @@ from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
 
 from langtrace_python_sdk.instrumentation.openai.patch import (
+    async_embeddings_create,
+    async_images_generate,
     chat_completions_create,
     embeddings_create,
     images_generate,
+    async_chat_completions_create,
 )
 
 import logging
@@ -25,21 +28,43 @@ class OpenAIInstrumentation(BaseInstrumentor):
         tracer_provider = kwargs.get("tracer_provider")
         tracer = get_tracer(__name__, "", tracer_provider)
         version = importlib.metadata.version("openai")
+
         wrap_function_wrapper(
             "openai.resources.chat.completions",
             "Completions.create",
             chat_completions_create("openai.chat.completions.create", version, tracer),
         )
+
+        wrap_function_wrapper(
+            "openai.resources.chat.completions",
+            "AsyncCompletions.create",
+            async_chat_completions_create(
+                "openai.chat.completions.create_stream", version, tracer
+            ),
+        )
+
         wrap_function_wrapper(
             "openai.resources.images",
             "Images.generate",
             images_generate("openai.images.generate", version, tracer),
         )
+
+        wrap_function_wrapper(
+            "openai.resources.images",
+            "AsyncImages.generate",
+            async_images_generate("openai.images.generate", version, tracer),
+        )
         wrap_function_wrapper(
             "openai.resources.embeddings",
             "Embeddings.create",
             embeddings_create("openai.embeddings.create", version, tracer),
         )
 
+        wrap_function_wrapper(
+            "openai.resources.embeddings",
+            "AsyncEmbeddings.create",
+            async_embeddings_create("openai.embeddings.create", version, tracer),
+        )
+
     def _uninstrument(self, **kwargs):
         pass

langtrace_python_sdk/instrumentation/openai/patch.py

@@ -9,10 +9,11 @@ from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
 from langtrace_python_sdk.constants.instrumentation.common import (
-    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, SERVICE_PROVIDERS)
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+    SERVICE_PROVIDERS,
+)
 from langtrace_python_sdk.constants.instrumentation.openai import APIS
-from langtrace_python_sdk.utils.llm import (calculate_prompt_tokens,
-                                            estimate_tokens)
+from langtrace_python_sdk.utils.llm import calculate_prompt_tokens, estimate_tokens
 
 
 def images_generate(original_method, version, tracer):
@@ -40,7 +41,7 @@ def images_generate(original_method, version, tracer):
             "llm.model": kwargs.get("model"),
             "llm.stream": kwargs.get("stream"),
             "llm.prompts": json.dumps([kwargs.get("prompt", [])]),
-            **(extra_attributes if extra_attributes is not None else {})
+            **(extra_attributes if extra_attributes is not None else {}),
         }
 
         attributes = LLMSpanAttributes(**span_attributes)
@@ -87,6 +88,78 @@ def images_generate(original_method, version, tracer):
     return traced_method
 
 
+def async_images_generate(original_method, version, tracer):
+    """
+    Wrap the `generate` method of the `Images` class to trace it.
+    """
+
+    async def traced_method(wrapped, instance, args, kwargs):
+        base_url = (
+            str(instance._client._base_url)
+            if hasattr(instance, "_client") and hasattr(instance._client, "_base_url")
+            else ""
+        )
+        service_provider = SERVICE_PROVIDERS["OPENAI"]
+        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": "llm",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "url.full": base_url,
+            "llm.api": APIS["IMAGES_GENERATION"]["ENDPOINT"],
+            "llm.model": kwargs.get("model"),
+            "llm.stream": kwargs.get("stream"),
+            "llm.prompts": json.dumps([kwargs.get("prompt", [])]),
+            **(extra_attributes if extra_attributes is not None else {}),
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        with tracer.start_as_current_span(
+            APIS["IMAGES_GENERATION"]["METHOD"], kind=SpanKind.CLIENT
+        ) as span:
+            async for field, value in attributes.model_dump(by_alias=True).items():
+                if value is not None:
+                    span.set_attribute(field, value)
+            try:
+                # Attempt to call the original method
+                result = await wrapped(*args, **kwargs)
+                if kwargs.get("stream") is False or kwargs.get("stream") is None:
+                    data = (
+                        result.data[0]
+                        if hasattr(result, "data") and len(result.data) > 0
+                        else {}
+                    )
+                    response = [
+                        {
+                            "url": data.url if hasattr(data, "url") else "",
+                            "revised_prompt": (
+                                data.revised_prompt
+                                if hasattr(data, "revised_prompt")
+                                else ""
+                            ),
+                        }
+                    ]
+                    span.set_attribute("llm.responses", json.dumps(response))
+
+                span.set_status(StatusCode.OK)
+                return result
+            except Exception as e:
+                # Record the exception in the span
+                span.record_exception(e)
+
+                # Set the span status to indicate an error
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+
+                # Reraise the exception to ensure it's not swallowed
+                raise
+
+    return traced_method
+
+
 def chat_completions_create(original_method, version, tracer):
     """Wrap the `create` method of the `ChatCompletion` class to trace it."""
 
@@ -105,6 +178,33 @@ def chat_completions_create(original_method, version, tracer):
 
         extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
 
+        # handle tool calls in the kwargs
+        llm_prompts = []
+        for item in kwargs.get("messages", []):
+            if "tool_calls" in item:
+                tool_calls = []
+                for tool_call in item["tool_calls"]:
+                    tool_call_dict = {
+                        "id": tool_call.id if hasattr(tool_call, "id") else "",
+                        "type": tool_call.type if hasattr(tool_call, "type") else "",
+                    }
+                    if hasattr(tool_call, "function"):
+                        tool_call_dict["function"] = {
+                            "name": (
+                                tool_call.function.name
+                                if hasattr(tool_call.function, "name")
+                                else ""
+                            ),
+                            "arguments": (
+                                tool_call.function.arguments
+                                if hasattr(tool_call.function, "arguments")
+                                else ""
+                            ),
+                        }
+                    tool_calls.append(tool_call_dict)
+                item["tool_calls"] = tool_calls
+            llm_prompts.append(item)
+
         span_attributes = {
             "langtrace.sdk.name": "langtrace-python-sdk",
             "langtrace.service.name": service_provider,
@@ -115,7 +215,7 @@ def chat_completions_create(original_method, version, tracer):
             "llm.api": APIS["CHAT_COMPLETION"]["ENDPOINT"],
             "llm.prompts": json.dumps(kwargs.get("messages", [])),
             "llm.stream": kwargs.get("stream"),
-            **(extra_attributes if extra_attributes is not None else {})
+            **(extra_attributes if extra_attributes is not None else {}),
         }
 
         attributes = LLMSpanAttributes(**span_attributes)
@@ -272,7 +372,225 @@ def chat_completions_create(original_method, version, tracer):
                 result_content.append(content[0] if len(content) > 0 else "")
                 yield chunk
         finally:
+            # Finalize span after processing all chunks
+            span.add_event(Event.STREAM_END.value)
+            span.set_attribute(
+                "llm.token.counts",
+                json.dumps(
+                    {
+                        "input_tokens": prompt_tokens,
+                        "output_tokens": completion_tokens,
+                        "total_tokens": prompt_tokens + completion_tokens,
+                    }
+                ),
+            )
+            span.set_attribute(
+                "llm.responses",
+                json.dumps(
+                    [
+                        {
+                            "message": {
+                                "role": "assistant",
+                                "content": "".join(result_content),
+                            }
+                        }
+                    ]
+                ),
+            )
+            span.set_status(StatusCode.OK)
+            span.end()
 
+    # return the wrapped method
+    return traced_method
+
+
+def async_chat_completions_create(original_method, version, tracer):
+    """Wrap the `create` method of the `ChatCompletion` class to trace it."""
+
+    async def traced_method(wrapped, instance, args, kwargs):
+        base_url = (
+            str(instance._client._base_url)
+            if hasattr(instance, "_client") and hasattr(instance._client, "_base_url")
+            else ""
+        )
+        service_provider = SERVICE_PROVIDERS["OPENAI"]
+        # If base url contains perplexity or azure, set the service provider accordingly
+        if "perplexity" in base_url:
+            service_provider = SERVICE_PROVIDERS["PPLX"]
+        elif "azure" in base_url:
+            service_provider = SERVICE_PROVIDERS["AZURE"]
+
+        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": "llm",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "url.full": base_url,
+            "llm.api": APIS["CHAT_COMPLETION"]["ENDPOINT"],
+            "llm.prompts": json.dumps(kwargs.get("messages", [])),
+            "llm.stream": kwargs.get("stream"),
+            **(extra_attributes if extra_attributes is not None else {}),
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        if kwargs.get("temperature") is not None:
+            attributes.llm_temperature = kwargs.get("temperature")
+        if kwargs.get("top_p") is not None:
+            attributes.llm_top_p = kwargs.get("top_p")
+        if kwargs.get("user") is not None:
+            attributes.llm_user = kwargs.get("user")
+        if kwargs.get("functions") is not None:
+            attributes.llm_function_prompts = json.dumps(kwargs.get("functions"))
+
+        # TODO(Karthik): Gotta figure out how to handle streaming with context
+        # with tracer.start_as_current_span(APIS["CHAT_COMPLETION"]["METHOD"],
+        #                                   kind=SpanKind.CLIENT) as span:
+        span = tracer.start_span(
+            APIS["CHAT_COMPLETION"]["METHOD"], kind=SpanKind.CLIENT
+        )
+        for field, value in attributes.model_dump(by_alias=True).items():
+            if value is not None:
+                span.set_attribute(field, value)
+        try:
+            # Attempt to call the original method
+            result = await wrapped(*args, **kwargs)
+            if kwargs.get("stream") is False or kwargs.get("stream") is None:
+                span.set_attribute("llm.model", result.model)
+                if hasattr(result, "choices") and result.choices is not None:
+                    responses = [
+                        {
+                            "message": {
+                                "role": (
+                                    choice.message.role
+                                    if choice.message and choice.message.role
+                                    else "assistant"
+                                ),
+                                "content": (
+                                    choice.message.content
+                                    if choice.message and choice.message.content
+                                    else (
+                                        choice.message.function_call.arguments
+                                        if choice.message
+                                        and choice.message.function_call.arguments
+                                        else ""
+                                    )
+                                ),
+                                **(
+                                    {
+                                        "content_filter_results": choice[
+                                            "content_filter_results"
+                                        ]
+                                    }
+                                    if "content_filter_results" in choice
+                                    else {}
+                                ),
+                            }
+                        }
+                        for choice in result.choices
+                    ]
+                    span.set_attribute("llm.responses", json.dumps(responses))
+                else:
+                    responses = []
+                    span.set_attribute("llm.responses", json.dumps(responses))
+                if (
+                    hasattr(result, "system_fingerprint")
+                    and result.system_fingerprint is not None
+                ):
+                    span.set_attribute(
+                        "llm.system.fingerprint", result.system_fingerprint
+                    )
+                # Get the usage
+                if hasattr(result, "usage") and result.usage is not None:
+                    usage = result.usage
+                    if usage is not None:
+                        usage_dict = {
+                            "input_tokens": result.usage.prompt_tokens,
+                            "output_tokens": usage.completion_tokens,
+                            "total_tokens": usage.total_tokens,
+                        }
+                        span.set_attribute("llm.token.counts", json.dumps(usage_dict))
+                span.set_status(StatusCode.OK)
+                span.end()
+                return result
+            else:
+                # iterate over kwargs.get("messages", {}) and calculate the prompt tokens
+                prompt_tokens = 0
+                for message in kwargs.get("messages", {}):
+                    prompt_tokens += calculate_prompt_tokens(
+                        json.dumps(message), kwargs.get("model")
+                    )
+
+                # iterate over kwargs.get("functions") and calculate the prompt tokens
+                if kwargs.get("functions") is not None:
+                    for function in kwargs.get("functions"):
+                        prompt_tokens += calculate_prompt_tokens(
+                            json.dumps(function), kwargs.get("model")
+                        )
+
+                return ahandle_streaming_response(
+                    result,
+                    span,
+                    prompt_tokens,
+                    function_call=kwargs.get("functions") is not None,
+                )
+
+        except Exception as error:
+            span.record_exception(error)
+            span.set_status(Status(StatusCode.ERROR, str(error)))
+            span.end()
+            raise
+
+    async def ahandle_streaming_response(
+        result, span, prompt_tokens, function_call=False
+    ):
+        """Process and yield streaming response chunks."""
+        result_content = []
+        span.add_event(Event.STREAM_START.value)
+        completion_tokens = 0
+        try:
+            async for chunk in result:
+                if hasattr(chunk, "model") and chunk.model is not None:
+                    span.set_attribute("llm.model", chunk.model)
+                if hasattr(chunk, "choices") and chunk.choices is not None:
+                    token_counts = [
+                        (
+                            estimate_tokens(choice.delta.content)
+                            if choice.delta and choice.delta.content
+                            else (
+                                estimate_tokens(choice.delta.function_call.arguments)
+                                if choice.delta.function_call
+                                and choice.delta.function_call.arguments
+                                else 0
+                            )
+                        )
+                        for choice in chunk.choices
+                    ]
+                    completion_tokens += sum(token_counts)
+                    content = [
+                        (
+                            choice.delta.content
+                            if choice.delta and choice.delta.content
+                            else (
+                                choice.delta.function_call.arguments
+                                if choice.delta.function_call
+                                and choice.delta.function_call.arguments
+                                else ""
+                            )
+                        )
+                        for choice in chunk.choices
+                    ]
+                else:
+                    content = []
+                span.add_event(
+                    Event.STREAM_OUTPUT.value, {"response": "".join(content)}
+                )
+                result_content.append(content[0] if len(content) > 0 else "")
+                yield chunk
+        finally:
             # Finalize span after processing all chunks
             span.add_event(Event.STREAM_END.value)
             span.set_attribute(
@@ -330,7 +648,7 @@ def embeddings_create(original_method, version, tracer):
             "llm.api": APIS["EMBEDDINGS_CREATE"]["ENDPOINT"],
             "llm.model": kwargs.get("model"),
             "llm.prompts": "",
-            **(extra_attributes if extra_attributes is not None else {})
+            **(extra_attributes if extra_attributes is not None else {}),
         }
 
         attributes = LLMSpanAttributes(**span_attributes)
@@ -366,3 +684,66 @@ def embeddings_create(original_method, version, tracer):
                 raise
 
     return traced_method
+
+
+def async_embeddings_create(original_method, version, tracer):
+    """
+    Wrap the `create` method of the `Embeddings` class to trace it.
+    """
+
+    async def traced_method(wrapped, instance, args, kwargs):
+        base_url = (
+            str(instance._client._base_url)
+            if hasattr(instance, "_client") and hasattr(instance._client, "_base_url")
+            else ""
+        )
+
+        service_provider = SERVICE_PROVIDERS["OPENAI"]
+        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": "llm",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "url.full": base_url,
+            "llm.api": APIS["EMBEDDINGS_CREATE"]["ENDPOINT"],
+            "llm.model": kwargs.get("model"),
+            "llm.prompts": "",
+            **(extra_attributes if extra_attributes is not None else {}),
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+        kwargs.get("encoding_format")
+
+        if kwargs.get("encoding_format") is not None:
+            attributes.llm_encoding_format = kwargs.get("encoding_format")
+        if kwargs.get("dimensions") is not None:
+            attributes["llm.dimensions"] = kwargs.get("dimensions")
+        if kwargs.get("user") is not None:
+            attributes["llm.user"] = kwargs.get("user")
+
+        with tracer.start_as_current_span(
+            APIS["EMBEDDINGS_CREATE"]["METHOD"], kind=SpanKind.CLIENT
+        ) as span:
+
+            async for field, value in attributes.model_dump(by_alias=True).items():
+                if value is not None:
+                    span.set_attribute(field, value)
+            try:
+                # Attempt to call the original method
+                result = await wrapped(*args, **kwargs)
+                span.set_status(StatusCode.OK)
+                return result
+            except Exception as e:
+                # Record the exception in the span
+                span.record_exception(e)
+
+                # Set the span status to indicate an error
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+
+                # Reraise the exception to ensure it's not swallowed
+                raise
+
+    return traced_method

langtrace_python_sdk/langtrace.py

@@ -41,7 +41,6 @@ def init(
     api_key: str = None,
     batch: bool = True,
     write_to_langtrace_cloud: bool = True,
-    debug_log_to_console: bool = False,
     custom_remote_exporter=None,
     api_host: Optional[str] = None,
 ):
@@ -54,20 +53,24 @@ def init(
     )
     console_exporter = ConsoleSpanExporter()
     batch_processor_remote = BatchSpanProcessor(remote_write_exporter)
+    simple_processor_remote = SimpleSpanProcessor(remote_write_exporter)
     batch_processor_console = BatchSpanProcessor(console_exporter)
     simple_processor_console = SimpleSpanProcessor(console_exporter)
 
-    if debug_log_to_console:
+    if write_to_langtrace_cloud:
+        provider.add_span_processor(batch_processor_remote)
+    elif custom_remote_exporter is not None:
+        if batch:
+            provider.add_span_processor(batch_processor_remote)
+        else:
+            provider.add_span_processor(simple_processor_remote)
+    else:
         if batch:
             provider.add_span_processor(batch_processor_console)
         else:
             provider.add_span_processor(simple_processor_console)
 
-    if write_to_langtrace_cloud:
-        if batch:
-            provider.add_span_processor(batch_processor_remote)
-        else:
-            raise ValueError("Batching is required for remote write")
+
 
     # Initialize tracer
     trace.set_tracer_provider(provider)

langtrace_python_sdk/version.py

@@ -1 +1 @@
-__version__ = "1.3.1"
+__version__ = "1.3.2"

{langtrace_python_sdk-1.3.1.dist-info → langtrace_python_sdk-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 1.3.1
+Version: 1.3.2
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>
@@ -19,6 +19,7 @@ Requires-Dist: trace-attributes
 Provides-Extra: dev
 Requires-Dist: anthropic; extra == 'dev'
 Requires-Dist: chromadb; extra == 'dev'
+Requires-Dist: cohere; extra == 'dev'
 Requires-Dist: langchain; extra == 'dev'
 Requires-Dist: langchain-openai; extra == 'dev'
 Requires-Dist: llama-index; extra == 'dev'
@@ -144,7 +145,7 @@ pip install langtrace-python-sdk
 
 ``` python
 from langtrace_python_sdk import langtrace # Must precede any llm module imports
-langtrace.init(write_to_langtrace_cloud=False, batch=False)
+langtrace.init(write_to_langtrace_cloud=False)
 ```
 
 ## Langtrace self hosted custom exporter

{langtrace_python_sdk-1.3.1.dist-info → langtrace_python_sdk-1.3.2.dist-info}/RECORD

@@ -1,30 +1,32 @@
 examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 examples/anthropic_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-examples/anthropic_example/completion.py,sha256=97CA6u7iLdTj6qQ5XA7nB0bcNMxUwXJKpNYSCW-BM6Q,791
+examples/anthropic_example/completion.py,sha256=GpkfkBY-PaIqoWjpnVFB6QVqw1O6B_MYQPxn_JbkeOw,751
 examples/chroma_example/__init__.py,sha256=Tq6pae7fHA7dwuDslabB5MTNedL21gu2RaZicpxSyLU,25
-examples/chroma_example/basic.py,sha256=VE-I7Db58Dyb0G6WgX9FeloHLGuRRvfB4aNvSIVL4Uk,910
+examples/chroma_example/basic.py,sha256=RT4yi8mhN_bgTbeGZnHEscLT9z_VlFnHekIM9psefLk,870
 examples/cohere_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-examples/cohere_example/chat.py,sha256=MpTyvXPNTMcjKzQUsF4xepwTxBNcDbUYmjawzjZIIo4,889
-examples/cohere_example/chat_stream.py,sha256=t9XmyC_sT3ZdDQKzECPcX-8hpyYzrL6OXihsAKmPxTA,680
-examples/cohere_example/embed_create.py,sha256=JYLCfnES4TX-RbU6n3wIlLEfr5pfCwOwdRopjvxytew,552
-examples/fastapi_example/basic_route.py,sha256=3wu1cogsR9eeuwid9kRBepVxMUZ0np-T5qkmsvQh0Lw,1145
+examples/cohere_example/chat.py,sha256=L96GnhPm43l-iS5loyLBbP5f2J7ZiKzf9Yt-kwHn-5E,849
+examples/cohere_example/chat_stream.py,sha256=wYmcTF232yfmiozmhGdXLsWX8sTFmRawSW8ApDaZmJY,641
+examples/cohere_example/embed_create.py,sha256=MC1lmxIi_SRLxmiKyL17fq-M95NqWqBiAI1VH234E7E,514
+examples/fastapi_example/basic_route.py,sha256=O0gaAdYgdbZ1LElV5JuJyq-FZMHcfJCysqQPpKa8fNI,1128
+examples/hiveagent_example/basic.py,sha256=MuzPMHtrhkxv2T7Ke8Rz3TsSum_XZ0IyPc2ufOt0U1Y,444
 examples/langchain_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 examples/langchain_example/basic.py,sha256=mSVcE-Kx7jNS4U_zrm5WZI98xyw6WTrhd2GMVGgn9Cg,2653
 examples/langchain_example/tool.py,sha256=8T8_IDbgA58XbsfyH5_xhA8ZKQfyfyFxF8wor-PsRjA,2556
 examples/llamaindex_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-examples/llamaindex_example/basic.py,sha256=a8Z9F6egBdoo4GzcSMQ-0zkpBn2CuQg4JSI8kmSE-8Q,694
+examples/llamaindex_example/agent.py,sha256=_iIXy9lfDz6ySf6aTeeRqejlfGnXZ7msxLBjGiJth3E,2777
+examples/llamaindex_example/basic.py,sha256=gvns3oDUy0c4I5ewnj9-B36_1La8y6qD3VQaq6v3syM,654
 examples/llamaindex_example/data/abramov.txt,sha256=Ou-GyWZm5AjHLgxviBoRE9ikNv5MScsF0cd--0vVVhI,32667
 examples/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-examples/openai/chat_completion.py,sha256=ynVWdvEwDxNPpkWu9fv4al7_1mm3rFilFvqkrcRjdpA,1702
+examples/openai/chat_completion.py,sha256=1AiLIr0sWBKcqzhCbTJkspZyuGDZATxhbKBCKjzvM-E,1731
 examples/openai/embeddings_create.py,sha256=AhDNAqg-WzRYLJAE_b2RKGjuVCh4aZSU7MxcZv2kCHQ,518
-examples/openai/function_calling.py,sha256=Zd1gkl1TU-g_cxXox3_8vmFRZVyZSyyLaboEJLc6N2A,2375
+examples/openai/function_calling.py,sha256=qsbmlkWnOvdemekMqsB0roBhpn_GsNBWrR2td0vVEIs,2335
 examples/openai/images_generate.py,sha256=ZioxTuHKE_yYlhpESqXKVzdkiwdegkmLVB7N8T2LU00,506
-examples/perplexity_example/basic.py,sha256=jEqZnY9cmDezMAwMvKaZeRk7vW1H68Zc2de3gDnb6hg,704
+examples/perplexity_example/basic.py,sha256=oTLwEYlvpD4wEnqEUrUSlQ0SeQ0u50Jeab4ggkikQg0,671
 examples/pinecone_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-examples/pinecone_example/basic.py,sha256=hdV6-5Fmol9zeyFzDtdabD62vkqUJ4lCHG2YcVNpIpI,933
+examples/pinecone_example/basic.py,sha256=OkYjN3J5kxw-kloOV3Q-iyI6opkbarWsMom-_AMP2ZA,893
 langtrace_python_sdk/__init__.py,sha256=SlHg447-nQBbw8exRNJP_OyHUZ39Sldb7aaQ35hIRm8,262
-langtrace_python_sdk/langtrace.py,sha256=-9WC49AOmxmEWl_fUXkEAKgshg3pmI5J-_d_1hITjY8,3447
-langtrace_python_sdk/version.py,sha256=-ypEJktJToAL9by62JJKWEzDo_KPCQtmE5kwFgX24z4,22
+langtrace_python_sdk/langtrace.py,sha256=83-AkdASO7UF9FHR9BDZUSeYv9GFZkJJQD2YLKbqzo8,3562
+langtrace_python_sdk/version.py,sha256=HgKA3RqZvC7slo8MgLyffCGwJbQ3cY6I7oUMFvGLWps,22
 langtrace_python_sdk/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/constants/exporter/langtrace_exporter.py,sha256=5MNjnAOg-4am78J3gVMH6FSwq5N8TOj72ugkhsw4vi0,46
 langtrace_python_sdk/constants/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -35,7 +37,7 @@ langtrace_python_sdk/constants/instrumentation/common.py,sha256=iqoWV1laoFxzqqwz
 langtrace_python_sdk/constants/instrumentation/openai.py,sha256=9VF6ic9Ed3bpSvdp6iNmrpx2Ppo6DPav3hoUcqSQSv0,1048
 langtrace_python_sdk/constants/instrumentation/pinecone.py,sha256=Xaqqw-xBO0JJLGk75hiCUQGztNm0HiVaLQvjtYK7VJM,472
 langtrace_python_sdk/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langtrace_python_sdk/extensions/langtrace_exporter.py,sha256=K-grSUEBkSGfo_LwyyZDr_iz3oDy1mHnx34FfD-qFSQ,4067
+langtrace_python_sdk/extensions/langtrace_exporter.py,sha256=3KKeWSLECAxO-FMTndwF5Evv39t9-GG7p67DfYJpNEY,4194
 langtrace_python_sdk/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/anthropic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/anthropic/instrumentation.py,sha256=DTvz6fNMMxYc2z6oqOveBX6mIXHoOFeOoosyXB2HJ6Y,1159
@@ -45,7 +47,7 @@ langtrace_python_sdk/instrumentation/chroma/instrumentation.py,sha256=9k8KueizRJ
 langtrace_python_sdk/instrumentation/chroma/patch.py,sha256=fddeGMP8obll2Tra04S8C0jEiJ97v_y1WC1QdO4bO4A,2303
 langtrace_python_sdk/instrumentation/cohere/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/cohere/instrumentation.py,sha256=-DWjAq4_H3Q8MCyH2qt3NiLndgrRy9BIUbrZZHsY0pY,1431
-langtrace_python_sdk/instrumentation/cohere/patch.py,sha256=PpDEmWc3XFnrFOvyytluaJN25TQqE4ZOR0WZMYqzg2E,15727
+langtrace_python_sdk/instrumentation/cohere/patch.py,sha256=ELur2aK2DakDWDf26pvas4r9vpawX7oxwgDiHLMj27U,16631
 langtrace_python_sdk/instrumentation/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/langchain/instrumentation.py,sha256=UBUx31IErih1zDGkwez5ZFT2qGvCHxhdGHvJsEyhvEo,2938
 langtrace_python_sdk/instrumentation/langchain/patch.py,sha256=ofageMjQZ_AGlnfknBI06dkaDsyNuqYRz-3EZhv9izY,3294
@@ -56,18 +58,18 @@ langtrace_python_sdk/instrumentation/langchain_core/__init__.py,sha256=47DEQpj8H
 langtrace_python_sdk/instrumentation/langchain_core/instrumentation.py,sha256=1Y4q_F2nN79y-dap_if35vH9oowIuDi6mo0ELYIltNI,5417
 langtrace_python_sdk/instrumentation/langchain_core/patch.py,sha256=L20qbFCChGJhYDAyftZ7snev7OElN-V3X4m3IZNEDYc,7959
 langtrace_python_sdk/instrumentation/llamaindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langtrace_python_sdk/instrumentation/llamaindex/instrumentation.py,sha256=wVSvxSJb1owoEBCSqPQRzsbdEkPAQzTqXKKSxGk0sSY,2488
-langtrace_python_sdk/instrumentation/llamaindex/patch.py,sha256=NqBsPM4eE3yMu1aIev8p8yH5Thsv72JL68ABEZNe2ug,2043
+langtrace_python_sdk/instrumentation/llamaindex/instrumentation.py,sha256=wozDvDQcGpfM-kMUhwY2be6RBOJwJnfSfxqSrPUSCM8,3021
+langtrace_python_sdk/instrumentation/llamaindex/patch.py,sha256=8IM2dedF81w8_vVyA56JptyvlQl_bQO4UcB56sptuGs,3700
 langtrace_python_sdk/instrumentation/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langtrace_python_sdk/instrumentation/openai/instrumentation.py,sha256=stlFopPggB8mgnn4QdVh41rmA8mlzH5x-C00XHfApCE,1408
-langtrace_python_sdk/instrumentation/openai/patch.py,sha256=fTyZudq7hjk-BEZad4ayX6SaCCF0053_mSmeC43Lu-c,15463
+langtrace_python_sdk/instrumentation/openai/instrumentation.py,sha256=Pv4n4z_kSxvZGVxrj3AopBoWQSxIOtMKolkxHrchRdM,2162
+langtrace_python_sdk/instrumentation/openai/patch.py,sha256=6hZ8ExTHHUnib8sU5k5OXt9zFKl3iTL2-PzsHJxW5ao,31587
 langtrace_python_sdk/instrumentation/pinecone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/pinecone/instrumentation.py,sha256=o0EUd5jvHaDKOUTj4NjnL5UfDHDHxyXkWGlTW4oeRDk,1784
 langtrace_python_sdk/instrumentation/pinecone/patch.py,sha256=5lF7hQmg2-U2EWtOC0w8_peRaNMysBomb0fjiNoS6eQ,2200
 langtrace_python_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/utils/llm.py,sha256=4z2e-md_ELXCEuOIRVWracR6qH2pmsOxCqpkuF9_3Nw,1589
 langtrace_python_sdk/utils/with_root_span.py,sha256=N7ONrcF0myZbHBy5gpQffDbX-Kf63Crsz9szG0i3m08,1889
-langtrace_python_sdk-1.3.1.dist-info/METADATA,sha256=eTyOCa7I4N386Gi0evo8yefecH0ntGFMK2nSzihOVfg,9061
-langtrace_python_sdk-1.3.1.dist-info/WHEEL,sha256=as-1oFTWSeWBgyzh0O_qF439xqBe6AbBgt4MfYe5zwY,87
-langtrace_python_sdk-1.3.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-langtrace_python_sdk-1.3.1.dist-info/RECORD,,
+langtrace_python_sdk-1.3.2.dist-info/METADATA,sha256=A_nxn2VgpTf-Odan3oLLgS6W0hM4sswdDRCO8zFm4Fs,9086
+langtrace_python_sdk-1.3.2.dist-info/WHEEL,sha256=K0BPUNF1N3kQ9olb8aVEtkObePEjdr2JOLT1N83EVws,87
+langtrace_python_sdk-1.3.2.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+langtrace_python_sdk-1.3.2.dist-info/RECORD,,