solana-agent 28.1.1__py3-none-any.whl → 28.2.1__py3-none-any.whl

solana_agent/cli.py

@@ -0,0 +1,128 @@
+from typing import Optional
+import typer
+import asyncio
+import logging
+from typing_extensions import Annotated
+from rich.console import Console
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.prompt import Prompt
+
+from solana_agent.client.solana_agent import SolanaAgent
+
+# --- Basic Logging Configuration ---
+logging.basicConfig(level=logging.WARNING, format="%(levelname)s:%(name)s:%(message)s")
+# --- End Logging Configuration ---
+
+app = typer.Typer()
+console = Console()
+
+
+async def stream_agent_response(
+    agent: SolanaAgent,
+    user_id: str,
+    message: str,
+    prompt: Optional[str] = None,
+):
+    """Helper function to stream and display agent response."""
+    full_response = ""
+    with Live(console=console, refresh_per_second=10, transient=True) as live:
+        live.update(Spinner("dots", "Thinking..."))
+        try:
+            first_chunk = True
+            async for chunk in agent.process(
+                user_id=user_id,
+                message=message,
+                output_format="text",
+                prompt=prompt,  # Pass prompt override if provided
+            ):
+                if first_chunk:
+                    live.update("", refresh=True)  # Clear spinner
+                    first_chunk = False
+                full_response += chunk
+                live.update(full_response)
+
+            if first_chunk:  # No response received
+                live.update("[yellow]Agent did not produce a response.[/yellow]")
+
+        except Exception as e:
+            # Display error within the Live context
+            live.update(f"[bold red]\nError during processing:[/bold red] {e}")
+            # Keep the error message visible after Live exits by printing it again
+            console.print(f"[bold red]Error during processing:[/bold red] {e}")
+            full_response = ""  # Ensure error message isn't printed as final response
+
+    # Print the final complete response cleanly after Live context exits
+    if full_response:
+        console.print(f"[bright_blue]Agent:[/bright_blue] {full_response}")
+
+
+@app.command()
+def chat(
+    user_id: Annotated[
+        str, typer.Option(help="The user ID for the conversation.")
+    ] = "cli_user",
+    config: Annotated[
+        str, typer.Option(help="Path to the configuration JSON file.")
+    ] = "config.json",
+    prompt: Annotated[  # Allow prompt override via option
+        str, typer.Option(help="Optional system prompt override for the session.")
+    ] = None,
+):
+    """
+    Start an interactive chat session with the Solana Agent.
+    Type 'exit' or 'quit' to end the session.
+    """
+    try:
+        with console.status("[bold green]Initializing agent...", spinner="dots"):
+            agent = SolanaAgent(config_path=config)
+        console.print("[green]Agent initialized. Start chatting![/green]")
+        console.print("[dim]Type 'exit' or 'quit' to end.[/dim]")
+
+    except FileNotFoundError:
+        console.print(
+            f"[bold red]Error:[/bold red] Configuration file not found at '{config}'"
+        )
+        raise typer.Exit(code=1)
+    except ValueError as e:
+        console.print(f"[bold red]Error loading configuration:[/bold red] {e}")
+        raise typer.Exit(code=1)
+    except Exception as e:
+        console.print(
+            f"[bold red]An unexpected error occurred during initialization:[/bold red] {e}"
+        )
+        raise typer.Exit(code=1)
+
+    # --- Main Interaction Loop ---
+    while True:
+        try:
+            # Use Rich's Prompt for better input handling
+            user_message = Prompt.ask("[bold green]You[/bold green]")
+
+            if user_message.lower() in ["exit", "quit"]:
+                console.print("[yellow]Exiting chat session.[/yellow]")
+                break
+
+            if not user_message.strip():  # Handle empty input
+                continue
+
+            # Run the async streaming function for the user's message
+            # Pass the optional prompt override from the command line option
+            asyncio.run(stream_agent_response(agent, user_id, user_message, prompt))
+
+        except KeyboardInterrupt:  # Allow Ctrl+C to exit gracefully
+            console.print(
+                "\n[yellow]Exiting chat session (KeyboardInterrupt).[/yellow]"
+            )
+            break
+        except Exception as loop_error:
+            # Catch errors during the input/processing loop without crashing
+            console.print(
+                f"[bold red]An error occurred in the chat loop:[/bold red] {loop_error}"
+            )
+            # Optionally add a small delay or specific error handling here
+            # Consider if you want to break the loop on certain errors
+
+
+if __name__ == "__main__":
+    app()

