langtrace-python-sdk 2.2.25__tar.gz → 2.2.26__tar.gz

{langtrace_python_sdk-2.2.25 → langtrace_python_sdk-2.2.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 2.2.25
+Version: 2.2.26
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>
@@ -20,7 +20,7 @@ Requires-Dist: opentelemetry-instrumentation>=0.47b0
 Requires-Dist: opentelemetry-sdk>=1.25.0
 Requires-Dist: sqlalchemy
 Requires-Dist: tiktoken>=0.1.1
-Requires-Dist: trace-attributes==7.0.3
+Requires-Dist: trace-attributes==7.0.4
 Provides-Extra: dev
 Requires-Dist: anthropic; extra == 'dev'
 Requires-Dist: chromadb; extra == 'dev'
@@ -31,6 +31,7 @@ Requires-Dist: groq; extra == 'dev'
 Requires-Dist: langchain; extra == 'dev'
 Requires-Dist: langchain-community; extra == 'dev'
 Requires-Dist: langchain-openai; extra == 'dev'
+Requires-Dist: mistralai; extra == 'dev'
 Requires-Dist: ollama; extra == 'dev'
 Requires-Dist: openai; extra == 'dev'
 Requires-Dist: pinecone-client; extra == 'dev'
@@ -291,6 +292,7 @@ Langtrace automatically captures traces from the following vendors:
 | Groq         | LLM             | :x:                | :white_check_mark:              |
 | Perplexity   | LLM             | :white_check_mark: | :white_check_mark:              |
 | Gemini       | LLM             | :x:                | :white_check_mark:              |
+| Mistral      | LLM             | :x:                | :white_check_mark:              |
 | Langchain    | Framework       | :x:                | :white_check_mark:              |
 | LlamaIndex   | Framework       | :white_check_mark: | :white_check_mark:              |
 | Langgraph    | Framework       | :x:                | :white_check_mark:              |

{langtrace_python_sdk-2.2.25 → langtrace_python_sdk-2.2.26}/README.md

@@ -246,6 +246,7 @@ Langtrace automatically captures traces from the following vendors:
 | Groq         | LLM             | :x:                | :white_check_mark:              |
 | Perplexity   | LLM             | :white_check_mark: | :white_check_mark:              |
 | Gemini       | LLM             | :x:                | :white_check_mark:              |
+| Mistral      | LLM             | :x:                | :white_check_mark:              |
 | Langchain    | Framework       | :x:                | :white_check_mark:              |
 | LlamaIndex   | Framework       | :white_check_mark: | :white_check_mark:              |
 | Langgraph    | Framework       | :x:                | :white_check_mark:              |

{langtrace_python_sdk-2.2.25 → langtrace_python_sdk-2.2.26}/pyproject.toml

@@ -18,7 +18,7 @@ classifiers=[
     "Operating System :: OS Independent",
 ]
 dependencies = [
-  'trace-attributes==7.0.3',
+  'trace-attributes==7.0.4',
   'opentelemetry-api>=1.25.0',
   'opentelemetry-sdk>=1.25.0',
   'opentelemetry-instrumentation>=0.47b0',
@@ -52,7 +52,8 @@ dev = [
     "ollama",
     "groq",
     "google-generativeai",
-    "google-cloud-aiplatform"
+    "google-cloud-aiplatform",
+    "mistralai"
 ]
 
 test = [

{langtrace_python_sdk-2.2.25 → langtrace_python_sdk-2.2.26}/src/examples/crewai_example/trip_planner/agents.py

@@ -12,9 +12,9 @@ class TravelAgents:
     def __init__(self):
         self.OpenAIGPT35 = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.7)
         self.OpenAIGPT4 = ChatOpenAI(model_name="gpt-4", temperature=0.7)
-        self.Ollama = ChatOllama(model="openhermes")
+        self.Ollama = ChatOllama(model="llama3")
         self.Cohere = ChatCohere(model="command-r")
-        self.Anthropic = ChatAnthropic(model="claude-3-5-sonnet")
+        self.Anthropic = ChatAnthropic(model="claude-3-5-sonnet-20240620")
 
     def expert_travel_agent(self):
         return Agent(
@@ -28,7 +28,7 @@ class TravelAgents:
             # tools=[tool_1, tool_2],
             allow_delegation=False,
             verbose=True,
-            llm=self.OpenAIGPT4,
+            llm=self.Cohere,
         )
 
     def city_selection_expert(self):
@@ -39,7 +39,7 @@ class TravelAgents:
             # tools=[tool_1, tool_2],
             allow_delegation=False,
             verbose=True,
-            llm=self.OpenAIGPT4,
+            llm=self.Cohere,
         )
 
     def local_tour_guide(self):
@@ -50,5 +50,5 @@ class TravelAgents:
             # tools=[tool_1, tool_2],
             allow_delegation=False,
             verbose=True,
-            llm=self.OpenAIGPT4,
+            llm=self.Cohere,
         )

