langtrace-python-sdk 2.2.20__py3-none-any.whl → 2.2.22__py3-none-any.whl

examples/crewai_example/simple_agent/agents.py

@@ -0,0 +1,32 @@
+from crewai import Agent
+from langchain_openai import ChatOpenAI
+from langchain_anthropic import ChatAnthropic
+from langchain_cohere import ChatCohere
+from langchain_ollama import ChatOllama
+
+
+class PoetryAgents:
+    def __init__(self):
+        self.open_ai = ChatOpenAI(
+            model_name="gpt-4", temperature=0.7, stream_usage=True
+        )
+        self.anthropic = ChatAnthropic(
+            model_name="claude-3-5-sonnet-20240620", temperature=0.7
+        )
+
+        self.cohere = ChatCohere(model="command-r", temperature=0.7)
+        self.ollama = ChatOllama(model="llama3", temperature=0.7)
+
+    def create_poet_agent(self):
+        return Agent(
+            role="Expert Poetry Writer",
+            backstory="""
+                    I am an Expert in poetry writing and creative expression.
+                    I have been writing poetry for over 10 years and have published several collections.
+                    I have a deep understanding of various poetic forms, styles, and themes. I am here to help you create beautiful and meaningful poetry that resonates with your emotions and experiences.
+                """,
+            goal="""Create a poem that captures the essence of a given theme or emotion""",
+            allow_delegation=False,
+            verbose=True,
+            llm=self.ollama,
+        )

examples/crewai_example/simple_agent/main.py

@@ -0,0 +1,48 @@
+from crewai import Crew
+from textwrap import dedent
+from .agents import PoetryAgents
+from .tasks import PoetryTasks
+from langtrace_python_sdk import langtrace
+from dotenv import load_dotenv
+import agentops
+
+load_dotenv()
+agentops.init()
+langtrace.init(write_spans_to_console=False, batch=False)
+
+
+class PoetryCrew:
+    def __init__(self, topic) -> None:
+        self.topic = topic
+
+    def run(self):
+        agents = PoetryAgents()
+        tasks = PoetryTasks()
+
+        poetry_agent = agents.create_poet_agent()
+
+        create_poem = tasks.create_poem(poetry_agent, self.topic)
+
+        crew = Crew(agents=[poetry_agent], tasks=[create_poem], verbose=True)
+        res = crew.kickoff()
+        return res
+
+
+# This is the main function that you will use to run your custom crew.
+if __name__ == "__main__":
+    print("## Welcome to Poetry Crew")
+    print("-------------------------------")
+    topic = input(
+        dedent(
+            """
+      What topic do you want to write a poem on?
+    """
+        )
+    )
+
+    poetry_crew = PoetryCrew(topic=topic)
+    result = poetry_crew.run()
+    print("\n\n########################")
+    print("## Here is you poem")
+    print("########################\n")
+    print(result)

examples/crewai_example/simple_agent/tasks.py

@@ -0,0 +1,21 @@
+from crewai import Task
+from textwrap import dedent
+
+
+class PoetryTasks:
+    def create_poem(self, agent, topic):
+        return Task(
+            description=dedent(
+                f"""
+            **Task**: Create a Poem on {topic}
+            **Description**: Write a poem on the given topic that captures the essence of the theme or emotion. 
+                The poem should be creative, expressive, and resonate with the reader's emotions and experiences. 
+                Your poem should be well-structured, engaging, and evoke a sense of beauty and meaning.
+
+            **Parameters**: 
+            - Topic: {topic}
+        """
+            ),
+            expected_output="A creative and expressive poem that captures the essence of the given topic.",
+            agent=agent,
+        )

examples/crewai_example/trip_planner/agents.py

@@ -0,0 +1,54 @@
+from crewai import Agent
+from langchain_openai import ChatOpenAI
+from langchain_ollama import ChatOllama
+from langchain_cohere import ChatCohere
+from langchain_anthropic import ChatAnthropic
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+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.Cohere = ChatCohere(model="command-r")
+        self.Anthropic = ChatAnthropic(model="claude-3-5-sonnet")
+
+    def expert_travel_agent(self):
+        return Agent(
+            role="Expert Travel Agent",
+            backstory="""
+                    I am an Expert in travel planning and itinerary creation.
+                    I have been in the travel industry for over 10 years and have helped thousands of clients plan their dream vacations.
+                    I have extensive knowledge of popular travel destinations, local attractions, and travel logistics. I am here to help you create a personalized travel itinerary that suits your preferences and budget.
+                """,
+            goal="""Create a 7 day travel itinerary with detailed per-day plans, include budget, packing suggestions, and local/safety tips.""",
+            # tools=[tool_1, tool_2],
+            allow_delegation=False,
+            verbose=True,
+            llm=self.OpenAIGPT4,
+        )
+
+    def city_selection_expert(self):
+        return Agent(
+            role="City Selection Expert",
+            backstory="""Expert at analyzing and selecting the best cities for travel based on data""",
+            goal="""Select the best cities based on weather, season, prices and traveler preferences""",
+            # tools=[tool_1, tool_2],
+            allow_delegation=False,
+            verbose=True,
+            llm=self.OpenAIGPT4,
+        )
+
+    def local_tour_guide(self):
+        return Agent(
+            role="Local Expert at this city",
+            goal="Provide the BEST insights about the selected city",
+            backstory="""A knowledgeable local guide with extensive information about the city, it's attractions and customs""",
+            # tools=[tool_1, tool_2],
+            allow_delegation=False,
+            verbose=True,
+            llm=self.OpenAIGPT4,
+        )

examples/crewai_example/trip_planner/main.py

