langtrace-python-sdk 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

examples/openai/async_tool_calling_nonstreaming.py

@@ -0,0 +1,93 @@
+import json
+
+from dotenv import find_dotenv, load_dotenv
+from openai import AsyncOpenAI
+
+from langtrace_python_sdk import langtrace
+
+# from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+langtrace.init(write_to_langtrace_cloud=False)
+
+client = AsyncOpenAI()
+
+# Example dummy function hard coded to return the same weather
+# In production, this could be your backend API or an external API
+def get_current_weather(location, unit="fahrenheit"):
+    """Get the current weather in a given location"""
+    if "tokyo" in location.lower():
+        return json.dumps({"location": "Tokyo", "temperature": "10", "unit": unit})
+    elif "san francisco" in location.lower():
+        return json.dumps({"location": "San Francisco", "temperature": "72", "unit": unit})
+    elif "paris" in location.lower():
+        return json.dumps({"location": "Paris", "temperature": "22", "unit": unit})
+    else:
+        return json.dumps({"location": location, "temperature": "unknown"})
+
+
+async def run_conversation():
+    # Step 1: send the conversation and available functions to the model
+    messages = [{"role": "user", "content": "What's the weather like in San Francisco, Tokyo, and Paris?"}]
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_current_weather",
+                "description": "Get the current weather in a given location",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "location": {
+                            "type": "string",
+                            "description": "The city and state, e.g. San Francisco, CA",
+                        },
+                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+                    },
+                    "required": ["location"],
+                },
+            },
+        }
+    ]
+    response = await client.chat.completions.create(
+        model="gpt-3.5-turbo-0125",
+        messages=messages,
+        tools=tools,
+        tool_choice="auto",  # auto is default, but we'll be explicit
+    )
+    # print(response)
+    response_message = response.choices[0].message
+    tool_calls = response_message.tool_calls
+    # Step 2: check if the model wanted to call a function
+    if tool_calls:
+        # Step 3: call the function
+        # Note: the JSON response may not always be valid; be sure to handle errors
+        available_functions = {
+            "get_current_weather": get_current_weather,
+        }  # only one function in this example, but you can have multiple
+        messages.append(response_message)  # extend conversation with assistant's reply
+        # Step 4: send the info for each function call and function response to the model
+        for tool_call in tool_calls:
+            function_name = tool_call.function.name
+            function_to_call = available_functions[function_name]
+            function_args = json.loads(tool_call.function.arguments)
+            function_response = function_to_call(
+                location=function_args.get("location"),
+                unit=function_args.get("unit"),
+            )
+            messages.append(
+                {
+                    "tool_call_id": tool_call.id,
+                    "role": "tool",
+                    "name": function_name,
+                    "content": function_response,
+                }
+            )  # extend conversation with function response
+        second_response = await client.chat.completions.create(
+            model="gpt-3.5-turbo-0125",
+            messages=messages,
+        )  # get a new response from the model where it can see the function response
+        # print(second_response)
+        return second_response
+

examples/openai/async_tool_calling_streaming.py

