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

agentops/instrumentation/agentic/smolagents/README.md

@@ -0,0 +1,88 @@
+# SmoLAgents Instrumentation
+
+This module provides OpenTelemetry instrumentation for the SmoLAgents framework. It captures telemetry data from model operations, agent executions, and tool usage.
+
+## Features
+
+- Model operation tracking
+  - Text generation
+  - Token usage
+  - Streaming responses
+  - Latency metrics
+
+- Agent execution monitoring
+  - Step-by-step execution
+  - Planning phases
+  - Tool usage
+  - Execution time
+
+- Tool usage analytics
+  - Tool call patterns
+  - Success/failure rates
+  - Execution time
+  - Error tracking
+
+## Usage
+
+```python
+from agentops import init
+from agentops.instrumentation.smolagents import SmolagentsInstrumentor
+
+# Initialize AgentOps with your API key
+init(api_key="your-api-key")
+
+# The instrumentation will be automatically activated
+# All SmoLAgents operations will now be tracked
+```
+
+## Metrics Collected
+
+1. Token Usage
+   - Input tokens
+   - Output tokens
+   - Total tokens per operation
+
+2. Timing Metrics
+   - Operation duration
+   - Time to first token (streaming)
+   - Tool execution time
+   - Planning phase duration
+
+3. Agent Metrics
+   - Step counts
+   - Planning steps
+   - Tools used
+   - Success/failure rates
+
+4. Error Tracking
+   - Generation errors
+   - Tool execution errors
+   - Parsing errors
+
+## Architecture
+
+The instrumentation is built on OpenTelemetry and follows the same pattern as other AgentOps instrumentors:
+
+1. Attribute Extractors
+   - Model attributes
+   - Agent attributes
+   - Tool call attributes
+
+2. Wrappers
+   - Method wrappers for sync operations
+   - Stream wrappers for async operations
+   - Context propagation handling
+
+3. Metrics
+   - Histograms for distributions
+   - Counters for events
+   - Custom attributes for filtering
+
+## Contributing
+
+When adding new features or modifying existing ones:
+
+1. Follow the established pattern for attribute extraction
+2. Maintain context propagation
+3. Add appropriate error handling
+4. Update tests and documentation 

agentops/instrumentation/agentic/smolagents/__init__.py

@@ -0,0 +1,12 @@
+"""SmoLAgents instrumentation for AgentOps."""
+
+from agentops.instrumentation.common import LibraryInfo
+
+# Library information
+_library_info = LibraryInfo(name="smolagents", default_version="1.16.0")
+LIBRARY_NAME = _library_info.name
+LIBRARY_VERSION = _library_info.version
+
+from agentops.instrumentation.agentic.smolagents.instrumentor import SmolagentsInstrumentor  # noqa: E402
+
+__all__ = ["SmolagentsInstrumentor"]

agentops/instrumentation/agentic/smolagents/attributes/agent.py