@@ -0,0 +1,96 @@
+from crewai import Crew
+from textwrap import dedent
+from .agents import TravelAgents
+from .tasks import TravelTasks
+from langtrace_python_sdk import langtrace
+from dotenv import load_dotenv
+
+load_dotenv()
+
+langtrace.init()
+
+
+class TripCrew:
+    def __init__(self, origin, cities, date_range, interests):
+        self.origin = origin
+        self.cities = cities
+        self.date_range = date_range
+        self.interests = interests
+
+    def run(self):
+        # Define your custom agents and tasks in agents.py and tasks.py
+        agents = TravelAgents()
+        tasks = TravelTasks()
+
+        # Define your custom agents and tasks here
+        expert_travel_agent = agents.expert_travel_agent()
+        city_selection_expert = agents.city_selection_expert()
+        local_tour_guide = agents.local_tour_guide()
+
+        # Custom tasks include agent name and variables as input
+        plan_itinerary = tasks.plan_itinerary(
+            expert_travel_agent, self.cities, self.date_range, self.interests
+        )
+
+        identify_city = tasks.identify_city(
+            city_selection_expert,
+            self.origin,
+            self.cities,
+            self.interests,
+            self.date_range,
+        )
+
+        gather_city_info = tasks.gather_city_info(
+            local_tour_guide, self.cities, self.date_range, self.interests
+        )
+
+        # Define your custom crew here
+        crew = Crew(
+            agents=[expert_travel_agent, city_selection_expert, local_tour_guide],
+            tasks=[plan_itinerary, identify_city, gather_city_info],
+            verbose=True,
+        )
+
+        result = crew.kickoff()
+        return result
+
+
+# This is the main function that you will use to run your custom crew.
+if __name__ == "__main__":
+    print("## Welcome to Trip Planner Crew")
+    print("-------------------------------")
+    origin = input(
+        dedent(
+            """
+      From where will you be traveling from?
+    """
+        )
+    )
+    cities = input(
+        dedent(
+            """
+      What are the cities options you are interested in visiting?
+    """
+        )
+    )
+    date_range = input(
+        dedent(
+            """
+      What is the date range you are interested in traveling?
+    """
+        )
+    )
+    interests = input(
+        dedent(
+            """
+      What are some of your high level interests and hobbies?
+    """
+        )
+    )
+
+    trip_crew = TripCrew(origin, cities, date_range, interests)
+    result = trip_crew.run()
+    print("\n\n########################")
+    print("## Here is you Trip Plan")
+    print("########################\n")
+    print(result)

examples/crewai_example/trip_planner/tasks.py

@@ -0,0 +1,120 @@
+from crewai import Task
+from textwrap import dedent
+
+"""
+Creating Tasks Cheat Sheet:
+- Begin with the end in mind. Identify the specific outcome your tasks are aiming to achieve.
+- Break down the outcome into actionable tasks, assigning each task to the appropriate agent.
+- Ensure tasks are descriptive, providing clear instructions and expected deliverables.
+
+Goal:
+- Develop a detailed itinerary, including city selection, attractions, and practical travel advice.
+
+Key Steps for Task Creation:
+1. Identify the Desired Outcome: Define what success looks like for your project.
+    - A detailed 7 day travel itenerary.
+
+2. Task Breakdown: Divide the goal into smaller, manageable tasks that agents can execute.
+    - Itenerary Planning: develop a detailed plan for each day of the trip.
+    - City Selection: Analayze and pick the best cities to visit.
+    - Local Tour Guide: Find a local expert to provide insights and recommendations.
+
+3. Assign Tasks to Agents: Match tasks with agents based on their roles and expertise.
+
+4. Task Description Template:
+  - Use this template as a guide to define each task in your CrewAI application. 
+  - This template helps ensure that each task is clearly defined, actionable, and aligned with the specific goals of your project.
+
+  Template:
+  ---------
+  def [task_name](self, agent, [parameters]):
+      return Task(description=dedent(f'''
+      **Task**: [Provide a concise name or summary of the task.]
+      **Description**: [Detailed description of what the agent is expected to do, including actionable steps and expected outcomes. This should be clear and direct, outlining the specific actions required to complete the task.]
+
+      **Parameters**: 
+      - [Parameter 1]: [Description]
+      - [Parameter 2]: [Description]
+      ... [Add more parameters as needed.]
+
+      **Note**: [Optional section for incentives or encouragement for high-quality work. This can include tips, additional context, or motivations to encourage agents to deliver their best work.]
+
+      '''), agent=agent)
+
+"""
+
+
+class TravelTasks:
+    def __tip_section(self):
+        return "If you do your BEST WORK, I'll give you a $10,000 commission!"
+
+    def plan_itinerary(self, agent, city, travel_dates, interests):
+        return Task(
+            description=dedent(
+                f"""
+            **Task**: Develop a 7-Day Travel Itinerary
+            **Description**: Expand the city guide into a full 7-day travel itinerary with detailed 
+                per-day plans, including weather forecasts, places to eat, packing suggestions, 
+                and a budget breakdown. You MUST suggest actual places to visit, actual hotels to stay, 
+                and actual restaurants to go to. This itinerary should cover all aspects of the trip, 
+                from arrival to departure, integrating the city guide information with practical travel logistics.
+
+            **Parameters**: 
+            - City: {city}
+            - Trip Date: {travel_dates}
+            - Traveler Interests: {interests}
+
+            **Note**: {self.__tip_section()}
+        """
+            ),
+            expected_output="A detailed 7-day travel itinerary with per-day plans, budget breakdown, and practical travel advice.",
+            agent=agent,
+        )
+
+    def identify_city(self, agent, origin, cities, interests, travel_dates):
+        return Task(
+            description=dedent(
+                f"""
+                    **Task**:  Identify the Best City for the Trip
+                    **Description**: Analyze and select the best city for the trip based on specific 
+                        criteria such as weather patterns, seasonal events, and travel costs. 
+                        This task involves comparing multiple cities, considering factors like current weather 
+                        conditions, upcoming cultural or seasonal events, and overall travel expenses. 
+                        Your final answer must be a detailed report on the chosen city, 
+                        including actual flight costs, weather forecast, and attractions.
+
+
+                    **Parameters**: 
+                    - Origin: {origin}
+                    - Cities: {cities}
+                    - Interests: {interests}
+                    - Travel Date: {travel_dates}
+
+                    **Note**: {self.__tip_section()}
+        """
+            ),
+            agent=agent,
+            expected_output="A detailed report on the best city for the trip, including flight costs, weather forecast, and attractions.",
+        )
+
+    def gather_city_info(self, agent, city, travel_dates, interests):
+        return Task(
+            description=dedent(
+                f"""
+                    **Task**:  Gather In-depth City Guide Information
+                    **Description**: Compile an in-depth guide for the selected city, gathering information about 
+                        key attractions, local customs, special events, and daily activity recommendations. 
+                        This guide should provide a thorough overview of what the city has to offer, including 
+                        hidden gems, cultural hotspots, must-visit landmarks, weather forecasts, and high-level costs.
+
+                    **Parameters**: 
+                    - Cities: {city}
+                    - Interests: {interests}
+                    - Travel Date: {travel_dates}
+
+                    **Note**: {self.__tip_section()}
+        """
+            ),
+            expected_output="An in-depth city guide with detailed information on attractions, local customs, events, and daily activity recommendations.",
+            agent=agent,
+        )

examples/crewai_example/trip_planner/tools/calculator.py

