solana-agent 11.3.0__py3-none-any.whl → 14.0.0__py3-none-any.whl

solana_agent/repositories/agent.py

@@ -0,0 +1,99 @@
+"""
+MongoDB implementation of the agent repository.
+"""
+from typing import List, Optional, Any
+
+from solana_agent.domains.agents import AIAgent
+from solana_agent.interfaces.repositories.agent import AgentRepository
+
+
+class MongoAgentRepository(AgentRepository):
+    """MongoDB implementation of the AgentRepository interface."""
+
+    def __init__(self, db_adapter):
+        """Initialize the repository with a database adapter."""
+        self.db = db_adapter
+        self.ai_agents_collection = "agents"
+
+        # Ensure collections exist
+        self.db.create_collection(self.ai_agents_collection)
+
+        # Create indexes
+        self.db.create_index(self.ai_agents_collection,
+                             [("name", 1)], unique=True)
+
+    def get_ai_agent_by_name(self, name: str) -> Optional[AIAgent]:
+        """Get an AI agent by name.
+
+        Args:
+            name: The name of the AI agent
+
+        Returns:
+            The AI agent or None if not found
+        """
+        # Query the AI agents collection for a document with matching name
+        doc = self.db.find_one(self.ai_agents_collection, {"name": name})
+
+        # If no document found, return None
+        if not doc:
+            return None
+
+        # Convert the document to an AIAgent domain model
+        try:
+            return AIAgent.model_validate(doc)
+        except Exception as e:
+            print(f"Error parsing AI agent with name {name}: {e}")
+            return None
+
+    def get_ai_agent(self, name: str) -> Optional[AIAgent]:
+        """Get an AI agent by name."""
+        doc = self.db.find_one(self.ai_agents_collection, {"name": name})
+        if not doc:
+            return None
+
+        return AIAgent.model_validate(doc)
+
+    def get_all_ai_agents(self) -> List[AIAgent]:
+        """Get all AI agents in the system.
+
+        Returns:
+            List of all AI agents
+        """
+        # Query all documents from the AI agents collection
+        docs = self.db.find(self.ai_agents_collection, {})
+
+        # Convert each document to an AIAgent domain model
+        ai_agents = []
+        for doc in docs:
+            try:
+                agent = AIAgent.model_validate(doc)
+                ai_agents.append(agent)
+            except Exception as e:
+                # Log the error but continue processing other agents
+                print(f"Error parsing AI agent from database: {e}")
+
+        return ai_agents
+
+    def save_ai_agent(self, agent: AIAgent) -> bool:
+        """Save an AI agent."""
+        doc = agent.model_dump()
+
+        # Check if agent already exists
+        existing = self.db.find_one(
+            self.ai_agents_collection, {"name": agent.name})
+
+        if existing:
+            # Update existing agent
+            return self.db.update_one(
+                self.ai_agents_collection,
+                {"name": agent.name},
+                {"$set": doc}
+            )
+        else:
+            # Create new agent
+            self.db.insert_one(self.ai_agents_collection, doc)
+            return True
+
+    def delete_ai_agent(self, name: str) -> bool:
+        """Delete an AI agent."""
+        return self.db.delete_one(self.ai_agents_collection, {"name": name})

solana_agent/repositories/memory.py

