mseep-agentops 0.4.18__py3-none-any.whl → 0.4.22__py3-none-any.whl

agentops/instrumentation/agentic/agno/attributes/team.py

@@ -0,0 +1,195 @@
+"""Agno Team run attributes handler."""
+
+from typing import Optional, Tuple, Dict, Any
+import json
+from agentops.instrumentation.common.attributes import AttributeMap
+from agentops.semconv import SpanAttributes, WorkflowAttributes
+from agentops.semconv.span_kinds import SpanKind as AgentOpsSpanKind
+
+
+def get_team_run_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> AttributeMap:
+    """Extract span attributes for Team method calls (both internal and public).
+
+    Args:
+        args: Positional arguments passed to the Team method
+        kwargs: Keyword arguments passed to the Team method
+        return_value: The return value from the Team method
+
+    Returns:
+        A dictionary of span attributes to be set on the workflow span
+    """
+    attributes: AttributeMap = {}
+
+    # Base attributes
+    attributes[SpanAttributes.AGENTOPS_SPAN_KIND] = AgentOpsSpanKind.WORKFLOW
+    attributes[SpanAttributes.LLM_SYSTEM] = "agno"
+    attributes[WorkflowAttributes.WORKFLOW_TYPE] = "team_run"
+
+    # Extract team information from instance
+    if args and len(args) > 0:
+        team = args[0]  # self (Team instance)
+
+        # Team identification
+        if hasattr(team, "name") and team.name:
+            attributes["team.name"] = str(team.name)
+            attributes["team.display_name"] = f"{team.name} (Team)"
+
+        if hasattr(team, "team_id") and team.team_id:
+            attributes["team.team_id"] = str(team.team_id)
+
+        if hasattr(team, "mode") and team.mode:
+            attributes["team.mode"] = str(team.mode)
+
+        if hasattr(team, "members") and team.members:
+            attributes["team.members_count"] = str(len(team.members))
+
+            # Add detailed member information
+            member_agents = []
+            for i, member in enumerate(team.members):
+                member_info = {}
+                if hasattr(member, "name") and member.name:
+                    member_info["name"] = str(member.name)
+                if hasattr(member, "agent_id") and member.agent_id:
+                    member_info["id"] = str(member.agent_id)
+                if hasattr(member, "role") and member.role:
+                    member_info["role"] = str(member.role)
+                if hasattr(member, "model") and member.model:
+                    if hasattr(member.model, "id"):
+                        member_info["model"] = str(member.model.id)
+
+                # Add member info to list
+                if member_info:
+                    member_agents.append(member_info)
+
+                    # Also add individual member attributes
+                    for key, value in member_info.items():
+                        attributes[f"team.member.{i}.{key}"] = value
+
+            # Add aggregated member list
+            if member_agents:
+                try:
+                    attributes["team.members"] = json.dumps(member_agents)
+                    # Also add a simple list of member names
+                    member_names = [m.get("name", "Unknown") for m in member_agents]
+                    attributes["team.member_names"] = ", ".join(member_names)
+                except:
+                    attributes["team.members"] = str(member_agents)
+
+    # Process input arguments - handle both internal and public method signatures
+    if args and len(args) >= 2:
+        input_arg = args[1]
+
+        # Check if it's internal method (has run_messages) or public method (direct message)
+        if hasattr(input_arg, "messages"):
+            # Internal method: args[1] is run_messages
+            run_messages = input_arg
+            # Get the user message for workflow input
+            user_messages = [msg for msg in run_messages.messages if hasattr(msg, "role") and msg.role == "user"]
+            if user_messages:
+                last_user_msg = user_messages[-1]
+                if hasattr(last_user_msg, "content"):
+                    attributes[WorkflowAttributes.WORKFLOW_INPUT] = str(last_user_msg.content)
+                    attributes[WorkflowAttributes.WORKFLOW_INPUT_TYPE] = "message"
+            # Count total messages
+            attributes["team.messages_count"] = str(len(run_messages.messages))
+        else:
+            # Public method: args[1] is the message directly
+            message = input_arg
+            if message is not None:
+                if isinstance(message, str):
+                    message_content = message
+                elif hasattr(message, "content"):
+                    message_content = str(message.content)
+                elif hasattr(message, "get_content_string"):
+                    message_content = message.get_content_string()
+                else:
+                    message_content = str(message)
+
+                attributes[WorkflowAttributes.WORKFLOW_INPUT] = message_content
+                attributes[WorkflowAttributes.WORKFLOW_INPUT_TYPE] = "message"
+
+    # Process keyword arguments
+    if kwargs:
+        if kwargs.get("user_id"):
+            attributes[SpanAttributes.LLM_USER] = kwargs["user_id"]
+
+        if kwargs.get("session_id"):
+            attributes["team.session_id"] = kwargs["session_id"]
+
+        if kwargs.get("response_format"):
+            attributes["team.response_format"] = str(type(kwargs["response_format"]).__name__)
+
+        if kwargs.get("stream"):
+            attributes["team.streaming"] = str(kwargs["stream"])
+
+        if kwargs.get("stream_intermediate_steps"):
+            attributes["team.stream_intermediate_steps"] = str(kwargs["stream_intermediate_steps"])
+
+        if kwargs.get("retries"):
+            attributes["team.retries"] = str(kwargs["retries"])
+
+        # Media attachments
+        if kwargs.get("audio"):
+            attributes["team.has_audio"] = "true"
+        if kwargs.get("images"):
+            attributes["team.has_images"] = "true"
+        if kwargs.get("videos"):
+            attributes["team.has_videos"] = "true"
+        if kwargs.get("files"):
+            attributes["team.has_files"] = "true"
+
+        if kwargs.get("knowledge_filters"):
+            attributes["team.has_knowledge_filters"] = "true"
+
+    # Process return value (TeamRunResponse or Iterator)
+    if return_value:
+        # Handle both single response and iterator
+        if hasattr(return_value, "__iter__") and not isinstance(return_value, str):
+            # It's an iterator for streaming
+            attributes[WorkflowAttributes.WORKFLOW_OUTPUT_TYPE] = "team_run_response_stream"
+            attributes["team.is_streaming"] = "true"
+        else:
+            # Non-streaming response
+            if hasattr(return_value, "content"):
+                # It's a TeamRunResponse with content
+                content = str(return_value.content)
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT] = content
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_TYPE] = "team_run_response"
+            else:
+                # Unknown return type or response without content
+                output = str(return_value)
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT] = output
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_TYPE] = type(return_value).__name__
+
+        # Set additional team response attributes (for both streaming and non-streaming)
+        if hasattr(return_value, "run_id"):
+            attributes["team.run_id"] = str(return_value.run_id)
+
+        if hasattr(return_value, "session_id"):
+            attributes["team.response_session_id"] = str(return_value.session_id)
+
+        if hasattr(return_value, "team_id"):
+            attributes["team.response_team_id"] = str(return_value.team_id)
+
+        if hasattr(return_value, "model"):
+            attributes[SpanAttributes.LLM_RESPONSE_MODEL] = str(return_value.model)
+
+        if hasattr(return_value, "model_provider"):
+            attributes["team.model_provider"] = str(return_value.model_provider)
+
+        if hasattr(return_value, "event"):
+            attributes["team.event"] = str(return_value.event)
+
+        # Team-specific attributes
+        if hasattr(return_value, "content_type"):
+            attributes["team.response_content_type"] = str(return_value.content_type)
+
+    return attributes
+
+
+# Keep the public function as an alias for backward compatibility
+get_team_public_run_attributes = get_team_run_attributes

