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

monocle_apptrace/instrumentation/common/wrapper.py

@@ -10,6 +10,7 @@ from opentelemetry.context import set_value, attach, detach, get_value
 from opentelemetry.context import create_key, get_value, set_value
 from opentelemetry.context.context import Context
 from opentelemetry.trace.span import INVALID_SPAN, Span
+from opentelemetry.trace.status import StatusCode
 
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.common.utils import (
@@ -20,7 +21,9 @@ from monocle_apptrace.instrumentation.common.utils import (
     get_current_monocle_span,
     set_monocle_span_in_context
 )
-from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, ADD_NEW_WORKFLOW
+from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, ADD_NEW_WORKFLOW, AGENTIC_SPANS
+from monocle_apptrace.instrumentation.common.scope_wrapper import monocle_trace_scope
+
 logger = logging.getLogger(__name__)
 ISOLATE_MONOCLE_SPANS = os.getenv("MONOCLE_ISOLATE_SPANS", "true").lower() == "true"
 
@@ -79,26 +82,36 @@ def monocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap
         if SpanHandler.is_root_span(span) or add_workflow_span:
             # Recursive call for the actual span
             return_value, span_status = monocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
-            span.set_status(span_status)
+            span.set_status(StatusCode.OK)
             if not auto_close_span:
                 span.end()
         else:
             ex:Exception = None
-            try:
-                with SpanHandler.workflow_type(to_wrap, span):
-                    return_value = wrapped(*args, **kwargs)
-            except Exception as e:
-                ex = e
-                raise
-            finally:
-                def post_process_span_internal(ret_val):
-                    post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span ,ex)
-                    if not auto_close_span:
-                        span.end()
-                if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
-                    to_wrap.get("output_processor").get("response_processor")(to_wrap, return_value, post_process_span_internal)
-                else:
+            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs)
+            if has_more_processors(to_wrap):
+                try:
+                    return_value, span_status = monocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
+                except Exception as e:
+                    ex = e
+                    raise
+                finally:
                     post_process_span_internal(return_value)
+            else:
+                try:
+                    with SpanHandler.workflow_type(to_wrap, span):
+                        return_value = wrapped(*args, **kwargs)
+                except Exception as e:
+                    ex = e
+                    raise
+                finally:
+                    def post_process_span_internal(ret_val):
+                        post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span ,ex)
+                        if not auto_close_span:
+                            span.end()
+                    if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
+                        to_wrap.get("output_processor").get("response_processor")(to_wrap, return_value, post_process_span_internal)
+                    else:
+                        post_process_span_internal(return_value)
             span_status = span.status
     return return_value, span_status
 
@@ -117,7 +130,8 @@ def monocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, inst
             add_workflow_span = get_value(ADD_NEW_WORKFLOW) == True
             token = attach(set_value(ADD_NEW_WORKFLOW, False))
             try:
-                return_value, span_status = monocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, add_workflow_span, args, kwargs)
+                with monocle_trace_scope(get_builtin_scope_names(to_wrap)):
+                    return_value, span_status = monocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, add_workflow_span, args, kwargs)
             finally:
                 detach(token)
         return return_value
@@ -141,26 +155,36 @@ async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler,
         if SpanHandler.is_root_span(span) or add_workflow_span:
             # Recursive call for the actual span
             return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
-            span.set_status(span_status)
+            span.set_status(StatusCode.OK)
             if not auto_close_span:
                 span.end()
         else:
             ex:Exception = None
-            try:
-                with SpanHandler.workflow_type(to_wrap, span):
-                    return_value = await wrapped(*args, **kwargs)
-            except Exception as e:
-                ex = e
-                raise
-            finally:
-                def post_process_span_internal(ret_val):
-                    post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span, ex)
-                    if not auto_close_span:
-                        span.end()
-                if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
-                    to_wrap.get("output_processor").get("response_processor")(to_wrap, return_value, post_process_span_internal)
-                else:
+            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs)
+            if has_more_processors(to_wrap):
+                try:
+                    return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
+                except Exception as e:
+                    ex = e
+                    raise
+                finally:
                     post_process_span_internal(return_value)
+            else:
+                try:
+                    with SpanHandler.workflow_type(to_wrap, span):
+                        return_value = await wrapped(*args, **kwargs)
+                except Exception as e:
+                    ex = e
+                    raise
+                finally:
+                    def post_process_span_internal(ret_val):
+                        post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span, ex)
+                        if not auto_close_span:
+                            span.end()
+                    if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
+                        to_wrap.get("output_processor").get("response_processor")(to_wrap, return_value, post_process_span_internal)
+                    else:
+                        post_process_span_internal(return_value)
         span_status = span.status
     return return_value, span_status
 