@@ -0,0 +1,134 @@
+from typing import List, Dict, Any, Optional, Tuple
+from datetime import datetime, timezone
+from zep_cloud.client import AsyncZep as AsyncZepCloud
+from zep_python.client import AsyncZep
+from zep_cloud.types import Message
+from solana_agent.interfaces.providers.memory import MemoryProvider
+from solana_agent.interfaces.providers.data_storage import DataStorageProvider
+
+
+class MemoryRepository(MemoryProvider):
+    """Combined Zep and MongoDB implementation of MemoryProvider."""
+
+    def __init__(
+        self,
+        mongo_adapter: DataStorageProvider,
+        zep_api_key: Optional[str] = None,
+        zep_base_url: Optional[str] = None
+    ):
+        """Initialize the combined memory provider."""
+        # Initialize MongoDB
+        self.mongo = mongo_adapter
+        self.collection = "conversations"
+
+        # Ensure MongoDB collection and indexes
+        self.mongo.create_collection(self.collection)
+        self.mongo.create_index(self.collection, [("user_id", 1)])
+        self.mongo.create_index(self.collection, [("timestamp", 1)])
+
+        # Initialize Zep
+        if zep_api_key and not zep_base_url:
+            self.zep = AsyncZepCloud(api_key=zep_api_key)
+        elif zep_api_key and zep_base_url:
+            self.zep = AsyncZep(api_key=zep_api_key, base_url=zep_base_url)
+        else:
+            self.zep = AsyncZep(base_url="http://localhost:8000")
+
+    async def store(self, user_id: str, messages: List[Dict[str, Any]]) -> None:
+        """Store messages in both Zep and MongoDB."""
+        # Store in MongoDB as single document
+        try:
+            # Extract user and assistant messages
+            user_message = next(msg["content"]
+                                for msg in messages if msg["role"] == "user")
+            assistant_message = next(
+                msg["content"] for msg in messages if msg["role"] == "assistant")
+
+            doc = {
+                "user_id": user_id,
+                "user_message": self._truncate(user_message),
+                "assistant_message": self._truncate(assistant_message),
+                "timestamp": datetime.now(timezone.utc)
+            }
+            self.mongo.insert_one(self.collection, doc)
+        except Exception as e:
+            print(f"MongoDB storage error: {e}")
+
+        # Store in Zep with role-based format
+        try:
+            try:
+                await self.zep.user.add(user_id=user_id)
+            except Exception:
+                pass
+            try:
+                await self.zep.memory.add_session(
+                    session_id=user_id,
+                    user_id=user_id,
+                )
+            except Exception:
+                pass
+
+            zep_messages = [
+                Message(
+                    role=msg["role"],
+                    role_type=msg["role"],
+                    content=self._truncate(msg["content"])
+                )
+                for msg in messages
+            ]
+            await self.zep.memory.add(session_id=user_id, messages=zep_messages)
+        except Exception as e:
+            print(f"Zep storage error: {e}")
+
+    async def retrieve(self, user_id: str) -> str:
+        """Retrieve memory context from Zep only."""
+        try:
+            memory = await self.zep.memory.get(session_id=user_id)
+
+            return memory.context
+
+        except Exception as e:
+            print(f"Error retrieving Zep memory: {e}")
+            return ""
+
+    async def delete(self, user_id: str) -> None:
+        """Delete memory from both systems."""
+        try:
+            self.mongo.delete_many(
+                self.collection,
+                {"user_id": user_id}
+            )
+        except Exception as e:
+            print(f"MongoDB deletion error: {e}")
+
+        try:
+            await self.zep.memory.delete(session_id=user_id)
+            await self.zep.user.delete(user_id=user_id)
+        except Exception as e:
+            print(f"Zep deletion error: {e}")
+
+    def find(
+        self,
+        collection: str,
+        query: Dict,
+        sort: Optional[List[Tuple]] = None,
+        limit: int = 0,
+        skip: int = 0
+    ) -> List[Dict]:
+        """Find documents matching query."""
+        return self.mongo.find(collection, query, sort=sort, limit=limit, skip=skip)
+
+    def count_documents(self, collection: str, query: Dict) -> int:
+        return self.mongo.count_documents(collection, query)
+
+    def _truncate(self, text: str, limit: int = 2500) -> str:
+        """Truncate text to be within limits."""
+        if len(text) <= limit:
+            return text
+
+        truncated = text[:limit]
+        last_period = truncated.rfind(".")
+        if last_period > limit * 0.8:
+            return truncated[:last_period + 1]
+
+        return truncated + "..."

solana_agent/services/__init__.py

@@ -0,0 +1,6 @@
+"""
+Service implementations for the Solana Agent system.
+
+These services implement the business logic interfaces defined in 
+solana_agent.interfaces.services.
+"""

solana_agent/services/agent.py