langtrace_python_sdk-2.2.26/src/examples/litellm_example/basic.py

@@ -0,0 +1,98 @@
+from langtrace_python_sdk import with_langtrace_root_span, langtrace
+from dotenv import load_dotenv
+from litellm import completion, acompletion
+import litellm
+import asyncio
+
+load_dotenv()
+
+
+litellm.success_callback = ["langtrace"]
+langtrace.init()
+litellm.set_verbose = False
+
+
+@with_langtrace_root_span("Litellm Example OpenAI")
+def openAI(streaming=False):
+    response = completion(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"content": "respond only in Yoda speak.", "role": "system"},
+            {"content": "Hello, how are you?", "role": "user"},
+        ],
+        stream=streaming,
+        stream_options={"include_usage": True},
+    )
+    if streaming:
+        for _ in response:
+            pass
+    else:
+        return response
+
+
+# @with_langtrace_root_span("Litellm Example Anthropic Completion")
+def anthropic(streaming=False):
+    try:
+
+        response = completion(
+            model="claude-2.1",
+            messages=[
+                {"content": "respond only in Yoda speak.", "role": "system"},
+                {"content": "what is 2 + 2?", "role": "user"},
+            ],
+            temperature=0.5,
+            top_p=0.5,
+            n=1,
+            stream=streaming,
+            stream_options={"include_usage": True},
+        )
+        # print(response)
+        if streaming:
+            for _ in response:
+                pass
+        else:
+            return response
+    except Exception as e:
+        print("ERORRRR", e)
+
+
+# @with_langtrace_root_span("Litellm Example OpenAI Async Streaming")
+async def async_anthropic(streaming=False):
+    response = await acompletion(
+        model="claude-2.1",
+        messages=[{"content": "Hello, how are you?", "role": "user"}],
+        stream=streaming,
+        stream_options={"include_usage": True},
+        temperature=0.5,
+        top_p=0.5,
+        n=1,
+    )
+    if streaming:
+        async for _ in response:
+            pass
+    else:
+        return response
+
+
+def cohere(streaming=False):
+    response = completion(
+        model="command-r",
+        messages=[
+            {"content": "respond only in Yoda speak.", "role": "system"},
+            {"content": "Hello, how are you?", "role": "user"},
+        ],
+        stream=streaming,
+        stream_options={"include_usage": True},
+    )
+    if streaming:
+        for _ in response:
+            pass
+    else:
+        return response
+
+
+if __name__ == "__main__":
+    # openAI()
+    anthropic(streaming=False)
+    cohere(streaming=True)
+    # asyncio.run(async_anthropic(streaming=True))

langtrace_python_sdk-2.2.26/src/examples/mistral_example/__init__.py

