monocle-apptrace 0.5.0b1__py3-none-any.whl → 0.5.1b1__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/mcp_server.py

@@ -0,0 +1,94 @@
+import logging
+import click
+from mcp.server.fastmcp import FastMCP
+
+logger = logging.getLogger(__name__)
+
+app = FastMCP(
+    "monocle-mcp",
+)
+code_snippets = {
+    "python": "from monocle_apptrace import setup_monocle_telemetry"
+    "setup_monocle_telemetry(workflow_name='my_workflow')\n",
+    "typescript": "import { trace } from 'monocle';\n\ntrace();\n",
+}
+setup_instructions = {
+    "python": "pip install monocle_apptrace package and add monocle_apptrace at the end of the requirement.txt for future. This code snippet provided below should be just below other imports in your application code.",
+    "typescript": "Install monocle package and add the trace function call at the top of your application. This code snippet provided below should be just below other imports in your application code.",
+}
+
+description = {
+    "python": "This will automatically trace your Python application, capturing telemetry data for your genAI operations.",
+    "typescript": "This will automatically trace your TypeScript application, capturing telemetry data for your genAI operations.",
+}
+
+
+# Use the existing dictionaries to get language-specific information
+# code_snippet = code_snippets.get(app_language, code_snippets['python'])
+# instructions = setup_instructions.get(app_language, setup_instructions['python'])
+# desc = description.get(app_language, description['python'])
+enable_monocle_prompt = """Do following changes to the project:
+1. run command 'pip install monocle_apptrace'
+2. Add following line to  requirements.txt in current directory 'monocle_apptrace' if it's not there already
+3. Add following lines just below other imports in the file if it's not there already:
+from monocle_apptrace import setup_monocle_telemetry
+setup_monocle_telemetry(workflow_name=<module-name>, monocle_exporters_list='file'))
+"""
+
+monocle_trace_prompt: str = """
+You are a helpful assistant to analyze given Monocle trace data. Review the trace data and provide a summary of whether the execution was successful or if there were any errors. Your job is to analyze the trace data and provide a summary. Be very concise in reporting. Check for errors or problem situations. First provide a headline that indicates status of the trace and if there are problems. If there are problems, then provide a brief summary of the problems. If there are problems, then provide a brief summary of the root causes.
+Use the trace details provided below to understand the data.
+ 
+Monocle trace has recorded the traced the execution of a genAI application. Each step of the genAI operation is captured as span. The trace file is a JSON structure that is an array of span JSON elements. There's a root span that represents the overall execution context.
+The important span JSON elements are as follows:
+- context.trace_id is the unique id common for alls spans.
+- context.span_id is the unique id for each span.
+- parent_id indicates the parent span of that span. The span that has no parent is the root span.
+- status.status_code indicate the status of span. It can be OK or ERROR or UNSET. If the span status is ERROR, then it generally propogated to it's parent and all the way to the root span. This means the entire trace is in error. However, sometimes the parent span will handle the error (eg. if parent name indicagtes 'retry') and the trace will be successful, even though an individual span has error.
+- attributes captures various attributes involved in that span's operation
+    - attribute."span.type" indicates the type of operation
+        - When the span.type is "workflow", that span captures the summary of the entire application
+    - entity.[NUMBER] are the different entties involved in the operation, for example large language model, agent, tool etc
+    - entity.type indicates the type of that entity
+- events is an array that captures the details of the operation such as input, output and metadata
+    - events array element with name=data.input captures the input provided to the operation
+    - events array element with name=data.output captures the output generated by the operation
+    - events array element with name=metaata captures the metadata of the operation
+        - total_tokens is the count of tokens
+        - completion_tokens is the count of ouput tokens
+        - prompt_tokens is the count of input tokens
+        - finish_type indicates how the operation finished, for example stop sequence or max tokens etc. If the finish_type is not success and indicates problems such as max tokens, then the operation is not successful. Check the status of it's parent span and check if it's due to the finish type of this child span. In that case callout the root cause as the child span error for the parent span error.
+"""
+
+@app.prompt(name="enable_tracing")
+def enable_monocle_tracing_prompt(app_language: str = "python") -> str:
+    """Trace agentic code"""
+    return enable_monocle_prompt.format(app_language=app_language)
+
+
+@app.prompt(name="analyze")
+def analyze_monocle_tracing_prompt() -> str:
+    """Identify root cause from trace"""
+    return monocle_trace_prompt
+
+
+@click.command()
+@click.option(
+    "--log-level",
+    default="info",
+    help="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+)
+def main(log_level: str) -> int:
+    # Configure logging
+    logging.basicConfig(
+        level=getattr(logging, log_level.upper()),
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+
+    # Run the FastMCP server using stdio transport
+    app.run(transport="stdio")
+    return 0
+
+
+if __name__ == "__main__":
+    main()  # type: ignore