@@ -179,28 +203,40 @@ async def amonocle_iter_wrapper_span_processor(tracer: Tracer, handler: SpanHand
             # Recursive call for the actual span
             async for item in amonocle_iter_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs):
                 yield item
-
+            span.set_status(StatusCode.OK)
             if not auto_close_span:
                 span.end()
         else:
             ex:Exception = None
-            try:
-                with SpanHandler.workflow_type(to_wrap, span):
-                    async for item in wrapped(*args, **kwargs):
+            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs)
+            if has_more_processors(to_wrap):
+                try:
+                    async for item in amonocle_iter_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs):
                         last_item = item
                         yield item
-            except Exception as e:
-                ex = e
-                raise
-            finally:
-                def post_process_span_internal(ret_val):
-                    post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span, ex)
-                    if not auto_close_span:
-                        span.end()
-                if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
-                    to_wrap.get("output_processor").get("response_processor")(to_wrap, None, post_process_span_internal)
-                else:
-                    post_process_span_internal(last_item)
+                except Exception as e:
+                    ex = e
+                    raise
+                finally:
+                    post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, last_item, span, parent_span, ex)
+            else:
+                try:
+                    with SpanHandler.workflow_type(to_wrap, span):
+                        async for item in wrapped(*args, **kwargs):
+                            last_item = item
+                            yield item
+                except Exception as e:
+                    ex = e
+                    raise
+                finally:
+                    def post_process_span_internal(ret_val):
+                        post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span, ex)
+                        if not auto_close_span:
+                            span.end()
+                    if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
+                        to_wrap.get("output_processor").get("response_processor")(to_wrap, None, post_process_span_internal)
+                    else:
+                        post_process_span_internal(last_item)
     return
 
 async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
@@ -218,7 +254,8 @@ async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrappe
             add_workflow_span = get_value(ADD_NEW_WORKFLOW) == True
             token = attach(set_value(ADD_NEW_WORKFLOW, False))
             try:
-                return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, 
+                with monocle_trace_scope(get_builtin_scope_names(to_wrap)):
+                    return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, 
                                                                         add_workflow_span, args, kwargs)
             finally:
                 detach(token)
@@ -244,8 +281,9 @@ async def amonocle_iter_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, w
             add_workflow_span = get_value(ADD_NEW_WORKFLOW) == True
             token = attach(set_value(ADD_NEW_WORKFLOW, False))
             try:
-                async for item in amonocle_iter_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, add_workflow_span, args, kwargs):
-                    yield item
+                with monocle_trace_scope(get_builtin_scope_names(to_wrap)):
+                    async for item in amonocle_iter_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, add_workflow_span, args, kwargs):
+                        yield item
             finally:
                 detach(token)
         return
@@ -351,3 +389,27 @@ def start_as_monocle_span(tracer: Tracer, name: str, auto_close_span: bool) -> I
         detach(original_span_token)
         detach(new_monocle_token)
     detach(monocle_span_token)
+
+def get_builtin_scope_names(to_wrap) -> str:
+    output_processor = to_wrap.get("output_processor", None)
+    span_type = output_processor.get("type", None) if output_processor else None
+    if span_type and span_type in AGENTIC_SPANS:
+        return span_type
+    return None
+
+def get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs):
+    if has_more_processors(to_wrap):
+        next_output_processor_list = to_wrap.get('output_processor_list',[]).copy()
+        while len(next_output_processor_list) > 0:
+            next_output_processor = next_output_processor_list.pop(0)
+            if handler.should_skip(next_output_processor, instance, args, kwargs):
+                next_output_processor = None
+            else:
+                break
+        to_wrap = to_wrap.copy()
+        to_wrap['output_processor_list'] = next_output_processor_list
+        to_wrap['output_processor'] = next_output_processor
+    return to_wrap
+
+def has_more_processors(to_wrap) -> bool:
+    return len(to_wrap.get('output_processor_list', [])) > 0

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

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

monocle_apptrace/instrumentation/metamodel/adk/_helper.py

@@ -84,6 +84,18 @@ def extract_agent_input(arguments: Dict[str, Any]) -> Any:
     """
     return arguments['args'][0].user_content.parts[0].text
 
+def extract_agent_request_input(arguments: Dict[str, Any]) -> Any:
+    """
+    Extract the input data from agent request.
+
+    Args:
+        arguments: Dictionary containing agent call arguments
+
+    Returns:
+        Any: The extracted input data
+    """
+    return arguments['kwargs']['new_message'].parts[0].text if 'new_message' in arguments['kwargs'] else None
+
 def extract_agent_response(result: Any) -> Any:
     """
     Extract the response data from agent result.