@@ -0,0 +1,354 @@
+"""Attribute extractors for SmoLAgents agent operations."""
+
+from typing import Any, Dict, Optional, Tuple
+import uuid
+import json
+
+from agentops.instrumentation.common.attributes import get_common_attributes
+from agentops.semconv.agent import AgentAttributes
+from agentops.semconv.tool import ToolAttributes
+
+
+def get_agent_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, Any]:
+    """Extract attributes from an agent execution call.
+
+    Args:
+        args: Optional tuple of positional arguments
+        kwargs: Optional dict of keyword arguments
+        return_value: Optional return value from the function
+
+    Returns:
+        Dictionary of extracted attributes
+    """
+    attributes = get_common_attributes()
+
+    try:
+        # Extract agent instance information
+        agent_instance = None
+        if args and len(args) > 0:
+            agent_instance = args[0]
+        elif kwargs and "self" in kwargs:
+            agent_instance = kwargs["self"]
+
+        if agent_instance:
+            # Extract agent name
+            agent_name = getattr(agent_instance, "name", agent_instance.__class__.__name__)
+            attributes[AgentAttributes.AGENT_NAME] = agent_name
+
+            # Generate agent ID if not present
+            agent_id = getattr(agent_instance, "id", str(uuid.uuid4()))
+            attributes[AgentAttributes.AGENT_ID] = agent_id
+
+            # Extract agent role/type
+            attributes[AgentAttributes.AGENT_ROLE] = "executor"
+
+            # Extract tools information
+            tools = getattr(agent_instance, "tools", [])
+            if tools:
+                tool_names = []
+                for tool in tools:
+                    tool_name = getattr(tool, "name", str(tool))
+                    tool_names.append(tool_name)
+                attributes[AgentAttributes.AGENT_TOOLS] = json.dumps(tool_names)
+            else:
+                attributes[AgentAttributes.AGENT_TOOLS] = "[]"
+
+            # Extract managed agents information
+            managed_agents = getattr(agent_instance, "managed_agents", [])
+            if managed_agents:
+                managed_agent_names = []
+                for managed_agent in managed_agents:
+                    agent_name = getattr(managed_agent, "name", managed_agent.__class__.__name__)
+                    managed_agent_names.append(agent_name)
+                attributes[AgentAttributes.AGENT_MANAGED_AGENTS] = json.dumps(managed_agent_names)
+            else:
+                attributes[AgentAttributes.AGENT_MANAGED_AGENTS] = "[]"
+
+        # Extract input/task from args or kwargs
+        task_input = None
+        if args and len(args) > 1:
+            task_input = args[1]
+        elif kwargs and "task" in kwargs:
+            task_input = kwargs["task"]
+        elif kwargs and "prompt" in kwargs:
+            task_input = kwargs["prompt"]
+
+        if task_input:
+            attributes["agent.task"] = str(task_input)
+
+        # Extract return value/output
+        if return_value is not None:
+            attributes["agentops.entity.output"] = str(return_value)
+
+    except Exception:
+        # If extraction fails, continue with basic attributes
+        pass
+
+    return attributes
+
+
+def get_agent_stream_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, Any]:
+    """Extract attributes from an agent streaming call.
+
+    Args:
+        args: Optional tuple of positional arguments
+        kwargs: Optional dict of keyword arguments
+        return_value: Optional return value from the function
+
+    Returns:
+        Dictionary of extracted attributes
+    """
+    attributes = get_common_attributes()
+
+    try:
+        # Extract reasoning/task information
+        if kwargs:
+            if "max_steps" in kwargs:
+                attributes["agent.max_steps"] = str(kwargs["max_steps"])
+
+            # Extract task/reasoning from various parameter names
+            task_info = None
+            for param_name in ["task", "prompt", "reasoning", "query"]:
+                if param_name in kwargs:
+                    task_info = kwargs[param_name]
+                    break
+
+            if task_info:
+                attributes["agent.reasoning"] = str(task_info)
+
+        # Extract from args
+        if args and len(args) > 1:
+            task_info = args[1]
+            attributes["agent.reasoning"] = str(task_info)
+
+    except Exception:
+        # If extraction fails, continue with basic attributes
+        pass
+
+    return attributes
+
+
+def get_agent_step_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, Any]:
+    """Extract attributes from an agent step execution.
+
+    Args:
+        args: Optional tuple of positional arguments
+        kwargs: Optional dict of keyword arguments
+        return_value: Optional return value from the function
+
+    Returns:
+        Dictionary of extracted attributes
+    """
+    attributes = get_common_attributes()
+
+    try:
+        # Try to extract step information
+        step_number = getattr(args[0] if args else None, "step_count", None)
+        if step_number is not None:
+            attributes["agent.step_number"] = str(step_number)
+
+        # Extract step name/type
+        step_name = "ActionStep"  # Default for smolagents
+        attributes["agent.name"] = step_name
+
+        # Extract return value
+        if return_value is not None:
+            attributes["agentops.entity.output"] = str(return_value)
+
+    except Exception:
+        # If extraction fails, continue with basic attributes
+        pass
+
+    return attributes
+
+
+def get_tool_call_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, Any]:
+    """Extract attributes from a tool call execution.
+
+    Args:
+        args: Optional tuple of positional arguments
+        kwargs: Optional dict of keyword arguments
+        return_value: Optional return value from the function
+
+    Returns:
+        Dictionary of extracted attributes
+    """
+    attributes = get_common_attributes()
+
+    try:
+        # Generate tool execution ID
+        tool_id = str(uuid.uuid4())
+        attributes[ToolAttributes.TOOL_ID] = tool_id
+
+        # Extract tool information from various sources
+        tool_name = "unknown"
+        tool_description = "unknown"
+        tool_parameters = "{}"
+
+        # Try to extract from instance (first arg)
+        if args and len(args) > 0:
+            instance = args[0]
+            if hasattr(instance, "name"):
+                tool_name = instance.name
+            if hasattr(instance, "description"):
+                tool_description = instance.description
+
+        # Try to extract from kwargs
+        if kwargs:
+            if "tool_call" in kwargs:
+                tool_call = kwargs["tool_call"]
+                if hasattr(tool_call, "function"):
+                    tool_name = tool_call.function.name
+                    if hasattr(tool_call.function, "arguments"):
+                        tool_parameters = tool_call.function.arguments
+            elif "name" in kwargs:
+                tool_name = kwargs["name"]
+            elif "function_name" in kwargs:
+                tool_name = kwargs["function_name"]
+
+            # Extract parameters
+            if "parameters" in kwargs:
+                tool_parameters = json.dumps(kwargs["parameters"])
+            elif "arguments" in kwargs:
+                tool_parameters = json.dumps(kwargs["arguments"])
+            elif "args" in kwargs:
+                tool_parameters = json.dumps(kwargs["args"])
+
+        # Set tool attributes
+        attributes[ToolAttributes.TOOL_NAME] = tool_name
+        attributes[ToolAttributes.TOOL_DESCRIPTION] = tool_description
+        attributes[ToolAttributes.TOOL_PARAMETERS] = tool_parameters
+        attributes[ToolAttributes.TOOL_STATUS] = "pending"
+        attributes[ToolAttributes.TOOL_OUTPUT_TYPE] = "unknown"
+        attributes[ToolAttributes.TOOL_INPUTS] = "{}"
+
+        # Extract return value
+        if return_value is not None:
+            attributes["tool.result"] = str(return_value)
+            attributes[ToolAttributes.TOOL_STATUS] = "success"
+
+    except Exception:
+        # If extraction fails, set basic attributes
+        attributes[ToolAttributes.TOOL_NAME] = "unknown"
+        attributes[ToolAttributes.TOOL_DESCRIPTION] = "unknown"
+        attributes[ToolAttributes.TOOL_ID] = str(uuid.uuid4())
+        attributes[ToolAttributes.TOOL_PARAMETERS] = "{}"
+        attributes[ToolAttributes.TOOL_STATUS] = "pending"
+
+    return attributes
+
+
+def get_planning_step_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, Any]:
+    """Extract attributes from a planning step execution.
+
+    Args:
+        args: Optional tuple of positional arguments
+        kwargs: Optional dict of keyword arguments
+        return_value: Optional return value from the function
+
+    Returns:
+        Dictionary of extracted attributes
+    """
+    attributes = get_common_attributes()
+
+    try:
+        # Extract planning information
+        if kwargs:
+            if "planning_step" in kwargs:
+                step = kwargs["planning_step"]
+                attributes["agent.planning.step"] = str(step)
+            if "reasoning" in kwargs:
+                attributes["agent.planning.reasoning"] = str(kwargs["reasoning"])
+
+        # Extract return value
+        if return_value is not None:
+            attributes["agentops.entity.output"] = str(return_value)
+
+    except Exception:
+        # If extraction fails, continue with basic attributes
+        pass
+
+    return attributes
+
+
+def get_managed_agent_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, Any]:
+    """Extract attributes from a managed agent call.
+
+    Args:
+        args: Optional tuple of positional arguments
+        kwargs: Optional dict of keyword arguments
+        return_value: Optional return value from the function
+
+    Returns:
+        Dictionary of extracted attributes
+    """
+    attributes = get_common_attributes()
+
+    try:
+        # Extract managed agent information
+        agent_instance = None
+        if args and len(args) > 0:
+            agent_instance = args[0]
+        elif kwargs and "agent" in kwargs:
+            agent_instance = kwargs["agent"]
+
+        if agent_instance:
+            # Extract agent details
+            agent_name = getattr(agent_instance, "name", agent_instance.__class__.__name__)
+            agent_id = getattr(agent_instance, "id", str(uuid.uuid4()))
+            agent_description = getattr(agent_instance, "description", "")
+
+            attributes[AgentAttributes.AGENT_NAME] = agent_name
+            attributes[AgentAttributes.AGENT_ID] = agent_id
+            attributes[AgentAttributes.AGENT_ROLE] = "managed"
+            attributes[AgentAttributes.AGENT_TYPE] = agent_instance.__class__.__name__
+
+            if agent_description:
+                attributes[AgentAttributes.AGENT_DESCRIPTION] = agent_description
+
+            # Check if this agent provides run summaries
+            attributes["agent.provide_run_summary"] = "false"  # Default for smolagents
+
+        # Extract task information
+        task = None
+        if args and len(args) > 1:
+            task = args[1]
+        elif kwargs and "task" in kwargs:
+            task = kwargs["task"]
+
+        if task:
+            attributes["agent.task"] = str(task)
+
+        # Extract return value
+        if return_value is not None:
+            attributes["agentops.entity.output"] = str(return_value)
+
+    except Exception:
+        # If extraction fails, continue with basic attributes
+        pass
+
+    return attributes

