agentfield 0.1.22rc2__py3-none-any.whl

agentfield/did_manager.py

@@ -0,0 +1,337 @@
+"""
+DID Manager for AgentField SDK
+
+Handles Decentralized Identity (DID) and Verifiable Credentials (VC) functionality
+for agent nodes, reasoners, and skills.
+"""
+
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+import requests
+from datetime import datetime
+
+from .logger import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class DIDIdentity:
+    """Represents a DID identity with cryptographic keys."""
+
+    did: str
+    private_key_jwk: str
+    public_key_jwk: str
+    derivation_path: str
+    component_type: str
+    function_name: Optional[str] = None
+
+
+@dataclass
+class DIDIdentityPackage:
+    """Complete DID identity package for an agent."""
+
+    agent_did: DIDIdentity
+    reasoner_dids: Dict[str, DIDIdentity]
+    skill_dids: Dict[str, DIDIdentity]
+    agentfield_server_id: str
+
+
+@dataclass
+class DIDExecutionContext:
+    """Context for DID-enabled execution."""
+
+    execution_id: str
+    workflow_id: str
+    session_id: str
+    caller_did: str
+    target_did: str
+    agent_node_did: str
+    timestamp: datetime
+
+
+class DIDManager:
+    """
+    Manages DID operations for AgentField SDK agents.
+
+    Handles:
+    - Agent registration with AgentField Server
+    - DID resolution and verification
+    - Execution context creation
+    - Integration with agent lifecycle
+    """
+
+    def __init__(
+        self, agentfield_server_url: str, agent_node_id: str, api_key: Optional[str] = None
+    ):
+        """
+        Initialize DID Manager.
+
+        Args:
+            agentfield_server_url: URL of the AgentField Server
+            agent_node_id: Unique identifier for this agent node
+            api_key: Optional API key for authentication
+        """
+        self.agentfield_server_url = agentfield_server_url.rstrip("/")
+        self.agent_node_id = agent_node_id
+        self.api_key = api_key
+        self.identity_package: Optional[DIDIdentityPackage] = None
+        self.enabled = False
+
+    def _get_auth_headers(self) -> Dict[str, str]:
+        """Return auth headers if API key is configured."""
+        if not self.api_key:
+            return {}
+        return {"X-API-Key": self.api_key}
+
+    def register_agent(
+        self, reasoners: List[Dict[str, Any]], skills: List[Dict[str, Any]]
+    ) -> bool:
+        """
+        Register agent with AgentField Server and obtain DID identity package.
+
+        Args:
+            reasoners: List of reasoner definitions
+            skills: List of skill definitions
+
+        Returns:
+            True if registration successful, False otherwise
+        """
+        try:
+            logger.debug(
+                f"DID registration for agent: {self.agent_node_id} "
+                f"({len(reasoners)} reasoners, {len(skills)} skills)"
+            )
+
+            # Prepare registration request
+            registration_data = {
+                "agent_node_id": self.agent_node_id,
+                "reasoners": reasoners,
+                "skills": skills,
+            }
+
+            # Send registration request to AgentField Server
+            headers = {"Content-Type": "application/json"}
+            headers.update(self._get_auth_headers())
+            response = requests.post(
+                f"{self.agentfield_server_url}/api/v1/did/register",
+                json=registration_data,
+                headers=headers,
+                timeout=30,
+            )
+
+            if response.status_code == 200:
+                result = response.json()
+                if result.get("success"):
+                    # Parse identity package
+                    package_data = result["identity_package"]
+                    self.identity_package = self._parse_identity_package(package_data)
+                    self.enabled = True
+                    logger.debug(
+                        f"Agent {self.agent_node_id} successfully registered with DID system"
+                    )
+                    return True
+                else:
+                    error_msg = result.get("error", "Unknown error")
+                    logger.error(f"DID registration failed: {error_msg}")
+                    return False
+            else:
+                error_msg = f"{response.status_code} - {response.text}"
+                logger.error(f"DID registration request failed: {error_msg}")
+                return False
+
+        except Exception as e:
+            logger.error(f"Error during DID registration: {e}")
+            return False
+
+    def create_execution_context(
+        self,
+        execution_id: str,
+        workflow_id: str,
+        session_id: str,
+        caller_function: str,
+        target_function: str,
+    ) -> Optional[DIDExecutionContext]:
+        """
+        Create execution context for DID-enabled execution.
+
+        Args:
+            execution_id: Unique execution identifier
+            workflow_id: Workflow identifier
+            session_id: Session identifier
+            caller_function: Name of calling function
+            target_function: Name of target function
+
+        Returns:
+            ExecutionContext if successful, None otherwise
+        """
+        if not self.enabled or not self.identity_package:
+            return None
+
+        try:
+            # Resolve caller DID
+            caller_did = self._get_function_did(caller_function)
+            if not caller_did:
+                logger.warning(
+                    f"Could not resolve DID for caller function: {caller_function}"
+                )
+                return None
+
+            # Resolve target DID
+            target_did = self._get_function_did(target_function)
+            if not target_did:
+                logger.warning(
+                    f"Could not resolve DID for target function: {target_function}"
+                )
+                return None
+
+            return DIDExecutionContext(
+                execution_id=execution_id,
+                workflow_id=workflow_id,
+                session_id=session_id,
+                caller_did=caller_did,
+                target_did=target_did,
+                agent_node_did=self.identity_package.agent_did.did,
+                timestamp=datetime.utcnow(),
+            )
+
+        except Exception as e:
+            logger.error(f"Error creating execution context: {e}")
+            return None
+
+    def get_agent_did(self) -> Optional[str]:
+        """Get the agent node DID."""
+        if self.identity_package:
+            return self.identity_package.agent_did.did
+        return None
+
+    def get_function_did(self, function_name: str) -> Optional[str]:
+        """
+        Get DID for a specific function (reasoner or skill).
+
+        Args:
+            function_name: Name of the function
+
+        Returns:
+            DID string if found, None otherwise
+        """
+        return self._get_function_did(function_name)
+
+    def resolve_did(self, did: str) -> Optional[Dict[str, Any]]:
+        """
+        Resolve a DID to get its public information.
+
+        Args:
+            did: DID to resolve
+
+        Returns:
+            DID document if successful, None otherwise
+        """
+        try:
+            response = requests.get(
+                f"{self.agentfield_server_url}/api/v1/did/resolve/{did}",
+                headers=self._get_auth_headers(),
+                timeout=10,
+            )
+
+            if response.status_code == 200:
+                return response.json()
+            else:
+                logger.warning(f"Failed to resolve DID {did}: {response.status_code}")
+                return None
+
+        except Exception as e:
+            logger.error(f"Error resolving DID {did}: {e}")
+            return None
+
+    def is_enabled(self) -> bool:
+        """Check if DID system is enabled and configured."""
+        return self.enabled and self.identity_package is not None
+
+    def get_identity_summary(self) -> Dict[str, Any]:
+        """
+        Get summary of identity package for debugging/monitoring.
+
+        Returns:
+            Dictionary with identity information (no private keys)
+        """
+        if not self.identity_package:
+            return {"enabled": False, "message": "No identity package available"}
+
+        return {
+            "enabled": True,
+            "agent_did": self.identity_package.agent_did.did,
+            "agentfield_server_id": self.identity_package.agentfield_server_id,
+            "reasoner_count": len(self.identity_package.reasoner_dids),
+            "skill_count": len(self.identity_package.skill_dids),
+            "reasoner_dids": {
+                name: identity.did
+                for name, identity in self.identity_package.reasoner_dids.items()
+            },
+            "skill_dids": {
+                name: identity.did
+                for name, identity in self.identity_package.skill_dids.items()
+            },
+        }
+
+    def _parse_identity_package(
+        self, package_data: Dict[str, Any]
+    ) -> DIDIdentityPackage:
+        """Parse identity package from registration response."""
+        # Parse agent DID
+        agent_data = package_data["agent_did"]
+        agent_did = DIDIdentity(
+            did=agent_data["did"],
+            private_key_jwk=agent_data["private_key_jwk"],
+            public_key_jwk=agent_data["public_key_jwk"],
+            derivation_path=agent_data["derivation_path"],
+            component_type=agent_data["component_type"],
+            function_name=agent_data.get("function_name"),
+        )
+
+        # Parse reasoner DIDs
+        reasoner_dids = {}
+        for name, reasoner_data in package_data["reasoner_dids"].items():
+            reasoner_dids[name] = DIDIdentity(
+                did=reasoner_data["did"],
+                private_key_jwk=reasoner_data["private_key_jwk"],
+                public_key_jwk=reasoner_data["public_key_jwk"],
+                derivation_path=reasoner_data["derivation_path"],
+                component_type=reasoner_data["component_type"],
+                function_name=reasoner_data.get("function_name"),
+            )
+
+        # Parse skill DIDs
+        skill_dids = {}
+        for name, skill_data in package_data["skill_dids"].items():
+            skill_dids[name] = DIDIdentity(
+                did=skill_data["did"],
+                private_key_jwk=skill_data["private_key_jwk"],
+                public_key_jwk=skill_data["public_key_jwk"],
+                derivation_path=skill_data["derivation_path"],
+                component_type=skill_data["component_type"],
+                function_name=skill_data.get("function_name"),
+            )
+
+        return DIDIdentityPackage(
+            agent_did=agent_did,
+            reasoner_dids=reasoner_dids,
+            skill_dids=skill_dids,
+            agentfield_server_id=package_data["agentfield_server_id"],
+        )
+
+    def _get_function_did(self, function_name: str) -> Optional[str]:
+        """Get DID for a function by name."""
+        if not self.identity_package:
+            return None
+
+        # Check reasoners
+        if function_name in self.identity_package.reasoner_dids:
+            return self.identity_package.reasoner_dids[function_name].did
+
+        # Check skills
+        if function_name in self.identity_package.skill_dids:
+            return self.identity_package.skill_dids[function_name].did
+
+        # Return agent DID as fallback
+        return self.identity_package.agent_did.did

