monocle-apptrace 0.5.0b1__py3-none-any.whl → 0.5.1__py3-none-any.whl

monocle_apptrace/instrumentation/metamodel/llamaindex/llamaindex_processor.py

@@ -1,4 +1,5 @@
 from opentelemetry.context import attach, detach, get_current, get_value, set_value, Context
+from monocle_apptrace.instrumentation.common.constants import AGENT_PREFIX_KEY
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.metamodel.llamaindex._helper import (
     is_delegation_tool, LLAMAINDEX_AGENT_NAME_KEY, get_agent_name
@@ -21,14 +22,15 @@ class DelegationHandler(SpanHandler):
 
         return super().hydrate_span(agent_request_wrapper, wrapped, instance, args, kwargs, result, span, parent_span, ex)
 
-
 # There are two different APIs for tool calling FunctionTool.call() and AgentWorkflow.tool_call(). In case of single agent calling tool, only the FunctionTool.call() is used. In case of multi agent case,
 # the AgentWorkflow.tool_call() is used which inturn calls FunctionTool.call(). We can't entirely rely on the FunctionTool.call() to extract tool span details, especially the agent delegation details are not available there.
 # Hence we want to distinguish between single agent tool call and multi agent tool call. In case of multi agent tool call, we suppress the FunctionTool.call() span and use AgentWorkflow.tool_call() span to capture the tool call details.
 class LlamaIndexToolHandler(DelegationHandler):
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
-        return attach(set_value(TOOL_INVOCATION_STARTED, True))
-    
+        cur_context = get_current()
+        cur_context = set_value(TOOL_INVOCATION_STARTED, True, cur_context)
+        return attach(cur_context)
+
     def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token=None):
         if token:
             detach(token)
@@ -40,6 +42,15 @@ class LlamaIndexSingleAgenttToolHandlerWrapper(DelegationHandler):
         return super().skip_span(to_wrap, wrapped, instance, args, kwargs)
 
 class LlamaIndexAgentHandler(SpanHandler):
+    def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
+        cur_context = get_current()
+        cur_context = set_value(AGENT_PREFIX_KEY, "handoff", cur_context)
+        return attach(cur_context)
+
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token=None):
+        if token:
+            detach(token)
+    
     # LlamaIndex uses direct OpenAI call for agent inferences. Given that the workflow type is set to llamaindex, the openAI inference does not record the input/output events.
     # To avoid this, we set the workflow type to generic for agent inference spans so we can capture the prompts and responses.
     def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span, parent_span = None, ex:Exception = None) -> bool:

monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py

