solana-agent 19.0.2__tar.gz → 19.1.1__tar.gz

{solana_agent-19.0.2 → solana_agent-19.1.1}/PKG-INFO

@@ -1,23 +1,25 @@
 Metadata-Version: 2.3
 Name: solana-agent
-Version: 19.0.2
+Version: 19.1.1
 Summary: Agentic IQ
 License: MIT
 Keywords: ai,openai,ai agents,agi
 Author: Bevan Hunt
 Author-email: bevan@bevanhunt.com
 Requires-Python: >=3.12,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Dist: openai (>=1.68.2,<2.0.0)
-Requires-Dist: pydantic (>=2.10.6,<3.0.0)
+Requires-Dist: pydantic (>=2.11.1,<3.0.0)
 Requires-Dist: pymongo (>=4.11.3,<5.0.0)
 Requires-Dist: zep-cloud (>=2.8.0,<3.0.0)
 Requires-Dist: zep-python (>=2.0.2,<3.0.0)
+Project-URL: Documentation, https://docs.solana-agent.com
 Project-URL: Repository, https://github.com/truemagic-coder/solana-agent
 Description-Content-Type: text/markdown
 
@@ -64,7 +66,7 @@ Build your AI business in three lines of code!
 
 * [Python](https://python.org) - Programming Language
 * [OpenAI](https://openai.com) - LLMs
-* [MongoDB](https://mongodb.com) - Conversational History
+* [MongoDB](https://mongodb.com) - Conversational History (optional)
 * [Zep](https://getzep.com) - Conversational Memory (optional)
 
 ## Installation
@@ -90,17 +92,17 @@ config = {
         ],
         "voice": "The voice of the brand is that of a research business."
     },
-    "mongo": {
+    "mongo": { # optional
         "connection_string": "mongodb://localhost:27017",
         "database": "solana_agent"
     },
-    "openai": {
-        "api_key": "your-openai-api-key",
-    },
     "zep": { # optional
         "api_key": "your-zep-api-key",
         "base_url": "your-zep-base-url", # not applicable if using Zep Cloud
     },
+    "openai": {
+        "api_key": "your-openai-api-key",
+    },
     "agents": [
         {
             "name": "research_specialist",
@@ -142,23 +144,26 @@ config = {
         ],
         "voice": "The voice of the brand is that of a research business."
     },
-    "mongo": {
+    "openai": { # optional
+        "api_key": "your-openai-api-key",
+    },
+    "ollama": { # optional
+        "url": "your-ollama-url",
+    },
+    "mongo": { # optional
         "connection_string": "mongodb://localhost:27017",
         "database": "solana_agent"
     },
-    "openai": {
-        "api_key": "your-openai-api-key",
-    },
     "zep": { # optional
         "api_key": "your-zep-api-key",
         "base_url": "your-zep-base-url", # not applicable if using Zep Cloud
     },
     "tools": {
-    "search_internet": {
-        "api_key": "your-perplexity-key", # Required
-        "citations": True, # Optional, defaults to True
-        "model": "sonar"  # Optional, defaults to "sonar"
-    },
+        "search_internet": {
+            "api_key": "your-perplexity-key", # Required
+            "citations": True, # Optional, defaults to True
+            "model": "sonar"  # Optional, defaults to "sonar"
+        },
     },
     "agents": [
         {
@@ -247,13 +252,16 @@ config = {
         ],
         "voice": "The voice of the brand is that of a research business."
     },
-    "mongo": {
+    "openai": { # optional
+        "api_key": "your-openai-api-key",
+    },
+    "ollama": { # optional
+        "url": "your-ollama-url",
+    },
+    "mongo": { # optional
         "connection_string": "mongodb://localhost:27017",
         "database": "solana_agent"
     },
-    "openai": {
-        "api_key": "your-openai-api-key",
-    },
     "zep": { # optional
         "api_key": "your-zep-api-key",
         "base_url": "your-zep-base-url", # not applicable if using Zep Cloud
@@ -282,24 +290,32 @@ async for response in solana_agent.process("user123", "What are the latest AI de
     print(response, end="")
 ```
 
-## Notes on Tools
+## Notes
 * Solana Agent agents can only call one tool per response.
 * Solana Agent agents choose the best tool for the job.
 * Solana Agent tools do not use OpenAI function calling.
 * Solana Agent tools are async functions.
+* Solana Agent will use OpenAI for audio and Ollama and for text if both config vars are set
+
+## Local Setup
+
+A Docker Compose and Zep Config file is available at the root of this project
 
 ## API Documentation
-* Available at [Solana Agent Documentation Site](https://docs.solana-agent.com)
 
-## Solana Agent Kit
+The official up-to-date documentation site
+
+[Solana Agent Documentation Site](https://docs.solana-agent.com)
+
+## Official Tools
 
-A collection of Solana Agent tools
+The official collection of tools in one plugin
 
 [Solana Agent Kit](https://github.com/truemagic-coder/solana-agent-kit)
 
 ## Example App
 
-A Solana Agent example app written in FastAPI and Next.js
+The official example app written in FastAPI and Next.js
 
 [Solana Agent Example App](https://github.com/truemagic-coder/solana-agent-app)
 

{solana_agent-19.0.2 → solana_agent-19.1.1}/README.md

@@ -41,7 +41,7 @@ Build your AI business in three lines of code!
 
 * [Python](https://python.org) - Programming Language
 * [OpenAI](https://openai.com) - LLMs
-* [MongoDB](https://mongodb.com) - Conversational History
+* [MongoDB](https://mongodb.com) - Conversational History (optional)
 * [Zep](https://getzep.com) - Conversational Memory (optional)
 
 ## Installation
@@ -67,17 +67,17 @@ config = {
         ],
         "voice": "The voice of the brand is that of a research business."
     },
-    "mongo": {
+    "mongo": { # optional
         "connection_string": "mongodb://localhost:27017",
         "database": "solana_agent"
     },
-    "openai": {
-        "api_key": "your-openai-api-key",
-    },
     "zep": { # optional
         "api_key": "your-zep-api-key",
         "base_url": "your-zep-base-url", # not applicable if using Zep Cloud
     },
+    "openai": {
+        "api_key": "your-openai-api-key",
+    },
     "agents": [
         {
             "name": "research_specialist",
@@ -119,23 +119,26 @@ config = {
         ],
         "voice": "The voice of the brand is that of a research business."
     },
-    "mongo": {
+    "openai": { # optional
+        "api_key": "your-openai-api-key",
+    },
+    "ollama": { # optional
+        "url": "your-ollama-url",
+    },
+    "mongo": { # optional
         "connection_string": "mongodb://localhost:27017",
         "database": "solana_agent"
     },
-    "openai": {
-        "api_key": "your-openai-api-key",
-    },
     "zep": { # optional
         "api_key": "your-zep-api-key",
         "base_url": "your-zep-base-url", # not applicable if using Zep Cloud
     },
     "tools": {
-    "search_internet": {
-        "api_key": "your-perplexity-key", # Required
-        "citations": True, # Optional, defaults to True
-        "model": "sonar"  # Optional, defaults to "sonar"
-    },
+        "search_internet": {
+            "api_key": "your-perplexity-key", # Required
+            "citations": True, # Optional, defaults to True
+            "model": "sonar"  # Optional, defaults to "sonar"
+        },
     },
     "agents": [
         {
@@ -224,13 +227,16 @@ config = {
         ],
         "voice": "The voice of the brand is that of a research business."
     },
-    "mongo": {
+    "openai": { # optional
+        "api_key": "your-openai-api-key",
+    },
+    "ollama": { # optional
+        "url": "your-ollama-url",
+    },
+    "mongo": { # optional
         "connection_string": "mongodb://localhost:27017",
         "database": "solana_agent"
     },
-    "openai": {
-        "api_key": "your-openai-api-key",
-    },
     "zep": { # optional
         "api_key": "your-zep-api-key",
         "base_url": "your-zep-base-url", # not applicable if using Zep Cloud
@@ -259,24 +265,32 @@ async for response in solana_agent.process("user123", "What are the latest AI de
     print(response, end="")
 ```
 
-## Notes on Tools
+## Notes
 * Solana Agent agents can only call one tool per response.
 * Solana Agent agents choose the best tool for the job.
 * Solana Agent tools do not use OpenAI function calling.
 * Solana Agent tools are async functions.
+* Solana Agent will use OpenAI for audio and Ollama and for text if both config vars are set
+
+## Local Setup
+
+A Docker Compose and Zep Config file is available at the root of this project
 
 ## API Documentation
-* Available at [Solana Agent Documentation Site](https://docs.solana-agent.com)
 
-## Solana Agent Kit
+The official up-to-date documentation site
+
+[Solana Agent Documentation Site](https://docs.solana-agent.com)
+
+## Official Tools
 
-A collection of Solana Agent tools
+The official collection of tools in one plugin
 
 [Solana Agent Kit](https://github.com/truemagic-coder/solana-agent-kit)
 
 ## Example App
 
-A Solana Agent example app written in FastAPI and Next.js
+The official example app written in FastAPI and Next.js
 
 [Solana Agent Example App](https://github.com/truemagic-coder/solana-agent-app)
 

{solana_agent-19.0.2 → solana_agent-19.1.1}/pyproject.toml

@@ -1,14 +1,18 @@
 [tool.poetry]
 name = "solana-agent"
-version = "19.0.2"
+version = "19.1.1"
 description = "Agentic IQ"
 authors = ["Bevan Hunt <bevan@bevanhunt.com>"]
 license = "MIT"
 readme = "README.md"
 repository = "https://github.com/truemagic-coder/solana-agent"
+documentation = "https://docs.solana-agent.com"
 keywords = ["ai", "openai", "ai agents", "agi"]
 classifiers = [
-    "Programming Language :: Python :: 3 :: Only",
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 packages = [{ include = "solana_agent" }]
@@ -19,20 +23,22 @@ python_paths = [".", "tests"]
 [tool.poetry.dependencies]
 python = ">=3.12,<4.0"
 openai = "^1.68.2"
-pydantic = "^2.10.6"
+pydantic = "^2.11.1"
 pymongo = "^4.11.3"
 zep-cloud = "^2.8.0"
 zep-python = "^2.0.2"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 pytest = "^8.3.5"
 pytest-cov = "^6.0.0"
 pytest-asyncio = "^0.26.0"
+pytest-mock = "^3.14.0"
 pytest-github-actions-annotate-failures = "^0.3.0"
 sphinx = "^8.2.3"
 sphinx-rtd-theme = "^3.0.2"
 myst-parser = "^4.0.1"
 sphinx-autobuild = "^2024.10.3"
+mongomock = "^4.3.0"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/adapters/llm_adapter.py

@@ -135,19 +135,6 @@ class OpenAIAdapter(LLMProvider):
             print(traceback.format_exc())
             yield f"I apologize, but I encountered an error: {str(e)}"
 
-    def generate_embedding(self, text: str) -> List[float]:  # pragma: no cover
-        """Generate embeddings for a given text using OpenAI's embedding model."""
-        try:
-            response = self.client.embeddings.create(
-                model="text-embedding-3-small",
-                input=text
-            )
-            return response.data[0].embedding
-        except Exception as e:
-            print(f"Error generating embedding: {e}")
-            # Return a zero vector as fallback (not ideal but prevents crashing)
-            return [0.0] * 1536  # Standard size for text-embedding-3-small
-
     async def parse_structured_output(
         self,
         prompt: str,

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/client/solana_agent.py

@@ -44,6 +44,7 @@ class SolanaAgent(SolanaAgentInterface):
         self,
         user_id: str,
         message: Union[str, bytes],
+        prompt: Optional[str] = None,
         output_format: Literal["text", "audio"] = "text",
         audio_voice: Literal["alloy", "ash", "ballad", "coral", "echo",
                              "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
@@ -59,6 +60,7 @@ class SolanaAgent(SolanaAgentInterface):
         Args:
             user_id: User ID
             message: Text message or audio bytes
+            prompt: Optional prompt for the agent
             output_format: Response format ("text" or "audio")
             audio_voice: Voice to use for audio output
             audio_instructions: Optional instructions for audio synthesis
@@ -76,6 +78,7 @@ class SolanaAgent(SolanaAgentInterface):
             audio_instructions=audio_instructions,
             audio_output_format=audio_output_format,
             audio_input_format=audio_input_format,
+            prompt=prompt,
         ):
             yield chunk
 
@@ -94,7 +97,7 @@ class SolanaAgent(SolanaAgentInterface):
         page_num: int = 1,
         page_size: int = 20,
         sort_order: str = "desc"  # "asc" for oldest-first, "desc" for newest-first
-    ) -> Dict[str, Any]:
+    ) -> Dict[str, Any]:  # pragma: no cover
         """
         Get paginated message history for a user.
 
@@ -121,22 +124,11 @@ class SolanaAgent(SolanaAgentInterface):
         Returns:
             True if successful, False
         """
-
-        try:
-            print(f"Attempting to register tool: {tool.name}")
-            success = self.query_service.agent_service.tool_registry.register_tool(
-                tool)
-            if success:
-                print(f"Tool {tool.name} registered successfully")
-                # Get all agents and assign the tool to them
-                agents = self.query_service.agent_service.get_all_ai_agents()
-                for agent_name in agents:
-                    print(f"Assigning {tool.name} to agent {agent_name}")
-                    self.query_service.agent_service.assign_tool_for_agent(
-                        agent_name, tool.name)
-            return success
-        except Exception as e:
-            print(f"Error in register_tool: {str(e)}")
-            import traceback
-            print(traceback.format_exc())
-            return False
+        success = self.query_service.agent_service.tool_registry.register_tool(
+            tool)
+        if success:
+            agents = self.query_service.agent_service.get_all_ai_agents()
+            for agent_name in agents:
+                self.query_service.agent_service.assign_tool_for_agent(
+                    agent_name, tool.name)
+        return success

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/factories/agent_factory.py

@@ -37,10 +37,19 @@ class SolanaAgentFactory:
             Configured QueryService instance
         """
         # Create adapters
-        db_adapter = MongoDBAdapter(
-            connection_string=config["mongo"]["connection_string"],
-            database_name=config["mongo"]["database"],
-        )
+
+        if "mongo" in config:
+            # MongoDB connection string and database name
+            if "connection_string" not in config["mongo"]:
+                raise ValueError("MongoDB connection string is required.")
+            if "database" not in config["mongo"]:
+                raise ValueError("MongoDB database name is required.")
+            db_adapter = MongoDBAdapter(
+                connection_string=config["mongo"]["connection_string"],
+                database_name=config["mongo"]["database"],
+            )
+        else:
+            db_adapter = None
 
         llm_adapter = OpenAIAdapter(
             api_key=config["openai"]["api_key"],
@@ -59,12 +68,25 @@ class SolanaAgentFactory:
             )
 
         # Create repositories
-        if "zep" in config:
+        memory_provider = None
+
+        if "zep" in config and "mongo" in config:
+            if "api_key" not in config["zep"]:
+                raise ValueError("Zep API key is required.")
             memory_provider = MemoryRepository(
                 db_adapter, config["zep"].get("api_key"), config["zep"].get("base_url"))
-        else:
+
+        if "mongo" in config and not "zep" in config:
             memory_provider = MemoryRepository(db_adapter)
 
+        if "zep" in config and not "mongo" in config:
+            if "api_key" not in config["zep"]:
+                raise ValueError("Zep API key is required.")
+            memory_provider = MemoryRepository(
+                zep_api_key=config["zep"].get("api_key"),
+                zep_base_url=config["zep"].get("base_url")
+            )
+
         # Create primary services
         agent_service = AgentService(
             llm_provider=llm_adapter,
@@ -87,8 +109,12 @@ class SolanaAgentFactory:
             config=config,
             tool_registry=agent_service.tool_registry
         )
-        loaded_plugins = agent_service.plugin_manager.load_plugins()
-        print(f"Loaded {loaded_plugins} plugins")
+        try:
+            loaded_plugins = agent_service.plugin_manager.load_plugins()
+            print(f"Loaded {loaded_plugins} plugins")
+        except Exception as e:
+            print(f"Error loading plugins: {e}")
+            loaded_plugins = 0
 
         # Register predefined agents
         for agent_config in config.get("agents", []):
@@ -103,25 +129,18 @@ class SolanaAgentFactory:
                 for tool_name in agent_config["tools"]:
                     print(
                         f"Available tools before registering {tool_name}: {agent_service.tool_registry.list_all_tools()}")
-                    try:
-                        agent_service.assign_tool_for_agent(
-                            agent_config["name"], tool_name
-                        )
-                        print(
-                            f"Successfully registered {tool_name} for agent {agent_config['name']}")
-                    except ValueError as e:
-                        print(
-                            f"Error registering tool {tool_name} for agent {agent_config['name']}: {e}")
+                    agent_service.assign_tool_for_agent(
+                        agent_config["name"], tool_name
+                    )
+                    print(
+                        f"Successfully registered {tool_name} for agent {agent_config['name']}")
 
         # Global tool registrations
         if "agent_tools" in config:
             for agent_name, tools in config["agent_tools"].items():
                 for tool_name in tools:
-                    try:
-                        agent_service.assign_tool_for_agent(
-                            agent_name, tool_name)
-                    except ValueError as e:
-                        print(f"Error registering tool: {e}")
+                    agent_service.assign_tool_for_agent(
+                        agent_name, tool_name)
 
         # Create and return the query service
         query_service = QueryService(

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/interfaces/client/client.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, Dict, Literal, Union
+from typing import Any, AsyncGenerator, Dict, Literal, Optional, Union
 
 from solana_agent.interfaces.plugins.plugins import Tool
 
@@ -15,12 +15,13 @@ class SolanaAgent(ABC):
         output_format: Literal["text", "audio"] = "text",
         audio_voice: Literal["alloy", "ash", "ballad", "coral", "echo",
                              "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
-        audio_instructions: str = None,
+        audio_instructions: Optional[str] = None,
         audio_output_format: Literal['mp3', 'opus',
                                      'aac', 'flac', 'wav', 'pcm'] = "aac",
         audio_input_format: Literal[
             "flac", "mp3", "mp4", "mpeg", "mpga", "m4a", "ogg", "wav", "webm"
         ] = "mp4",
+        prompt: Optional[str] = None,
     ) -> AsyncGenerator[Union[str, bytes], None]:
         """Process a user message and return the response stream."""
         pass

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/interfaces/providers/llm.py

@@ -19,11 +19,6 @@ class LLMProvider(ABC):
         """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],

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/interfaces/services/agent.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, Dict, List, Literal, Union
+from typing import Any, AsyncGenerator, Dict, List, Literal, Optional, Union
 
 from solana_agent.domains.agent import AIAgent
 
@@ -17,11 +17,6 @@ class AgentService(ABC):
         """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,
@@ -32,12 +27,13 @@ class AgentService(ABC):
         output_format: Literal["text", "audio"] = "text",
         audio_voice: Literal["alloy", "ash", "ballad", "coral", "echo",
                              "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
-        audio_instructions: str = None,
+        audio_instructions: Optional[str] = None,
         audio_output_format: Literal['mp3', 'opus',
                                      'aac', 'flac', 'wav', 'pcm'] = "aac",
         audio_input_format: Literal[
             "flac", "mp3", "mp4", "mpeg", "mpga", "m4a", "ogg", "wav", "webm"
         ] = "mp4",
+        prompt: Optional[str] = None,
     ) -> AsyncGenerator[Union[str, bytes], None]:
         """Generate a response from an agent."""
         pass

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/interfaces/services/query.py

@@ -19,6 +19,7 @@ class QueryService(ABC):
         audio_input_format: Literal[
             "flac", "mp3", "mp4", "mpeg", "mpga", "m4a", "ogg", "wav", "webm"
         ] = "mp4",
+        prompt: Optional[str] = None,
     ) -> AsyncGenerator[Union[str, bytes], None]:
         """Process the user request and generate a response."""
         pass

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/plugins/manager.py

@@ -35,19 +35,21 @@ class PluginManager(PluginManagerInterface):
             True if registration succeeded, False otherwise
         """
         try:
-            # Store plugin by name
-            self._plugins[plugin.name] = plugin
-
-            # Initialize the plugin with the tool registry
+            # Initialize the plugin with the tool registry first
             plugin.initialize(self.tool_registry)
 
-            # *** ADD THIS LINE: Configure the plugin with our config ***
-            print(f"Configuring plugin {plugin.name} with config")
+            # Then configure the plugin
             plugin.configure(self.config)
 
+            # Only store plugin if both initialize and configure succeed
+            self._plugins[plugin.name] = plugin
+            print(f"Successfully registered plugin {plugin.name}")
             return True
+
         except Exception as e:
             print(f"Error registering plugin {plugin.name}: {e}")
+            # Remove plugin from registry if it was added
+            self._plugins.pop(plugin.name, None)
             return False
 
     def load_plugins(self) -> List[str]:
@@ -59,30 +61,27 @@ class PluginManager(PluginManagerInterface):
         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}")
+        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}")
 
         return loaded_plugins
 

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/plugins/registry.py

@@ -76,6 +76,23 @@ class ToolRegistry(ToolRegistryInterface):
         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)
+        """Configure all registered tools with new configuration.
+
+        Args:
+            config: Configuration dictionary to apply
+        """
+        self._config.update(config)
+        configure_errors = []
+
+        for name, tool in self._tools.items():
+            try:
+                print(f"Configuring tool: {name}")
+                tool.configure(self._config)
+            except Exception as e:
+                print(f"Error configuring tool {name}: {e}")
+                configure_errors.append((name, str(e)))
+
+        if configure_errors:
+            print("The following tools failed to configure:")
+            for name, error in configure_errors:
+                print(f"- {name}: {error}")

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/plugins/tools/auto_tool.py

@@ -34,6 +34,8 @@ class AutoTool(Tool):
 
     def configure(self, config: Dict[str, Any]) -> None:
         """Configure the tool with settings from config."""
+        if config is None:
+            raise TypeError("Config cannot be None")
         self._config = config
 
     def get_schema(self) -> Dict[str, Any]:

solana_agent-19.1.1/solana_agent/repositories/memory.py

@@ -0,0 +1,199 @@
+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.adapters.mongodb_adapter import MongoDBAdapter
+
+
+class MemoryRepository(MemoryProvider):
+    """Combined Zep and MongoDB implementation of MemoryProvider."""
+
+    def __init__(
+        self,
+        mongo_adapter: Optional[MongoDBAdapter] = None,
+        zep_api_key: Optional[str] = None,
+        zep_base_url: Optional[str] = None
+    ):
+        """Initialize the combined memory provider."""
+        if not mongo_adapter:
+            self.mongo = None
+            self.collection = None
+        else:
+            # Initialize MongoDB
+            self.mongo = mongo_adapter
+            self.collection = "conversations"
+
+            try:
+                # 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)])
+            except Exception as e:
+                print(f"Error initializing MongoDB: {e}")
+
+        # 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 = None
+
+    async def store(self, user_id: str, messages: List[Dict[str, Any]]) -> None:
+        """Store messages in both Zep and MongoDB."""
+        if not user_id:
+            raise ValueError("User ID cannot be None or empty")
+        if not messages or not isinstance(messages, list):
+            raise ValueError("Messages must be a non-empty list")
+        if not all(isinstance(msg, dict) and "role" in msg and "content" in msg for msg in messages):
+            raise ValueError(
+                "All messages must be dictionaries with 'role' and 'content' keys")
+        for msg in messages:
+            if msg["role"] not in ["user", "assistant"]:
+                raise ValueError(
+                    f"Invalid role '{msg['role']}' in message. Only 'user' and 'assistant' roles are accepted.")
+
+        # Store in MongoDB
+        if self.mongo and len(messages) >= 2:
+            try:
+                # Get last user and assistant messages
+                user_msg = None
+                assistant_msg = None
+                for msg in reversed(messages):
+                    if msg.get("role") == "user" and not user_msg:
+                        user_msg = msg.get("content")
+                    elif msg.get("role") == "assistant" and not assistant_msg:
+                        assistant_msg = msg.get("content")
+                    if user_msg and assistant_msg:
+                        break
+
+                if user_msg and assistant_msg:
+                    # Store truncated messages
+                    doc = {
+                        "user_id": user_id,
+                        "user_message": self._truncate(user_msg),
+                        "assistant_message": self._truncate(assistant_msg),
+                        "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
+        if not self.zep:
+            return
+
+        try:
+            await self.zep.user.add(user_id=user_id)
+        except Exception as e:
+            print(f"Zep user addition error: {e}")
+
+        try:
+            await self.zep.memory.add_session(session_id=user_id, user_id=user_id)
+        except Exception as e:
+            print(f"Zep session creation error: {e}")
+
+        # Convert messages to Zep format
+        zep_messages = []
+        for msg in messages:
+            if "role" in msg and "content" in msg:
+                zep_msg = Message(
+                    role=msg["role"],
+                    content=msg["content"],
+                    role_type=msg["role"],
+                )
+                zep_messages.append(zep_msg)
+
+        # Add messages to Zep memory
+        if zep_messages:
+            try:
+                await self.zep.memory.add(
+                    session_id=user_id,
+                    messages=zep_messages
+                )
+            except Exception as e:
+                print(f"Zep memory addition error: {e}")
+
+    async def retrieve(self, user_id: str) -> str:
+        """Retrieve memory context from Zep only."""
+        if not self.zep:
+            return ""
+
+        try:
+            memory = await self.zep.memory.get(session_id=user_id)
+            if memory is None or not hasattr(memory, 'context') or memory.context is None:
+                return ""
+            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."""
+        if self.mongo:
+            try:
+                self.mongo.delete_all(
+                    self.collection,
+                    {"user_id": user_id}
+                )
+            except Exception as e:
+                print(f"MongoDB deletion error: {e}")
+
+        if not self.zep:
+            return
+
+        try:
+            await self.zep.memory.delete(session_id=user_id)
+        except Exception as e:
+            print(f"Zep memory deletion error: {e}")
+
+        try:
+            await self.zep.user.delete(user_id=user_id)
+        except Exception as e:
+            print(f"Zep user deletion error: {e}")
+
+    def find(
+        self,
+        collection: str,
+        query: Dict,
+        sort: Optional[List[Tuple]] = None,
+        limit: int = 0,
+        skip: int = 0
+    ) -> List[Dict]:  # pragma: no cover
+        """Find documents in MongoDB."""
+        if not self.mongo:
+            return []
+
+        try:
+            return self.mongo.find(collection, query, sort=sort, limit=limit, skip=skip)
+        except Exception as e:
+            print(f"MongoDB find error: {e}")
+            return []
+
+    def count_documents(self, collection: str, query: Dict) -> int:
+        """Count documents in MongoDB."""
+        if not self.mongo:
+            return 0
+        return self.mongo.count_documents(collection, query)
+
+    def _truncate(self, text: str, limit: int = 2500) -> str:
+        """Truncate text to be within limits."""
+        if text is None:
+            raise AttributeError("Cannot truncate None text")
+
+        if not text:
+            return ""
+
+        if len(text) <= limit:
+            return text
+
+        # Try to truncate at last period before limit
+        last_period = text.rfind('.', 0, limit)
+        if last_period > 0:
+            return text[:last_period + 1]
+
+        # If no period found, truncate at limit and add ellipsis
+        return text[:limit] + "..."

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/services/agent.py

@@ -13,6 +13,7 @@ from typing import AsyncGenerator, Dict, List, Literal, Optional, Any, Union
 from solana_agent.interfaces.services.agent import AgentService as AgentServiceInterface
 from solana_agent.interfaces.providers.llm import LLMProvider
 from solana_agent.interfaces.plugins.plugins import ToolRegistry as ToolRegistryInterface
+from solana_agent.plugins.manager import PluginManager
 from solana_agent.plugins.registry import ToolRegistry
 from solana_agent.domains.agent import AIAgent, BusinessMission
 
@@ -40,8 +41,10 @@ class AgentService(AgentServiceInterface):
         self.tool_registry = ToolRegistry(config=self.config)
         self.agents: List[AIAgent] = []
 
-        # Will be set by factory if plugin system is enabled
-        self.plugin_manager = None
+        self.plugin_manager = PluginManager(
+            config=self.config,
+            tool_registry=self.tool_registry,
+        )
 
     def register_ai_agent(
         self, name: str, instructions: str, specialization: str,
@@ -108,20 +111,6 @@ class AgentService(AgentServiceInterface):
         """
         return {agent.name: agent for agent in self.agents}
 
-    def get_specializations(self) -> Dict[str, str]:
-        """Get all registered specializations.
-
-        Returns:
-            Dictionary mapping specialization names to descriptions
-        """
-        specializations = {}
-
-        for agent in self.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.
 
@@ -187,6 +176,7 @@ class AgentService(AgentServiceInterface):
         audio_input_format: Literal[
             "flac", "mp3", "mp4", "mpeg", "mpga", "m4a", "ogg", "wav", "webm"
         ] = "mp4",
+        prompt: Optional[str] = None,
     ) -> AsyncGenerator[Union[str, bytes], None]:  # pragma: no cover
         """Generate a response with support for text/audio input/output.
 
@@ -200,6 +190,7 @@ class AgentService(AgentServiceInterface):
             audio_instructions: Optional instructions for audio synthesis
             audio_output_format: Audio output format
             audio_input_format: Audio input format
+            prompt: Optional prompt for the agent
 
         Yields:
             Text chunks or audio bytes depending on output_format
@@ -233,7 +224,9 @@ class AgentService(AgentServiceInterface):
             # Add User ID and memory context
             system_prompt += f"\n\nUser ID: {user_id}"
             if memory_context:
-                system_prompt += f"\n\nMemory Context: {memory_context}"
+                system_prompt += f"\n\nMEMORY CONTEXT: {memory_context}"
+            if prompt:
+                system_prompt += f"\n\nADDITIONAL PROMPT: {prompt}"
 
             # Keep track of the complete text response
             complete_text_response = ""

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/services/query.py

@@ -46,14 +46,19 @@ class QueryService(QueryServiceInterface):
         audio_input_format: Literal[
             "flac", "mp3", "mp4", "mpeg", "mpga", "m4a", "ogg", "wav", "webm"
         ] = "mp4",
+        prompt: Optional[str] = None,
     ) -> AsyncGenerator[Union[str, bytes], None]:  # pragma: no cover
         """Process the user request with appropriate agent.
 
         Args:
             user_id: User ID
             query: Text query or audio bytes
-            output_format: Response format ("text" or "audio") 
-            voice: Voice to use for audio output
+            output_format: Response format ("text" or "audio")
+            audio_voice: Voice for TTS (text-to-speech)
+            audio_instructions: Optional instructions for TTS
+            audio_output_format: Audio output format
+            audio_input_format: Audio input format
+            prompt: Optional prompt for the agent
 
         Yields:
             Response chunks (text strings or audio bytes)
@@ -105,7 +110,8 @@ class QueryService(QueryServiceInterface):
                     audio_voice=audio_voice,
                     audio_input_format=audio_input_format,
                     audio_output_format=audio_output_format,
-                    audio_instructions=audio_instructions
+                    audio_instructions=audio_instructions,
+                    prompt=prompt,
                 ):
                     yield audio_chunk
 
@@ -122,7 +128,8 @@ class QueryService(QueryServiceInterface):
                     user_id=user_id,
                     query=user_text,
                     memory_context=memory_context,
-                    output_format="text"
+                    output_format="text",
+                    prompt=prompt,
                 ):
                     yield chunk
                     full_text_response += chunk

{solana_agent-19.0.2 → solana_agent-19.1.1}/solana_agent/services/routing.py

@@ -95,7 +95,7 @@ class RoutingService(RoutingServiceInterface):
                 "confidence": 0.0
             }
 
-    async def route_query(self, query: str) -> str:
+    async def route_query(self, query: str) -> str:  # pragma: no cover
         """Route a query to the appropriate agent.
 
         Args:

solana_agent-19.0.2/solana_agent/repositories/memory.py

@@ -1,143 +0,0 @@
-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.adapters.mongodb_adapter import MongoDBAdapter
-
-
-class MemoryRepository(MemoryProvider):
-    """Combined Zep and MongoDB implementation of MemoryProvider."""
-
-    def __init__(
-        self,
-        mongo_adapter: MongoDBAdapter,
-        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 = None
-
-    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": user_message,
-                "assistant_message": 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
-        if not self.zep:
-            return
-
-        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."""
-        if not self.zep:
-            return ""
-
-        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_all(
-                self.collection,
-                {"user_id": user_id}
-            )
-        except Exception as e:
-            print(f"MongoDB deletion error: {e}")
-
-        if not self.zep:
-            return
-
-        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 + "..."