agentfield/dynamic_skills.py

@@ -0,0 +1,304 @@
+import asyncio
+from typing import Any, Dict, Optional, Type
+
+from pydantic import BaseModel, create_model
+from fastapi import Request
+
+from agentfield.agent_utils import AgentUtils
+from agentfield.execution_context import ExecutionContext
+from agentfield.logger import log_debug, log_error, log_info, log_warn
+
+
+class DynamicMCPSkillManager:
+    """
+    Dynamic MCP Skill Generator that converts MCP tools into AgentField skills.
+
+    This class discovers MCP servers, lists their tools, and dynamically
+    registers each tool as a AgentField skill with proper schema generation
+    and execution context handling.
+    """
+
+    def __init__(self, agent, dev_mode: bool = False):
+        """
+        Initialize the Dynamic MCP Skill Manager.
+
+        Args:
+            agent: The AgentField agent instance
+            dev_mode: Enable development mode logging
+        """
+        self.agent = agent
+        self.dev_mode = dev_mode
+        self.registered_skills: Dict[str, Dict] = {}
+
+    async def discover_and_register_all_skills(self) -> None:
+        """
+        Discover and register all MCP tools as AgentField skills.
+
+        This method:
+        1. Checks for MCP client registry availability
+        2. Iterates through all connected MCP servers
+        3. Waits for server readiness
+        4. Performs health checks on each server
+        5. Lists tools from healthy servers
+        6. Registers each tool as a AgentField skill
+        """
+        if not self.agent.mcp_client_registry:
+            if self.dev_mode:
+                log_warn("MCP client registry not available")
+            return
+
+        if self.dev_mode:
+            log_info("Starting MCP skill discovery...")
+
+        # Get all registered MCP clients
+        clients = self.agent.mcp_client_registry.clients
+
+        if not clients:
+            if self.dev_mode:
+                log_info("No MCP servers found in registry")
+            return
+
+        # Wait for server readiness
+        await asyncio.sleep(1)
+
+        for server_alias, client in clients.items():
+            try:
+                if self.dev_mode:
+                    log_debug(f"Processing MCP server: {server_alias}")
+
+                # Perform health check
+                is_healthy = await client.health_check()
+                if not is_healthy:
+                    if self.dev_mode:
+                        log_warn(
+                            f"MCP server {server_alias} failed health check, skipping"
+                        )
+                    continue
+
+                # List tools from the server
+                tools = await client.list_tools()
+                if not tools:
+                    if self.dev_mode:
+                        log_info(f"No tools found in MCP server {server_alias}")
+                    continue
+
+                if self.dev_mode:
+                    log_debug(f"Found {len(tools)} tools in {server_alias}")
+
+                # Register each tool as a skill
+                for tool in tools:
+                    try:
+                        skill_name = AgentUtils.generate_skill_name(
+                            server_alias, tool.get("name", "")
+                        )
+                        await self._register_mcp_tool_as_skill(
+                            server_alias, tool, skill_name
+                        )
+
+                        if self.dev_mode:
+                            log_info(f"Registered skill: {skill_name}")
+
+                    except Exception as e:
+                        if self.dev_mode:
+                            log_error(
+                                f"Failed to register tool {tool.get('name', 'unknown')} from {server_alias}: {e}"
+                            )
+                        continue
+
+            except Exception as e:
+                if self.dev_mode:
+                    log_error(f"Error processing MCP server {server_alias}: {e}")
+                continue
+
+        if self.dev_mode:
+            log_info(
+                f"MCP skill discovery complete. Registered {len(self.registered_skills)} skills"
+            )
+
+    async def _register_mcp_tool_as_skill(
+        self, server_alias: str, tool: Dict[str, Any], skill_name: str
+    ) -> None:
+        """
+        Register an MCP tool as a AgentField skill.
+
+        This method:
+        1. Extracts tool metadata (name, description)
+        2. Generates Pydantic input schema from tool definition
+        3. Creates async wrapper function for MCP tool calls
+        4. Sets function metadata
+        5. Creates FastAPI endpoint
+        6. Handles execution context from request headers
+        7. Stores and clears execution context appropriately
+        8. Registers skill metadata with agent
+        9. Adds to internal skill registry
+
+        Args:
+            server_alias: MCP server alias
+            tool: Tool definition from MCP server
+            skill_name: Generated skill name
+        """
+        tool_name = tool.get("name", "")
+        description = tool.get(
+            "description", f"MCP tool {tool_name} from {server_alias}"
+        )
+
+        # Generate Pydantic input schema
+        input_schema = self._create_input_schema_from_tool(skill_name, tool)
+
+        # Create async wrapper function for MCP tool calls
+        async def mcp_skill_wrapper(**kwargs):
+            """Dynamically created MCP skill function"""
+            try:
+                # Get MCP client for this server
+                client = self.agent.mcp_client_registry.get_client(server_alias)
+                if not client:
+                    return {
+                        "status": "error",
+                        "error": f"MCP client for server '{server_alias}' not available",
+                        "server": server_alias,
+                        "tool": tool_name,
+                        "args": kwargs,
+                    }
+
+                # Call the MCP tool
+                result = await client.call_tool(tool_name, kwargs)
+
+                return {
+                    "status": "success",
+                    "result": result,
+                    "server": server_alias,
+                    "tool": tool_name,
+                }
+
+            except Exception as e:
+                return {
+                    "status": "error",
+                    "error": str(e),
+                    "server": server_alias,
+                    "tool": tool_name,
+                    "args": kwargs,
+                }
+
+        # Set function metadata
+        mcp_skill_wrapper.__name__ = skill_name
+        mcp_skill_wrapper.__doc__ = description
+
+        # Create FastAPI endpoint
+        endpoint_path = f"/skills/{skill_name}"
+
+        # Create the endpoint function dynamically
+        async def mcp_skill_endpoint(input_data: Any, request: Request):
+            """Dynamically created MCP skill endpoint"""
+            # Validate input data against the schema
+            validated_data = (
+                input_schema(**input_data)
+                if isinstance(input_data, dict)
+                else input_data
+            )
+
+            # Handle execution context from request headers
+            execution_context = ExecutionContext.from_request(
+                request, self.agent.node_id
+            )
+
+            # Store execution context in agent
+            self.agent._current_execution_context = execution_context
+
+            try:
+                # Convert input to function arguments
+                if hasattr(validated_data, "dict"):
+                    kwargs = validated_data.model_dump()
+                elif isinstance(validated_data, dict):
+                    kwargs = validated_data
+                else:
+                    kwargs = {}
+
+                # Call the MCP skill wrapper
+                result = await mcp_skill_wrapper(**kwargs)
+
+                return result
+
+            finally:
+                # Clear execution context after completion
+                self.agent._current_execution_context = None
+
+        # Set the correct parameter annotation for FastAPI
+        mcp_skill_endpoint.__annotations__ = {
+            "input_data": input_schema,
+            "request": Request,
+            "return": dict,
+        }
+
+        # Register the endpoint
+        self.agent.post(endpoint_path, response_model=dict)(mcp_skill_endpoint)
+
+        # Register skill metadata with agent
+        skill_metadata = {
+            "id": skill_name,
+            "input_schema": input_schema.model_json_schema(),
+            "tags": ["mcp", server_alias],
+            "description": description,
+            "server_alias": server_alias,
+            "tool_name": tool_name,
+        }
+
+        self.agent.skills.append(skill_metadata)
+
+        # Add to internal skill registry
+        self.registered_skills[skill_name] = skill_metadata
+
+    def _create_input_schema_from_tool(
+        self, skill_name: str, tool: Dict[str, Any]
+    ) -> Type[BaseModel]:
+        """
+        Create Pydantic input schema from MCP tool definition.
+
+        Schema Generation Rules:
+        - Extract inputSchema.properties and required fields
+        - Map JSON Schema types to Python types
+        - Handle required vs optional fields appropriately
+        - Set default values when specified
+        - Use Optional[Type] for non-required fields without defaults
+        - Fallback to generic {"data": Optional[Dict[str, Any]]} if no properties
+        - Create model with name pattern: {skill_name}Input
+
+        Args:
+            skill_name: Name of the skill
+            tool: Tool definition from MCP server
+
+        Returns:
+            Pydantic BaseModel class for input validation
+        """
+        input_schema = tool.get("inputSchema", {})
+        properties = input_schema.get("properties", {})
+        required_fields = set(input_schema.get("required", []))
+
+        # If no properties defined, use generic schema
+        if not properties:
+            return create_model(
+                f"{skill_name}Input", data=(Optional[Dict[str, Any]], None)
+            )
+
+        # Build field definitions for Pydantic model
+        field_definitions = {}
+
+        for field_name, field_def in properties.items():
+            field_type = AgentUtils.map_json_type_to_python(
+                field_def.get("type", "string")
+            )
+            default_value = field_def.get("default")
+            is_required = field_name in required_fields
+
+            if is_required and default_value is None:
+                # Required field without default
+                field_definitions[field_name] = (field_type, ...)
+            elif default_value is not None:
+                # Field with default value
+                field_definitions[field_name] = (field_type, default_value)
+            else:
+                # Optional field without default
+                field_definitions[field_name] = (Optional[field_type], None)
+
+        # Create and return the Pydantic model
+        model_name = f"{skill_name}Input"
+        return create_model(model_name, **field_definitions)