@@ -83,7 +83,7 @@ LLAMAINDEX_METHODS = [
         "object": "AgentWorkflow",
         "method": "run",
         "span_handler": "llamaindex_agent_handler",
-        "wrapper_method": atask_wrapper,
+        "wrapper_method": task_wrapper,
         "output_processor": AGENT_REQUEST
     },
     {

monocle_apptrace/instrumentation/metamodel/mcp/_helper.py

@@ -37,7 +37,8 @@ def get_output_text(arguments):
 
 def get_name(arguments):
     """Get the name of the tool from the instance."""
-
+    if 'parent_span' in arguments:
+        arguments['parent_span'].set_attribute("is_mcp", True)
     args = arguments["args"]
     if (
         args

monocle_apptrace/instrumentation/metamodel/mcp/entities/inference.py

@@ -1,7 +1,9 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_SUBTYPES, SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.mcp import _helper
 
 TOOLS = {
-    "type": "agentic.mcp.invocation",
+    "type": SPAN_TYPES.AGENTIC_MCP_INVOCATION,
+    "subtype": SPAN_SUBTYPES.ROUTING,
     "attributes": [
         [
             {

monocle_apptrace/instrumentation/metamodel/mcp/mcp_processor.py

@@ -1,11 +1,6 @@
-from opentelemetry.context import set_value, attach, detach
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.metamodel.mcp._helper import (
    get_name
-
-)
-from monocle_apptrace.instrumentation.metamodel.langgraph.entities.inference import (
-    AGENT_DELEGATION, AGENT_REQUEST
 )
 
 class MCPAgentHandler(SpanHandler):

monocle_apptrace/instrumentation/metamodel/mcp/methods.py

@@ -17,5 +17,5 @@ MCP_METHODS = [
         "object": "",
         "method": "convert_mcp_tool_to_langchain_tool",
         "wrapper_method": _helper.langchain_mcp_wrapper,
-    },
+    }
 ]

monocle_apptrace/instrumentation/metamodel/openai/_helper.py

@@ -3,7 +3,9 @@ This module provides utility functions for extracting system, user,
 and assistant messages from various input formats.
 """
 
+import json
 import logging
+from opentelemetry.context import get_value
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
     get_json_dumps,
@@ -17,7 +19,7 @@ from monocle_apptrace.instrumentation.metamodel.finish_types import (
     map_openai_finish_reason_to_finish_type,
     OPENAI_FINISH_REASON_MAPPING
 )
-from monocle_apptrace.instrumentation.common.constants import CHILD_ERROR_CODE
+from monocle_apptrace.instrumentation.common.constants import AGENT_PREFIX_KEY, CHILD_ERROR_CODE, INFERENCE_AGENT_DELEGATION, INFERENCE_TURN_END, INFERENCE_TOOL_CALL
 
 logger = logging.getLogger(__name__)
 
@@ -28,7 +30,7 @@ def extract_messages(kwargs):
         if 'instructions' in kwargs:
             messages.append({'system': kwargs.get('instructions', {})})
         if 'input' in kwargs:
-            if isinstance(kwargs['input'], str): 
+            if isinstance(kwargs['input'], str):
                 messages.append({'user': kwargs.get('input', "")})
             # [
             #     {
@@ -41,13 +43,81 @@ def extract_messages(kwargs):
             #     }
             # ]
             if isinstance(kwargs['input'], list):
+                # kwargs['input']
+                # [
+                #     {
+                #         "content": "I need to book a flight from NYC to LAX and also book the Hilton hotel in Los Angeles. Also check the weather in Los Angeles.",
+                #         "role": "user"
+                #     },
+                #     {
+                #         "arguments": "{}",
+                #         "call_id": "call_dSljcToR2LWwqWibPt0qjeHD",
+                #         "name": "transfer_to_flight_agent",
+                #         "type": "function_call",
+                #         "id": "fc_689c30f96f708191aabb0ffd8098cdbd016ef325124ac05f",
+                #         "status": "completed"
+                #     },
+                #     {
+                #         "arguments": "{}",
+                #         "call_id": "call_z0MTZroziWDUd0fxVemGM5Pg",
+                #         "name": "transfer_to_hotel_agent",
+                #         "type": "function_call",
+                #         "id": "fc_689c30f99b808191a8743ff407fa8ee2016ef325124ac05f",
+                #         "status": "completed"
+                #     },
+                #     {
+                #         "arguments": "{\"city\":\"Los Angeles\"}",
+                #         "call_id": "call_rrdRSPv5vcB4pgl6P4W8U2bX",
+                #         "name": "get_weather_tool",
+                #         "type": "function_call",
+                #         "id": "fc_689c30f9b824819196d4ad9379d570f7016ef325124ac05f",
+                #         "status": "completed"
+                #     },
+                #     {
+                #         "call_id": "call_rrdRSPv5vcB4pgl6P4W8U2bX",
+                #         "output": "The weather in Los Angeles is sunny and 75.",
+                #         "type": "function_call_output"
+                #     },
+                #     {
+                #         "call_id": "call_z0MTZroziWDUd0fxVemGM5Pg",
+                #         "output": "Multiple handoffs detected, ignoring this one.",
+                #         "type": "function_call_output"
+                #     },
+                #     {
+                #         "call_id": "call_dSljcToR2LWwqWibPt0qjeHD",
+                #         "output": "{\"assistant\": \"Flight Agent\"}",
+                #         "type": "function_call_output"
+                #     }
+                # ]
                 for item in kwargs['input']:
                     if isinstance(item, dict) and 'role' in item and 'content' in item:
                         messages.append({item['role']: item['content']})
+                    elif isinstance(item, dict) and 'type' in item and item['type'] == 'function_call':
+                        messages.append({
+                            "tool_function": item.get("name", ""),
+                            "tool_arguments": item.get("arguments", ""),
+                            "call_id": item.get("call_id", "")
+                        })
+                    elif isinstance(item, dict) and 'type' in item and item['type'] == 'function_call_output':
+                        messages.append({
+                            "call_id": item.get("call_id", ""),
+                            "output": item.get("output", "")
+                        })
         if 'messages' in kwargs and len(kwargs['messages']) >0:
             for msg in kwargs['messages']:
                 if msg.get('content') and msg.get('role'):
                     messages.append({msg['role']: msg['content']})
+                elif msg.get('tool_calls') and msg.get('role'):
+                    try:
+                        tool_call_messages = []
+                        for tool_call in msg['tool_calls']:
+                            tool_call_messages.append(get_json_dumps({
+                                "tool_function": tool_call.function.name,
+                                "tool_arguments": tool_call.function.arguments,
+                            }))
+                        messages.append({msg['role']: tool_call_messages})
+                    except Exception as e:
+                        logger.warning("Warning: Error occurred while processing tool calls: %s", str(e))
 
         return [get_json_dumps(message) for message in messages]
     except Exception as e:
@@ -61,6 +131,29 @@ def extract_assistant_message(arguments):
         status = get_status_code(arguments)
         if status == 'success' or status == 'completed':
             response = arguments["result"]
+            if hasattr(response, "tools") and isinstance(response.tools, list) and len(response.tools) > 0 and isinstance(response.tools[0], dict):
+                tools = []
+                for tool in response.tools:
+                    tools.append({
+                        "tool_id": tool.get("id", ""),
+                        "tool_name": tool.get("name", ""),
+                        "tool_arguments": tool.get("arguments", "")
+                    })
+                messages.append({"tools": tools})
+            if hasattr(response, "output") and isinstance(response.output, list) and len(response.output) > 0:
+                response_messages = []
+                role = "assistant"
+                for response_message in response.output:
+                    if(response_message.type == "function_call"):
+                        role = "tools"
+                        response_messages.append({
+                            "tool_id": response_message.call_id,
+                            "tool_name": response_message.name,
+                            "tool_arguments": response_message.arguments
+                        })
+                if len(response_messages) > 0:
+                    messages.append({role: response_messages})
+                    
             if hasattr(response, "output_text") and len(response.output_text):
                 role = response.role if hasattr(response, "role") else "assistant"
                 messages.append({role: response.output_text})
@@ -82,7 +175,7 @@ def extract_assistant_message(arguments):
                 return get_exception_message(arguments)
             elif hasattr(arguments["result"], "error"):
                 return arguments["result"].error
-        
+
     except (IndexError, AttributeError) as e:
         logger.warning(
             "Warning: Error occurred in extract_assistant_message: %s", str(e)
@@ -194,11 +287,11 @@ def extract_finish_reason(arguments):
             if hasattr(arguments["exception"], "code") and arguments["exception"].code in OPENAI_FINISH_REASON_MAPPING.keys():
                 return arguments["exception"].code
         response = arguments["result"]
-        
+
         # Handle streaming responses
         if hasattr(response, "finish_reason") and response.finish_reason:
             return response.finish_reason
-            
+
         # Handle non-streaming responses
         if response is not None and hasattr(response, "choices") and len(response.choices) > 0:
             if hasattr(response.choices[0], "finish_reason"):
@@ -211,3 +304,15 @@ def extract_finish_reason(arguments):
 def map_finish_reason_to_finish_type(finish_reason):
     """Map OpenAI finish_reason to finish_type based on the possible errors mapping"""
     return map_openai_finish_reason_to_finish_type(finish_reason)
+
+def agent_inference_type(arguments):
+    """Extract agent inference type from OpenAI response"""
+    message = json.loads(extract_assistant_message(arguments))
+    # message["tools"][0]["tool_name"]
+    if message and message.get("tools") and isinstance(message["tools"], list) and len(message["tools"]) > 0:
+        agent_prefix = get_value(AGENT_PREFIX_KEY)
+        tool_name = message["tools"][0].get("tool_name", "")
+        if tool_name and agent_prefix and tool_name.startswith(agent_prefix):
+            return INFERENCE_AGENT_DELEGATION
+        return INFERENCE_TOOL_CALL
+    return INFERENCE_TURN_END

monocle_apptrace/instrumentation/metamodel/openai/entities/inference.py

@@ -2,13 +2,14 @@ import logging
 import random
 import time
 from types import SimpleNamespace
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.openai import (
     _helper,
 )
 from monocle_apptrace.instrumentation.common.utils import (
     get_error_message,
     patch_instance_method,
-    resolve_from_alias
+    resolve_from_alias,
 )
 
 logger = logging.getLogger(__name__)
@@ -17,7 +18,11 @@ logger = logging.getLogger(__name__)
 def _process_stream_item(item, state):
     """Process a single stream item and update state."""
     try:
-        if hasattr(item, "type") and isinstance(item.type, str) and item.type.startswith("response."):
+        if (
+            hasattr(item, "type")
+            and isinstance(item.type, str)
+            and item.type.startswith("response.")
+        ):
             if state["waiting_for_first_token"]:
                 state["waiting_for_first_token"] = False
                 state["first_token_time"] = time.time_ns()
@@ -40,7 +45,11 @@ def _process_stream_item(item, state):
                 state["first_token_time"] = time.time_ns()
 
             state["accumulated_response"] += item.choices[0].delta.content
-        elif hasattr(item, "object") and item.object == "chat.completion.chunk" and item.usage:
+        elif (
+            hasattr(item, "object")
+            and item.object == "chat.completion.chunk"
+            and item.usage
+        ):
             # Handle the case where the response is a chunk
             state["token_usage"] = item.usage
             state["stream_closed_time"] = time.time_ns()
@@ -49,7 +58,7 @@ def _process_stream_item(item, state):
                 hasattr(item, "choices")
                 and item.choices
                 and len(item.choices) > 0
-                and hasattr(item.choices[0], 'finish_reason')
+                and hasattr(item.choices[0], "finish_reason")
                 and item.choices[0].finish_reason
             ):
                 finish_reason = item.choices[0].finish_reason
@@ -65,6 +74,37 @@ def _process_stream_item(item, state):
 
 
 def _create_span_result(state, stream_start_time):
+    # extract tool calls from the accumulated_temp_list
+    # this can only be done when all the streaming is complete.
+    for item in state["accumulated_temp_list"]:
+        try:
+            if (
+                item.choices
+                and isinstance(item.choices, list)
+                and hasattr(item.choices[0], "delta")
+                and hasattr(item.choices[0].delta, "tool_calls")
+                and item.choices[0].delta.tool_calls
+                and item.choices[0].delta.tool_calls[0].id
+                and item.choices[0].delta.tool_calls[0].function
+            ):
+                state["tools"] = state.get("tools", [])
+                state["tools"].append(
+                    {
+                        "id": item.choices[0].delta.tool_calls[0].id,
+                        "name": item.choices[0].delta.tool_calls[0].function.name,
+                        "arguments": item.choices[0]
+                        .delta.tool_calls[0]
+                        .function.arguments,
+                    }
+                )
+            if (item.choices and item.choices[0].finish_reason):
+                state["finish_reason"] = item.choices[0].finish_reason
+        except Exception as e:
+            logger.warning(
+                "Warning: Error occurred while processing tool calls: %s",
+                str(e),
+            )
+
     """Create the span result object."""
     return SimpleNamespace(
         type="stream",
@@ -75,14 +115,15 @@ def _create_span_result(state, stream_start_time):
             "metadata": int(state["stream_closed_time"] or time.time_ns()),
         },
         output_text=state["accumulated_response"],
+        tools=state["tools"] if "tools" in state else None,
         usage=state["token_usage"],
-        finish_reason=state["finish_reason"]
+        finish_reason=state["finish_reason"],
     )
 
 
 def process_stream(to_wrap, response, span_processor):
     stream_start_time = time.time_ns()
-    
+
     # Shared state for both sync and async processing
     state = {
         "waiting_for_first_token": True,
@@ -108,7 +149,7 @@ def process_stream(to_wrap, response, span_processor):
                 span_processor(ret_val)
 
         patch_instance_method(response, "__iter__", new_iter)
-        
+
     if to_wrap and hasattr(response, "__aiter__"):
         original_iter = response.__aiter__
 
@@ -125,7 +166,7 @@ def process_stream(to_wrap, response, span_processor):
 
 
 INFERENCE = {
-    "type": "inference",
+    "type": SPAN_TYPES.INFERENCE,
     "is_auto_close": lambda kwargs: kwargs.get("stream", False) is False,
     "response_processor": process_stream,
     "attributes": [
@@ -200,10 +241,9 @@ INFERENCE = {
         {
             "name": "data.output",
             "attributes": [
-
                 {
                     "attribute": "error_code",
-                    "accessor": lambda arguments: get_error_message(arguments)
+                    "accessor": lambda arguments: get_error_message(arguments),
                 },
                 {
                     "_comment": "this is result from LLM",
@@ -211,7 +251,7 @@ INFERENCE = {
                     "accessor": lambda arguments: _helper.extract_assistant_message(
                         arguments,
                     ),
-                }
+                },
             ],
         },
         {
@@ -226,14 +266,20 @@ INFERENCE = {
                 {
                     "_comment": "finish reason from OpenAI response",
                     "attribute": "finish_reason",
-                    "accessor": lambda arguments: _helper.extract_finish_reason(arguments)
+                    "accessor": lambda arguments: _helper.extract_finish_reason(
+                        arguments
+                    ),
                 },
                 {
                     "_comment": "finish type mapped from finish reason",
                     "attribute": "finish_type",
                     "accessor": lambda arguments: _helper.map_finish_reason_to_finish_type(
                         _helper.extract_finish_reason(arguments)
-                    )
+                    ),
+                },
+                {
+                    "attribute": "inference_sub_type",
+                    "accessor": lambda arguments: _helper.agent_inference_type(arguments)
                 }
             ],
         },

monocle_apptrace/instrumentation/metamodel/requests/entities/http.py

@@ -1,6 +1,7 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.requests import _helper
 REQUEST_HTTP_PROCESSOR = {
-    "type": "http.send",
+    "type": SPAN_TYPES.HTTP_SEND,
     "attributes": [
         [
             {

monocle_apptrace/instrumentation/metamodel/teamsai/_helper.py

@@ -1,3 +1,4 @@
+import json
 import logging
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
@@ -170,4 +171,14 @@ def extract_inference_endpoint(instance):
     if inference_endpoint.is_none() and "meta" in instance.client.__dict__:
         inference_endpoint = try_option(getattr, instance.client.meta, 'endpoint_url').map(str)
 
-    return inference_endpoint.unwrap_or(extract_provider_name(instance))
+    return inference_endpoint.unwrap_or(extract_provider_name(instance))
+
+def agent_inference_type(arguments):
+    """
+    Extracts the agent inference type from the arguments.
+    """
+    output = extract_assistant_message(arguments)
+    command = json.loads(json.loads(output).get("assistant", "")).get("action", "").get("name")
+    if command == "SAY":
+        return "turn"
+    return "tool_call"

monocle_apptrace/instrumentation/metamodel/teamsai/entities/inference/teamsai_output_processor.py

@@ -1,9 +1,10 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.teamsai import (
     _helper,
 )
 from monocle_apptrace.instrumentation.common.utils import get_error_message, get_llm_type
 TEAMAI_OUTPUT_PROCESSOR = {
-    "type": "inference.framework",
+    "type": SPAN_TYPES.INFERENCE_FRAMEWORK,
     "attributes": [
         [
             {
@@ -66,5 +67,15 @@ TEAMAI_OUTPUT_PROCESSOR = {
                 }
             ]
         },
+        {
+            "name": "metadata",
+            "_comment": "metadata for Teams AI",
+            "attributes": [
+                {
+                    "attribute": "inference_sub_type",
+                    "accessor": lambda arguments: _helper.agent_inference_type(arguments)
+                }
+            ]
+        }
     ]
 }

{monocle_apptrace-0.5.0b1.dist-info → monocle_apptrace-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.5.0b1
+Version: 0.5.1
 Summary: package with monocle genAI tracing
 Project-URL: Homepage, https://github.com/monocle2ai/monocle
 Project-URL: Issues, https://github.com/monocle2ai/monocle/issues
@@ -25,12 +25,14 @@ Requires-Dist: anthropic-haystack; extra == 'dev'
 Requires-Dist: anthropic==0.57.1; extra == 'dev'
 Requires-Dist: azure-storage-blob==12.22.0; extra == 'dev'
 Requires-Dist: boto3==1.37.24; extra == 'dev'
-Requires-Dist: chromadb==1.0.10; extra == 'dev'
+Requires-Dist: chromadb==1.0.15; extra == 'dev'
 Requires-Dist: click==8.2.1; extra == 'dev'
 Requires-Dist: datasets==2.20.0; extra == 'dev'
 Requires-Dist: faiss-cpu==1.8.0; extra == 'dev'
-Requires-Dist: fastapi>=0.115.1; extra == 'dev'
+Requires-Dist: fastapi>=0.115.0; extra == 'dev'
 Requires-Dist: flask; extra == 'dev'
+Requires-Dist: google-adk==1.10.0; extra == 'dev'
+Requires-Dist: google-generativeai==0.8.5; extra == 'dev'
 Requires-Dist: haystack-ai==2.3.0; extra == 'dev'
 Requires-Dist: httpx==0.28.1; extra == 'dev'
 Requires-Dist: instructorembedding==1.0.1; extra == 'dev'
@@ -46,16 +48,19 @@ Requires-Dist: langchain==0.3.25; extra == 'dev'
 Requires-Dist: langchainhub==0.1.21; extra == 'dev'
 Requires-Dist: langgraph-supervisor==0.0.28; extra == 'dev'
 Requires-Dist: langgraph==0.5.4; extra == 'dev'
-Requires-Dist: llama-index-embeddings-huggingface==0.5.4; extra == 'dev'
-Requires-Dist: llama-index-llms-anthropic==0.6.19; extra == 'dev'
-Requires-Dist: llama-index-llms-azure-openai==0.3.2; extra == 'dev'
-Requires-Dist: llama-index-llms-mistralai==0.4.0; extra == 'dev'
-Requires-Dist: llama-index-vector-stores-chroma==0.4.1; extra == 'dev'
-Requires-Dist: llama-index-vector-stores-opensearch==0.5.4; extra == 'dev'
-Requires-Dist: llama-index==0.12.37; extra == 'dev'
+Requires-Dist: llama-index-embeddings-huggingface==0.6.0; extra == 'dev'
+Requires-Dist: llama-index-llms-anthropic==0.8.1; extra == 'dev'
+Requires-Dist: llama-index-llms-azure-openai==0.4.0; extra == 'dev'
+Requires-Dist: llama-index-llms-mistralai==0.7.0; extra == 'dev'
+Requires-Dist: llama-index-llms-openai==0.5.0; extra == 'dev'
+Requires-Dist: llama-index-tools-mcp==0.3.0; extra == 'dev'
+Requires-Dist: llama-index-vector-stores-chroma==0.5.0; extra == 'dev'
+Requires-Dist: llama-index-vector-stores-opensearch==0.6.0; extra == 'dev'
+Requires-Dist: llama-index==0.13.0; extra == 'dev'
 Requires-Dist: mcp==1.12.1; extra == 'dev'
 Requires-Dist: mistral-haystack==0.0.2; extra == 'dev'
 Requires-Dist: numpy==1.26.4; extra == 'dev'
+Requires-Dist: openai-agents==0.2.6; extra == 'dev'
 Requires-Dist: opendal==0.45.14; extra == 'dev'
 Requires-Dist: opensearch-haystack==1.2.0; extra == 'dev'
 Requires-Dist: opentelemetry-instrumentation-flask; extra == 'dev'