@@ -0,0 +1,167 @@
+import json
+
+from dotenv import find_dotenv, load_dotenv
+from openai import AsyncOpenAI
+
+from langtrace_python_sdk import langtrace
+
+# from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+langtrace.init(write_to_langtrace_cloud=False)
+
+client = AsyncOpenAI()
+
+
+# Example dummy function hard coded to return the same weather
+# In production, this could be your backend API or an external API
+def get_current_weather(location, unit="fahrenheit"):
+    """Get the current weather in a given location"""
+    if "tokyo" in location.lower():
+        return json.dumps({"location": "Tokyo", "temperature": "10", "unit": unit})
+    elif "san francisco" in location.lower():
+        return json.dumps({"location": "San Francisco", "temperature": "72", "unit": unit})
+    elif "paris" in location.lower():
+        return json.dumps({"location": "Paris", "temperature": "22", "unit": unit})
+    else:
+        return json.dumps({"location": location, "temperature": "unknown"})
+
+
+def get_current_time(location):
+    """Get the current time in a given location"""
+    if "tokyo" in location.lower():
+        return json.dumps({"location": "Tokyo", "time": "10"})
+    elif "san francisco" in location.lower():
+        return json.dumps({"location": "San Francisco", "time": "72"})
+    elif "paris" in location.lower():
+        return json.dumps({"location": "Paris", "time": "22"})
+    else:
+        return json.dumps({"location": location, "time": "unknown"})
+
+
+async def run_conversation():
+    # Step 1: send the conversation and available functions to the model
+    messages = [{"role": "user", "content": "What's the weather like in San Francisco, Tokyo, and Paris?"}]
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_current_weather",
+                "description": "Get the current weather in a given location",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "location": {
+                            "type": "string",
+                            "description": "The city and state, e.g. San Francisco, CA",
+                        },
+                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+                    },
+                    "required": ["location"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "get_current_time",
+                "description": "Get the current time in a given location",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "location": {
+                            "type": "string",
+                            "description": "The city and state, e.g. San Francisco, CA",
+                        },
+                    },
+                    "required": ["location"],
+                },
+            },
+        }
+    ]
+    response = await client.chat.completions.create(
+        model="gpt-4",
+        messages=messages,
+        tools=tools,
+        tool_choice="auto",  # auto is default, but we'll be explicit
+        stream=True,
+    )
+
+    # For streaming, uncomment the following lines
+    tool_call_dict = {}
+    tool_calls = []
+    id = ""
+    name = ""
+    arguments = ""
+    async for chunk in response:
+        if chunk.choices[0].delta is not None and chunk.choices[0].delta.tool_calls is not None:
+            for choice in chunk.choices:
+                for tool_call in choice.delta.tool_calls:
+                    if tool_call.id and id != tool_call.id:
+                        id = tool_call.id if tool_call.id else ""
+                        name = tool_call.function.name if tool_call.function and tool_call.function.name else ""
+                        tool_call_dict[name] = {
+                            "id": id,
+                            "function": {
+                                "name": name,
+                                "arguments": arguments
+                            },
+                            "type": "function"
+                        }
+                    arguments += tool_call.function.arguments if tool_call.function and tool_call.function.arguments else ""
+                if name != "":
+                    tool_call_dict[name] = {
+                        "id": id,
+                        "function": {
+                            "name": name,
+                            "arguments": arguments
+                        },
+                        "type": "function"
+                    }
+    for key, value in tool_call_dict.items():
+        tool_calls.append(value)
+
+    # Step 2: check if the model wanted to call a function
+    if tool_calls:
+        # Step 3: call the function
+        # Note: the JSON response may not always be valid; be sure to handle errors
+        available_functions = {
+            "get_current_weather": get_current_weather,
+            "get_current_time": get_current_time,
+        }  # only one function in this example, but you can have multiple
+        # messages.append(response_message)  # extend conversation with assistant's reply
+        # Step 4: send the info for each function call and function response to the model
+        for tool_call in tool_calls:
+            function_name = tool_call['function']['name']
+            function_to_call = available_functions[function_name]
+            function_args = json.loads(tool_call['function']['arguments'])
+            function_response = function_to_call(
+                location=function_args.get("location"),
+                unit=function_args.get("unit"),
+            )
+            func_res = json.loads(function_response)
+            content = f"Use the below information to answer the user's question: The current weather in {func_res['location']} is {func_res['temperature']} degrees {func_res['unit']}"
+            messages.append(
+                {
+                    "role": "system",
+                    "content": content
+                }
+            )  # extend conversation with function response
+        print(messages)
+        second_response = await client.chat.completions.create(
+            model="gpt-4",
+            messages=messages,
+            stream=True,
+        )  # get a new response from the model where it can see the function response
+        result = []
+        async for chunk in second_response:
+            if chunk.choices[0].delta.content is not None:
+                content = [
+                    choice.delta.content if choice.delta and
+                    choice.delta.content else ""
+                    for choice in chunk.choices]
+                result.append(
+                    content[0] if len(content) > 0 else "")
+        print("".join(result))
+        # return second_response

examples/openai/chat_completion.py

