solana-agent 12.0.0__py3-none-any.whl → 14.0.1__py3-none-any.whl

solana_agent/interfaces/plugins/plugins.py

@@ -0,0 +1,118 @@
+"""
+Plugin system interfaces.
+
+These interfaces define the contracts for the plugin system,
+enabling extensibility through tools and plugins.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, List, Any, Optional, Callable
+
+
+class Tool(ABC):
+    """Interface for tools that can be used by agents."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Get the name of the tool."""
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """Get the description of the tool."""
+        pass
+
+    @abstractmethod
+    def configure(self, config: Dict[str, Any]) -> None:
+        """Configure the tool with global configuration."""
+        pass
+
+    @abstractmethod
+    def get_schema(self) -> Dict[str, Any]:
+        """Get the schema for the tool parameters."""
+        pass
+
+    @abstractmethod
+    def execute(self, **params) -> Dict[str, Any]:
+        """Execute the tool with the given parameters."""
+        pass
+
+
+class ToolRegistry(ABC):
+    """Interface for the tool registry."""
+
+    @abstractmethod
+    def register_tool(self, tool: Tool) -> bool:
+        """Register a tool in the registry."""
+        pass
+
+    @abstractmethod
+    def get_tool(self, tool_name: str) -> Optional[Tool]:
+        """Get a tool by name."""
+        pass
+
+    @abstractmethod
+    def assign_tool_to_agent(self, agent_name: str, tool_name: str) -> bool:
+        """Give an agent access to a specific tool."""
+        pass
+
+    @abstractmethod
+    def get_agent_tools(self, agent_name: str) -> List[Dict[str, Any]]:
+        """Get all tools available to an agent."""
+        pass
+
+    @abstractmethod
+    def list_all_tools(self) -> List[str]:
+        """List all registered tools."""
+        pass
+
+    @abstractmethod
+    def configure_all_tools(self, config: Dict[str, Any]) -> None:
+        """Configure all registered tools with the same config."""
+        pass
+
+
+class Plugin(ABC):
+    """Interface for plugins that can be loaded by the system."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Get the name of the plugin."""
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """Get the description of the plugin."""
+        pass
+
+    @abstractmethod
+    def initialize(self, tool_registry: ToolRegistry) -> bool:
+        """Initialize the plugin and register its tools."""
+        pass
+
+
+class PluginManager(ABC):
+    """Interface for the plugin manager."""
+
+    @abstractmethod
+    def register_plugin(self, plugin: Plugin) -> bool:
+        """Register a plugin in the manager."""
+        pass
+
+    @abstractmethod
+    def load_plugins(self) -> List[str]:
+        """Load all registered plugins."""
+        pass
+
+    @abstractmethod
+    def get_plugin(self, name: str) -> Optional[Plugin]:
+        """Get a plugin by name."""
+        pass
+
+    @abstractmethod
+    def list_plugins(self) -> List[Dict[str, Any]]:
+        """List all registered plugins with their details."""
+        pass

solana_agent/interfaces/providers/data_storage.py

@@ -0,0 +1,53 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional
+
+
+class DataStorageProvider(ABC):
+    """Interface for data storage providers."""
+
+    @abstractmethod
+    def create_collection(self, name: str) -> None:
+        """Create a new collection."""
+        pass
+
+    @abstractmethod
+    def collection_exists(self, name: str) -> bool:
+        """Check if collection exists."""
+        pass
+
+    @abstractmethod
+    def insert_one(self, collection: str, document: Dict) -> str:
+        """Insert a document into a collection."""
+        pass
+
+    @abstractmethod
+    def find_one(self, collection: str, query: Dict) -> Optional[Dict]:
+        """Find a single document."""
+        pass
+
+    @abstractmethod
+    def find(
+        self, collection: str, query: Dict, sort: Optional[List] = None, limit: int = 0, skip: int = 0
+    ) -> List[Dict]:
+        """Find documents matching query."""
+        pass
+
+    @abstractmethod
+    def update_one(self, collection: str, query: Dict, update: Dict, upsert: bool = False) -> bool:
+        """Update a document."""
+        pass
+
+    @abstractmethod
+    def delete_one(self, collection: str, query: Dict) -> bool:
+        """Delete a document."""
+        pass
+
+    @abstractmethod
+    def create_index(self, collection: str, keys: List, **kwargs) -> None:
+        """Create an index."""
+        pass
+
+    @abstractmethod
+    def count_documents(self, collection: str, query: Dict) -> int:
+        """Count documents matching query."""
+        pass