@@ -145,6 +157,18 @@ def get_delegating_agent(arguments) -> str:
             return None
     return from_agent
 
+def should_skip_delegation(arguments):
+    """
+    Determine whether to skip the delegation based on the arguments.
+
+    Args:
+        arguments: Dictionary containing agent call arguments
+
+    Returns:
+        bool: True if delegation should be skipped, False otherwise
+    """
+    return get_delegating_agent(arguments) is None
+
 def extract_tool_input(arguments: Dict[str, Any]) -> Any:
     """
     Extract the input data from tool arguments.

monocle_apptrace/instrumentation/metamodel/adk/entities/agent.py

@@ -1,6 +1,8 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_SUBTYPES, SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.adk import _helper
 AGENT = {
-      "type": "agentic.invocation",
+      "type": SPAN_TYPES.AGENTIC_INVOCATION,
+      "subtype": SPAN_SUBTYPES.ROUTING,
       "attributes": [
         [
               {
@@ -48,3 +50,62 @@ AGENT = {
         }
       ]
     }
+
+REQUEST = {
+      "type": "agentic.request",
+      "attributes": [
+        [
+              {
+                "_comment": "agent type",
+                "attribute": "type",
+                "accessor": lambda arguments:'agent.adk'
+              }
+        ],
+      ],
+      "events": [
+        {
+          "name":"data.input",
+          "attributes": [
+            {
+                "_comment": "this is Agent input",
+                "attribute": "input",
+                "accessor": lambda arguments: _helper.extract_agent_request_input(arguments)
+            }
+          ]
+        },
+        {
+          "name":"data.output",
+          "attributes": [
+            {
+                "_comment": "this is response from LLM",
+                "attribute": "response",
+                "accessor": lambda arguments: _helper.extract_agent_response(arguments['result'])
+            }
+          ]
+        }
+      ]
+}
+
+DELEGATION = {
+      "type": "agentic.delegation",
+      "should_skip": lambda arguments: _helper.should_skip_delegation(arguments),
+      "attributes": [
+        [
+              {
+                "_comment": "agent type",
+                "attribute": "type",
+                "accessor": lambda arguments:'agent.adk'
+              },
+              {
+                "_comment": "name of the agent",
+                "attribute": "from_agent",
+                "accessor": lambda arguments: _helper.get_delegating_agent(arguments)
+              },
+              {
+                "_comment": "name of the agent called",
+                "attribute": "to_agent",
+                "accessor": lambda arguments: _helper.get_agent_name(arguments['instance'])
+              }
+        ]
+      ]
+}

monocle_apptrace/instrumentation/metamodel/adk/entities/tool.py

@@ -1,6 +1,8 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_SUBTYPES, SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.adk import _helper
 TOOL = {
-      "type": "agentic.tool.invocation",
+      "type": SPAN_TYPES.AGENTIC_TOOL_INVOCATION,
+      "subtype": SPAN_SUBTYPES.ROUTING,
       "attributes": [
         [
               {

monocle_apptrace/instrumentation/metamodel/adk/methods.py

@@ -1,6 +1,6 @@
 from monocle_apptrace.instrumentation.common.wrapper import task_wrapper, atask_wrapper, atask_iter_wrapper
 from monocle_apptrace.instrumentation.metamodel.adk.entities.agent import (
-    AGENT,
+    AGENT, REQUEST, DELEGATION
 )
 from monocle_apptrace.instrumentation.metamodel.adk.entities.tool import (
     TOOL
@@ -12,7 +12,7 @@ ADK_METHODS = [
       "object": "BaseAgent",
       "method": "run_async",
       "wrapper_method": atask_iter_wrapper,
-      "output_processor": AGENT,
+      "output_processor_list": [DELEGATION, AGENT]
     },
     {
       "package": "google.adk.tools.function_tool",
@@ -20,5 +20,12 @@ ADK_METHODS = [
       "method": "run_async",
       "wrapper_method": atask_wrapper,
       "output_processor": TOOL,
+    },
+    {
+      "package": "google.adk.runners",
+      "object": "Runner",
+      "method": "run_async",
+      "wrapper_method": atask_iter_wrapper,
+      "output_processor": REQUEST,
     }
 ]

monocle_apptrace/instrumentation/metamodel/agents/_helper.py

@@ -158,6 +158,11 @@ def get_runner_agent_name(instance) -> str:
     """Get the name of an agent."""
     return get_name(instance)
 
+def get_tool_type(span):
+    if (span.attributes.get("is_mcp", False)):
+        return "tool.mcp"
+    else:
+        return "tool.openai_agents"
 
 def get_tool_name(instance) -> str:
     """Get the name of a tool."""

monocle_apptrace/instrumentation/metamodel/agents/agents_processor.py

@@ -34,21 +34,42 @@ def constructor_wrapper(
 
     original_func = kwargs.get("on_invoke_tool", None)
     result = None
+    mcp_url = None
+    # kwargs.get("on_invoke_tool").args[0].params["url"]
+    if (
+        kwargs.get("on_invoke_tool")
+        and hasattr(kwargs.get("on_invoke_tool"), "args")
+        and len(kwargs.get("on_invoke_tool").args) > 0
+        and hasattr(kwargs.get("on_invoke_tool").args[0], "params")
+    ):
+        mcp_url = kwargs.get("on_invoke_tool").args[0].params.get("url", None)
+        if mcp_url:
+            logger.debug(f"Using MCP URL: {mcp_url}")
     tool_instance = SimpleNamespace(
         name=kwargs.get("name", "unknown_tool"),
         description=kwargs.get("description", "No description provided"),
     )
     if original_func and not getattr(original_func, "_monocle_wrapped", False):
         # Now wrap the function with our instrumentation
+
         async def wrapped_func(*func_args, **func_kwargs):
-            # Use the handler to create spans when the decorated function is called
-            return await atask_wrapper(tracer=tracer, handler=handler, to_wrap=to_wrap)(
-                wrapped=original_func,
-                instance=tool_instance,
-                source_path=source_path,
-                args=func_args,
-                kwargs=func_kwargs,
-            )
+            token = None
+            try:
+                if mcp_url:
+                    token = attach(set_value("mcp.url", mcp_url))
+                # Use the handler to create spans when the decorated function is called
+                return await atask_wrapper(
+                    tracer=tracer, handler=handler, to_wrap=to_wrap
+                )(
+                    wrapped=original_func,
+                    instance=tool_instance,
+                    source_path=source_path,
+                    args=func_args,
+                    kwargs=func_kwargs,
+                )
+            finally:
+                if token:
+                    detach(token)
 
         kwargs["on_invoke_tool"] = wrapped_func
         # Preserve function metadata
@@ -150,3 +171,4 @@ class AgentsSpanHandler(BaseSpanHandler):
         return super().post_task_processing(
             to_wrap, wrapped, instance, args, kwargs, result, ex, span, parent_span
         )
+

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

@@ -1,7 +1,9 @@
+from monocle_apptrace.instrumentation.common.constants import AGENT_REQUEST_SPAN_NAME, SPAN_SUBTYPES, SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.agents import _helper
 
 AGENT = {
-    "type": "agentic.invocation",
+    "type": SPAN_TYPES.AGENTIC_INVOCATION,
+    "subtype": SPAN_SUBTYPES.ROUTING,
     "attributes": [
         [
             {
@@ -66,7 +68,8 @@ AGENT = {
 }
 
 AGENT_REQUEST = {
-    "type": "agentic.request",
+    "type": AGENT_REQUEST_SPAN_NAME,
+    "subtype": SPAN_SUBTYPES.PLANNING,
     "attributes": [
         [
             {
@@ -105,13 +108,14 @@ AGENT_REQUEST = {
 }
 
 TOOLS = {
-    "type": "agentic.tool.invocation",
+    "type": SPAN_TYPES.AGENTIC_TOOL_INVOCATION,
+    "subtype": SPAN_SUBTYPES.ROUTING,
     "attributes": [
         [
             {
                 "_comment": "tool type",
                 "attribute": "type",
-                "accessor": lambda arguments: "tool.openai_agents",
+                "accessor": lambda arguments: _helper.get_tool_type(arguments["span"]),
             },
             {
                 "_comment": "name of the tool",
@@ -168,7 +172,8 @@ TOOLS = {
 }
 
 AGENT_DELEGATION = {
-    "type": "agentic.delegation",
+    "type": SPAN_TYPES.AGENTIC_DELEGATION,
+    "subtype": SPAN_SUBTYPES.ROUTING,
     "attributes": [
         [
             {

monocle_apptrace/instrumentation/metamodel/agents/methods.py

@@ -3,6 +3,7 @@ from monocle_apptrace.instrumentation.metamodel.agents.entities.inference import
     AGENT,
     AGENT_DELEGATION,
     TOOLS,
+    AGENT_REQUEST
 )
 from monocle_apptrace.instrumentation.metamodel.agents.agents_processor import (
     constructor_wrapper,
@@ -17,7 +18,7 @@ AGENTS_METHODS = [
         "method": "run",
         "wrapper_method": atask_wrapper,
         "span_handler": "agents_agent_handler",
-        "output_processor": AGENT,
+        "output_processor": AGENT_REQUEST,
     },
     {
         "package": "agents.run",
@@ -25,7 +26,7 @@ AGENTS_METHODS = [
         "method": "run_sync",
         "wrapper_method": task_wrapper,
         "span_handler": "agents_agent_handler",
-        "output_processor": AGENT,
+        "output_processor": AGENT_REQUEST,
     },
     # AgentRunner class methods (internal runner)
     {
@@ -42,7 +43,6 @@ AGENTS_METHODS = [
         "object": "FunctionTool",
         "method": "__init__",  # Empty string means wrap the function itself
         "wrapper_method": constructor_wrapper,
-        "span_handler": "agents_tool_handler",
         "output_processor": TOOLS,
     },
     {
@@ -50,7 +50,6 @@ AGENTS_METHODS = [
         "object": "Handoff",
         "method": "__init__",  # Empty string means wrap the function itself
         "wrapper_method": handoff_constructor_wrapper,
-        "span_handler": "agents_tool_handler",
         "output_processor": AGENT_DELEGATION,
     },
 ]

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

@@ -1,6 +1,7 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.aiohttp import _helper
 AIO_HTTP_PROCESSOR = {
-    "type": "http.process",
+    "type": SPAN_TYPES.HTTP_PROCESS,
     "attributes": [
         [
             {

monocle_apptrace/instrumentation/metamodel/anthropic/_helper.py

@@ -16,7 +16,7 @@ from monocle_apptrace.instrumentation.common.utils import (
     get_exception_message,
 )
 from monocle_apptrace.instrumentation.metamodel.finish_types import map_anthropic_finish_reason_to_finish_type
-from monocle_apptrace.instrumentation.common.constants import AGENT_PREFIX_KEY, INFERENCE_AGENT_DELEGATION, INFERENCE_COMMUNICATION, INFERENCE_TOOL_CALL
+from monocle_apptrace.instrumentation.common.constants import AGENT_PREFIX_KEY, INFERENCE_AGENT_DELEGATION, INFERENCE_TURN_END, INFERENCE_TOOL_CALL
 
 
 logger = logging.getLogger(__name__)
@@ -177,7 +177,7 @@ def agent_inference_type(arguments):
                     if agent_prefix and agent_prefix in assistant_message:
                         return INFERENCE_AGENT_DELEGATION
         
-        return INFERENCE_COMMUNICATION
+        return INFERENCE_TURN_END
     except Exception as e:
         logger.warning("Warning: Error occurred in agent_inference_type: %s", str(e))
-        return INFERENCE_COMMUNICATION
+        return INFERENCE_TURN_END

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

@@ -1,10 +1,11 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.anthropic import (
     _helper,
 )
 from monocle_apptrace.instrumentation.common.utils import (get_error_message, resolve_from_alias)
 
 INFERENCE = {
-    "type": "inference",
+    "type": SPAN_TYPES.INFERENCE,
     "attributes": [
         [
             {

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

@@ -1,6 +1,7 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.azfunc import _helper
 AZFUNC_HTTP_PROCESSOR = {
-    "type": "http.process",
+    "type": SPAN_TYPES.HTTP_PROCESS,
     "attributes": [
         [
             {

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

@@ -1,6 +1,7 @@
 import logging
 import time
 from types import SimpleNamespace
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.azureaiinference import _helper
 from monocle_apptrace.instrumentation.common.utils import (
     get_error_message,
@@ -133,7 +134,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": [

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

@@ -1,9 +1,10 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.botocore import (
     _helper,
 )
 from monocle_apptrace.instrumentation.common.utils import (get_error_message, get_llm_type, get_status,)
 INFERENCE = {
-    "type": "inference",
+    "type": SPAN_TYPES.INFERENCE,
     "attributes": [
         [
             {

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

@@ -1,7 +1,8 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.fastapi import _helper
 
 FASTAPI_HTTP_PROCESSOR = {
-    "type": "http.process",
+    "type": SPAN_TYPES.HTTP_PROCESS,
     "attributes": [
         [
             {