@@ -7,7 +7,7 @@ from langtrace_python_sdk.utils.with_root_span import (
 
 _ = load_dotenv(find_dotenv())
 
-langtrace.init(write_to_langtrace_cloud=True)
+langtrace.init(write_to_langtrace_cloud=False)
 client = OpenAI()
 
 
@@ -26,7 +26,7 @@ def api2():
     response = client.chat.completions.create(
         model="gpt-4",
         messages=[{"role": "user", "content": "Say this is a test three times"}],
-        stream=False,
+        stream=True,
     )
     return response
 
@@ -35,25 +35,24 @@ def api2():
 def chat_completion():
     response = api1()
     response = api2()
-    return response
+    result = []
+    for chunk in response:
+        if chunk.choices[0].delta.content is not None:
+            content = [
+                choice.delta.content if choice.delta and
+                choice.delta.content else ""
+                for choice in chunk.choices]
+            result.append(
+                content[0] if len(content) > 0 else "")
 
+    print("".join(result))
+    # return response
 
-# print(response)
+
+# # print(response)
 # stream = client.chat.completions.create(
 #     model="gpt-4",
 #     messages=[{"role": "user", "content": "Say this is a test three times"}, {"role": "assistant", "content": "This is a test. This is a test. This is a test"},
 #               {"role": "user", "content": "Say this is a mock 4 times"}],
 #     stream=False,
 # )
-
-# result = []
-# for chunk in response:
-#     if chunk.choices[0].delta.content is not None:
-#         content = [
-#             choice.delta.content if choice.delta and
-#             choice.delta.content else ""
-#             for choice in chunk.choices]
-#         result.append(
-#             content[0] if len(content) > 0 else "")
-
-# print("".join(result))

examples/openai/function_calling.py

@@ -34,7 +34,7 @@ student_custom_functions = [
 ]
 
 
-@with_langtrace_root_span()
+# @with_langtrace_root_span()
 def function_calling():
     response = client.chat.completions.create(
         model="gpt-3.5-turbo",
@@ -46,21 +46,21 @@ def function_calling():
         ],
         functions=student_custom_functions,
         function_call="auto",
-        stream=False,
+        stream=True,
     )
 
-    # result = []
-    # for chunk in response:
-    #     if chunk.choices[0].delta.function_call is not None:
-    #         content = [
-    #             choice.delta.function_call.arguments if choice.delta.function_call and
-    #             choice.delta.function_call.arguments else ""
-    #             for choice in chunk.choices]
-    #         result.append(
-    #             content[0] if len(content) > 0 else "")
+    result = []
+    for chunk in response:
+        if chunk.choices[0].delta.function_call is not None:
+            content = [
+                choice.delta.function_call.arguments if choice.delta.function_call and
+                choice.delta.function_call.arguments else ""
+                for choice in chunk.choices]
+            result.append(
+                content[0] if len(content) > 0 else "")
 
-    # print("".join(result))
+    print("".join(result))
 
     # Loading the response as a JSON object
-    json_response = json.loads(response.choices[0].message.function_call.arguments)
-    print(json_response)
+    # json_response = json.loads(response.choices[0].message.function_call.arguments)
+    # print(json_response)

examples/openai/tool_calling_nonstreaming.py

@@ -0,0 +1,92 @@
+import json
+
+from dotenv import find_dotenv, load_dotenv
+from openai import OpenAI
+
+from langtrace_python_sdk import langtrace
+
+# from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+langtrace.init(write_to_langtrace_cloud=False)
+
+client = OpenAI()
+
+# Example dummy function hard coded to return the same weather
+# In production, this could be your backend API or an external API
+def get_current_weather(location, unit="fahrenheit"):
+    """Get the current weather in a given location"""
+    if "tokyo" in location.lower():
+        return json.dumps({"location": "Tokyo", "temperature": "10", "unit": unit})
+    elif "san francisco" in location.lower():
+        return json.dumps({"location": "San Francisco", "temperature": "72", "unit": unit})
+    elif "paris" in location.lower():
+        return json.dumps({"location": "Paris", "temperature": "22", "unit": unit})
+    else:
+        return json.dumps({"location": location, "temperature": "unknown"})
+
+
+def run_conversation():
+    # Step 1: send the conversation and available functions to the model
+    messages = [{"role": "user", "content": "What's the weather like in San Francisco, Tokyo, and Paris?"}]
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_current_weather",
+                "description": "Get the current weather in a given location",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "location": {
+                            "type": "string",
+                            "description": "The city and state, e.g. San Francisco, CA",
+                        },
+                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+                    },
+                    "required": ["location"],
+                },
+            },
+        }
+    ]
+    response = client.chat.completions.create(
+        model="gpt-3.5-turbo-0125",
+        messages=messages,
+        tools=tools,
+        tool_choice="auto",  # auto is default, but we'll be explicit
+    )
+    # print(response)
+    response_message = response.choices[0].message
+    tool_calls = response_message.tool_calls
+    # Step 2: check if the model wanted to call a function
+    if tool_calls:
+        # Step 3: call the function
+        # Note: the JSON response may not always be valid; be sure to handle errors
+        available_functions = {
+            "get_current_weather": get_current_weather,
+        }  # only one function in this example, but you can have multiple
+        messages.append(response_message)  # extend conversation with assistant's reply
+        # Step 4: send the info for each function call and function response to the model
+        for tool_call in tool_calls:
+            function_name = tool_call.function.name
+            function_to_call = available_functions[function_name]
+            function_args = json.loads(tool_call.function.arguments)
+            function_response = function_to_call(
+                location=function_args.get("location"),
+                unit=function_args.get("unit"),
+            )
+            messages.append(
+                {
+                    "tool_call_id": tool_call.id,
+                    "role": "tool",
+                    "name": function_name,
+                    "content": function_response,
+                }
+            )  # extend conversation with function response
+        second_response = client.chat.completions.create(
+            model="gpt-3.5-turbo-0125",
+            messages=messages,
+        )  # get a new response from the model where it can see the function response
+        # print(second_response)
+        return second_response