solana_agent/interfaces/providers/llm.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from typing import AsyncGenerator, List, Type, TypeVar
+
+from pydantic import BaseModel
+
+
+T = TypeVar('T', bound=BaseModel)
+
+
+class LLMProvider(ABC):
+    """Interface for language model providers."""
+
+    @abstractmethod
+    async def generate_text(
+        self,
+        prompt: str,
+        system_prompt: str = "",
+        needs_search: bool = False,
+        **kwargs,
+    ) -> AsyncGenerator[str, None]:
+        """Generate text from the language model."""
+        pass
+
+    @abstractmethod
+    def generate_embedding(self, text: str) -> List[float]:
+        """Generate embedding vector for text."""
+        pass
+
+    @abstractmethod
+    async def parse_structured_output(
+        self, prompt: str, system_prompt: str, model_class: Type[T], **kwargs
+    ) -> T:
+        """Generate structured output using a specific model class."""
+        pass

solana_agent/interfaces/providers/memory.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Tuple
+
+
+class MemoryProvider(ABC):
+    """Interface for conversation memory providers."""
+
+    @abstractmethod
+    async def store(self, user_id: str, messages: List[Dict[str, Any]]) -> None:
+        """Store messages in memory."""
+        pass
+
+    @abstractmethod
+    async def retrieve(self, user_id: str) -> str:
+        """Retrieve memory for a user as formatted string."""
+        pass
+
+    @abstractmethod
+    async def delete(self, user_id: str) -> None:
+        """Delete memory for a user."""
+        pass
+
+    @abstractmethod
+    def find(
+        self,
+        collection: str,
+        query: Dict,
+        sort: Optional[List[Tuple]] = None,
+        limit: int = 0,
+        skip: int = 0
+    ) -> List[Dict]:
+        """Find documents matching query."""
+        pass
+
+    @abstractmethod
+    def count_documents(self, collection: str, query: Dict) -> int:
+        """Count documents matching query."""
+        pass

solana_agent/interfaces/repositories/agent.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+from solana_agent.domains.agents import AIAgent
+
+
+class AgentRepository(ABC):
+    """Interface for agent data access."""
+
+    @abstractmethod
+    def get_ai_agent_by_name(self, name: str) -> Optional[AIAgent]:
+        """Get an AI agent by name."""
+        pass
+
+    @abstractmethod
+    def get_ai_agent(self, name: str) -> Optional[AIAgent]:
+        """Get an AI agent by name."""
+        pass
+
+    @abstractmethod
+    def get_all_ai_agents(self) -> List[AIAgent]:
+        """Get all AI agents."""
+        pass
+
+    @abstractmethod
+    def save_ai_agent(self, agent: AIAgent) -> bool:
+        """Save an AI agent."""
+        pass
+
+    @abstractmethod
+    def delete_ai_agent(self, name: str) -> bool:
+        """Delete an AI agent."""
+        pass