@@ -0,0 +1,14 @@
+import asyncio
+from examples.mistral_example.complete import chat_complete
+from examples.mistral_example.complete_async import complete_async
+from examples.mistral_example.embeddings import embeddings_create
+from langtrace_python_sdk import langtrace, with_langtrace_root_span
+
+langtrace.init()
+
+class MistralRunner:
+    @with_langtrace_root_span("Mistral")
+    def run(self):
+        chat_complete()
+        asyncio.run(complete_async())
+        embeddings_create()

langtrace_python_sdk-2.2.26/src/examples/mistral_example/complete.py

@@ -0,0 +1,18 @@
+import os
+from langtrace_python_sdk import with_langtrace_root_span
+from mistralai import Mistral
+
+@with_langtrace_root_span("chat_complete")
+def chat_complete():
+    model = "mistral-large-latest"
+    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
+    chat_response = client.chat.complete(
+        model= model,
+        messages = [
+            {
+                "role": "user",
+                "content": "I need 10 cocktail recipes with tequila other than the classics like margarita, tequila"
+            },
+        ]
+    )
+    print(chat_response.choices[0].message.content)

langtrace_python_sdk-2.2.26/src/examples/mistral_example/complete_async.py

@@ -0,0 +1,16 @@
+import os
+from langtrace_python_sdk import with_langtrace_root_span
+from mistralai import Mistral
+
+@with_langtrace_root_span("chat_complete_async")
+async def complete_async():
+    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
+    res = await client.chat.complete_async(model="mistral-small-latest", messages=[
+        {
+            "content": "Which locations should I visit when I travel to New york? Answer in one short sentence.",
+            "role": "user",
+        },
+    ])
+    if res is not None:
+        # handle response
+        print(res.choices[0].message.content)

langtrace_python_sdk-2.2.26/src/examples/mistral_example/embeddings.py

@@ -0,0 +1,17 @@
+import os
+from langtrace_python_sdk import with_langtrace_root_span
+from mistralai import Mistral
+
+
+@with_langtrace_root_span("create_embeddings")
+def embeddings_create():
+    model = "mistral-embed"
+
+    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
+
+    embeddings_batch_response = client.embeddings.create(
+        model=model,
+        inputs=["Embed this sentence.", "As well as this one."],
+    )
+
+    print(embeddings_batch_response.data[0].embedding)

{langtrace_python_sdk-2.2.25 → langtrace_python_sdk-2.2.26}/src/langtrace_python_sdk/constants/instrumentation/common.py

@@ -29,6 +29,7 @@ SERVICE_PROVIDERS = {
     "OLLAMA": "Ollama",
     "VERTEXAI": "VertexAI",
     "GEMINI": "Gemini",
+    "MISTRAL": "Mistral",
 }
 
 LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY = "langtrace_additional_attributes"

langtrace_python_sdk-2.2.26/src/langtrace_python_sdk/constants/instrumentation/mistral.py

@@ -0,0 +1,24 @@
+from langtrace.trace_attributes import MistralMethods
+
+APIS = {
+    "CHAT_COMPLETE": {
+        "METHOD": MistralMethods.CHAT_COMPLETE.value,
+        "ENDPOINT": "/v1/chat/completions",
+    },
+    "ASYNC_CHAT_COMPLETE": {
+        "METHOD": MistralMethods.ASYNC_CHAT_COMPLETE.value,
+        "ENDPOINT": "/v1/chat/completions",
+    },
+    "CHAT_STREAM": {
+        "METHOD": MistralMethods.CHAT_STREAM.value,
+        "ENDPOINT": "/v1/chat/completions",
+    },
+    "EMBEDDINGS_CREATE": {
+        "METHOD": MistralMethods.EMBEDDINGS_CREATE.value,
+        "ENDPOINT": "/v1/embeddings",
+    },
+    "ASYNC_EMBEDDINGS_CREATE": {
+        "METHOD": MistralMethods.ASYNC_EMBEDDINGS_CREATE.value,
+        "ENDPOINT": "/v1/embeddings",
+    },
+}