examples/openai/tool_calling_streaming.py

@@ -0,0 +1,167 @@
+import json
+
+from dotenv import find_dotenv, load_dotenv
+from openai import OpenAI
+
+from langtrace_python_sdk import langtrace
+
+# from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+langtrace.init(write_to_langtrace_cloud=False)
+
+client = OpenAI()
+
+
+# Example dummy function hard coded to return the same weather
+# In production, this could be your backend API or an external API
+def get_current_weather(location, unit="fahrenheit"):
+    """Get the current weather in a given location"""
+    if "tokyo" in location.lower():
+        return json.dumps({"location": "Tokyo", "temperature": "10", "unit": unit})
+    elif "san francisco" in location.lower():
+        return json.dumps({"location": "San Francisco", "temperature": "72", "unit": unit})
+    elif "paris" in location.lower():
+        return json.dumps({"location": "Paris", "temperature": "22", "unit": unit})
+    else:
+        return json.dumps({"location": location, "temperature": "unknown"})
+
+
+def get_current_time(location):
+    """Get the current time in a given location"""
+    if "tokyo" in location.lower():
+        return json.dumps({"location": "Tokyo", "time": "10"})
+    elif "san francisco" in location.lower():
+        return json.dumps({"location": "San Francisco", "time": "72"})
+    elif "paris" in location.lower():
+        return json.dumps({"location": "Paris", "time": "22"})
+    else:
+        return json.dumps({"location": location, "time": "unknown"})
+
+
+def run_conversation():
+    # Step 1: send the conversation and available functions to the model
+    messages = [{"role": "user", "content": "What's the weather like in San Francisco, Tokyo, and Paris?"}]
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_current_weather",
+                "description": "Get the current weather in a given location",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "location": {
+                            "type": "string",
+                            "description": "The city and state, e.g. San Francisco, CA",
+                        },
+                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+                    },
+                    "required": ["location"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "get_current_time",
+                "description": "Get the current time in a given location",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "location": {
+                            "type": "string",
+                            "description": "The city and state, e.g. San Francisco, CA",
+                        },
+                    },
+                    "required": ["location"],
+                },
+            },
+        }
+    ]
+    response = client.chat.completions.create(
+        model="gpt-4",
+        messages=messages,
+        tools=tools,
+        tool_choice="auto",  # auto is default, but we'll be explicit
+        stream=True,
+    )
+
+    # For streaming, uncomment the following lines
+    tool_call_dict = {}
+    tool_calls = []
+    id = ""
+    name = ""
+    arguments = ""
+    for chunk in response:
+        if chunk.choices[0].delta is not None and chunk.choices[0].delta.tool_calls is not None:
+            for choice in chunk.choices:
+                for tool_call in choice.delta.tool_calls:
+                    if tool_call.id and id != tool_call.id:
+                        id = tool_call.id if tool_call.id else ""
+                        name = tool_call.function.name if tool_call.function and tool_call.function.name else ""
+                        tool_call_dict[name] = {
+                            "id": id,
+                            "function": {
+                                "name": name,
+                                "arguments": arguments
+                            },
+                            "type": "function"
+                        }
+                    arguments += tool_call.function.arguments if tool_call.function and tool_call.function.arguments else ""
+                if name != "":
+                    tool_call_dict[name] = {
+                        "id": id,
+                        "function": {
+                            "name": name,
+                            "arguments": arguments
+                        },
+                        "type": "function"
+                    }
+    for key, value in tool_call_dict.items():
+        tool_calls.append(value)
+
+    # Step 2: check if the model wanted to call a function
+    if tool_calls:
+        # Step 3: call the function
+        # Note: the JSON response may not always be valid; be sure to handle errors
+        available_functions = {
+            "get_current_weather": get_current_weather,
+            "get_current_time": get_current_time,
+        }  # only one function in this example, but you can have multiple
+        # messages.append(response_message)  # extend conversation with assistant's reply
+        # Step 4: send the info for each function call and function response to the model
+        for tool_call in tool_calls:
+            function_name = tool_call['function']['name']
+            function_to_call = available_functions[function_name]
+            function_args = json.loads(tool_call['function']['arguments'])
+            function_response = function_to_call(
+                location=function_args.get("location"),
+                unit=function_args.get("unit"),
+            )
+            func_res = json.loads(function_response)
+            content = f"Use the below information to answer the user's question: The current weather in {func_res['location']} is {func_res['temperature']} degrees {func_res['unit']}"
+            messages.append(
+                {
+                    "role": "system",
+                    "content": content
+                }
+            )  # extend conversation with function response
+        print(messages)
+        second_response = client.chat.completions.create(
+            model="gpt-4",
+            messages=messages,
+            stream=True,
+        )  # get a new response from the model where it can see the function response
+        result = []
+        for chunk in second_response:
+            if chunk.choices[0].delta.content is not None:
+                content = [
+                    choice.delta.content if choice.delta and
+                    choice.delta.content else ""
+                    for choice in chunk.choices]
+                result.append(
+                    content[0] if len(content) > 0 else "")
+        print("".join(result))
+        # return second_response