@@ -0,0 +1,16 @@
+from langchain.tools import tool
+
+
+class CalculatorTools:
+
+    @tool("Make a calculation")
+    def calculate(self, operation):
+        """Useful to perform any mathematical calculations,
+        like sum, minus, multiplication, division, etc.
+        The input to this tool should be a mathematical
+        expression, a couple examples are `200*7` or `5000/2*10`
+        """
+        try:
+            return eval(operation)
+        except SyntaxError:
+            return "Error: Invalid syntax in mathematical expression"

examples/crewai_example/trip_planner/tools/search_tools.py

@@ -0,0 +1,73 @@
+import json
+import os
+
+import requests
+from langchain.tools import tool
+
+
+class SearchTools:
+
+    @tool("Search the internet")
+    def search_internet(self, query):
+        """Useful to search the internet
+        about a a given topic and return relevant results"""
+        top_result_to_return = 4
+        url = "https://google.serper.dev/search"
+        payload = json.dumps({"q": query})
+        headers = {
+            "X-API-KEY": os.environ["SERPER_API_KEY"],
+            "content-type": "application/json",
+        }
+        response = requests.request(
+            "POST", url, headers=headers, data=payload, timeout=2000
+        )
+        # check if there is an organic key
+        if "organic" not in response.json():
+            return "Sorry, I couldn't find anything about that, there could be an error with you serper api key."
+        else:
+            results = response.json()["organic"]
+            string = []
+            for result in results[:top_result_to_return]:
+                try:
+                    string.append(
+                        "\n".join(
+                            [
+                                f"Title: {result['title']}",
+                                f"Link: {result['link']}",
+                                f"Snippet: {result['snippet']}",
+                                "\n-----------------",
+                            ]
+                        )
+                    )
+                except KeyError:
+                    next
+
+            return "\n".join(string)
+
+
+# from pydantic import BaseModel, Field
+# from langchain.tools import tool
+
+# # Define a Pydantic model for the tool's input parameters
+# class CalculationInput(BaseModel):
+#     operation: str = Field(..., description="The mathematical operation to perform")
+#     factor: float = Field(..., description="A factor by which to multiply the result of the operation")
+
+# # Use the tool decorator with the args_schema parameter pointing to the Pydantic model
+# @tool("perform_calculation", args_schema=CalculationInput, return_direct=True)
+# def perform_calculation(operation: str, factor: float) -> str:
+#     """
+#     Performs a specified mathematical operation and multiplies the result by a given factor.
+
+#     Parameters:
+#     - operation (str): A string representing a mathematical operation (e.g., "10 + 5").
+#     - factor (float): A factor by which to multiply the result of the operation.
+
+#     Returns:
+#     - A string representation of the calculation result.
+#     """
+#     # Perform the calculation
+#     result = eval(operation) * factor
+
+#     # Return the result as a string
+#     return f"The result of '{operation}' multiplied by {factor} is {result}."

langtrace_python_sdk/instrumentation/anthropic/patch.py

@@ -17,8 +17,11 @@ limitations under the License.
 import json
 
 from langtrace.trace_attributes import Event, LLMSpanAttributes