agentops/instrumentation/agentic/agno/attributes/tool.py

@@ -0,0 +1,210 @@
+"""Agno tool execution attributes handler."""
+
+import json
+from typing import Optional, Tuple, Dict, Any
+import time
+from agentops.instrumentation.common.attributes import AttributeMap
+from agentops.semconv import SpanAttributes
+from agentops.semconv.span_kinds import SpanKind as AgentOpsSpanKind
+from agentops.semconv.tool import ToolAttributes
+
+
+def get_tool_execution_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> AttributeMap:
+    """Extract span attributes for tool execution calls (FunctionCall.execute/aexecute).
+
+    Args:
+        args: Positional arguments passed to the execute method (self)
+        kwargs: Keyword arguments passed to the execute method
+        return_value: The return value from the execute method (FunctionExecutionResult)
+
+    Returns:
+        A dictionary of span attributes to be set on the tool execution span
+    """
+    attributes: AttributeMap = {}
+
+    # Base attributes
+    attributes[SpanAttributes.AGENTOPS_SPAN_KIND] = AgentOpsSpanKind.TOOL
+    attributes[SpanAttributes.LLM_SYSTEM] = "agno"
+
+    # AgentOps entity attributes
+    attributes[SpanAttributes.AGENTOPS_ENTITY_NAME] = "tool"
+
+    # Process the FunctionCall object (self in execute method)
+    if args and len(args) > 0:
+        function_call = args[0]
+
+        # Add detailed function call information
+        attributes["tool.function_call_type"] = str(type(function_call).__name__)
+
+        # Extract tool information
+        if hasattr(function_call, "function") and function_call.function:
+            function = function_call.function
+
+            # Get function name and add display name
+            if hasattr(function, "__name__"):
+                func_name = function.__name__
+                attributes["tool.function_name"] = func_name
+                attributes["tool.display_name"] = f"{func_name} (Tool)"
+
+            tool_name = getattr(function, "name", "unknown_tool")
+
+            # Set span attributes for the tool execution span
+            attributes[ToolAttributes.TOOL_NAME] = tool_name
+            attributes["tool.function_name"] = tool_name
+
+            # Function details and context
+            if hasattr(function, "description"):
+                description = getattr(function, "description", "")
+                if description:
+                    attributes[ToolAttributes.TOOL_DESCRIPTION] = description
+                    attributes["tool.function_description"] = description
+
+            # Function source information
+            if hasattr(function, "entrypoint") and function.entrypoint:
+                entrypoint = function.entrypoint
+                if hasattr(entrypoint, "__module__"):
+                    attributes["tool.function_module"] = str(entrypoint.__module__)
+                if hasattr(entrypoint, "__name__"):
+                    attributes["tool.function_method"] = str(entrypoint.__name__)
+                if hasattr(entrypoint, "__qualname__"):
+                    attributes["tool.function_qualname"] = str(entrypoint.__qualname__)
+
+            # Tool capabilities
+            if hasattr(function, "requires_confirmation"):
+                attributes["tool.requires_confirmation"] = str(function.requires_confirmation)
+            if hasattr(function, "show_result"):
+                attributes["tool.show_result"] = str(function.show_result)
+            if hasattr(function, "stop_after_tool_call"):
+                attributes["tool.stop_after_tool_call"] = str(function.stop_after_tool_call)
+
+            # Extract tool arguments with better formatting
+            if hasattr(function_call, "arguments") and function_call.arguments:
+                try:
+                    if isinstance(function_call.arguments, str):
+                        args_dict = json.loads(function_call.arguments)
+                    else:
+                        args_dict = function_call.arguments
+
+                    # Format arguments nicely
+                    formatted_args = []
+                    for key, value in args_dict.items():
+                        value_str = str(value)
+                        formatted_args.append(f"{key}={value_str}")
+
+                    attributes[ToolAttributes.TOOL_PARAMETERS] = json.dumps(args_dict)
+                    attributes["tool.formatted_args"] = ", ".join(formatted_args)
+                    attributes["tool.args_count"] = str(len(args_dict))
+                except Exception as e:
+                    attributes[ToolAttributes.TOOL_PARAMETERS] = str(function_call.arguments)
+                    attributes["tool.args_parse_error"] = str(e)
+
+        # Extract call ID and metadata
+        if hasattr(function_call, "tool_call_id"):
+            attributes["tool.call_id"] = str(function_call.tool_call_id)
+
+        # Check for any agent context
+        if hasattr(function_call, "_agent") and function_call._agent:
+            agent = function_call._agent
+            if hasattr(agent, "name"):
+                attributes["tool.calling_agent_name"] = str(agent.name)
+            if hasattr(agent, "agent_id"):
+                attributes["tool.calling_agent_id"] = str(agent.agent_id)
+
+    # Process return value
+    if return_value is not None:
+        # Add timing information
+        attributes["tool.execution_timestamp"] = str(int(time.time() * 1000))
+
+        # Determine execution status and result information
+        if hasattr(return_value, "value"):
+            # FunctionExecutionResult with value
+            result_value = return_value.value
+            attributes["tool.execution_status"] = "success"
+        else:
+            # Direct return value
+            result_value = return_value
+            attributes["tool.execution_status"] = "success"
+
+        # Process result value
+        if result_value is not None:
+            result_type = type(result_value).__name__
+            attributes["tool.execution_result_status"] = str(result_type)
+
+            # Handle FunctionExecutionResult objects specifically
+            if hasattr(result_value, "status") and hasattr(result_value, "result"):
+                # This looks like a FunctionExecutionResult
+                status = getattr(result_value, "status", "unknown")
+                actual_result = getattr(result_value, "result", None)
+                error = getattr(result_value, "error", None)
+
+                attributes["tool.execution_result_status"] = str(status)
+                attributes[ToolAttributes.TOOL_STATUS] = str(status)
+
+                if error:
+                    attributes["tool.execution_error"] = str(error)
+                    attributes["tool.error"] = str(error)
+
+                if actual_result is not None:
+                    actual_result_type = type(actual_result).__name__
+                    attributes["tool.actual_result_type"] = actual_result_type
+
+                    # Enhanced generator handling
+                    if hasattr(actual_result, "__iter__") and hasattr(actual_result, "__next__"):
+                        attributes["tool.result_is_generator"] = "true"
+
+                        # Try to get more meaningful information about the generator
+                        generator_info = []
+
+                        # Get function name from the generator
+                        if hasattr(actual_result, "gi_code"):
+                            func_name = actual_result.gi_code.co_name
+                            attributes["tool.generator_function"] = func_name
+                            generator_info.append(f"function={func_name}")
+
+                        if generator_info:
+                            result_str = f"Generator<{actual_result_type}>({', '.join(generator_info)})"
+                        else:
+                            result_str = f"Generator<{actual_result_type}> - {str(actual_result)}"
+                    else:
+                        # Regular result
+                        result_str = str(actual_result)
+                else:
+                    result_str = str(status)
+            else:
+                # Not a FunctionExecutionResult, handle as direct result
+                if hasattr(result_value, "__iter__") and hasattr(result_value, "__next__"):
+                    # It's a generator
+                    attributes["tool.result_is_generator"] = "true"
+
+                    if hasattr(result_value, "gi_code"):
+                        func_name = result_value.gi_code.co_name
+                        attributes["tool.generator_function"] = func_name
+                        result_str = f"Generator<{result_type}> function={func_name} - {str(result_value)}"
+                    else:
+                        result_str = f"Generator<{result_type}> - {str(result_value)}"
+                else:
+                    # Regular result
+                    result_str = str(result_value)
+        else:
+            result_str = "None"
+
+        # Set the main result attribute
+        attributes[ToolAttributes.TOOL_RESULT] = result_str
+
+        # Add additional analysis attributes
+        attributes["tool.result_length"] = str(len(result_str))
+
+    # Set final execution status
+    if not attributes.get(ToolAttributes.TOOL_STATUS):
+        attributes[ToolAttributes.TOOL_STATUS] = "success"
+
+    # Add execution summary for debugging
+    tool_name = attributes.get(ToolAttributes.TOOL_NAME, "unknown")
+    call_type = attributes.get("tool.transfer_type", "unknown")
+    attributes["tool.execution_summary"] = f"Tool '{tool_name}' executed with type '{call_type}'"
+
+    return attributes