langtrace_python_sdk/instrumentation/openai/patch.py

@@ -75,12 +75,12 @@ def images_generate(original_method, version, tracer):
 
                 span.set_status(StatusCode.OK)
                 return result
-            except Exception as e:
+            except Exception as err:
                 # Record the exception in the span
-                span.record_exception(e)
+                span.record_exception(err)
 
                 # Set the span status to indicate an error
-                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.set_status(Status(StatusCode.ERROR, str(err)))
 
                 # Reraise the exception to ensure it's not swallowed
                 raise
@@ -147,12 +147,12 @@ def async_images_generate(original_method, version, tracer):
 
                 span.set_status(StatusCode.OK)
                 return result
-            except Exception as e:
+            except Exception as err:
                 # Record the exception in the span
-                span.record_exception(e)
+                span.record_exception(err)
 
                 # Set the span status to indicate an error
-                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.set_status(Status(StatusCode.ERROR, str(err)))
 
                 # Reraise the exception to ensure it's not swallowed
                 raise
@@ -181,9 +181,9 @@ def chat_completions_create(original_method, version, tracer):
         # handle tool calls in the kwargs
         llm_prompts = []
         for item in kwargs.get("messages", []):
-            if "tool_calls" in item:
+            if hasattr(item, "tool_calls") and item.tool_calls is not None:
                 tool_calls = []
-                for tool_call 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 "",
@@ -202,8 +202,9 @@ def chat_completions_create(original_method, version, tracer):
                             ),
                         }
                     tool_calls.append(tool_call_dict)
-                item["tool_calls"] = tool_calls
-            llm_prompts.append(item)
+                llm_prompts.append(tool_calls)
+            else:
+                llm_prompts.append(item)
 
         span_attributes = {
             "langtrace.sdk.name": "langtrace-python-sdk",
@@ -213,13 +214,14 @@ def chat_completions_create(original_method, version, tracer):
             "langtrace.version": "1.0.0",
             "url.full": base_url,
             "llm.api": APIS["CHAT_COMPLETION"]["ENDPOINT"],
-            "llm.prompts": json.dumps(kwargs.get("messages", [])),
+            "llm.prompts": json.dumps(llm_prompts),
             "llm.stream": kwargs.get("stream"),
             **(extra_attributes if extra_attributes is not None else {}),
         }
 
         attributes = LLMSpanAttributes(**span_attributes)
 
+        tools = []
         if kwargs.get("temperature") is not None:
             attributes.llm_temperature = kwargs.get("temperature")
         if kwargs.get("top_p") is not None:
@@ -227,7 +229,11 @@ def chat_completions_create(original_method, version, tracer):
         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"))
+            tools.append(json.dumps(kwargs.get("functions")))
+        if kwargs.get("tools") is not None:
+            tools.append(json.dumps(kwargs.get("tools")))
+        if len(tools) > 0:
+            attributes.llm_tools = json.dumps(tools)
 
         # TODO(Karthik): Gotta figure out how to handle streaming with context
         # with tracer.start_as_current_span(APIS["CHAT_COMPLETION"]["METHOD"],