solana_agent/factories/agent_factory.py

@@ -6,6 +6,7 @@ services and components used in the system.
 """
 
 import importlib
+import logging
 from typing import Dict, Any, List
 
 # Service imports
@@ -30,6 +31,9 @@ from solana_agent.adapters.mongodb_adapter import MongoDBAdapter
 from solana_agent.domains.agent import BusinessMission
 from solana_agent.plugins.manager import PluginManager
 
+# Setup logger for this module
+logger = logging.getLogger(__name__)
+
 
 class SolanaAgentFactory:
     """Factory for creating and wiring components of the Solana Agent system."""
@@ -45,7 +49,9 @@ class SolanaAgentFactory:
             class_path = config.get("class")
             guardrail_config = config.get("config", {})
             if not class_path:
-                print(f"Guardrail config missing 'class': {config}")
+                logger.warning(
+                    f"Guardrail config missing 'class': {config}"
+                )  # Use logger.warning
                 continue
             try:
                 module_path, class_name = class_path.rsplit(".", 1)
@@ -54,15 +60,23 @@ class SolanaAgentFactory:
                 # Instantiate the guardrail, handling potential errors during init
                 try:
                     guardrails.append(guardrail_class(config=guardrail_config))
-                    print(f"Successfully loaded guardrail: {class_path}")
+                    logger.info(
+                        f"Successfully loaded guardrail: {class_path}"
+                    )  # Use logger.info
                 except Exception as init_e:
-                    print(f"Error initializing guardrail '{class_path}': {init_e}")
+                    logger.error(
+                        f"Error initializing guardrail '{class_path}': {init_e}"
+                    )  # Use logger.error
                     # Optionally re-raise or just skip this guardrail
 
             except (ImportError, AttributeError, ValueError) as e:
-                print(f"Error loading guardrail class '{class_path}': {e}")
+                logger.error(
+                    f"Error loading guardrail class '{class_path}': {e}"
+                )  # Use logger.error
             except Exception as e:  # Catch unexpected errors during import/getattr
-                print(f"Unexpected error loading guardrail '{class_path}': {e}")
+                logger.exception(
+                    f"Unexpected error loading guardrail '{class_path}': {e}"
+                )  # Use logger.exception
         return guardrails
 
     @staticmethod
@@ -142,7 +156,7 @@ class SolanaAgentFactory:
         output_guardrails: List[OutputGuardrail] = (
             SolanaAgentFactory._create_guardrails(guardrail_config.get("output", []))
         )
-        print(
+        logger.info(  # Use logger.info
             f"Loaded {len(input_guardrails)} input guardrails and {len(output_guardrails)} output guardrails."
         )
 
@@ -161,7 +175,7 @@ class SolanaAgentFactory:
         )
 
         # Debug the agent service tool registry
-        print(
+        logger.debug(  # Use logger.debug
             f"Agent service tools after initialization: {agent_service.tool_registry.list_all_tools()}"
         )
 
@@ -171,9 +185,9 @@ class SolanaAgentFactory:
         )
         try:
             loaded_plugins = agent_service.plugin_manager.load_plugins()
-            print(f"Loaded {loaded_plugins} plugins")
+            logger.info(f"Loaded {loaded_plugins} plugins")  # Use logger.info
         except Exception as e:
-            print(f"Error loading plugins: {e}")
+            logger.error(f"Error loading plugins: {e}")  # Use logger.error
             loaded_plugins = 0
 
         # Register predefined agents
@@ -187,11 +201,11 @@ class SolanaAgentFactory:
             # Register tools for this agent
             if "tools" in agent_config:
                 for tool_name in agent_config["tools"]:
-                    print(
+                    logger.debug(  # Use logger.debug
                         f"Available tools before registering {tool_name}: {agent_service.tool_registry.list_all_tools()}"
                     )
                     agent_service.assign_tool_for_agent(agent_config["name"], tool_name)
-                    print(
+                    logger.info(  # Use logger.info
                         f"Successfully registered {tool_name} for agent {agent_config['name']}"
                     )
 
@@ -220,6 +234,11 @@ class SolanaAgentFactory:
                     openai_dimensions = 3072
                 elif openai_model_name == "text-embedding-3-small":  # pragma: no cover
                     openai_dimensions = 1536  # pragma: no cover
+                else:  # pragma: no cover
+                    logger.warning(
+                        f"Unknown OpenAI embedding model '{openai_model_name}' specified for KB. Defaulting dimensions to 3072."
+                    )  # pragma: no cover
+                    openai_dimensions = 3072  # pragma: no cover
 
                 # Create Pinecone adapter for KB
                 # It now relies on external embeddings, so dimension MUST match OpenAI model
@@ -264,13 +283,13 @@ class SolanaAgentFactory:
                         "breakpoint_percentile", 95
                     ),
                 )
-                print("Knowledge Base Service initialized successfully.")
+                logger.info(
+                    "Knowledge Base Service initialized successfully."
+                )  # Use logger.info
 
             except Exception as e:
-                print(f"Failed to initialize Knowledge Base: {e}")
-                import traceback
-
-                print(traceback.format_exc())
+                # Use logger.exception to include traceback automatically
+                logger.exception(f"Failed to initialize Knowledge Base: {e}")
                 knowledge_base = None  # Ensure KB is None if init fails
 
         # Create and return the query service

solana_agent/plugins/manager.py

@@ -6,6 +6,7 @@ loads, and manages plugins.
 """
 
 import importlib