solana_agent/interfaces/services/agent.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+from typing import Any, AsyncGenerator, Dict, List
+
+
+class AgentService(ABC):
+    """Interface for agent management and response generation."""
+
+    @abstractmethod
+    def register_ai_agent(self, name: str, instructions: str, specialization: str, model: str = "gpt-4o-mini") -> None:
+        """Register an AI agent with its specialization."""
+        pass
+
+    @abstractmethod
+    def get_agent_system_prompt(self, agent_name: str) -> str:
+        """Get the system prompt for an agent."""
+        pass
+
+    @abstractmethod
+    def get_specializations(self) -> Dict[str, str]:
+        """Get all registered specializations."""
+        pass
+
+    @abstractmethod
+    async def generate_response(self, agent_name: str, user_id: str, query: str, memory_context: str = "", **kwargs) -> AsyncGenerator[str, None]:
+        """Generate a response from an agent."""
+        pass
+
+    @abstractmethod
+    def assign_tool_for_agent(self, agent_name: str, tool_name: str) -> bool:
+        """Assign a tool to an agent."""
+        pass
+
+    @abstractmethod
+    def get_agent_tools(self, agent_name: str) -> List[Dict[str, Any]]:
+        """Get tools available to an agent."""
+        pass
+
+    @abstractmethod
+    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."""
+        pass

solana_agent/interfaces/services/query.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+from typing import AsyncGenerator
+
+
+class QueryService(ABC):
+    """Interface for processing user queries."""
+
+    @abstractmethod
+    async def process(self, user_id: str, query: str) -> AsyncGenerator[str, None]:
+        """Process a query from a user."""
+        pass

solana_agent/interfaces/services/routing.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from typing import Any, Tuple
+
+
+class RoutingService(ABC):
+    """Interface for query routing services."""
+
+    @abstractmethod
+    async def route_query(self, user_id: str, query: str) -> Tuple[str, Any]:
+        """Route a query to the appropriate agent.
+
+        Args:
+            user_id: User ID
+            query: User query
+
+        Returns:
+            Tuple of (agent_name, ticket)
+        """
+        pass

solana_agent/plugins/__init__.py

@@ -0,0 +1,6 @@
+"""
+Plugin system for the Solana Agent.
+
+This package provides plugin management, tool registration, and plugin discovery
+mechanisms that extend the agent system with custom functionality.
+"""

solana_agent/plugins/manager.py

@@ -0,0 +1,147 @@
+"""
+Plugin manager for the Solana Agent system.
+
+This module implements the concrete PluginManager that discovers,
+loads, and manages plugins.
+"""
+import importlib
+from typing import Dict, List, Any, Optional
+import importlib.metadata
+
+from solana_agent.interfaces.plugins.plugins import PluginManager as PluginManagerInterface
+from solana_agent.interfaces.plugins.plugins import Plugin
+from solana_agent.plugins.registry import ToolRegistry
+
+
+class PluginManager(PluginManagerInterface):
+    """Manager for discovering and loading plugins."""
+
+    # Class variable to track loaded entry points
+    _loaded_entry_points = set()
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None, tool_registry: Optional[ToolRegistry] = None):
+        """Initialize with optional configuration and tool registry."""
+        self.config = config or {}
+        self.tool_registry = tool_registry or ToolRegistry()
+        self._plugins = {}  # Changed to instance variable
+
+    def register_plugin(self, plugin: Plugin) -> bool:
+        """Register a plugin in the manager.
+
+        Args:
+            plugin: The plugin to register
+
+        Returns:
+            True if registration succeeded, False otherwise
+        """
+        try:
+            # Store plugin by name
+            self._plugins[plugin.name] = plugin
+
+            # Initialize the plugin with the tool registry
+            plugin.initialize(self.tool_registry)
+
+            # *** ADD THIS LINE: Configure the plugin with our config ***
+            print(f"Configuring plugin {plugin.name} with config")
+            plugin.configure(self.config)
+
+            return True
+        except Exception as e:
+            print(f"Error registering plugin {plugin.name}: {e}")
+            return False
+
+    def load_plugins(self) -> List[str]:
+        """Load all plugins using entry points and apply configuration.
+
+        Returns:
+            List of loaded plugin names
+        """
+        loaded_plugins = []
+
+        # Discover plugins through entry points
+        try:
+            for entry_point in importlib.metadata.entry_points(group='solana_agent.plugins'):
+                # Skip if this entry point has already been loaded
+                entry_point_id = f"{entry_point.name}:{entry_point.value}"
+                if entry_point_id in PluginManager._loaded_entry_points:
+                    print(
+                        f"Skipping already loaded plugin: {entry_point.name}")
+                    continue
+
+                try:
+                    print(f"Found plugin entry point: {entry_point.name}")
+                    PluginManager._loaded_entry_points.add(entry_point_id)
+                    plugin_factory = entry_point.load()
+                    plugin = plugin_factory()
+
+                    # Register the plugin
+                    if self.register_plugin(plugin):
+                        # Use entry_point.name instead of plugin.name
+                        loaded_plugins.append(entry_point.name)
+
+                except Exception as e:
+                    print(f"Error loading plugin {entry_point.name}: {e}")
+        except Exception as e:
+            print(f"Error discovering plugins: {e}")
+
+        return loaded_plugins
+
+    def get_plugin(self, name: str) -> Optional[Plugin]:
+        """Get a plugin by name.
+
+        Args:
+            name: Name of the plugin to retrieve
+
+        Returns:
+            Plugin instance or None if not found
+        """
+        return self._plugins.get(name)
+
+    def list_plugins(self) -> List[Dict[str, Any]]:
+        """List all registered plugins with their details.
+
+        Returns:
+            List of plugin details dictionaries
+        """
+        return [
+            {
+                "name": plugin.name,
+                "description": plugin.description
+            }
+            for plugin in self._plugins.values()
+        ]
+
+    def execute_tool(self, tool_name: str, **kwargs) -> Dict[str, Any]:
+        """Execute a tool with the given parameters.
+
+        Args:
+            tool_name: Name of the tool to execute
+            **kwargs: Parameters to pass to the tool
+
+        Returns:
+            Dictionary with execution results
+        """
+        tool = self.tool_registry.get_tool(tool_name)
+        if not tool:
+            return {"status": "error", "message": f"Tool {tool_name} not found"}
+
+        try:
+            return tool.execute(**kwargs)
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    def configure(self, config: Dict[str, Any]) -> None:
+        """Configure the plugin manager and all plugins.
+
+        Args:
+            config: Configuration dictionary
+        """
+        self.config.update(config)
+        self.tool_registry.configure_all_tools(config)
+        print("Configuring all plugins with updated config")
+        for name, plugin in self._plugins.items():
+            try:
+                print(f"Configuring plugin: {name}")
+                plugin.configure(self.config)
+            except Exception as e:
+                print(f"Error configuring plugin {name}: {e}")

solana_agent/plugins/registry.py

@@ -0,0 +1,64 @@
+"""
+Tool registry for the Solana Agent system.
+
+This module implements the concrete ToolRegistry that manages tools 
+and their access permissions.
+"""
+from typing import Dict, List, Any, Optional
+
+from solana_agent.interfaces.plugins.plugins import ToolRegistry as ToolRegistryInterface
+from solana_agent.interfaces.plugins.plugins import Tool
+
+
+class ToolRegistry(ToolRegistryInterface):
+    """Instance-based registry that manages tools and their access permissions."""
+
+    def __init__(self):
+        """Initialize an empty tool registry."""
+        self._tools = {}  # name -> tool instance
+        self._agent_tools = {}  # agent_name -> [tool_names]
+
+    def register_tool(self, tool: Tool) -> bool:
+        """Register a tool with this registry."""
+        self._tools[tool.name] = tool
+        print(f"Registered tool: {tool.name}")
+        return True
+
+    def get_tool(self, tool_name: str) -> Optional[Tool]:
+        """Get a tool by name."""
+        return self._tools.get(tool_name)
+
+    def assign_tool_to_agent(self, agent_name: str, tool_name: str) -> bool:
+        """Give an agent access to a specific tool."""
+        if tool_name not in self._tools:
+            print(f"Error: Tool {tool_name} is not registered")
+            return False
+
+        if agent_name not in self._agent_tools:
+            self._agent_tools[agent_name] = []
+
+        if tool_name not in self._agent_tools[agent_name]:
+            self._agent_tools[agent_name].append(tool_name)
+
+        return True
+
+    def get_agent_tools(self, agent_name: str) -> List[Dict[str, Any]]:
+        """Get all tools available to an agent."""
+        tool_names = self._agent_tools.get(agent_name, [])
+        return [
+            {
+                "name": name,
+                "description": self._tools[name].description,
+                "parameters": self._tools[name].get_schema()
+            }
+            for name in tool_names if name in self._tools
+        ]
+
+    def list_all_tools(self) -> List[str]:
+        """List all registered tools."""
+        return list(self._tools.keys())
+
+    def configure_all_tools(self, config: Dict[str, Any]) -> None:
+        """Configure all registered tools with the same config."""
+        for tool in self._tools.values():
+            tool.configure(config)

solana_agent/plugins/tools/__init__.py

@@ -0,0 +1,10 @@
+"""
+Tools for the Solana Agent system.
+
+This package contains the base AutoTool class and built-in tool implementations.
+"""
+
+from solana_agent.plugins.tools.auto_tool import *
+
+# Version of the domain model
+__version__ = '14.0.0'

solana_agent/plugins/tools/auto_tool.py

@@ -0,0 +1,47 @@
+"""
+AutoTool implementation for the Solana Agent system.
+
+This module provides the base AutoTool class that implements the Tool interface
+and can be extended to create custom tools.
+"""
+from typing import Dict, Any
+
+from solana_agent.interfaces.plugins.plugins import Tool
+
+
+class AutoTool(Tool):
+    """Base class for tools that automatically register with the system."""
+
+    def __init__(self, name: str, description: str, registry=None):
+        """Initialize the tool with name and description."""
+        self._name = name
+        self._description = description
+        self._config = {}
+
+        # Register with the provided registry if given
+        if registry is not None:
+            registry.register_tool(self)
+
+    @property
+    def name(self) -> str:
+        """Get the name of the tool."""
+        return self._name
+
+    @property
+    def description(self) -> str:
+        """Get the description of the tool."""
+        return self._description
+
+    def configure(self, config: Dict[str, Any]) -> None:
+        """Configure the tool with settings from config."""
+        self._config = config
+
+    def get_schema(self) -> Dict[str, Any]:
+        """Return the JSON schema for this tool's parameters."""
+        # Override in subclasses
+        return {}
+
+    def execute(self, **params) -> Dict[str, Any]:
+        """Execute the tool with the provided parameters."""
+        # Override in subclasses
+        raise NotImplementedError("Tool must implement execute method")

solana_agent/repositories/__init__.py

@@ -0,0 +1,6 @@
+"""
+Repository implementations for data access.
+
+This package contains repository implementations that provide
+data access capabilities for the domain models.
+"""