-from langtrace_python_sdk.utils import set_span_attribute, silently_fail
+from langtrace_python_sdk.utils import set_span_attribute
+from langtrace_python_sdk.utils.silently_fail import silently_fail
+
 from langtrace_python_sdk.utils.llm import (
+    StreamWrapper,
     get_extra_attributes,
     get_langtrace_attributes,
     get_llm_request_attributes,
@@ -26,7 +29,6 @@ from langtrace_python_sdk.utils.llm import (
     get_span_name,
     is_streaming,
     set_event_completion,
-    set_event_completion_chunk,
     set_usage_attributes,
 )
 from opentelemetry.trace import SpanKind
@@ -83,61 +85,7 @@ def messages_create(original_method, version, tracer):
             span.end()
             raise
 
-    def handle_streaming_response(result, span):
-        """Process and yield streaming response chunks."""
-        result_content = []
-        span.add_event(Event.STREAM_START.value)
-        input_tokens = 0
-        output_tokens = 0
-        try:
-            for chunk in result:
-                if (
-                    hasattr(chunk, "message")
-                    and chunk.message is not None
-                    and hasattr(chunk.message, "model")
-                    and chunk.message.model is not None
-                ):
-                    span.set_attribute(
-                        SpanAttributes.LLM_RESPONSE_MODEL, chunk.message.model
-                    )
-                content = ""
-                if hasattr(chunk, "delta") and chunk.delta is not None:
-                    content = chunk.delta.text if hasattr(chunk.delta, "text") else ""
-                # Assuming content needs to be aggregated before processing
-                result_content.append(content if len(content) > 0 else "")
-
-                if hasattr(chunk, "message") and hasattr(chunk.message, "usage"):
-                    input_tokens += (
-                        chunk.message.usage.input_tokens
-                        if hasattr(chunk.message.usage, "input_tokens")
-                        else 0
-                    )
-                    output_tokens += (
-                        chunk.message.usage.output_tokens
-                        if hasattr(chunk.message.usage, "output_tokens")
-                        else 0
-                    )
-
-                # Assuming span.add_event is part of a larger logging or event system
-                # Add event for each chunk of content
-                if content:
-                    set_event_completion_chunk(span, "".join(content))
-
-                # Assuming this is part of a generator, yield chunk or aggregated content
-                yield content
-        finally:
-
-            # Finalize span after processing all chunks
-            span.add_event(Event.STREAM_END.value)
-            set_usage_attributes(
-                span, {"input_tokens": input_tokens, "output_tokens": output_tokens}
-            )
-            completion = [{"role": "assistant", "content": "".join(result_content)}]
-            set_event_completion(span, completion)
-
-            span.set_status(StatusCode.OK)
-            span.end()
-
+    @silently_fail
     def set_response_attributes(result, span, kwargs):
         if not is_streaming(kwargs):
             if hasattr(result, "content") and result.content is not None:
@@ -174,7 +122,7 @@ def messages_create(original_method, version, tracer):
             span.end()
             return result
         else:
-            return handle_streaming_response(result, span)
+            return StreamWrapper(result, span)
 
     # return the wrapped method
     return traced_method

langtrace_python_sdk/instrumentation/cohere/patch.py

@@ -407,15 +407,8 @@ def chat_stream(original_method, version, tracer):
         try:
             # Attempt to call the original method
             result = wrapped(*args, **kwargs)
-            span.add_event(Event.STREAM_START.value)
             try:
                 for event in result:
-                    if hasattr(event, "text") and event.text is not None:
-                        content = event.text
-                    else:
-                        content = ""
-                    set_event_completion_chunk(span, "".join(content))
-
                     if (
                         hasattr(event, "finish_reason")
                         and event.finish_reason == "COMPLETE"
@@ -496,15 +489,14 @@ def chat_stream(original_method, version, tracer):
                                         (usage.input_tokens or 0)
                                         + (usage.output_tokens or 0),
                                     )
-
-                                    span.set_attribute(
-                                        "search_units",
-                                        usage.search_units or 0,
-                                    )
+                                    if usage.search_units is not None:
+                                        span.set_attribute(
+                                            "search_units",
+                                            usage.search_units or 0,
+                                        )
 
                     yield event
             finally:
-                span.add_event(Event.STREAM_END.value)
                 span.set_status(StatusCode.OK)
                 span.end()
 

langtrace_python_sdk/instrumentation/langchain_core/instrumentation.py

@@ -66,8 +66,14 @@ def patch_module_classes(
         if name.startswith("_") or name in exclude_classes:
             continue
         # loop through all public methods of the class
-        for method_name, method in inspect.getmembers(obj, predicate=inspect.isfunction):
-            if method_name in exclude_methods or method.__qualname__.split('.')[0] != name:
+        for method_name, method in inspect.getmembers(
+            obj, predicate=inspect.isfunction
+        ):
+            if (
+                method_name in exclude_methods
+                or method.__qualname__.split(".")[0] != name
+                or method_name.startswith("_")
+            ):
                 continue
             try:
                 method_path = f"{name}.{method_name}"
@@ -108,6 +114,9 @@ class LangchainCoreInstrumentation(BaseInstrumentor):
             "format",
             "format_messages",
             "format_prompt",
+            "__or__",
+            "__init__",
+            "__repr__",
         ]
         exclude_classes = [
             "BaseChatPromptTemplate",
@@ -125,7 +134,13 @@ class LangchainCoreInstrumentation(BaseInstrumentor):
         modules_to_patch = [
             ("langchain_core.retrievers", "retriever", generic_patch, True, True),
             ("langchain_core.prompts.chat", "prompt", generic_patch, True, True),
-            ("langchain_core.language_models.llms", "generate", generic_patch, True, True),
+            (
+                "langchain_core.language_models.llms",
+                "generate",
+                generic_patch,
+                True,
+                True,
+            ),
             ("langchain_core.runnables.base", "runnable", runnable_patch, True, True),
             (
                 "langchain_core.runnables.passthrough",

langtrace_python_sdk/instrumentation/ollama/patch.py

@@ -1,6 +1,7 @@
 from langtrace_python_sdk.constants.instrumentation.ollama import APIS
 from langtrace_python_sdk.utils import set_span_attribute
 from langtrace_python_sdk.utils.llm import (
+    StreamWrapper,
     get_extra_attributes,
     get_langtrace_attributes,
     get_llm_request_attributes,
@@ -16,9 +17,10 @@ from opentelemetry.trace import SpanKind
 import json
 from opentelemetry.trace.status import Status, StatusCode
 from langtrace.trace_attributes import SpanAttributes
+from opentelemetry.trace import Tracer
 
 
-def generic_patch(operation_name, version, tracer):
+def generic_patch(operation_name, version, tracer: Tracer):
     def traced_method(wrapped, instance, args, kwargs):
         api = APIS[operation_name]
         service_provider = SERVICE_PROVIDERS["OLLAMA"]
@@ -35,36 +37,29 @@ def generic_patch(operation_name, version, tracer):
         }
 
         attributes = LLMSpanAttributes(**span_attributes)
-        with tracer.start_as_current_span(
-            name=get_span_name(f'ollama.{api["METHOD"]}'), kind=SpanKind.CLIENT
-        ) as span:
-            _set_input_attributes(span, kwargs, attributes)
-
-            try:
-                result = wrapped(*args, **kwargs)
-                if result:
-                    if span.is_recording():
-
-                        if kwargs.get("stream"):
-                            return _handle_streaming_response(
-                                span, result, api["METHOD"]
-                            )
 
-                        _set_response_attributes(span, result)
-                        span.set_status(Status(StatusCode.OK))
+        span = tracer.start_span(
+            name=get_span_name(f'ollama.{api["METHOD"]}'), kind=SpanKind.CLIENT
+        )
+        _set_input_attributes(span, kwargs, attributes)
 
-                span.end()
-                return result
+        try:
+            result = wrapped(*args, **kwargs)
+            if kwargs.get("stream"):
+                return StreamWrapper(result, span)
+            else:
+                _set_response_attributes(span, result)
+            return result
 
-            except Exception as err:
-                # Record the exception in the span
-                span.record_exception(err)
+        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)))
+            # 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
+            # Reraise the exception to ensure it's not swallowed
+            raise
 
     return traced_method
 
@@ -82,30 +77,28 @@ def ageneric_patch(operation_name, version, tracer):
             **get_extra_attributes(),
         }
         attributes = LLMSpanAttributes(**span_attributes)
-        with tracer.start_as_current_span(api["METHOD"], kind=SpanKind.CLIENT) as span:
-            _set_input_attributes(span, kwargs, attributes)
-            try:
-                result = await wrapped(*args, **kwargs)
-                if result:
-                    if span.is_recording():
-                        if kwargs.get("stream"):
-                            return _ahandle_streaming_response(
-                                span, result, api["METHOD"]
-                            )
-
-                        _set_response_attributes(span, result)
-                        span.set_status(Status(StatusCode.OK))
-                span.end()
-                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
+        span = tracer.start_span(
+            name=get_span_name(f'ollama.{api["METHOD"]}'), kind=SpanKind.CLIENT
+        )
+
+        _set_input_attributes(span, kwargs, attributes)
+        try:
+            result = await wrapped(*args, **kwargs)
+            if kwargs.get("stream"):
+                return StreamWrapper(span, result)
+            else:
+                _set_response_attributes(span, result)
+            span.end()
+            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
 
     return traced_method
 
@@ -162,63 +155,3 @@ def _set_input_attributes(span, kwargs, attributes):
             SpanAttributes.LLM_PRESENCE_PENALTY,
             options.get("presence_penalty"),
         )