+import logging
 from typing import Dict, List, Any, Optional
 import importlib.metadata
 
@@ -15,6 +16,9 @@ from solana_agent.interfaces.plugins.plugins import (
 from solana_agent.interfaces.plugins.plugins import Plugin
 from solana_agent.plugins.registry import ToolRegistry
 
+# Setup logger for this module
+logger = logging.getLogger(__name__)
+
 
 class PluginManager(PluginManagerInterface):
     """Manager for discovering and loading plugins."""
@@ -50,11 +54,15 @@ class PluginManager(PluginManagerInterface):
 
             # Only store plugin if both initialize and configure succeed
             self._plugins[plugin.name] = plugin
-            print(f"Successfully registered plugin {plugin.name}")
+            logger.info(
+                f"Successfully registered plugin {plugin.name}"
+            )  # Use logger.info
             return True
 
         except Exception as e:
-            print(f"Error registering plugin {plugin.name}: {e}")
+            logger.error(
+                f"Error registering plugin {plugin.name}: {e}"
+            )  # Use logger.error
             # Remove plugin from registry if it was added
             self._plugins.pop(plugin.name, None)
             return False
@@ -74,11 +82,15 @@ class PluginManager(PluginManagerInterface):
             # 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}")
+                logger.info(
+                    f"Skipping already loaded plugin: {entry_point.name}"
+                )  # Use logger.info
                 continue
 
             try:
-                print(f"Found plugin entry point: {entry_point.name}")
+                logger.info(
+                    f"Found plugin entry point: {entry_point.name}"
+                )  # Use logger.info
                 PluginManager._loaded_entry_points.add(entry_point_id)
                 plugin_factory = entry_point.load()
                 plugin = plugin_factory()
@@ -89,7 +101,9 @@ class PluginManager(PluginManagerInterface):
                     loaded_plugins.append(entry_point.name)
 
             except Exception as e:
-                print(f"Error loading plugin {entry_point.name}: {e}")
+                logger.error(
+                    f"Error loading plugin {entry_point.name}: {e}"
+                )  # Use logger.error
 
         return loaded_plugins
 
@@ -142,10 +156,12 @@ class PluginManager(PluginManagerInterface):
         """
         self.config.update(config)
         self.tool_registry.configure_all_tools(config)
-        print("Configuring all plugins with updated config")
+        logger.info("Configuring all plugins with updated config")  # Use logger.info
         for name, plugin in self._plugins.items():
             try:
-                print(f"Configuring plugin: {name}")
+                logger.info(f"Configuring plugin: {name}")  # Use logger.info
                 plugin.configure(self.config)
             except Exception as e:
-                print(f"Error configuring plugin {name}: {e}")
+                logger.error(
+                    f"Error configuring plugin {name}: {e}"
+                )  # Use logger.error

solana_agent/plugins/registry.py

@@ -5,6 +5,7 @@ This module implements the concrete ToolRegistry that manages tools
 and their access permissions.
 """
 
+import logging  # Import logging
 from typing import Dict, List, Any, Optional
 
 from solana_agent.interfaces.plugins.plugins import (
@@ -12,6 +13,9 @@ from solana_agent.interfaces.plugins.plugins import (
 )
 from solana_agent.interfaces.plugins.plugins import Tool
 
+# Setup logger for this module
+logger = logging.getLogger(__name__)
+
 
 class ToolRegistry(ToolRegistryInterface):
     """Instance-based registry that manages tools and their access permissions."""
@@ -28,10 +32,12 @@ class ToolRegistry(ToolRegistryInterface):
             tool.configure(self._config)
 
             self._tools[tool.name] = tool
-            print(f"Successfully registered and configured tool: {tool.name}")
+            logger.info(
+                f"Successfully registered and configured tool: {tool.name}"
+            )  # Use logger.info
             return True
         except Exception as e:
-            print(f"Error registering tool: {str(e)}")
+            logger.error(f"Error registering tool: {str(e)}")  # Use logger.error
             return False
 
     def get_tool(self, tool_name: str) -> Optional[Tool]:
@@ -41,7 +47,7 @@ class ToolRegistry(ToolRegistryInterface):
     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(
+            logger.error(  # Use logger.error
                 f"Error: Tool {tool_name} is not registered. Available tools: {list(self._tools.keys())}"
             )
             return False
@@ -53,8 +59,12 @@ class ToolRegistry(ToolRegistryInterface):
             # Add new tool to existing list
             self._agent_tools[agent_name] = [*self._agent_tools[agent_name], tool_name]
 
-        print(f"Successfully assigned tool {tool_name} to agent {agent_name}")
-        print(f"Agent {agent_name} now has access to: {self._agent_tools[agent_name]}")
+        logger.info(
+            f"Successfully assigned tool {tool_name} to agent {agent_name}"
+        )  # Use logger.info
+        logger.info(
+            f"Agent {agent_name} now has access to: {self._agent_tools[agent_name]}"
+        )  # Use logger.info
 
         return True
 
@@ -70,7 +80,10 @@ class ToolRegistry(ToolRegistryInterface):
             for name in tool_names
             if name in self._tools
         ]
-        print(f"Tools available to agent {agent_name}: {[t['name'] for t in tools]}")
+        # Changed to debug level as this might be verbose during normal operation
+        logger.debug(
+            f"Tools available to agent {agent_name}: {[t['name'] for t in tools]}"
+        )  # Use logger.debug
         return tools
 
     def list_all_tools(self) -> List[str]:
@@ -88,13 +101,13 @@ class ToolRegistry(ToolRegistryInterface):
 
         for name, tool in self._tools.items():
             try:
-                print(f"Configuring tool: {name}")
+                logger.info(f"Configuring tool: {name}")  # Use logger.info
                 tool.configure(self._config)
             except Exception as e:
-                print(f"Error configuring tool {name}: {e}")
+                logger.error(f"Error configuring tool {name}: {e}")  # Use logger.error
                 configure_errors.append((name, str(e)))
 
         if configure_errors:
-            print("The following tools failed to configure:")
+            logger.error("The following tools failed to configure:")  # Use logger.error
             for name, error in configure_errors:
-                print(f"- {name}: {error}")
+                logger.error(f"- {name}: {error}")  # Use logger.error

solana_agent/repositories/memory.py

@@ -1,3 +1,4 @@
+import logging  # Import logging
 from copy import deepcopy
 from typing import List, Dict, Any, Optional, Tuple
 from datetime import datetime, timezone
@@ -6,6 +7,9 @@ from zep_cloud.types import Message
 from solana_agent.interfaces.providers.memory import MemoryProvider
 from solana_agent.adapters.mongodb_adapter import MongoDBAdapter
 
+# Setup logger for this module
+logger = logging.getLogger(__name__)
+
 
 class MemoryRepository(MemoryProvider):
     """Combined Zep and MongoDB implementation of MemoryProvider."""
@@ -30,7 +34,7 @@ class MemoryRepository(MemoryProvider):
                 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}")
+                logger.error(f"Error initializing MongoDB: {e}")  # Use logger.error
 
         self.zep = None
         # Initialize Zep
@@ -80,7 +84,7 @@ class MemoryRepository(MemoryProvider):
                     }
                     self.mongo.insert_one(self.collection, doc)
             except Exception as e:
-                print(f"MongoDB storage error: {e}")
+                logger.error(f"MongoDB storage error: {e}")  # Use logger.error
 
         # Store in Zep
         if not self.zep:
@@ -107,17 +111,21 @@ class MemoryRepository(MemoryProvider):
                     try:
                         await self.zep.user.add(user_id=user_id)
                     except Exception as e:
-                        print(f"Zep user addition error: {e}")
+                        logger.error(
+                            f"Zep user addition error: {e}"
+                        )  # Use logger.error
 
                     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}")
+                        logger.error(
+                            f"Zep session creation error: {e}"
+                        )  # Use logger.error
                     await self.zep.memory.add(session_id=user_id, messages=zep_messages)
                 except Exception as e:
-                    print(f"Zep memory addition error: {e}")
+                    logger.error(f"Zep memory addition error: {e}")  # Use logger.error
                     return
 
     async def retrieve(self, user_id: str) -> str:
@@ -131,7 +139,7 @@ class MemoryRepository(MemoryProvider):
             return memories
 
         except Exception as e:
-            print(f"Error retrieving memories: {e}")
+            logger.error(f"Error retrieving memories: {e}")  # Use logger.error
             return ""
 
     async def delete(self, user_id: str) -> None:
@@ -140,7 +148,7 @@ class MemoryRepository(MemoryProvider):
             try:
                 self.mongo.delete_all(self.collection, {"user_id": user_id})
             except Exception as e:
-                print(f"MongoDB deletion error: {e}")
+                logger.error(f"MongoDB deletion error: {e}")  # Use logger.error
 
         if not self.zep:
             return
@@ -148,12 +156,12 @@ class MemoryRepository(MemoryProvider):
         try:
             await self.zep.memory.delete(session_id=user_id)
         except Exception as e:
-            print(f"Zep memory deletion error: {e}")
+            logger.error(f"Zep memory deletion error: {e}")  # Use logger.error
 
         try:
             await self.zep.user.delete(user_id=user_id)
         except Exception as e:
-            print(f"Zep user deletion error: {e}")
+            logger.error(f"Zep user deletion error: {e}")  # Use logger.error
 
     def find(
         self,
@@ -170,7 +178,7 @@ class MemoryRepository(MemoryProvider):
         try:
             return self.mongo.find(collection, query, sort=sort, limit=limit, skip=skip)
         except Exception as e:
-            print(f"MongoDB find error: {e}")
+            logger.error(f"MongoDB find error: {e}")  # Use logger.error
             return []
 
     def count_documents(self, collection: str, query: Dict) -> int: