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

monocle_apptrace/instrumentation/common/wrapper.py

@@ -1,7 +1,16 @@
 # pylint: disable=protected-access
+from contextlib import contextmanager
+import os
+from typing import AsyncGenerator, Iterator, Optional
 import logging
 from opentelemetry.trace import Tracer
+from opentelemetry.trace.propagation import _SPAN_KEY, set_span_in_context, get_current_span
+from opentelemetry.trace import propagation
 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 (
@@ -9,10 +18,14 @@ from monocle_apptrace.instrumentation.common.utils import (
     with_tracer_wrapper,
     set_scope,
     remove_scope,
-    get_parent_span
+    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"
 
 def get_auto_close_span(to_wrap, kwargs):
     try:
@@ -38,6 +51,8 @@ def pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped,
 def post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span, ex):
     if not (SpanHandler.is_root_span(span) or get_value(ADD_NEW_WORKFLOW) == True):
         try:
+            if parent_span == INVALID_SPAN:
+                parent_span = None
             handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span, ex)
         except Exception as e:
             logger.info(f"Warning: Error occurred in hydrate_span: {e}")
@@ -60,33 +75,43 @@ def monocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap
     return_value = None
     span_status = None
     auto_close_span = get_auto_close_span(to_wrap, kwargs)
-    parent_span = get_parent_span()
-    with tracer.start_as_current_span(name, end_on_exit=auto_close_span) as span:
+    parent_span = get_current_monocle_span()
+    with start_as_monocle_span(tracer, name, auto_close_span) as span:
         pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped, instance, args, kwargs, span, source_path)
         
         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
 
@@ -105,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
@@ -115,41 +141,103 @@ def monocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, inst
         except Exception as e:
             logger.info(f"Warning: Error occurred in post_tracing: {e}")
 
-async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, add_workflow_span, args, kwargs):
+async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, add_workflow_span,
+                                        args, kwargs):
     # Main span processing logic
     name = get_span_name(to_wrap, instance)
     return_value = None
     span_status = None
     auto_close_span = get_auto_close_span(to_wrap, kwargs)
-    parent_span = get_parent_span()
-    with tracer.start_as_current_span(name, end_on_exit=auto_close_span) as span:
+    parent_span = get_current_monocle_span()
+    with start_as_monocle_span(tracer, name, auto_close_span) as span:
         pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped, instance, args, kwargs, span, source_path)
         
         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
+    return return_value, span_status
+
+async def amonocle_iter_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, add_workflow_span,
+                                        args, kwargs) -> AsyncGenerator[any, None]:
+    # Main span processing logic
+    name = get_span_name(to_wrap, instance)
+    auto_close_span = get_auto_close_span(to_wrap, kwargs)
+    parent_span = get_current_monocle_span()
+    last_item = None
+
+    with start_as_monocle_span(tracer, name, auto_close_span) as span:
+        pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped, instance, args, kwargs, span, source_path)
+
+        if SpanHandler.is_root_span(span) or add_workflow_span:
+            # 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
+            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:
+                    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):
     return_value = None
@@ -166,7 +254,9 @@ 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, add_workflow_span, args, kwargs)    
+                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)
         return return_value
@@ -176,6 +266,33 @@ async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrappe
         except Exception as e:
             logger.info(f"Warning: Error occurred in post_tracing: {e}")
 
+async def amonocle_iter_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs) -> AsyncGenerator[any, None]:
+    token = None
+    pre_trace_token = None
+    try:
+        try:
+            pre_trace_token = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+        except Exception as e:
+            logger.info(f"Warning: Error occurred in pre_tracing: {e}")
+        if to_wrap.get('skip_span', False) or handler.skip_span(to_wrap, wrapped, instance, args, kwargs):
+            async for item in wrapped(*args, **kwargs):
+                yield item
+        else:
+            add_workflow_span = get_value(ADD_NEW_WORKFLOW) == True
+            token = attach(set_value(ADD_NEW_WORKFLOW, False))
+            try:
+                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
+    finally:
+        try:
+            handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, None, pre_trace_token)
+        except Exception as e:
+            logger.info(f"Warning: Error occurred in post_tracing: {e}")
+
 @with_tracer_wrapper
 def task_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
     return monocle_wrapper(tracer, handler, to_wrap, wrapped, instance, source_path, args, kwargs)
@@ -184,6 +301,12 @@ def task_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instanc
 async def atask_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
     return await amonocle_wrapper(tracer, handler, to_wrap, wrapped, instance, source_path, args, kwargs)
 
+@with_tracer_wrapper
+async def atask_iter_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs) -> AsyncGenerator[any, None]:
+    async for item in amonocle_iter_wrapper(tracer, handler, to_wrap, wrapped, instance, source_path, args, kwargs):
+        yield item
+    return
+
 @with_tracer_wrapper
 def scope_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
     scope_name = to_wrap.get('scope_name', None)