-
-
-def _handle_streaming_response(span, response, api):
-    accumulated_tokens = None
-    if api == "chat":
-        accumulated_tokens = {"message": {"content": "", "role": ""}}
-    if api == "completion" or api == "generate":
-        accumulated_tokens = {"response": ""}
-    span.add_event(Event.STREAM_START.value)
-    try:
-        for chunk in response:
-            content = None
-            if api == "chat":
-                content = chunk["message"]["content"]
-                accumulated_tokens["message"]["content"] += chunk["message"]["content"]
-                accumulated_tokens["message"]["role"] = chunk["message"]["role"]
-            if api == "generate":
-                content = chunk["response"]
-                accumulated_tokens["response"] += chunk["response"]
-
-            set_event_completion_chunk(span, content)
-
-        _set_response_attributes(span, chunk | accumulated_tokens)
-    finally:
-        # Finalize span after processing all chunks
-        span.add_event(Event.STREAM_END.value)
-        span.set_status(StatusCode.OK)
-        span.end()
-
-    return response
-
-
-async def _ahandle_streaming_response(span, response, api):
-    accumulated_tokens = None
-    if api == "chat":
-        accumulated_tokens = {"message": {"content": "", "role": ""}}
-    if api == "completion" or api == "generate":
-        accumulated_tokens = {"response": ""}
-
-    span.add_event(Event.STREAM_START.value)
-    try:
-        async for chunk in response:
-            content = None
-            if api == "chat":
-                content = chunk["message"]["content"]
-                accumulated_tokens["message"]["content"] += chunk["message"]["content"]
-                accumulated_tokens["message"]["role"] = chunk["message"]["role"]
-            if api == "generate":
-                content = chunk["response"]
-                accumulated_tokens["response"] += chunk["response"]
-
-            set_event_completion_chunk(span, content)
-        _set_response_attributes(span, chunk | accumulated_tokens)
-    finally:
-        # Finalize span after processing all chunks
-        span.add_event(Event.STREAM_END.value)
-        span.set_status(StatusCode.OK)
-        span.end()
-
-    return response

langtrace_python_sdk/utils/llm.py

@@ -235,7 +235,7 @@ class StreamWrapper:
     span: Span
 
     def __init__(
-        self, stream, span, prompt_tokens, function_call=False, tool_calls=False
+        self, stream, span, prompt_tokens=0, function_call=False, tool_calls=False
     ):
         self.stream = stream
         self.span = span
@@ -245,16 +245,20 @@ class StreamWrapper:
         self.result_content = []
         self.completion_tokens = 0
         self._span_started = False
+        self._response_model = None
         self.setup()
 
     def setup(self):
         if not self._span_started:
-            self.span.add_event(Event.STREAM_START.value)
             self._span_started = True
 
     def cleanup(self):
         if self._span_started:
-            self.span.add_event(Event.STREAM_END.value)
+            set_span_attribute(
+                self.span,
+                SpanAttributes.LLM_RESPONSE_MODEL,
+                self._response_model,
+            )
             set_span_attribute(
                 self.span,
                 SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
@@ -279,7 +283,6 @@ class StreamWrapper:
                     }
                 ],
             )
-
             self.span.set_status(StatusCode.OK)
             self.span.end()
             self._span_started = False
@@ -322,21 +325,26 @@ class StreamWrapper:
             self.cleanup()
             raise StopAsyncIteration
 
-    def process_chunk(self, chunk):
+    def set_response_model(self, chunk):
+        if self._response_model:
+            return
+
+        # OpenAI response model is set on all chunks
         if hasattr(chunk, "model") and chunk.model is not None:
-            set_span_attribute(
-                self.span,
-                SpanAttributes.LLM_RESPONSE_MODEL,
-                chunk.model,
-            )
+            self._response_model = chunk.model
+
+        # Anthropic response model is set on the first chunk message
+        if hasattr(chunk, "message") and chunk.message is not None:
+            if hasattr(chunk.message, "model") and chunk.message.model is not None:
+                self._response_model = chunk.message.model
 
+    def build_streaming_response(self, chunk):
+        content = []
+        # OpenAI
         if hasattr(chunk, "choices") and chunk.choices is not None:
-            content = []
             if not self.function_call and not self.tool_calls:
                 for choice in chunk.choices:
                     if choice.delta and choice.delta.content is not None:
-                        token_counts = estimate_tokens(choice.delta.content)
-                        self.completion_tokens += token_counts
                         content = [choice.delta.content]
             elif self.function_call:
                 for choice in chunk.choices:
@@ -345,10 +353,6 @@ class StreamWrapper:
                         and choice.delta.function_call is not None
                         and choice.delta.function_call.arguments is not None
                     ):
-                        token_counts = estimate_tokens(
-                            choice.delta.function_call.arguments
-                        )
-                        self.completion_tokens += token_counts
                         content = [choice.delta.function_call.arguments]
             elif self.tool_calls:
                 for choice in chunk.choices:
@@ -361,30 +365,52 @@ class StreamWrapper:
                                 and tool_call.function is not None
                                 and tool_call.function.arguments is not None
                             ):
-                                token_counts = estimate_tokens(
-                                    tool_call.function.arguments
-                                )
-                                self.completion_tokens += token_counts
                                 content.append(tool_call.function.arguments)
-            set_event_completion_chunk(
-                self.span,
-                "".join(content) if len(content) > 0 and content[0] is not None else "",
-            )
-            if content:
-                self.result_content.append(content[0])
 
-        if hasattr(chunk, "text"):
-            token_counts = estimate_tokens(chunk.text)
-            self.completion_tokens += token_counts
+        # VertexAI
+        if hasattr(chunk, "text") and chunk.text is not None:
             content = [chunk.text]
-            set_event_completion_chunk(
-                self.span,
-                "".join(content) if len(content) > 0 and content[0] is not None else "",
-            )
 
-            if content:
-                self.result_content.append(content[0])
+        # Anthropic
+        if hasattr(chunk, "delta") and chunk.delta is not None:
+            content = [chunk.delta.text] if hasattr(chunk.delta, "text") else []
+
+        if isinstance(chunk, dict):
+            if "message" in chunk:
+                if "content" in chunk["message"]:
+                    content = [chunk["message"]["content"]]
+        if content:
+            self.result_content.append(content[0])
+
+    def set_usage_attributes(self, chunk):
+
+        # Anthropic & OpenAI
+        if hasattr(chunk, "type") and chunk.type == "message_start":
+            self.prompt_tokens = chunk.message.usage.input_tokens
 
+        if hasattr(chunk, "usage") and chunk.usage is not None:
+            if hasattr(chunk.usage, "output_tokens"):
+                self.completion_tokens = chunk.usage.output_tokens
+
+            if hasattr(chunk.usage, "prompt_tokens"):
+                self.prompt_tokens = chunk.usage.prompt_tokens
+
+            if hasattr(chunk.usage, "completion_tokens"):
+                self.completion_tokens = chunk.usage.completion_tokens
+
+        # VertexAI
         if hasattr(chunk, "usage_metadata"):
             self.completion_tokens = chunk.usage_metadata.candidates_token_count
             self.prompt_tokens = chunk.usage_metadata.prompt_token_count