agentops/instrumentation/agentic/agno/attributes/workflow.py

@@ -0,0 +1,254 @@
+"""Workflow attribute extraction for agno workflow instrumentation."""
+
+from typing import Any, Dict, Optional, Tuple
+from opentelemetry.util.types import AttributeValue
+import json
+
+from agentops.semconv.instrumentation import InstrumentationAttributes
+from agentops.semconv.span_kinds import SpanKind as AgentOpsSpanKind
+from agentops.semconv.workflow import WorkflowAttributes
+from agentops.instrumentation.common.attributes import get_common_attributes
+
+
+def get_workflow_run_attributes(
+    args: Tuple[Any, ...] = (),
+    kwargs: Optional[Dict[str, Any]] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, AttributeValue]:
+    """Extract attributes from workflow run operations.
+
+    Args:
+        args: Positional arguments passed to the workflow run method
+        kwargs: Keyword arguments passed to the workflow run method
+        return_value: Return value from the workflow run method
+
+    Returns:
+        Dictionary of OpenTelemetry attributes for workflow runs
+    """
+    attributes = get_common_attributes()
+    kwargs = kwargs or {}
+
+    if args and len(args) > 0:
+        workflow = args[0]
+
+        # Core workflow attributes
+        if hasattr(workflow, "name") and workflow.name:
+            attributes[WorkflowAttributes.WORKFLOW_NAME] = str(workflow.name)
+        if hasattr(workflow, "workflow_id") and workflow.workflow_id:
+            attributes[WorkflowAttributes.WORKFLOW_ID] = str(workflow.workflow_id)
+        if hasattr(workflow, "description") and workflow.description:
+            attributes[WorkflowAttributes.WORKFLOW_DESCRIPTION] = str(workflow.description)
+        if hasattr(workflow, "app_id") and workflow.app_id:
+            attributes[WorkflowAttributes.WORKFLOW_APP_ID] = str(workflow.app_id)
+
+        # Set workflow type
+        attributes[WorkflowAttributes.WORKFLOW_TYPE] = "agno_workflow"
+
+        # Session and user attributes
+        if hasattr(workflow, "session_id") and workflow.session_id:
+            attributes[WorkflowAttributes.WORKFLOW_SESSION_ID] = str(workflow.session_id)
+        if hasattr(workflow, "session_name") and workflow.session_name:
+            attributes[WorkflowAttributes.WORKFLOW_SESSION_NAME] = str(workflow.session_name)
+        if hasattr(workflow, "user_id") and workflow.user_id:
+            attributes[WorkflowAttributes.WORKFLOW_USER_ID] = str(workflow.user_id)
+
+        # Run-specific attributes
+        if hasattr(workflow, "run_id") and workflow.run_id:
+            attributes[WorkflowAttributes.WORKFLOW_RUN_ID] = str(workflow.run_id)
+
+        # Configuration attributes
+        if hasattr(workflow, "debug_mode"):
+            attributes[WorkflowAttributes.WORKFLOW_DEBUG_MODE] = bool(workflow.debug_mode)
+        if hasattr(workflow, "monitoring"):
+            attributes[WorkflowAttributes.WORKFLOW_MONITORING] = bool(workflow.monitoring)
+        if hasattr(workflow, "telemetry"):
+            attributes[WorkflowAttributes.WORKFLOW_TELEMETRY] = bool(workflow.telemetry)
+
+        # Memory and storage attributes
+        if hasattr(workflow, "memory") and workflow.memory:
+            memory_type = type(workflow.memory).__name__
+            attributes[WorkflowAttributes.WORKFLOW_MEMORY_TYPE] = memory_type
+
+        if hasattr(workflow, "storage") and workflow.storage:
+            storage_type = type(workflow.storage).__name__
+            attributes[WorkflowAttributes.WORKFLOW_STORAGE_TYPE] = storage_type
+
+        # Input parameters from kwargs
+        if kwargs:
+            # Store workflow input
+            attributes[WorkflowAttributes.WORKFLOW_INPUT] = str(kwargs)
+
+            # Count and types of input parameters
+            attributes[WorkflowAttributes.WORKFLOW_INPUT_PARAMETER_COUNT] = len(kwargs)
+            param_types = list(set(type(v).__name__ for v in kwargs.values()))
+            if param_types:
+                attributes[WorkflowAttributes.WORKFLOW_INPUT_TYPE] = str(param_types)
+
+            # Store specific input keys (without values for privacy)
+            input_keys = list(kwargs.keys())
+            if input_keys:
+                attributes[WorkflowAttributes.WORKFLOW_INPUT_PARAMETER_KEYS] = str(input_keys)
+
+        # Workflow method parameters if available
+        if hasattr(workflow, "_run_parameters") and workflow._run_parameters:
+            param_count = len(workflow._run_parameters)
+            attributes[WorkflowAttributes.WORKFLOW_METHOD_PARAMETER_COUNT] = param_count
+
+        if hasattr(workflow, "_run_return_type") and workflow._run_return_type:
+            attributes[WorkflowAttributes.WORKFLOW_METHOD_RETURN_TYPE] = str(workflow._run_return_type)
+
+    # Process return value attributes
+    if return_value is not None:
+        return_type = type(return_value).__name__
+        attributes[WorkflowAttributes.WORKFLOW_OUTPUT_TYPE] = return_type
+
+        # Handle RunResponse objects
+        if hasattr(return_value, "content"):
+            # Store workflow output
+            if return_value.content:
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT] = str(return_value.content)
+
+            if hasattr(return_value, "content_type"):
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_CONTENT_TYPE] = str(return_value.content_type)
+            if hasattr(return_value, "event"):
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_EVENT] = str(return_value.event)
+            if hasattr(return_value, "model"):
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_MODEL] = (
+                    str(return_value.model) if return_value.model else ""
+                )
+            if hasattr(return_value, "model_provider"):
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_MODEL_PROVIDER] = (
+                    str(return_value.model_provider) if return_value.model_provider else ""
+                )
+
+            # Count various response components
+            if hasattr(return_value, "messages") and return_value.messages:
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_MESSAGE_COUNT] = len(return_value.messages)
+            if hasattr(return_value, "tools") and return_value.tools:
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_TOOL_COUNT] = len(return_value.tools)
+            if hasattr(return_value, "images") and return_value.images:
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_IMAGE_COUNT] = len(return_value.images)
+            if hasattr(return_value, "videos") and return_value.videos:
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_VIDEO_COUNT] = len(return_value.videos)
+            if hasattr(return_value, "audio") and return_value.audio:
+                attributes[WorkflowAttributes.WORKFLOW_OUTPUT_AUDIO_COUNT] = len(return_value.audio)
+
+        # Handle generators/iterators
+        elif hasattr(return_value, "__iter__") and not isinstance(return_value, (str, bytes)):
+            attributes[WorkflowAttributes.WORKFLOW_OUTPUT_IS_STREAMING] = True
+
+    # Set span kind - AgentOpsSpanKind.WORKFLOW is already a string
+    attributes[InstrumentationAttributes.INSTRUMENTATION_TYPE] = AgentOpsSpanKind.WORKFLOW
+
+    return attributes
+
+
+def get_workflow_session_attributes(
+    args: Tuple[Any, ...] = (),
+    kwargs: Optional[Dict[str, Any]] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, AttributeValue]:
+    """Extract attributes from workflow session operations.
+
+    Args:
+        args: Positional arguments passed to the session method
+        kwargs: Keyword arguments passed to the session method
+        return_value: Return value from the session method
+
+    Returns:
+        Dictionary of OpenTelemetry attributes for workflow sessions
+    """
+    attributes = get_common_attributes()
+    kwargs = kwargs or {}
+
+    if args and len(args) > 0:
+        workflow = args[0]
+
+        # Session attributes
+        if hasattr(workflow, "session_id") and workflow.session_id:
+            attributes[WorkflowAttributes.WORKFLOW_SESSION_ID] = str(workflow.session_id)
+        if hasattr(workflow, "session_name") and workflow.session_name:
+            attributes[WorkflowAttributes.WORKFLOW_SESSION_NAME] = str(workflow.session_name)
+        if hasattr(workflow, "workflow_id") and workflow.workflow_id:
+            attributes[WorkflowAttributes.WORKFLOW_SESSION_WORKFLOW_ID] = str(workflow.workflow_id)
+        if hasattr(workflow, "user_id") and workflow.user_id:
+            attributes[WorkflowAttributes.WORKFLOW_SESSION_USER_ID] = str(workflow.user_id)
+
+        # Session state attributes
+        if hasattr(workflow, "session_state") and workflow.session_state:
+            if isinstance(workflow.session_state, dict):
+                attributes[WorkflowAttributes.WORKFLOW_SESSION_STATE_KEYS] = str(list(workflow.session_state.keys()))
+                attributes[WorkflowAttributes.WORKFLOW_SESSION_STATE_SIZE] = len(workflow.session_state)
+
+        # Storage attributes
+        if hasattr(workflow, "storage") and workflow.storage:
+            storage_type = type(workflow.storage).__name__
+            attributes[WorkflowAttributes.WORKFLOW_SESSION_STORAGE_TYPE] = storage_type
+
+    # Process session return value if it's a WorkflowSession
+    if return_value is not None and hasattr(return_value, "session_id"):
+        attributes[WorkflowAttributes.WORKFLOW_SESSION_RETURNED_SESSION_ID] = str(return_value.session_id)
+        if hasattr(return_value, "created_at") and return_value.created_at:
+            attributes[WorkflowAttributes.WORKFLOW_SESSION_CREATED_AT] = int(return_value.created_at)
+        if hasattr(return_value, "updated_at") and return_value.updated_at:
+            attributes[WorkflowAttributes.WORKFLOW_SESSION_UPDATED_AT] = int(return_value.updated_at)
+
+    # Set span kind - AgentOpsSpanKind.WORKFLOW is already a string
+    attributes[InstrumentationAttributes.INSTRUMENTATION_TYPE] = AgentOpsSpanKind.WORKFLOW
+
+    return attributes
+
+
+def get_workflow_cache_attributes(
+    args: Tuple[Any, ...] = (),
+    kwargs: Optional[Dict[str, Any]] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, AttributeValue]:
+    """Extract attributes from workflow cache operations.
+
+    Args:
+        args: Positional arguments passed to the cache method
+        kwargs: Keyword arguments passed to the cache method
+        return_value: Return value from the cache method
+
+    Returns:
+        Dictionary of OpenTelemetry attributes for cache operations
+    """
+    attributes = get_common_attributes()
+    kwargs = kwargs or {}
+
+    if args and len(args) > 0:
+        workflow = args[0]
+
+        # Get workflow information
+        if hasattr(workflow, "workflow_id") and workflow.workflow_id:
+            attributes["cache.workflow_id"] = str(workflow.workflow_id)
+        if hasattr(workflow, "session_id") and workflow.session_id:
+            attributes["cache.session_id"] = str(workflow.session_id)
+
+        # Get cache state
+        if hasattr(workflow, "session_state") and isinstance(workflow.session_state, dict):
+            attributes["cache.size"] = len(workflow.session_state)
+            attributes["cache.keys"] = json.dumps(list(workflow.session_state.keys()))
+
+    # Determine cache operation type and result
+    if len(args) > 1:
+        cache_key = str(args[1])
+        attributes["cache.key"] = cache_key
+
+    if return_value is not None:
+        attributes["cache.hit"] = True
+        attributes["cache.result"] = "hit"
+
+        # Add value info
+        if isinstance(return_value, str):
+            attributes["cache.value_size"] = len(return_value)
+            if len(return_value) <= 100:
+                attributes["cache.value"] = return_value
+            else:
+                attributes["cache.value_preview"] = return_value[:100] + "..."
+    else:
+        attributes["cache.hit"] = False
+        attributes["cache.result"] = "miss"
+
+    return attributes