@@ -252,16 +258,7 @@ def chat_completions_create(original_method, version, tracer):
                                     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": extract_content(choice),
                                 **(
                                     {
                                         "content_filter_results": choice[
@@ -319,6 +316,7 @@ def chat_completions_create(original_method, version, tracer):
                     span,
                     prompt_tokens,
                     function_call=kwargs.get("functions") is not None,
+                    tool_calls=kwargs.get("tools") is not None,
                 )
 
         except Exception as error:
@@ -327,7 +325,7 @@ def chat_completions_create(original_method, version, tracer):
             span.end()
             raise
 
-    def handle_streaming_response(result, span, prompt_tokens, function_call=False):
+    def handle_streaming_response(result, span, prompt_tokens, function_call=False, tool_calls=False):
         """Process and yield streaming response chunks."""
         result_content = []
         span.add_event(Event.STREAM_START.value)
@@ -337,37 +335,29 @@ def chat_completions_create(original_method, version, tracer):
                 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
-                    ]
+                    if not function_call and not tool_calls:
+                        for choice in chunk.choices:
+                            if choice.delta and choice.delta.content is not None:
+                                token_counts = estimate_tokens(choice.delta.content)
+                                completion_tokens += token_counts
+                                content = [choice.delta.content]
+                    elif function_call:
+                        for choice in chunk.choices:
+                            if choice.delta and choice.delta.function_call and choice.delta.function_call.arguments is not None:
+                                token_counts = estimate_tokens(choice.delta.function_call.arguments)
+                                completion_tokens += token_counts
+                                content = [
+                                    choice.delta.function_call.arguments
+                                ]
+                    elif tool_calls:
+                        # TODO(Karthik): Tool calls streaming is tricky. The chunks after the
+                        # first one are missing the function name and id though the arguments
+                        # are spread across the chunks.
+                        content = []
                 else:
                     content = []
                 span.add_event(
-                    Event.STREAM_OUTPUT.value, {"response": "".join(content)}
+                    Event.STREAM_OUTPUT.value, {"response": "".join(content) if len(content) > 0 and content[0] is not None else ""}
                 )
                 result_content.append(content[0] if len(content) > 0 else "")
                 yield chunk
@@ -422,6 +412,34 @@ def async_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 hasattr(item, "tool_calls") and item.tool_calls is not None:
+                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)
+                llm_prompts.append(tool_calls)
+            else:
+                llm_prompts.append(item)
+
         span_attributes = {
             "langtrace.sdk.name": "langtrace-python-sdk",
             "langtrace.service.name": service_provider,
@@ -430,13 +448,14 @@ def async_chat_completions_create(original_method, version, tracer):
             "langtrace.version": "1.0.0",
             "url.full": base_url,
             "llm.api": APIS["CHAT_COMPLETION"]["ENDPOINT"],
-            "llm.prompts": json.dumps(kwargs.get("messages", [])),
+            "llm.prompts": json.dumps(llm_prompts),
             "llm.stream": kwargs.get("stream"),
             **(extra_attributes if extra_attributes is not None else {}),
         }
 
         attributes = LLMSpanAttributes(**span_attributes)
 
+        tools = []
         if kwargs.get("temperature") is not None:
             attributes.llm_temperature = kwargs.get("temperature")
         if kwargs.get("top_p") is not None:
@@ -444,7 +463,11 @@ def async_chat_completions_create(original_method, version, tracer):
         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"))
+            tools.append(json.dumps(kwargs.get("functions")))
+        if kwargs.get("tools") is not None:
+            tools.append(json.dumps(kwargs.get("tools")))
+        if len(tools) > 0:
+            attributes.llm_tools = json.dumps(tools)
 
         # TODO(Karthik): Gotta figure out how to handle streaming with context
         # with tracer.start_as_current_span(APIS["CHAT_COMPLETION"]["METHOD"],