+
+        # Ollama
+        if isinstance(chunk, dict):
+            if "prompt_eval_count" in chunk:
+                self.prompt_tokens = chunk["prompt_eval_count"]
+            if "eval_count" in chunk:
+                self.completion_tokens = chunk["eval_count"]
+
+    def process_chunk(self, chunk):
+        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__ = "2.2.20"
+__version__ = "2.2.22"

{langtrace_python_sdk-2.2.20.dist-info → langtrace_python_sdk-2.2.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 2.2.20
+Version: 2.2.22
 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-2.2.20.dist-info → langtrace_python_sdk-2.2.22.dist-info}/RECORD

@@ -9,7 +9,18 @@ examples/cohere_example/chat_stream.py,sha256=BvhUgBEuyMhyzRZ_2i_SBvO9Ndf0b7-aRD
 examples/cohere_example/embed.py,sha256=p9BJvOg09JVb8BfTCb63v3uh_wOsi_OyrCAJdXXrE6E,496
 examples/cohere_example/rerank.py,sha256=e7OU0A2FzfiQDuOmCy3Kg5LLNYGRmRIK5LqeLnTWlP4,1118
 examples/cohere_example/tools.py,sha256=a5uvS058tcwU6PJbF9EDO6LPVmPj2LoW4Vn8Web3Iq8,1656
+examples/crewai_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 examples/crewai_example/basic.py,sha256=PBu4f8yQfZO1L_22UDm_ReU9lnEcycjZcGuy5UpgDJM,1948
+examples/crewai_example/simple_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/crewai_example/simple_agent/agents.py,sha256=Lq_5zeftH7TV-dsDRxfxi6sfE3t2mpQ4WulFh1FAFfs,1329
+examples/crewai_example/simple_agent/main.py,sha256=MJq3Xd24RIUHaSDAUpQtZb5ht5YUu5xPwgYxEY4moJk,1223
+examples/crewai_example/simple_agent/tasks.py,sha256=bfx_vP59akrrjNRUbVT7GDzdZlEqTQXAtGcCOCk_UFY,796
+examples/crewai_example/trip_planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/crewai_example/trip_planner/agents.py,sha256=IpzLbgrmdMa-9mj6awjJUcOumX8Cg71OzRQ1L8fIog4,2378
+examples/crewai_example/trip_planner/main.py,sha256=Ju001KRksiH1Svu6p83CfTybAPq9hruJVH9p3BmtG_c,2623
+examples/crewai_example/trip_planner/tasks.py,sha256=ZGRaTAgkA66IN7q9EYbJqM8xWhUTxcF4ynnqTyBcSL4,5667
+examples/crewai_example/trip_planner/tools/calculator.py,sha256=bMfxJDAwbn6D26pe880S4BB3rcFeyvEyb15QR00T8kI,522
+examples/crewai_example/trip_planner/tools/search_tools.py,sha256=p8qZe_bi45OjBwiwwrH0lhTaQI_ZiLThSTEEN5dWxF0,2700
 examples/dspy_example/math_problems_cot.py,sha256=Z98nB6myt8WJse2dWS6Ap7CFUhC27lBNb37R1Gg80VQ,1282
 examples/dspy_example/math_problems_cot_parallel.py,sha256=5clw-IIVA0mWm0N0xWNDMQaSY07YVYW8R1mcyCJJ1_8,1764
 examples/dspy_example/program_of_thought_basic.py,sha256=oEbtJdeKENMUbex25-zyStWwurRWW6OdP0KDs-jUkko,984
@@ -63,7 +74,7 @@ examples/weaviate_example/__init__.py,sha256=8JMDBsRSEV10HfTd-YC7xb4txBjD3la56sn
 examples/weaviate_example/query_text.py,sha256=sG8O-bXQpflBAiYpgE_M2X7GcHUlZNgl_wJW8_h-W6Q,127024
 langtrace_python_sdk/__init__.py,sha256=VZM6i71NR7pBQK6XvJWRelknuTYUhqwqE7PlicKa5Wg,1166
 langtrace_python_sdk/langtrace.py,sha256=hh3okJYyxXvC9TMm_vaFOGz-5TxxJp1zQDmZmy63aRY,7813
-langtrace_python_sdk/version.py,sha256=kOrmSTcDQ0cSVmIBVsgETbkmkVVEbLmdHPzkY_Y2PbA,23
+langtrace_python_sdk/version.py,sha256=pX8tRH0Idy_gR6E_Dzk1LImPGfPmc0Pkc62fJ617lUk,23
 langtrace_python_sdk/constants/__init__.py,sha256=P8QvYwt5czUNDZsKS64vxm9Dc41ptGbuF1TFtAF6nv4,44
 langtrace_python_sdk/constants/exporter/langtrace_exporter.py,sha256=5MNjnAOg-4am78J3gVMH6FSwq5N8TOj72ugkhsw4vi0,46
 langtrace_python_sdk/constants/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -85,13 +96,13 @@ langtrace_python_sdk/extensions/langtrace_filesystem.py,sha256=34fZutG28EJ66l67O
 langtrace_python_sdk/instrumentation/__init__.py,sha256=yJd3aGu4kPfm2h6oe6kiCWvzTF9awpC1UztjXF9WSO4,1391
 langtrace_python_sdk/instrumentation/anthropic/__init__.py,sha256=donrurJAGYlxrSRA3BIf76jGeUcAx9Tq8CVpah68S0Y,101
 langtrace_python_sdk/instrumentation/anthropic/instrumentation.py,sha256=-srgE8qumAn0ulQYZxMa8ch-9IBH0XgBW_rfEnGk6LI,1684