@@ -245,4 +368,48 @@ def evaluate_scope_values(args, kwargs, to_wrap, scope_values):
             scope_values = None
     if isinstance(scope_values, dict):
         return scope_values
-    return None
+    return None
+
+@contextmanager
+def start_as_monocle_span(tracer: Tracer, name: str, auto_close_span: bool) -> Iterator["Span"]:
+    """ Wrapper to OTEL start_as_current_span to isolate monocle and non monocle spans.
+        This essentiall links monocle and non-monocle spans separately which is default behavior.
+        It can be optionally overridden by setting the environment variable MONOCLE_ISOLATE_SPANS to false.
+    """
+    if not ISOLATE_MONOCLE_SPANS:
+        # If not isolating, use the default start_as_current_span
+        yield tracer.start_as_current_span(name, end_on_exit=auto_close_span)
+        return
+    original_span = get_current_span()
+    monocle_span_token = attach(set_span_in_context(get_current_monocle_span()))
+    with tracer.start_as_current_span(name, end_on_exit=auto_close_span) as span:
+        new_monocle_token = attach(set_monocle_span_in_context(span))
+        original_span_token = attach(set_span_in_context(original_span))
+        yield span
+        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/common/wrapper_method.py

@@ -15,6 +15,8 @@ from monocle_apptrace.instrumentation.metamodel.openai.methods import (OPENAI_ME
 from monocle_apptrace.instrumentation.metamodel.openai._helper import OpenAISpanHandler
 from monocle_apptrace.instrumentation.metamodel.langgraph.methods import LANGGRAPH_METHODS
 from monocle_apptrace.instrumentation.metamodel.langgraph.langgraph_processor import LanggraphAgentHandler, LanggraphToolHandler
+from monocle_apptrace.instrumentation.metamodel.agents.methods import AGENTS_METHODS
+from monocle_apptrace.instrumentation.metamodel.agents.agents_processor import AgentsSpanHandler
 from monocle_apptrace.instrumentation.metamodel.flask.methods import (FLASK_METHODS, )
 from monocle_apptrace.instrumentation.metamodel.flask._helper import FlaskSpanHandler, FlaskResponseSpanHandler
 from monocle_apptrace.instrumentation.metamodel.requests.methods import (REQUESTS_METHODS, )
@@ -33,6 +35,8 @@ from monocle_apptrace.instrumentation.metamodel.lambdafunc.methods import LAMBDA
 from monocle_apptrace.instrumentation.metamodel.mcp.methods import MCP_METHODS
 from monocle_apptrace.instrumentation.metamodel.mcp.mcp_processor import MCPAgentHandler
 from monocle_apptrace.instrumentation.metamodel.a2a.methods import A2A_CLIENT_METHODS
+from monocle_apptrace.instrumentation.metamodel.litellm.methods import LITELLM_METHODS
+from monocle_apptrace.instrumentation.metamodel.adk.methods import ADK_METHODS
 
 class WrapperMethod:
     def __init__(
@@ -90,6 +94,7 @@ DEFAULT_METHODS_LIST = (
     FLASK_METHODS + 
     REQUESTS_METHODS + 
     LANGGRAPH_METHODS + 
+    AGENTS_METHODS +
     OPENAI_METHODS + 
     TEAMAI_METHODS +
     ANTHROPIC_METHODS + 
@@ -100,7 +105,9 @@ DEFAULT_METHODS_LIST = (
     FASTAPI_METHODS + 
     LAMBDA_HTTP_METHODS +
     MCP_METHODS + 
-    A2A_CLIENT_METHODS
+    A2A_CLIENT_METHODS +
+    LITELLM_METHODS +
+    ADK_METHODS
 )
 
 MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
@@ -118,6 +125,7 @@ MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "fastapi_response_handler": FastAPIResponseSpanHandler(),
     "langgraph_agent_handler": LanggraphAgentHandler(),
     "langgraph_tool_handler": LanggraphToolHandler(),
+    "agents_agent_handler": AgentsSpanHandler(),
     "llamaindex_tool_handler": LlamaIndexToolHandler(),
     "llamaindex_agent_handler": LlamaIndexAgentHandler(),
     "llamaindex_single_agent_tool_handler": LlamaIndexSingleAgenttToolHandlerWrapper(),

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

@@ -0,0 +1,206 @@
+"""
+Helper functions for the ADK (Agent Development Kit) metamodel instrumentation.
+This module provides utility functions to extract various attributes from agent and tool instances.
+"""
+
+from ast import arguments
+from typing import Any, Dict, Optional
+from monocle_apptrace.instrumentation.metamodel.finish_types import map_adk_finish_reason_to_finish_type
+
+def get_model_name(args):
+    return args[0].model if hasattr(args[0], 'model') else None
+
+def get_inference_type(arguments):
+    """ Find inference type from argument """
+    return 'inference.gemini' ## TBD verify non-gemini inference types
+
+def extract_inference_endpoint(instance):
+    """ Get inference service end point"""
+    if hasattr(instance,'api_client') and hasattr(instance.api_client, '_api_client'):
+        if hasattr(instance.api_client._api_client._http_options,'base_url'):
+            return instance.api_client._api_client._http_options.base_url
+    return None
+
+def extract_message(arguments):
+    return str(arguments['args'][0].contents)
+
+def extract_assistant_message(arguments):
+    return str(arguments['result'].content.parts)
+
+def update_span_from_llm_response(response, instance):
+    meta_dict = {}
+    if response is not None and hasattr(response, "usage_metadata") and response.usage_metadata is not None:
+        token_usage = response.usage_metadata
+        if token_usage is not None:
+            meta_dict.update({"completion_tokens": token_usage.candidates_token_count})
+            meta_dict.update({"prompt_tokens": token_usage.prompt_token_count })
+            meta_dict.update({"total_tokens": token_usage.total_token_count})
+    return meta_dict
+
+def extract_finish_reason(arguments):
+    if arguments["exception"] is not None:
+            return None
+    if hasattr(arguments['result'], 'error_code'):
+        return arguments['result'].error_code
+    return None
+
+def map_finish_reason_to_finish_type(finish_reason:str):
+    return map_adk_finish_reason_to_finish_type(finish_reason)
+
+def get_agent_name(instance: Any) -> str:
+    """
+    Extract the name of the agent from the given instance.
+
+    Args:
+        instance: The agent instance to extract name from
+
+    Returns:
+        str: The name of the agent, or a default value if not found
+    """
+    return getattr(instance, 'name', 'unknown_agent')
+
+def get_agent_description(instance: Any) -> str:
+    """
+    Extract the description of the agent from the given instance.
+
+    Args:
+        instance: The agent instance to extract description from
+
+    Returns:
+        str: The description of the agent, or a default value if not found
+    """
+    return getattr(instance, 'description', 'No description available')
+
+
+def extract_agent_input(arguments: Dict[str, Any]) -> Any:
+    """
+    Extract the input data from agent arguments.
+
+    Args:
+        arguments: Dictionary containing agent call arguments
+
+    Returns:
+        Any: The extracted input data
+    """
+    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.
+
+    Args:
+        result: The result returned by the agent
+
+    Returns:
+        Any: The extracted response data
+    """
+    if result:
+        return result.content.parts[0].text
+
+def get_tool_name(instance: Any) -> str:
+    """
+    Extract the name of the tool from the given instance.
+
+    Args:
+        instance: The tool instance to extract name from
+
+    Returns:
+        str: The name of the tool, or a default value if not found
+    """
+    return getattr(instance, 'name', getattr(instance, '__name__', 'unknown_tool'))
+
+def get_tool_description(instance: Any) -> str:
+    """
+    Extract the description of the tool from the given instance.
+
+    Args:
+        instance: The tool instance to extract description from
+
+    Returns:
+        str: The description of the tool, or a default value if not found
+    """
+    return getattr(instance, 'description', getattr(instance, '__doc__', 'No description available'))
+
+def get_source_agent(arguments) -> str:
+    """
+    Get the name of the source agent (the agent that is calling a tool or delegating to another agent).
+
+    Returns:
+        str: The name of the source agent
+    """
+    return arguments['kwargs']['tool_context'].agent_name
+
+def get_delegating_agent(arguments) -> str:
+    """
+    Get the name of the delegating agent (the agent that is delegating a task to another agent).
+
+    Args:
+        arguments: Dictionary containing agent call arguments 
+    Returns:
+        str: The name of the delegating agent
+    """
+    from_agent = arguments['args'][0].agent.name if hasattr(arguments['args'][0], 'agent') else None
+    if from_agent is not None:
+        if get_agent_name(arguments['instance']) == from_agent:
+            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.
+
+    Args:
+        arguments: Dictionary containing tool call arguments
+
+    Returns:
+        Any: The extracted input data
+    """
+    return str(arguments['kwargs'].get('args'))
+
+def extract_tool_response(result: Any) -> Any:
+    """
+    Extract the response data from tool result.
+
+    Args:
+        result: The result returned by the tool
+
+    Returns:
+        Any: The extracted response data
+    """
+    return str(result)
+
+def get_target_agent(instance: Any) -> str:
+    """
+    Extract the name of the target agent (the agent being called/delegated to).
+
+    Args:
+        instance: The target agent instance
+
+    Returns:
+        str: The name of the target agent
+    """
+    return getattr(instance, 'name', getattr(instance, '__name__', 'unknown_target_agent'))