agentops/instrumentation/agentic/smolagents/attributes/model.py

@@ -0,0 +1,205 @@
+"""Attribute extractors for SmoLAgents model operations."""
+
+from typing import Any, Dict, Optional, Tuple
+import json
+
+from agentops.instrumentation.common.attributes import (
+    get_common_attributes,
+)
+from agentops.semconv.message import MessageAttributes
+from agentops.semconv.span_attributes import SpanAttributes
+
+
+def get_model_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, Any]:
+    """Extract attributes from a model generation call.
+
+    Args:
+        args: Optional tuple of positional arguments
+        kwargs: Optional dict of keyword arguments
+        return_value: Optional return value from the function
+
+    Returns:
+        Dictionary of extracted attributes
+    """
+    attributes = get_common_attributes()
+
+    try:
+        # Extract model name from various sources
+        model_name = "unknown"
+
+        # Try to get from kwargs
+        if kwargs:
+            if "model" in kwargs:
+                model_name = kwargs["model"]
+            elif kwargs.get("self") and hasattr(kwargs["self"], "model_id"):
+                model_name = kwargs["self"].model_id
+
+        # Try to get from args (instance is usually first arg in methods)
+        if model_name == "unknown" and args and len(args) > 0:
+            instance = args[0]
+            if hasattr(instance, "model_id"):
+                model_name = instance.model_id
+
+        # Set model attributes
+        attributes[SpanAttributes.LLM_REQUEST_MODEL] = model_name
+
+        # Extract messages from kwargs
+        if kwargs and "messages" in kwargs:
+            messages = kwargs["messages"]
+            if isinstance(messages, list):
+                for i, message in enumerate(messages):
+                    message_dict = message
+                    if hasattr(message, "to_dict"):
+                        message_dict = message.to_dict()
+                    elif hasattr(message, "__dict__"):
+                        message_dict = message.__dict__
+
+                    if isinstance(message_dict, dict):
+                        # Set role
+                        role = message_dict.get("role", "user")
+                        attributes[MessageAttributes.PROMPT_ROLE.format(i=i)] = role
+
+                        # Set content
+                        content = message_dict.get("content", "")
+                        if content:
+                            attributes[MessageAttributes.PROMPT_CONTENT.format(i=i)] = str(content)
+
+        # Extract tools from kwargs
+        if kwargs and "tools_to_call_from" in kwargs:
+            tools = kwargs["tools_to_call_from"]
+            if tools and isinstance(tools, list):
+                for i, tool in enumerate(tools):
+                    tool_name = getattr(tool, "name", "unknown")
+                    tool_description = getattr(tool, "description", "")
+
+                    attributes[MessageAttributes.TOOL_CALL_NAME.format(i=i)] = tool_name
+                    if tool_description:
+                        attributes[MessageAttributes.TOOL_CALL_DESCRIPTION.format(i=i)] = tool_description
+
+        # Extract additional parameters
+        if kwargs:
+            if "temperature" in kwargs:
+                attributes[SpanAttributes.LLM_REQUEST_TEMPERATURE] = kwargs["temperature"]
+            if "max_tokens" in kwargs:
+                attributes[SpanAttributes.LLM_REQUEST_MAX_TOKENS] = kwargs["max_tokens"]
+            if "stop_sequences" in kwargs:
+                attributes[SpanAttributes.LLM_REQUEST_STOP_SEQUENCES] = json.dumps(kwargs["stop_sequences"])
+
+        # Extract response attributes
+        if return_value:
+            try:
+                # Handle ChatMessage response
+                if hasattr(return_value, "content"):
+                    attributes[MessageAttributes.COMPLETION_CONTENT.format(i=0)] = str(return_value.content)
+                if hasattr(return_value, "role"):
+                    attributes[MessageAttributes.COMPLETION_ROLE.format(i=0)] = return_value.role
+
+                # Handle tool calls in response
+                if hasattr(return_value, "tool_calls") and return_value.tool_calls:
+                    for j, tool_call in enumerate(return_value.tool_calls):
+                        if hasattr(tool_call, "function"):
+                            attributes[MessageAttributes.COMPLETION_TOOL_CALL_NAME.format(i=0, j=j)] = (
+                                tool_call.function.name
+                            )
+                            if hasattr(tool_call.function, "arguments"):
+                                attributes[MessageAttributes.COMPLETION_TOOL_CALL_ARGUMENTS.format(i=0, j=j)] = (
+                                    tool_call.function.arguments
+                                )
+                            if hasattr(tool_call, "id"):
+                                attributes[MessageAttributes.COMPLETION_TOOL_CALL_ID.format(i=0, j=j)] = tool_call.id
+
+                # Extract token usage
+                if hasattr(return_value, "token_usage") and return_value.token_usage:
+                    token_usage = return_value.token_usage
+                    if hasattr(token_usage, "input_tokens"):
+                        attributes[SpanAttributes.LLM_USAGE_PROMPT_TOKENS] = token_usage.input_tokens
+                    if hasattr(token_usage, "output_tokens"):
+                        attributes[SpanAttributes.LLM_USAGE_COMPLETION_TOKENS] = token_usage.output_tokens
+                    if hasattr(token_usage, "total_tokens"):
+                        attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS] = token_usage.total_tokens
+
+                # Extract response ID
+                if hasattr(return_value, "raw") and return_value.raw:
+                    raw_response = return_value.raw
+                    if hasattr(raw_response, "id"):
+                        attributes[SpanAttributes.LLM_RESPONSE_ID] = raw_response.id
+
+            except Exception:
+                # If we can't extract response attributes, continue with what we have
+                pass
+
+    except Exception:
+        # If extraction fails, return basic attributes
+        pass
+
+    return attributes
+
+
+def get_stream_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> Dict[str, Any]:
+    """Extract attributes from a streaming model generation call.
+
+    Args:
+        args: Optional tuple of positional arguments
+        kwargs: Optional dict of keyword arguments
+        return_value: Optional return value from the function
+
+    Returns:
+        Dictionary of extracted attributes
+    """
+    attributes = get_common_attributes()
+
+    try:
+        # Extract model name
+        model_name = "unknown"
+        if kwargs and kwargs.get("self") and hasattr(kwargs["self"], "model_id"):
+            model_name = kwargs["self"].model_id
+        elif args and len(args) > 0 and hasattr(args[0], "model_id"):
+            model_name = args[0].model_id
+
+        attributes[SpanAttributes.LLM_REQUEST_MODEL] = model_name
+        attributes["gen_ai.request.streaming"] = True
+
+        # Extract messages for streaming
+        if kwargs and "messages" in kwargs:
+            messages = kwargs["messages"]
+            if isinstance(messages, list):
+                for i, message in enumerate(messages):
+                    message_dict = message
+                    if hasattr(message, "to_dict"):
+                        message_dict = message.to_dict()
+                    elif hasattr(message, "__dict__"):
+                        message_dict = message.__dict__
+
+                    if isinstance(message_dict, dict):
+                        role = message_dict.get("role", "user")
+                        attributes[MessageAttributes.PROMPT_ROLE.format(i=i)] = role
+
+                        content = message_dict.get("content", "")
+                        if content:
+                            attributes[MessageAttributes.PROMPT_CONTENT.format(i=i)] = str(content)
+
+        # Extract tools for streaming
+        if kwargs and "tools_to_call_from" in kwargs:
+            tools = kwargs["tools_to_call_from"]
+            if tools and isinstance(tools, list):
+                for i, tool in enumerate(tools):
+                    tool_name = getattr(tool, "name", "unknown")
+                    tool_description = getattr(tool, "description", "")
+
+                    attributes[MessageAttributes.TOOL_CALL_NAME.format(i=i)] = tool_name
+                    if tool_description:
+                        attributes[MessageAttributes.TOOL_CALL_DESCRIPTION.format(i=i)] = tool_description
+
+    except Exception:
+        # If extraction fails, return basic attributes
+        pass
+
+    return attributes