-langtrace_python_sdk/instrumentation/anthropic/patch.py,sha256=cVVXYFzIIHkaEzdVvq-YrEgf7-RaaKlXb9CH-9RU9vg,6858
+langtrace_python_sdk/instrumentation/anthropic/patch.py,sha256=i_94sJXURVgKIUVKJ3mMqZydWtlv5BlIRqQEk8utrL4,4546
 langtrace_python_sdk/instrumentation/chroma/__init__.py,sha256=pNZ5UO8Q-d5VkXSobBf79reB6AmEl_usnnTp5Itv818,95
 langtrace_python_sdk/instrumentation/chroma/instrumentation.py,sha256=nT6PS6bsrIOO9kLV5GuUeRjMe6THHHAZGvqWBP1dYog,1807
 langtrace_python_sdk/instrumentation/chroma/patch.py,sha256=1jCbyum11ifbQFLO43eg0yW33Yc7NI_fwhRf1gspHcM,9087
 langtrace_python_sdk/instrumentation/cohere/__init__.py,sha256=sGUSLdTUyYf36Tm6L5jQflhzCqvmWrhnBOMYHjvp6Hs,95
 langtrace_python_sdk/instrumentation/cohere/instrumentation.py,sha256=YQFHZIBd7SSPD4b6Va-ZR0thf_AuBCqj5yzHLHJVWnM,2121
-langtrace_python_sdk/instrumentation/cohere/patch.py,sha256=YPFgNVX_DNoL4FCp5aFbcDP8z8nQTp7v78dA28XRioA,21280
+langtrace_python_sdk/instrumentation/cohere/patch.py,sha256=Mv9mk3HBdMYsartyYzqsGPkY791LkEoigyShaQBM0xk,21004
 langtrace_python_sdk/instrumentation/crewai/__init__.py,sha256=_UBKfvQv7l0g2_wnmA5F6CdSAFH0atNOVPd49zsN3aM,88
 langtrace_python_sdk/instrumentation/crewai/instrumentation.py,sha256=q07x6nnig9JPxDT6ZylyIShfXWjNafKBetnNcA1UdEU,1836
 langtrace_python_sdk/instrumentation/crewai/patch.py,sha256=4W7jEIJX4SJNViPlFTBJdSkvvPVJoI76Bb5DX673Ql8,6203
@@ -111,7 +122,7 @@ langtrace_python_sdk/instrumentation/langchain_community/__init__.py,sha256=mj5R
 langtrace_python_sdk/instrumentation/langchain_community/instrumentation.py,sha256=TmMRXcaiMR99Qg7r7pT1XunCr_GOQl_Csr6leSKYyTQ,5350
 langtrace_python_sdk/instrumentation/langchain_community/patch.py,sha256=ssNM9NyRtWiGgqaOZ9zK3R-VDYx_VwNmPq1RAZ-4Wzg,5232
 langtrace_python_sdk/instrumentation/langchain_core/__init__.py,sha256=kumE_reeqgM-ZvEZ6-XxyT-F-HAdKq_v_PKvsLb4EZQ,110
-langtrace_python_sdk/instrumentation/langchain_core/instrumentation.py,sha256=bTZOOr049GQSQqUnLhFtQIFSXrLs7j_3uHP5IN-6rJ0,6013
+langtrace_python_sdk/instrumentation/langchain_core/instrumentation.py,sha256=uiRGS3RLZGe442kzEyW2b9xJitb0EmZ8zs6Sj-cyol4,6295
 langtrace_python_sdk/instrumentation/langchain_core/patch.py,sha256=SvYTuYaVtKzoqmIz-_FIZbTCT00CItZOwjWvEOCwfDA,9552
 langtrace_python_sdk/instrumentation/langgraph/__init__.py,sha256=eitlHloY-aZ4ZuIEJx61AadEA3G7siyecP-V-lziAr8,101
 langtrace_python_sdk/instrumentation/langgraph/instrumentation.py,sha256=SUZZhWSIbcfsF1S5NtEqW8QzkRM_pKAuXB7pwk5tsOU,2526
@@ -121,7 +132,7 @@ langtrace_python_sdk/instrumentation/llamaindex/instrumentation.py,sha256=8iAg-O
 langtrace_python_sdk/instrumentation/llamaindex/patch.py,sha256=548hzPyT_k-2wmt9AArv4JzTT4j4AGKJq5Ar2bWv7o8,4615
 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=AYIT8N6LXTgd5HqjuDOtKSfqD-24a1_5bF3pd_R3HGM,8128
+langtrace_python_sdk/instrumentation/ollama/patch.py,sha256=5Y_pPVh1Pt8BcxyCiJWex3oNqYTcuOo5udh1-jNsCO0,5407
 langtrace_python_sdk/instrumentation/openai/__init__.py,sha256=VPHRNCQEdkizIVP2d0Uw_a7t8XOTSTprEIB8oboJFbs,95
 langtrace_python_sdk/instrumentation/openai/instrumentation.py,sha256=A0BJHRLcZ74TNVg6I0I9M5YWvSpAtXwMmME6N5CEQ_M,2945
 langtrace_python_sdk/instrumentation/openai/patch.py,sha256=4GCYJzZdUBopEDinpTwRBFf-Enb0hdNO16LiiMKqqvY,24226
@@ -140,7 +151,7 @@ langtrace_python_sdk/instrumentation/weaviate/patch.py,sha256=qX4VQqScH2kygn5lQa
 langtrace_python_sdk/types/__init__.py,sha256=KDW6S74FDxpeBa9xoH5zVEYfmRjccCCHzlW7lTJg1TA,3194
 langtrace_python_sdk/utils/__init__.py,sha256=SwYYPIh2AzEpI3zbwowQU2zJlwRwoVdWOCcrAKnkI9g,873
 langtrace_python_sdk/utils/langtrace_sampler.py,sha256=BupNndHbU9IL_wGleKetz8FdcveqHMBVz1bfKTTW80w,1753
-langtrace_python_sdk/utils/llm.py,sha256=zvVhSE4TkVQCqzfnPtGKXbct66Hj9ZFJ6N2fVbNfvbw,13129
+langtrace_python_sdk/utils/llm.py,sha256=hDOPyUp3kSL1g92uiHySARzBmVRMy3umGizz91vTDSI,13940
 langtrace_python_sdk/utils/misc.py,sha256=CD9NWRLxLpFd0YwlHJqzlpFNedXVWtAKGOjQWnDCo8k,838
 langtrace_python_sdk/utils/prompt_registry.py,sha256=n5dQMVLBw8aJZY8Utvf67bncc25ELf6AH9BYw8_hSzo,2619
 langtrace_python_sdk/utils/sdk_version_checker.py,sha256=FzjIWZjn53cX0LEVPdipQd1fO9lG8iGVUEVUs9Hyk6M,1713
@@ -151,14 +162,14 @@ tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conftest.py,sha256=0Jo6iCZTXbdvyJVhG9UpYGkLabL75378oauCzmt-Sa8,603
 tests/utils.py,sha256=8ZBYvxBH6PynipT1sqenfyjTGLhEV7SORQH1NJjnpsM,2500
 tests/anthropic/conftest.py,sha256=ht1zF3q4Xb1UiZ3BL_L-CQ3YWrd52Dqb4WTZ3f-GdG4,739