@@ -0,0 +1,320 @@
+"""
+Agent service implementation.
+
+This service manages AI and human agents, their registration, tool assignments,
+and response generation.
+"""
+import datetime as main_datetime
+from datetime import datetime
+import json
+from typing import AsyncGenerator, Dict, List, Optional, Any
+
+from solana_agent.interfaces.services.agent import AgentService as AgentServiceInterface
+from solana_agent.interfaces.providers.llm import LLMProvider
+from solana_agent.interfaces.repositories.agent import AgentRepository
+from solana_agent.interfaces.plugins.plugins import ToolRegistry
+from solana_agent.domains.agents import AIAgent, OrganizationMission
+
+
+class AgentService(AgentServiceInterface):
+    """Service for managing agents and generating responses."""
+
+    def __init__(
+        self,
+        llm_provider: LLMProvider,
+        agent_repository: AgentRepository,
+        organization_mission: Optional[OrganizationMission] = None,
+        config: Optional[Dict[str, Any]] = None,
+        tool_registry: Optional[ToolRegistry] = None,
+    ):
+        """Initialize the agent service.
+
+        Args:
+            llm_provider: Provider for language model interactions
+            agent_repository: Repository for agent data
+            organization_mission: Optional organization mission and values
+            config: Optional service configuration
+        """
+        self.llm_provider = llm_provider
+        self.agent_repository = agent_repository
+        self.organization_mission = organization_mission
+        self.config = config or {}
+
+        # Initialize tool registry with concrete implementation
+        if tool_registry:
+            self.tool_registry = tool_registry
+        else:
+            # Import the concrete implementation
+            from solana_agent.plugins.registry import ToolRegistry as ConcreteToolRegistry
+            self.tool_registry = ConcreteToolRegistry()
+
+        # Will be set by factory if plugin system is enabled
+        self.plugin_manager = None
+
+    def register_ai_agent(
+        self, name: str, instructions: str, specialization: str, model: str = "gpt-4o-mini"
+    ) -> None:
+        """Register an AI agent with its specialization.
+
+        Args:
+            name: Agent name
+            instructions: Agent instructions
+            specialization: Agent specialization
+            model: LLM model to use
+        """
+        agent = AIAgent(
+            name=name,
+            instructions=instructions,
+            specialization=specialization,
+            model=model
+        )
+        self.agent_repository.save_ai_agent(agent)
+
+    def get_agent_system_prompt(self, agent_name: str) -> str:
+        """Get the system prompt for an agent.
+
+        Args:
+            agent_name: Agent name
+
+        Returns:
+            System prompt
+        """
+        agent = self.agent_repository.get_ai_agent_by_name(agent_name)
+
+        # Build system prompt
+        system_prompt = f"You are {agent.name}, an AI assistant with the following instructions:\n\n"
+        system_prompt += agent.instructions
+
+        # add current time
+        system_prompt += f"\n\nThe current time is {datetime.now(tz=main_datetime.timezone.utc)}\n\n."
+
+        # Add mission and values if available
+        if self.organization_mission:
+            system_prompt += f"\n\nORGANIZATION MISSION:\n{self.organization_mission.mission_statement}"
+
+            if self.organization_mission.values:
+                values_text = "\n".join([
+                    f"- {value.get('name', '')}: {value.get('description', '')}"
+                    for value in self.organization_mission.values
+                ])
+                system_prompt += f"\n\nORGANIZATION VALUES:\n{values_text}"
+
+        # Add organization goals if available
+        if self.organization_mission and self.organization_mission.goals:
+            goals_text = "\n".join(
+                [f"- {goal}" for goal in self.organization_mission.goals])
+            system_prompt += f"\n\nORGANIZATION GOALS:\n{goals_text}"
+
+        return system_prompt
+
+    def get_all_ai_agents(self) -> Dict[str, AIAgent]:
+        """Get all registered AI agents.
+
+        Returns:
+            Dictionary mapping agent names to agents
+        """
+        agents = self.agent_repository.get_all_ai_agents()
+        return {agent.name: agent for agent in agents}
+
+    def get_specializations(self) -> Dict[str, str]:
+        """Get all registered specializations.
+
+        Returns:
+            Dictionary mapping specialization names to descriptions
+        """
+        specializations = {}
+
+        # Gather from AI agents
+        ai_agents = self.agent_repository.get_all_ai_agents()
+        for agent in ai_agents:
+            if agent.specialization:
+                specializations[agent.specialization] = f"AI expertise in {agent.specialization}"
+
+        return specializations
+
+    def assign_tool_for_agent(self, agent_name: str, tool_name: str) -> bool:
+        """Assign a tool to an agent.
+
+        Args:
+            agent_name: Agent name
+            tool_name: Tool name
+
+        Returns:
+            True if assignment was successful
+        """
+        return self.tool_registry.assign_tool_to_agent(agent_name, tool_name)
+
+    def get_agent_tools(self, agent_name: str) -> List[Dict[str, Any]]:
+        """Get tools available to an agent.
+
+        Args:
+            agent_name: Agent name
+
+        Returns:
+            List of tool configurations
+        """
+        return self.tool_registry.get_agent_tools(agent_name)
+
+    def execute_tool(self, agent_name: str, tool_name: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute a tool on behalf of an agent.
+
+        Args:
+            agent_name: Agent name
+            tool_name: Tool name
+            parameters: Tool parameters
+
+        Returns:
+            Tool execution result
+        """
+        if not self.tool_registry:
+            return {"status": "error", "message": "Tool registry not available"}
+
+        tool = self.tool_registry.get_tool(tool_name)
+        if not tool:
+            return {"status": "error", "message": f"Tool '{tool_name}' not found"}
+
+        # Check if agent has access to this tool
+        agent_tools = self.tool_registry.get_agent_tools(agent_name)
+        if not any(t.get("name") == tool_name for t in agent_tools):
+            return {
+                "status": "error",
+                "message": f"Agent '{agent_name}' doesn't have access to tool '{tool_name}'"
+            }
+
+        try:
+            return tool.execute(**parameters)
+        except Exception as e:
+            return {"status": "error", "message": f"Error executing tool: {str(e)}"}
+
+    async def generate_response(
+        self,
+        agent_name: str,
+        user_id: str,
+        query: str,
+        memory_context: str = "",
+        **kwargs
+    ) -> AsyncGenerator[str, None]:  # pragma: no cover
+        """Generate a response with tool execution support."""
+        agent = self.agent_repository.get_ai_agent_by_name(agent_name)
+        if not agent:
+            yield f"Agent '{agent_name}' not found."
+            return
+
+        # Get system prompt and add tool instructions
+        system_prompt = self.get_agent_system_prompt(agent_name)
+        if self.tool_registry:
+            tool_usage_prompt = self._get_tool_usage_prompt(agent_name)
+            if tool_usage_prompt:
+                system_prompt = f"{system_prompt}\n\n{tool_usage_prompt}"
+
+        # Add memory context
+        if memory_context:
+            system_prompt += f"\n\n Memory Context: {memory_context}"
+
+        try:
+            json_response = ""
+            is_json = False
+
+            async for chunk in self.llm_provider.generate_text(
+                user_id=user_id,
+                prompt=query,
+                system_prompt=system_prompt,
+                model=agent.model,
+                needs_search=True,  # Enable web search by default
+                **kwargs
+            ):
+                # Check for JSON start
+                if chunk.strip().startswith("{"):
+                    is_json = True
+                    json_response = chunk
+                    continue
+
+                # Collect JSON or yield normal text
+                if is_json:
+                    json_response += chunk
+                    try:
+                        # Try to parse complete JSON
+                        data = json.loads(json_response)
+
+                        # Handle tool call
+                        if "tool_call" in data:
+                            tool_data = data["tool_call"]
+                            tool_name = tool_data.get("name")
+                            parameters = tool_data.get("parameters", {})
+
+                            if tool_name:
+                                result = self.execute_tool(
+                                    agent_name, tool_name, parameters)
+                                if result.get("status") == "success":
+                                    yield result.get("result", "")
+                                else:
+                                    yield f"I apologize, but I encountered an issue: {result.get('message', 'Unknown error')}"
+                                break
+                        else:
+                            # If JSON but not a tool call, yield as text
+                            yield json_response
+                            break
+                    except json.JSONDecodeError:
+                        # Not complete JSON yet, keep collecting
+                        continue
+                else:
+                    yield chunk
+
+        except Exception as e:
+            print(f"Error in generate_response: {str(e)}")
+            import traceback
+            print(traceback.format_exc())
+            yield f"I apologize, but I encountered an error: {str(e)}"
+
+    def _get_tool_usage_prompt(self, agent_name: str) -> str:
+        """Generate JSON-based instructions for tool usage."""
+        # Get tools assigned to this agent
+        tools = self.get_agent_tools(agent_name)
+        if not tools:
+            return ""
+
+        # Get actual tool names
+        available_tool_names = [tool.get("name", "") for tool in tools]
+        tools_json = json.dumps(tools, indent=2)
+
+        # Create tool example if search is available
+        tool_example = ""
+        if "search_internet" in available_tool_names:
+            tool_example = """
+    For latest news query:
+    {
+        "tool_call": {
+            "name": "search_internet",
+            "parameters": {
+                "query": "latest Solana blockchain news March 2025"
+            }
+        }
+    }"""
+
+        return f"""
+    AVAILABLE TOOLS:
+    {tools_json}
+    
+    TOOL USAGE FORMAT:
+    {{
+        "tool_call": {{
+            "name": "<one_of:{', '.join(available_tool_names)}>",
+            "parameters": {{
+                // parameters as specified in tool definition above
+            }}
+        }}
+    }}
+    
+    {tool_example if tool_example else ''}
+    
+    RESPONSE RULES:
+    1. For tool usage:
+       - Only use tools from the AVAILABLE TOOLS list above
+       - Follow the exact parameter format shown in the tool definition
+       - Include "March 2025" in any search queries for current information
+    
+    2. Format Requirements:
+       - Return ONLY the JSON object for tool calls
+       - No explanation text before or after
+       - Use exact tool names as shown in AVAILABLE TOOLS
+    """