{langtrace_python_sdk-2.2.25 → langtrace_python_sdk-2.2.26}/src/langtrace_python_sdk/instrumentation/__init__.py

@@ -16,6 +16,7 @@ from .ollama import OllamaInstrumentor
 from .dspy import DspyInstrumentation
 from .vertexai import VertexAIInstrumentation
 from .gemini import GeminiInstrumentation
+from .mistral import MistralInstrumentation
 
 __all__ = [
     "AnthropicInstrumentation",
@@ -36,4 +37,5 @@ __all__ = [
     "DspyInstrumentation",
     "VertexAIInstrumentation",
     "GeminiInstrumentation",
+    "MistralInstrumentation",
 ]

langtrace_python_sdk-2.2.26/src/langtrace_python_sdk/instrumentation/mistral/__init__.py

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

langtrace_python_sdk-2.2.26/src/langtrace_python_sdk/instrumentation/mistral/instrumentation.py

@@ -0,0 +1,73 @@
+"""
+Copyright (c) 2024 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 importlib.metadata
+import logging
+from typing import Collection
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.trace import get_tracer
+from wrapt import wrap_function_wrapper as _W
+
+from langtrace_python_sdk.instrumentation.mistral.patch import (
+    chat_complete,
+    embeddings_create,
+)
+
+logging.basicConfig(level=logging.FATAL)
+
+class MistralInstrumentation(BaseInstrumentor):
+    
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["mistralai >= 1.0.1"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version = importlib.metadata.version("mistralai")
+
+        _W(
+            module="mistralai.chat",
+            name="Chat.complete",
+            wrapper=chat_complete("mistral.chat.complete", version, tracer),
+        )
+
+        _W(
+            module="mistralai.chat",
+            name="Chat.stream",
+            wrapper=chat_complete("mistral.chat.stream", version, tracer, is_streaming=True),
+        )
+
+        _W(
+            module="mistralai.chat",
+            name="Chat.complete_async",
+            wrapper=chat_complete("mistral.chat.complete_async", version, tracer, is_async=True),
+        )
+
+        _W(
+            module="mistralai.embeddings",
+            name="Embeddings.create",
+            wrapper=embeddings_create("mistral.embeddings.create", version, tracer),
+        )
+
+        _W(
+            module="mistralai.embeddings",
+            name="Embeddings.create_async",
+            wrapper=embeddings_create("mistral.embeddings.create_async", version, tracer, is_async=True),
+        )
+
+    def _uninstrument(self, **kwargs):
+        pass

langtrace_python_sdk-2.2.26/src/langtrace_python_sdk/instrumentation/mistral/patch.py

@@ -0,0 +1,192 @@
+"""
+Copyright (c) 2024 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 langtrace.trace_attributes import (
+    LLMSpanAttributes,
+    SpanAttributes,
+)
+from langtrace_python_sdk.utils import set_span_attribute
+from langtrace_python_sdk.utils.silently_fail import silently_fail
+from opentelemetry import trace
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace.status import Status, StatusCode
+from opentelemetry.trace.propagation import set_span_in_context
+from langtrace_python_sdk.constants.instrumentation.common import (
+    SERVICE_PROVIDERS,
+)
+from langtrace_python_sdk.constants.instrumentation.mistral import APIS
+from langtrace_python_sdk.utils.llm import (
+    get_extra_attributes,
+    get_langtrace_attributes,
+    get_llm_request_attributes,
+    get_llm_url,
+    get_span_name,
+    set_event_completion,
+    StreamWrapper,
+    set_span_attributes,
+    set_usage_attributes,
+)
+
+from langtrace_python_sdk.instrumentation.openai.patch import extract_content
+
+
+def chat_complete(original_method, version, tracer, is_async=False, is_streaming=False):
+        
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS["MISTRAL"]
+        llm_prompts = []
+        for item in kwargs.get("messages", []):
+            llm_prompts.append(item)
+
+        api = "ASYNC_CHAT_COMPLETE" if is_async else "CHAT_COMPLETE"
+
+        span_attributes = {
+            **get_langtrace_attributes(version, service_provider, vendor_type="llm"),
+            **get_llm_request_attributes(kwargs, prompts=llm_prompts),
+            **get_llm_url(instance),
+            SpanAttributes.LLM_PATH: APIS[api]["ENDPOINT"],
+            **get_extra_attributes(),
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+
+        span = tracer.start_span(
+            name=get_span_name(APIS[api]["METHOD"]),
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        )
+        _set_input_attributes(span, kwargs, attributes)
+
+        try:
+            result = wrapped(*args, **kwargs)
+            if is_streaming:
+                return StreamWrapper(
+                    result,
+                    span,
+                    function_call=kwargs.get("functions") is not None,
+                    tool_calls=kwargs.get("tools") is not None,
+                )
+            else:
+                _set_response_attributes(span, kwargs, result)
+                span.set_status(StatusCode.OK)
+                span.end()
+                return result
+                
+
+        except Exception as error:
+            span.record_exception(error)
+            span.set_status(Status(StatusCode.ERROR, str(error)))
+            span.end()
+            raise
+
+    return traced_method
+
+
+def embeddings_create(original_method, version, tracer, is_async=False):
+    """
+    Wrap the `create` method of the `Embeddings` class to trace it.
+    """
+
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS["MISTRAL"]
+
+        api = "ASYNC_EMBEDDINGS_CREATE" if is_async else "EMBEDDINGS_CREATE"
+
+        span_attributes = {
+            **get_langtrace_attributes(version, service_provider, vendor_type="llm"),
+            **get_llm_request_attributes(kwargs, operation_name="embed"),
+            **get_llm_url(instance),
+            SpanAttributes.LLM_PATH: APIS[api]["ENDPOINT"],
+            SpanAttributes.LLM_REQUEST_DIMENSIONS: kwargs.get("dimensions"),
+            **get_extra_attributes(),
+        }
+
+        encoding_format = kwargs.get("encoding_format")
+        if encoding_format is not None:
+            if not isinstance(encoding_format, list):
+                encoding_format = [encoding_format]
+            span_attributes[SpanAttributes.LLM_REQUEST_ENCODING_FORMATS] = (
+                encoding_format
+            )
+
+        if kwargs.get("inputs") is not None:
+            span_attributes[SpanAttributes.LLM_REQUEST_EMBEDDING_INPUTS] = json.dumps(
+                [kwargs.get("inputs", [])]
+            )
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        with tracer.start_as_current_span(
+            name=get_span_name(APIS[api]["METHOD"]),
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        ) as span:
+
+            set_span_attributes(span, attributes)
+            try:
+                # Attempt to call the original method
+                result = wrapped(*args, **kwargs)
+                span.set_status(StatusCode.OK)
+                return result
+            except Exception as err:
+                # Record the exception in the span
+                span.record_exception(err)
+
+                # Set the span status to indicate an error
+                span.set_status(Status(StatusCode.ERROR, str(err)))
+
+                # Reraise the exception to ensure it's not swallowed
+                raise err
+
+    return traced_method
+
+
+@silently_fail
+def _set_input_attributes(span, kwargs, attributes):
+    tools = []
+    for field, value in attributes.model_dump(by_alias=True).items():
+        set_span_attribute(span, field, value)
+
+    if kwargs.get("tools") is not None:
+        tools.append(json.dumps(kwargs.get("tools")))
+
+    if tools:
+        set_span_attribute(span, SpanAttributes.LLM_TOOLS, json.dumps(tools))
+
+
+@silently_fail
+def _set_response_attributes(span, kwargs, result):
+    set_span_attribute(span, SpanAttributes.LLM_RESPONSE_MODEL, result.model)
+    if hasattr(result, "choices") and result.choices is not None:
+        responses = [
+            {
+                "role": (
+                    choice.message.role
+                    if choice.message and choice.message.role
+                    else "assistant"
+                ),
+                "content": extract_content(choice),
+            }
+            for choice in result.choices
+        ]
+        set_event_completion(span, responses)
+
+    # Get the usage
+    if hasattr(result, "usage") and result.usage is not None:
+        set_usage_attributes(span, result.usage)

{langtrace_python_sdk-2.2.25 → langtrace_python_sdk-2.2.26}/src/langtrace_python_sdk/langtrace.py

@@ -56,6 +56,7 @@ from langtrace_python_sdk.instrumentation import (
     DspyInstrumentation,
     VertexAIInstrumentation,
     GeminiInstrumentation,
+    MistralInstrumentation,
 )
 from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
 from colorama import Fore
@@ -72,7 +73,7 @@ def init(
     disable_instrumentations: Optional[DisableInstrumentations] = None,
     disable_tracing_for_functions: Optional[InstrumentationMethods] = None,
     service_name: Optional[str] = None,
-    disable_logging = False
+    disable_logging=False,
 ):
     if disable_logging:
         sys.stdout = open(os.devnull, "w")
@@ -93,7 +94,9 @@ def init(
     provider = TracerProvider(resource=resource, sampler=sampler)
 
     remote_write_exporter = (
-        LangTraceExporter(api_key=api_key, api_host=host, disable_logging=disable_logging)
+        LangTraceExporter(
+            api_key=api_key, api_host=host, disable_logging=disable_logging
+        )
         if custom_remote_exporter is None
         else custom_remote_exporter
     )
@@ -125,6 +128,7 @@ def init(
         "crewai": CrewAIInstrumentation(),
         "vertexai": VertexAIInstrumentation(),
         "gemini": GeminiInstrumentation(),
+        "mistral": MistralInstrumentation(),
     }
 
     init_instrumentations(disable_instrumentations, all_instrumentations)

{langtrace_python_sdk-2.2.25 → langtrace_python_sdk-2.2.26}/src/langtrace_python_sdk/types/__init__.py

@@ -7,6 +7,7 @@ class InstrumentationType(Enum):
     COHERE = "cohere"
     ANTHROPIC = "anthropic"
     GROQ = "groq"
+    MISTRAL = "mistral"
     PINECONE = "pinecone"
     LLAMAINDEX = "llamaindex"
     CHROMADB = "chromadb"
@@ -43,6 +44,11 @@ class VendorMethods(TypedDict):
         "openai.images.generate",
         "openai.images.edit",
     ]
+    MistralMethods = Literal[
+        "mistral.chat.complete",
+        "mistral.chat.stream",
+        "mistral.embeddings.create",
+    ]
 
     ChromadbMethods = Literal[
         "chromadb.collection.add",
@@ -93,6 +99,7 @@ class VendorMethods(TypedDict):
 class InstrumentationMethods(TypedDict):
     open_ai: List[VendorMethods.OpenaiMethods]
     groq: List[VendorMethods.GroqMethods]
+    mistral: List[VendorMethods.MistralMethods]
     pinecone: List[VendorMethods.PineconeMethods]
     llamaindex: List[VendorMethods.LlamaIndexMethods]
     chromadb: List[VendorMethods.ChromadbMethods]

{langtrace_python_sdk-2.2.25 → langtrace_python_sdk-2.2.26}/src/langtrace_python_sdk/utils/llm.py

@@ -411,6 +411,12 @@ class StreamWrapper:
                 self.completion_tokens = chunk["eval_count"]
 
     def process_chunk(self, chunk):
+        # Mistral nests the chunk data under a `data` attribute
+        if (
+            hasattr(chunk, "data") and chunk.data is not None
+            and hasattr(chunk.data, "choices") 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-2.2.26/src/langtrace_python_sdk/version.py

@@ -0,0 +1 @@
+__version__ = "2.2.26"