-tests/anthropic/test_anthropic.py,sha256=lNalVzRk52smmwflFT8tFu-Jm9y56dyEWWgWlXarJeY,2942
+tests/anthropic/test_anthropic.py,sha256=5c2UELkvrVHb07t7wyHvxxAOn_M0-L8wuVT4z1FMHUU,2863
 tests/anthropic/cassettes/test_anthropic.yaml,sha256=z7YAqA_BBgI-hw7uyVMdLoIZdBYhKwl9cuTzUu9nAZs,2332
 tests/anthropic/cassettes/test_anthropic_streaming.yaml,sha256=D0w4-6dfsgrhbNLJEj8gZBV0yXfrAfA9u90Yu8Ac-TY,11675
 tests/anthropic/cassettes/test_async_anthropic_streaming.yaml,sha256=hQZPY2vwBaW3BWllLd0lcGQ73DjA8C3Ips1Hx9pA-ao,8373
 tests/chroma/conftest.py,sha256=kqb4VydCnlVpkvBX5Bu-pfnVS-ZZfju9cp6vq76tkJI,309
 tests/chroma/test_chroma.py,sha256=-KJHunvvVi1OoKKOcKCeHO1s399Gm9vJfd-EzgllQmk,1220
 tests/cohere/conftest.py,sha256=jBbyg-tut-ZJN5_5D64sGmaPIhT_nQQQAiW43kl5Rz4,621
-tests/cohere/test_cohere_chat.py,sha256=KJBWGXPPeTCKdch8O63-7IadmMvdZZrsUPAx0Z0aH60,4463
+tests/cohere/test_cohere_chat.py,sha256=2su_sOyxr9HinhfNY51MbriVG4JK711FSFJOWHzGQTY,4377
 tests/cohere/test_cohere_embed.py,sha256=Zx2gcc7YSp7rEOWelFVcRkL8V93wGP8ZFG7exrgJCJY,1500
 tests/cohere/test_cohere_rerank.py,sha256=RC52HVdM4ZYbLDcT1hnWNKDtbNJeDvOFIllULhUN4EA,2522
 tests/cohere/cassettes/test_cohere_chat.yaml,sha256=iQIhJwmWe2AQDmdguL6L0SZOPMD6B3mhDVUKPSLodA4,3271
@@ -175,7 +186,7 @@ tests/langchain/conftest.py,sha256=f29apdevxg7AM0mPQ1LoEd-yStGruqGLTQUp29heLJo,1
 tests/langchain/test_langchain.py,sha256=BYAQY3ShJIVnLS1b-TkJ4wMKhbiPV-E4-ISTjGyPxhM,646
 tests/langchain/cassettes/test_langchain.yaml,sha256=KPBTVIYMUPFaSNpwrTDgWzsu4p3hHj_yNDoudDa-Jis,3755
 tests/openai/conftest.py,sha256=BkehS6heg-O91Nzoc4546OSiAzy8KgSgk7VCO3A11zM,700
-tests/openai/test_chat_completion.py,sha256=I3XqMhMYsnSE8581UN_PGL_Y3A_kwa2mhb7zhxv52NQ,5081
+tests/openai/test_chat_completion.py,sha256=vkUtyF01U41J2TR8O8ygvoRXPniXI734QuQ79DgImOg,4863
 tests/openai/test_embeddings.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/openai/test_image_generation.py,sha256=u6lJCDPs2kZ_MfoaEXEszU_VTOQr7xGK7ki93E2e-wY,4902
 tests/openai/cassettes/test_async_chat_completion_streaming.yaml,sha256=z4LE2pknHrfNm9D2pKH1F_cHDAG8LIVp4SnzJBUd4t4,6719
@@ -189,8 +200,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-2.2.20.dist-info/METADATA,sha256=RiiPFYBgE6nH5CrpRVOgIiTw94B1xHtzTeVGYwoowmk,14705
-langtrace_python_sdk-2.2.20.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-langtrace_python_sdk-2.2.20.dist-info/entry_points.txt,sha256=1_b9-qvf2fE7uQNZcbUei9vLpFZBbbh9LrtGw95ssAo,70
-langtrace_python_sdk-2.2.20.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-langtrace_python_sdk-2.2.20.dist-info/RECORD,,
+langtrace_python_sdk-2.2.22.dist-info/METADATA,sha256=W2LdIpHk8FHlmtYVmgri3pLmJDK9D2Dq9mpBq15XYaw,14705
+langtrace_python_sdk-2.2.22.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+langtrace_python_sdk-2.2.22.dist-info/entry_points.txt,sha256=1_b9-qvf2fE7uQNZcbUei9vLpFZBbbh9LrtGw95ssAo,70
+langtrace_python_sdk-2.2.22.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+langtrace_python_sdk-2.2.22.dist-info/RECORD,,

tests/anthropic/test_anthropic.py

@@ -82,8 +82,4 @@ def test_anthropic_streaming(anthropic_client, exporter):
     assert attributes.get(SpanAttributes.LLM_REQUEST_MODEL) == llm_model_value
     assert attributes.get(SpanAttributes.LLM_IS_STREAMING) is True
 
-    events = streaming_span.events
-
-    assert len(events) - 4 == chunk_count
-
     assert_token_count(attributes)

tests/cohere/test_cohere_chat.py

@@ -112,7 +112,5 @@ def test_cohere_chat_streaming(cohere_client, exporter):
     events = cohere_span.events
     assert_prompt_in_events(events)
     assert_completion_in_events(events)
-    assert events[-1].name == "stream.end"
-    assert len(events) - 4 == chunks_count
 
     assert_token_count(attributes)

tests/openai/test_chat_completion.py

@@ -83,9 +83,6 @@ def test_chat_completion_streaming(exporter, openai_client):
     assert_completion_in_events(streaming_span.events)
     assert attributes.get(SpanAttributes.LLM_IS_STREAMING) is True
 
-    events = streaming_span.events
-    assert len(events) - 4 == chunk_count  # -2 for start and end events
-
     assert_token_count(attributes)
 
 
@@ -126,7 +123,4 @@ async def test_async_chat_completion_streaming(exporter, async_openai_client):
     assert_completion_in_events(streaming_span.events)
     assert attributes.get(SpanAttributes.LLM_IS_STREAMING) is True
 
-    events = streaming_span.events
-    assert len(events) - 4 == chunk_count  # -2 for start and end events
-
     assert_token_count(attributes)