@@ -469,16 +492,7 @@ def async_chat_completions_create(original_method, version, tracer):
                                     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": extract_content(choice),
                                 **(
                                     {
                                         "content_filter_results": choice[
@@ -536,6 +550,7 @@ def async_chat_completions_create(original_method, version, tracer):
                     span,
                     prompt_tokens,
                     function_call=kwargs.get("functions") is not None,
+                    tool_calls=kwargs.get("tools") is not None,
                 )
 
         except Exception as error:
@@ -544,9 +559,7 @@ def async_chat_completions_create(original_method, version, tracer):
             span.end()
             raise
 
-    async def ahandle_streaming_response(
-        result, span, prompt_tokens, function_call=False
-    ):
+    async def ahandle_streaming_response(result, span, prompt_tokens, function_call=False, tool_calls=False):
         """Process and yield streaming response chunks."""
         result_content = []
         span.add_event(Event.STREAM_START.value)
@@ -556,37 +569,29 @@ def async_chat_completions_create(original_method, version, tracer):
                 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
-                    ]
+                    if not function_call and not tool_calls:
+                        for choice in chunk.choices:
+                            if choice.delta and choice.delta.content is not None:
+                                token_counts = estimate_tokens(choice.delta.content)
+                                completion_tokens += token_counts
+                                content = [choice.delta.content]
+                    elif function_call:
+                        for choice in chunk.choices:
+                            if choice.delta and choice.delta.function_call and choice.delta.function_call.arguments is not None:
+                                token_counts = estimate_tokens(choice.delta.function_call.arguments)
+                                completion_tokens += token_counts
+                                content = [
+                                    choice.delta.function_call.arguments
+                                ]
+                    elif tool_calls:
+                        # TODO(Karthik): Tool calls streaming is tricky. The chunks after the
+                        # first one are missing the function name and id though the arguments
+                        # are spread across the chunks.
+                        content = []
                 else:
                     content = []
                 span.add_event(
-                    Event.STREAM_OUTPUT.value, {"response": "".join(content)}
+                    Event.STREAM_OUTPUT.value, {"response": "".join(content) if len(content) > 0 and content[0] is not None else ""}
                 )
                 result_content.append(content[0] if len(content) > 0 else "")
                 yield chunk
@@ -673,12 +678,12 @@ def embeddings_create(original_method, version, tracer):
                 result = wrapped(*args, **kwargs)
                 span.set_status(StatusCode.OK)
                 return result
-            except Exception as e:
+            except Exception as err:
                 # Record the exception in the span
-                span.record_exception(e)
+                span.record_exception(err)
 
                 # Set the span status to indicate an error
-                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.set_status(Status(StatusCode.ERROR, str(err)))
 
                 # Reraise the exception to ensure it's not swallowed
                 raise
@@ -736,14 +741,45 @@ def async_embeddings_create(original_method, version, tracer):
                 result = await wrapped(*args, **kwargs)
                 span.set_status(StatusCode.OK)
                 return result
-            except Exception as e:
+            except Exception as err:
                 # Record the exception in the span
-                span.record_exception(e)
+                span.record_exception(err)
 
                 # Set the span status to indicate an error
-                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.set_status(Status(StatusCode.ERROR, str(err)))
 
                 # Reraise the exception to ensure it's not swallowed
                 raise
 
     return traced_method
+
+
+def extract_content(choice):
+    # Check if choice.message exists and has a content attribute
+    if hasattr(choice, 'message') and hasattr(choice.message, 'content') and choice.message.content is not None:
+        return choice.message.content
+
+    # Check if choice.message has tool_calls and extract information accordingly
+    elif hasattr(choice, 'message') and hasattr(choice.message, 'tool_calls') and choice.message.tool_calls is not None:
+        result = [
+            {
+                "id": tool_call.id,
+                "type": tool_call.type,
+                "function": {
+                    "name": tool_call.function.name,
+                    "arguments": tool_call.function.arguments,
+                }
+            } for tool_call in choice.message.tool_calls
+        ]
+        return result
+
+    # Check if choice.message has a function_call and extract information accordingly
+    elif hasattr(choice, 'message') and hasattr(choice.message, 'function_call') and choice.message.function_call is not None:
+        return {
+            "name": choice.message.function_call.name,
+            "arguments": choice.message.function_call.arguments,
+        }
+
+    # Return an empty string if none of the above conditions are met
+    else:
+        return ""

langtrace_python_sdk/version.py

@@ -1 +1 @@
-__version__ = "1.3.3"
+__version__ = "1.3.5"

{langtrace_python_sdk-1.3.3.dist-info → langtrace_python_sdk-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 1.3.3
+Version: 1.3.5
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>
@@ -15,7 +15,7 @@ Requires-Dist: opentelemetry-instrumentation
 Requires-Dist: opentelemetry-sdk
 Requires-Dist: pinecone-client
 Requires-Dist: tiktoken
-Requires-Dist: trace-attributes
+Requires-Dist: trace-attributes==1.0.32
 Provides-Extra: dev
 Requires-Dist: anthropic; extra == 'dev'
 Requires-Dist: chromadb; extra == 'dev'

{langtrace_python_sdk-1.3.3.dist-info → langtrace_python_sdk-1.3.5.dist-info}/RECORD

@@ -17,16 +17,20 @@ examples/llamaindex_example/agent.py,sha256=_iIXy9lfDz6ySf6aTeeRqejlfGnXZ7msxLBj
 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=1AiLIr0sWBKcqzhCbTJkspZyuGDZATxhbKBCKjzvM-E,1731
+examples/openai/async_tool_calling_nonstreaming.py,sha256=foomPKwpju0PMazdE3xNrdZWguUYMnNXibqq01-uBvc,3806
+examples/openai/async_tool_calling_streaming.py,sha256=TayOsb0jcYYlFpnWWUYxwCVKuJhTfGfE8LkjYJNGSz4,6900
+examples/openai/chat_completion.py,sha256=B7djvaprhEhegKqQxAh95yhALIYVtanWid_w75uredg,1754
 examples/openai/embeddings_create.py,sha256=AhDNAqg-WzRYLJAE_b2RKGjuVCh4aZSU7MxcZv2kCHQ,518
-examples/openai/function_calling.py,sha256=qsbmlkWnOvdemekMqsB0roBhpn_GsNBWrR2td0vVEIs,2335
+examples/openai/function_calling.py,sha256=6Nm1ZjP4iKx1Za7ch3zIciQ5zcXWBb2-mpYfIhPs8oo,2320
 examples/openai/images_generate.py,sha256=ZioxTuHKE_yYlhpESqXKVzdkiwdegkmLVB7N8T2LU00,506
+examples/openai/tool_calling_nonstreaming.py,sha256=MxjUGD6Q2zg522E6kymGvXOikoL3qMoZf6pLQgws8zw,3776
+examples/openai/tool_calling_streaming.py,sha256=WnWWlgDqKuqN2DtWbpJs_JvmmQehBZp0Ke3ZXvCJdQw,6860
 examples/perplexity_example/basic.py,sha256=oTLwEYlvpD4wEnqEUrUSlQ0SeQ0u50Jeab4ggkikQg0,671
 examples/pinecone_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=83-AkdASO7UF9FHR9BDZUSeYv9GFZkJJQD2YLKbqzo8,3562
-langtrace_python_sdk/version.py,sha256=Vi6om3KImlKsS_Wg5CjUgYffoi2zx7T-SRPnnGL0G7M,22
+langtrace_python_sdk/version.py,sha256=tdqvkGH0OryRjjXzO3HS5DyYol-VTO9fC8m43nB2PgI,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
@@ -62,14 +66,14 @@ langtrace_python_sdk/instrumentation/llamaindex/instrumentation.py,sha256=D7_HPv
 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=Pv4n4z_kSxvZGVxrj3AopBoWQSxIOtMKolkxHrchRdM,2162
-langtrace_python_sdk/instrumentation/openai/patch.py,sha256=6hZ8ExTHHUnib8sU5k5OXt9zFKl3iTL2-PzsHJxW5ao,31587
+langtrace_python_sdk/instrumentation/openai/patch.py,sha256=ZxR6hLXbf05rw7tccNsEQv-uB8Zb8QvOzTJk1coJbkY,33819
 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.3.dist-info/METADATA,sha256=SQOqeK4DcO0lKolsayInA_t-pr3Stk26sH742xYFDT0,9086
-langtrace_python_sdk-1.3.3.dist-info/WHEEL,sha256=K0BPUNF1N3kQ9olb8aVEtkObePEjdr2JOLT1N83EVws,87
-langtrace_python_sdk-1.3.3.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-langtrace_python_sdk-1.3.3.dist-info/RECORD,,
+langtrace_python_sdk-1.3.5.dist-info/METADATA,sha256=yUAeoRPdsjv_i4VUE0lwzH10O1uNWt9-S-qj8yMhRAI,9094
+langtrace_python_sdk-1.3.5.dist-info/WHEEL,sha256=osohxoshIHTFJFVPhsi1UkZuLRGMHRXZzwEBW2ezjrc,87
+langtrace_python_sdk-1.3.5.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+langtrace_python_sdk-1.3.5.dist-info/RECORD,,

{langtrace_python_sdk-1.3.3.dist-info → langtrace_python_sdk-1.3.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.24.0
+Generator: hatchling 1.24.1
 Root-Is-Purelib: true
 Tag: py3-none-any