solana-agent 17.1.7__py3-none-any.whl → 17.1.9__py3-none-any.whl

solana_agent/domains/agent.py

@@ -23,8 +23,8 @@ class OrganizationMission(BaseModel):
         default_factory=list,
         description="Organization goals"
     )
-    guidance: Optional[str] = Field(
-        None, description="Additional guidance for agents")
+    voice: str = Field(
+        None, description="Organization voice or tone")
 
     @field_validator("mission_statement")
     @classmethod
@@ -34,6 +34,14 @@ class OrganizationMission(BaseModel):
             raise ValueError("Mission statement cannot be empty")
         return v
 
+    @field_validator("voice")
+    @classmethod
+    def voice_not_empty(cls, v: str) -> str:
+        """Validate that voice is not empty."""
+        if not v.strip():
+            raise ValueError("Voice cannot be empty")
+        return v
+
     @field_validator("values")
     @classmethod
     def validate_values(cls, values: List[Dict[str, str]]) -> List[Dict[str, str]]:
@@ -53,12 +61,6 @@ class AIAgent(BaseModel):
     instructions: str = Field(...,
                               description="Base instructions for the agent")
     specialization: str = Field(..., description="Agent's specialized domain")
-    created_at: datetime = Field(
-        default_factory=datetime.now, description="Creation timestamp")
-    updated_at: datetime = Field(
-        default_factory=datetime.now, description="Last update timestamp")
-    description: Optional[str] = Field(
-        None, description="Agent description or summary")
 
     @field_validator("name", "specialization")
     @classmethod

solana_agent/factories/agent_factory.py

@@ -13,7 +13,6 @@ from solana_agent.services.routing import RoutingService
 
 # Repository imports
 from solana_agent.repositories.memory import MemoryRepository
-from solana_agent.repositories.agent import MongoAgentRepository
 
 # Adapter imports
 from solana_agent.adapters.llm_adapter import OpenAIAdapter
@@ -56,7 +55,7 @@ class SolanaAgentFactory:
                 values=[{"name": k, "description": v}
                         for k, v in org_config.get("values", {}).items()],
                 goals=org_config.get("goals", []),
-                guidance=org_config.get("guidance", "")
+                voice=org_config.get("voice", "")
             )
 
         # Create repositories
@@ -65,11 +64,9 @@ class SolanaAgentFactory:
                 db_adapter, config["zep"].get("api_key"), config["zep"].get("base_url"))
         else:
             memory_provider = MemoryRepository(db_adapter)
-        agent_repo = MongoAgentRepository(db_adapter)
 
         # Create primary services
         agent_service = AgentService(
-            agent_repository=agent_repo,
             llm_provider=llm_adapter,
             organization_mission=organization_mission,
             config=config,
@@ -93,20 +90,6 @@ class SolanaAgentFactory:
         loaded_plugins = agent_service.plugin_manager.load_plugins()
         print(f"Loaded {loaded_plugins} plugins")
 
-        # Sync MongoDB with config-defined agents
-        config_defined_agents = [agent["name"]
-                                 for agent in config.get("agents", [])]
-        all_db_agents = agent_repo.get_all_ai_agents()
-        db_agent_names = [agent.name for agent in all_db_agents]
-
-        # Delete agents not in config
-        agents_to_delete = [
-            name for name in db_agent_names if name not in config_defined_agents]
-        for agent_name in agents_to_delete:
-            print(
-                f"Deleting agent '{agent_name}' from MongoDB - no longer defined in config")
-            agent_repo.delete_ai_agent(agent_name)
-
         # Register predefined agents
         for agent_config in config.get("agents", []):
             agent_service.register_ai_agent(

solana_agent/repositories/memory.py

@@ -46,8 +46,8 @@ class MemoryRepository(MemoryProvider):
 
             doc = {
                 "user_id": user_id,
-                "user_message": self._truncate(user_message),
-                "assistant_message": self._truncate(assistant_message),
+                "user_message": user_message,
+                "assistant_message": assistant_message,
                 "timestamp": datetime.now(timezone.utc)
             }
             self.mongo.insert_one(self.collection, doc)

solana_agent/services/agent.py

@@ -4,6 +4,7 @@ Agent service implementation.
 This service manages AI and human agents, their registration, tool assignments,
 and response generation.
 """
+import asyncio
 import datetime as main_datetime
 from datetime import datetime
 import json
@@ -11,7 +12,6 @@ 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.repositories.agent import AgentRepository
 from solana_agent.interfaces.plugins.plugins import ToolRegistry as ToolRegistryInterface
 from solana_agent.plugins.registry import ToolRegistry
 from solana_agent.domains.agent import AIAgent, OrganizationMission
@@ -23,7 +23,6 @@ class AgentService(AgentServiceInterface):
     def __init__(
         self,
         llm_provider: LLMProvider,
-        agent_repository: AgentRepository,
         organization_mission: Optional[OrganizationMission] = None,
         config: Optional[Dict[str, Any]] = None,
     ):
@@ -31,16 +30,15 @@ class AgentService(AgentServiceInterface):
 
         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 {}
         self.last_text_response = ""
         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
@@ -60,7 +58,7 @@ class AgentService(AgentServiceInterface):
             instructions=instructions,
             specialization=specialization,
         )
-        self.agent_repository.save_ai_agent(agent)
+        self.agents.append(agent)
 
     def get_agent_system_prompt(self, agent_name: str) -> str:
         """Get the system prompt for an agent.
@@ -71,7 +69,9 @@ class AgentService(AgentServiceInterface):
         Returns:
             System prompt
         """
-        agent = self.agent_repository.get_ai_agent_by_name(agent_name)
+
+        # Get agent by name
+        agent = next((a for a in self.agents if a.name == agent_name), None)
 
         # Build system prompt
         system_prompt = f"You are {agent.name}, an AI assistant with the following instructions:\n\n"
@@ -83,6 +83,7 @@ class AgentService(AgentServiceInterface):
         # Add mission and values if available
         if self.organization_mission:
             system_prompt += f"\n\nORGANIZATION MISSION:\n{self.organization_mission.mission_statement}"
+            system_prompt += f"\n\nVOICE OF THE BRAND:\n{self.organization_mission.voice}"
 
             if self.organization_mission.values:
                 values_text = "\n".join([
@@ -91,11 +92,11 @@ class AgentService(AgentServiceInterface):
                 ])
                 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}"
+            # Add organization goals if available
+            if 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
 
@@ -105,8 +106,7 @@ class AgentService(AgentServiceInterface):
         Returns:
             Dictionary mapping agent names to agents
         """
-        agents = self.agent_repository.get_all_ai_agents()
-        return {agent.name: agent for agent in agents}
+        return {agent.name: agent for agent in self.agents}
 
     def get_specializations(self) -> Dict[str, str]:
         """Get all registered specializations.
@@ -116,9 +116,7 @@ class AgentService(AgentServiceInterface):
         """
         specializations = {}
 
-        # Gather from AI agents
-        ai_agents = self.agent_repository.get_all_ai_agents()
-        for agent in ai_agents:
+        for agent in self.agents:
             if agent.specialization:
                 specializations[agent.specialization] = f"AI expertise in {agent.specialization}"
 
@@ -148,16 +146,8 @@ class AgentService(AgentServiceInterface):
         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.
+        """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"}
 
@@ -167,6 +157,7 @@ class AgentService(AgentServiceInterface):
 
         # 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",
@@ -174,8 +165,11 @@ class AgentService(AgentServiceInterface):
             }
 
         try:
-            return tool.execute(**parameters)
+            result = tool.execute(**parameters)
+            return result
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
             return {"status": "error", "message": f"Error executing tool: {str(e)}"}
 
     async def generate_response(
@@ -210,7 +204,7 @@ class AgentService(AgentServiceInterface):
         Yields:
             Text chunks or audio bytes depending on output_format
         """
-        agent = self.agent_repository.get_ai_agent_by_name(agent_name)
+        agent = next((a for a in self.agents if a.name == agent_name), None)
         if not agent:
             error_msg = f"Agent '{agent_name}' not found."
             if output_format == "audio":
@@ -247,6 +241,8 @@ class AgentService(AgentServiceInterface):
             is_json = False
             text_buffer = ""
 
+            print("\n=== Starting Response Generation ===")
+
             # Generate and stream response
             async for chunk in self.llm_provider.generate_text(
                 prompt=query_text,
@@ -264,28 +260,54 @@ class AgentService(AgentServiceInterface):
                     try:
                         # Try to parse complete JSON
                         data = json.loads(json_buffer)
+                        print(
+                            f"Successfully parsed JSON: {json.dumps(data, indent=2)}")
 
                         # Valid JSON found, handle it
-                        if "tool_call" in data:
-                            # Process tool call with existing method
-                            response_text = await self._handle_tool_call(
+                        if "tool_calls" in data:  # Now looking for tool_calls array
+                            tool_results = []
+                            async for tool_result in self._handle_multiple_tool_calls(
                                 agent_name=agent_name,
                                 json_chunk=json_buffer
-                            )
-
-                            # Add to complete text response
-                            complete_text_response += response_text
-
-                            # Output response based on format
-                            if output_format == "audio":
-                                async for audio_chunk in self.llm_provider.tts(
-                                    text=response_text,
-                                    voice=audio_voice,
-                                    response_format=audio_output_format
-                                ):
-                                    yield audio_chunk
-                            else:
-                                yield response_text
+                            ):
+                                tool_results.append(tool_result)
+
+                            # Combine results and create a new prompt with clear instructions
+                            tool_response = "\n".join(tool_results)
+                            process_prompt = f"""
+                                {tool_response}
+
+                                IMPORTANT INSTRUCTIONS:
+                                1. Maintain ALL factual details
+                                2. Include ALL statistics, numbers, and specific data points
+                                3. Use direct quotes where relevant
+                                4. Keep ALL source citations and references
+                                5. DO NOT omit or summarize away important details
+                                6. DO NOT add any information not present in the results
+                                7. DO NOT make any new tool calls or return JSON
+                            """
+
+                            # Process combined results through LLM with modified system prompt
+                            summary_system_prompt = self.get_agent_system_prompt(agent_name) + \
+                                "\n DO NOT make any tool calls or return JSON. Present ALL facts and maintain ALL details from the source material."
+
+                            async for processed_chunk in self.llm_provider.generate_text(
+                                prompt=process_prompt,
+                                system_prompt=summary_system_prompt,
+                            ):
+                                # Add to complete response
+                                complete_text_response += processed_chunk
+
+                                # Output response based on format
+                                if output_format == "audio":
+                                    async for audio_chunk in self.llm_provider.tts(
+                                        text=processed_chunk,
+                                        voice=audio_voice,
+                                        response_format=audio_output_format
+                                    ):
+                                        yield audio_chunk
+                                else:
+                                    yield processed_chunk
                         else:
                             # For non-tool JSON, still capture the text
                             complete_text_response += json_buffer
@@ -361,30 +383,6 @@ class AgentService(AgentServiceInterface):
             import traceback
             print(traceback.format_exc())
 
-    async def _handle_tool_call(
-        self,
-        agent_name: str,
-        json_chunk: str,
-    ) -> str:
-        """Handle tool calls and return formatted response."""
-        try:
-            data = json.loads(json_chunk)
-            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":
-                        return result.get("result", "")
-                    else:
-                        return f"I apologize, but I encountered an issue: {result.get('message', 'Unknown error')}"
-            return json_chunk
-        except json.JSONDecodeError:
-            return json_chunk
-
     def _get_tool_usage_prompt(self, agent_name: str) -> str:
         """Generate JSON-based instructions for tool usage."""
         # Get tools assigned to this agent
@@ -402,12 +400,12 @@ class AgentService(AgentServiceInterface):
             tool_example = """
     For latest news query:
     {
-        "tool_call": {
+        "tool_calls": [{
             "name": "search_internet",
             "parameters": {
                 "query": "latest Solana blockchain news March 2025"
             }
-        }
+        }]
     }"""
 
         return f"""
@@ -416,12 +414,12 @@ class AgentService(AgentServiceInterface):
     
     TOOL USAGE FORMAT:
     {{
-        "tool_call": {{
+        "tool_calls": [{{
             "name": "<one_of:{', '.join(available_tool_names)}>",
             "parameters": {{
                 // parameters as specified in tool definition above
             }}
-        }}
+        }}]
     }}
     
     {tool_example if tool_example else ''}
@@ -437,3 +435,53 @@ class AgentService(AgentServiceInterface):
        - No explanation text before or after
        - Use exact tool names as shown in AVAILABLE TOOLS
     """
+
+    async def _handle_multiple_tool_calls(
+        self,
+        agent_name: str,
+        json_chunk: str,
+    ) -> AsyncGenerator[str, None]:
+        """Handle multiple tool calls concurrently and yield results as they complete."""
+        try:
+            data = json.loads(json_chunk)
+            if "tool_calls" not in data:
+                yield json_chunk
+                return
+
+            tool_calls = data["tool_calls"]
+
+            if not isinstance(tool_calls, list):
+                print("Error: tool_calls is not a list")
+                yield "Error: 'tool_calls' must be an array of tool calls."
+                return
+
+            # Define individual tool execution coroutine
+            async def execute_single_tool(tool_info):
+                tool_name = tool_info.get("name")
+                parameters = tool_info.get("parameters", {})
+                print(f"\nExecuting tool: {tool_name}")
+                print(f"With parameters: {parameters}")
+
+                if not tool_name:
+                    return f"Error: Missing tool name in tool call."
+
+                result = self.execute_tool(agent_name, tool_name, parameters)
+
+                if result.get("status") == "success":
+                    return f"Result from {tool_name}: {result.get('result', '')}"
+                else:
+                    return f"Error from {tool_name}: {result.get('message', 'Unknown error')}"
+
+            # Execute all tool calls concurrently
+            tasks = [execute_single_tool(tool_call)
+                     for tool_call in tool_calls]
+            for task in asyncio.as_completed(tasks):
+                result = await task
+                yield result
+
+        except json.JSONDecodeError:
+            yield "Error: Could not parse tool calls JSON."
+        except Exception as e:
+            import traceback
+            print(traceback.format_exc())
+            yield f"Error processing tool calls: {str(e)}"

solana_agent/services/query.py

@@ -268,37 +268,12 @@ class QueryService(QueryServiceInterface):
         """
         if self.memory_provider:
             try:
-                # Truncate excessively long responses
-                truncated_assistant_message = self._truncate(assistant_message)
-                truncated_user_message = self._truncate(user_message)
-
                 await self.memory_provider.store(
                     user_id,
                     [
-                        {"role": "user", "content": truncated_user_message},
-                        {"role": "assistant", "content": truncated_assistant_message},
+                        {"role": "user", "content": user_message},
+                        {"role": "assistant", "content": assistant_message},
                     ],
                 )
             except Exception as e:
                 print(f"Error storing conversation: {e}")
-
-    def _truncate(self, text: str, limit: int = 2500) -> str:
-        """Truncate text to be within token limits.
-
-        Args:
-            text: Text to truncate
-            limit: Character limit
-
-        Returns:
-            Truncated text
-        """
-        if len(text) <= limit:
-            return text
-
-        # Try to truncate at a sentence boundary
-        truncated = text[:limit]
-        last_period = truncated.rfind(".")
-        if last_period > limit * 0.8:  # Only use period if reasonably close to the end
-            return truncated[:last_period + 1]
-
-        return truncated + "..."

solana_agent/services/routing.py

@@ -37,22 +37,43 @@ class RoutingService(RoutingServiceInterface):
         Returns:
             Analysis results including specializations and complexity
         """
+        # Get all available agents and their specializations
+        agents = self.agent_service.get_all_ai_agents()
+        available_specializations = []
+
+        for agent_id, agent in agents.items():
+            available_specializations.append({
+                "agent_name": agent_id,
+                "specialization": agent.specialization,
+            })
+
+        specializations_text = "\n".join([
+            f"- {spec['agent_name']}: {spec['specialization']}"
+            for spec in available_specializations
+        ])
+
         prompt = f"""
-        Analyze this user query and determine:
-        1. The primary specialization needed to address it
-        2. Any secondary specializations that might be helpful
+        Analyze this user query and determine which agent would be best suited to answer it.
+        
+        AVAILABLE AGENTS AND THEIR SPECIALIZATIONS:
+        {specializations_text}
+        
+        USER QUERY: {query}
+        
+        Please determine:
+        1. Which agent is the primary best match for this query (must be one of the listed agents)
+        2. Any secondary agents that might be helpful (must be from the listed agents)
         3. The complexity level (1-5, where 5 is most complex)
         4. Any key topics or technologies mentioned
-
-        User Query: {query}
-
-        Be objective and thorough in your analysis.
+        
+        Think carefully about whether the query is more technical/development-focused or more 
+        financial/market-focused to match with the appropriate agent.
         """
 
         try:
             analysis = await self.llm_provider.parse_structured_output(
                 prompt=prompt,
-                system_prompt="Analyze user queries to determine appropriate routing.",
+                system_prompt="Match user queries to the most appropriate agent based on specializations.",
                 model_class=QueryAnalysis,
             )
 
@@ -67,7 +88,7 @@ class RoutingService(RoutingServiceInterface):
             print(f"Error analyzing query: {e}")
             # Return default analysis on error
             return {
-                "primary_specialization": "general",
+                "primary_specialization": list(agents.keys())[0] if agents else "general",
                 "secondary_specializations": [],
                 "complexity_level": 1,
                 "topics": [],
@@ -84,8 +105,10 @@ class RoutingService(RoutingServiceInterface):
             Name of the best agent
         """
         # If only one agent - use that agent
-        if len(self.agent_service.get_all_ai_agents()) == 1:
-            return next(iter(self.agent_service.get_all_ai_agents().keys()))
+        agents = self.agent_service.get_all_ai_agents()
+        if len(agents) == 1:
+            print(f"Only one agent available: {next(iter(agents.keys()))}")
+            return next(iter(agents.keys()))
 
         # Analyze query
         analysis = await self._analyze_query(query)
@@ -107,8 +130,8 @@ class RoutingService(RoutingServiceInterface):
         """Find the best AI agent for a query.
 
         Args:
-            primary_specialization: Primary specialization needed
-            secondary_specializations: Secondary specializations
+            primary_specialization: Primary agent name or specialization
+            secondary_specializations: Secondary agent names or specializations
 
         Returns:
             Name of the best matching agent, or None if no match
@@ -118,33 +141,41 @@ class RoutingService(RoutingServiceInterface):
         if not ai_agents:
             return None
 
-        # Create a list to score agents
+        # First, check if primary_specialization is directly an agent name
+        if primary_specialization in ai_agents:
+            return primary_specialization
+
+        # If not a direct agent name match, use specialization matching
         agent_scores = []
 
         for agent_id, agent in ai_agents.items():
-            # Base score
             score = 0
 
-            # Check primary specialization
-            if agent.specialization.lower() == primary_specialization.lower():
+            # Check for specialization match
+            if agent.specialization.lower() in primary_specialization.lower() or \
+                    primary_specialization.lower() in agent.specialization.lower():
                 score += 10
 
             # Check secondary specializations
-            if hasattr(agent, 'secondary_specializations'):
-                for sec_spec in secondary_specializations:
-                    if sec_spec.lower() in [s.lower() for s in agent.secondary_specializations]:
-                        score += 3
+            for sec_spec in secondary_specializations:
+                if sec_spec in ai_agents:  # Direct agent name match
+                    if sec_spec == agent_id:
+                        score += 5
+                elif agent.specialization.lower() in sec_spec.lower() or \
+                        sec_spec.lower() in agent.specialization.lower():
+                    score += 3
 
             agent_scores.append((agent_id, score))
 
         # Sort by score
         agent_scores.sort(key=lambda x: x[1], reverse=True)
+        print(f"Agent scores: {agent_scores}")
 
         # Return the highest scoring agent, if any
         if agent_scores and agent_scores[0][1] > 0:
             return agent_scores[0][0]
 
-        # If no good match, return the first AI agent as fallback
+        # If no match found, return first agent as fallback
         if ai_agents:
             return next(iter(ai_agents.keys()))
 

{solana_agent-17.1.7.dist-info → solana_agent-17.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solana-agent
-Version: 17.1.7
+Version: 17.1.9
 Summary: Agentic IQ
 License: MIT
 Keywords: ai,openai,ai agents,agi
@@ -77,7 +77,7 @@ config = {
         "goals": [
             "Empower users with great answers to their queries.",
         ],
-        "guidance": "Align all interactions with the success of the user while respecting human dignity."
+        "voice": "The voice of the brand is that of a research organization."
     },
     "mongo": {
         "connection_string": "mongodb://localhost:27017",

{solana_agent-17.1.7.dist-info → solana_agent-17.1.9.dist-info}/RECORD

@@ -5,17 +5,16 @@ solana_agent/adapters/mongodb_adapter.py,sha256=qqEFbY_v1XGyFXBmwd5HSXSSHnA9wWo-
 solana_agent/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 solana_agent/client/solana_agent.py,sha256=Q9vnsoezsdhe6-T_tMb7Gr-697D1Bo2qIpr1-ytP1ak,5361
 solana_agent/domains/__init__.py,sha256=HiC94wVPRy-QDJSSRywCRrhrFfTBeHjfi5z-QfZv46U,168
-solana_agent/domains/agent.py,sha256=Ak_hD5gTCzRqAHLmqtxnny0Xki1qAKR7RzLW9LOQBTg,2930
+solana_agent/domains/agent.py,sha256=9ztePCPDMmbEF9NAsblRs0JVQciU3IVKoUF1QYTct9U,2838
 solana_agent/domains/routing.py,sha256=UDlgTjUoC9xIBVYu_dnf9-KG_bBgdEXAv_UtDOrYo0w,650
 solana_agent/factories/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-solana_agent/factories/agent_factory.py,sha256=7gMfX-80Olp11ZSzPsihH_whjlqbEEmfQD26253EbMk,5699
+solana_agent/factories/agent_factory.py,sha256=SuFTob-cbbUqc9gm06Sole7wEcxXs3sOS57eW_V2IHc,4886
 solana_agent/interfaces/__init__.py,sha256=IQs1WIM1FeKP1-kY2FEfyhol_dB-I-VAe2rD6jrVF6k,355
 solana_agent/interfaces/client/client.py,sha256=2-YxrNH54aDYf68KYSLfFVBktAJkVCGG8TE76yzM8N8,1445
 solana_agent/interfaces/plugins/plugins.py,sha256=zNrYTs-kO9RrFpFjKqPW8SDAlq3yeIsctJO7gFjuSHs,3326
 solana_agent/interfaces/providers/data_storage.py,sha256=NqGeFvAzhz9rr-liLPRNCGjooB2EIhe-EVsMmX__b0M,1658
 solana_agent/interfaces/providers/llm.py,sha256=Ay0-37ppAirGZdGS2LrDq0xAr_WY1_Gis84OXPGsaWs,1653
 solana_agent/interfaces/providers/memory.py,sha256=oNOH8WZXVW8assDigIWZAWiwkxbpDiKupxA2RB6tQvQ,1010
-solana_agent/interfaces/repositories/agent.py,sha256=r2MzVYOpEBVN00yqRxr3bUgWUgSwqoI1hRrdHhgFpFU,819
 solana_agent/interfaces/services/agent.py,sha256=V1v4NPwWdNNJhrVdiAUuHEqIpfrobKjJatSIWNa6mdQ,2155
 solana_agent/interfaces/services/query.py,sha256=bspnm-CN6zjRWnlFnkl34qo0EIW5m2TQR53NTEWMaq4,1271
 solana_agent/interfaces/services/routing.py,sha256=gohkt5f9uYDLpu4iDVDk9yj8js9P56R6QHSIDNylgwA,438
@@ -25,13 +24,12 @@ solana_agent/plugins/registry.py,sha256=Z41sW_E8vObg16gA9gB7IrcH5mRGFJMeNC879zJU
 solana_agent/plugins/tools/__init__.py,sha256=c0z7ij42gs94_VJrcn4Y8gUlTxMhsFNY6ahIsNswdLk,231
 solana_agent/plugins/tools/auto_tool.py,sha256=Z3CcOzwdXpzciH-5yphhd9qt1b9owTxhwC-dYmPF6B0,1489
 solana_agent/repositories/__init__.py,sha256=fP83w83CGzXLnSdq-C5wbw9EhWTYtqE2lQTgp46-X_4,163
-solana_agent/repositories/agent.py,sha256=e1rnsQiigkKwJNLKro86a3b6TBiky3GMfmCRc5b_jPw,3187
-solana_agent/repositories/memory.py,sha256=DrhaVxlE-iAOmX0sfDCqgdPJauYvrnPd7rmVlf6_HGE,4822
+solana_agent/repositories/memory.py,sha256=cDGoRz8FEkjwCE7j0XvA03-NL0TyROAt4_uwx288Th0,4790
 solana_agent/services/__init__.py,sha256=ab_NXJmwYUCmCrCzuTlZ47bJZINW0Y0F5jfQ9OovidU,163
-solana_agent/services/agent.py,sha256=RLsr5b-HbAsjhXxJThPnnTNz6OWPQbnDF4LNl6BGyVg,16740
-solana_agent/services/query.py,sha256=rm7XlTCcp5NeorIaLUdr7rdxtWCgg1Q1qe5YuI1bumo,11246
-solana_agent/services/routing.py,sha256=TPJ2Pas4acE93QzMEV6ZP670OtTNrVEPa76fz6urEV4,4996
-solana_agent-17.1.7.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
-solana_agent-17.1.7.dist-info/METADATA,sha256=sqs6N7pQNy-3Tnmk0_wD5kxHZZf3GtU5C5seXSmoX7M,4720
-solana_agent-17.1.7.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-solana_agent-17.1.7.dist-info/RECORD,,
+solana_agent/services/agent.py,sha256=K3_DB02VRjPKa4z-ik-1sz9fYGBWGwLjFvQugJKxonw,19295
+solana_agent/services/query.py,sha256=qXrvzAyMqESdF8QD3xYaz2vyfR7ndLpsh2TahYQ-LYg,10414
+solana_agent/services/routing.py,sha256=IPvBicgTYXqQ8iIRaatCsBGQVsOBGdAkq2i6U8hZlOY,6479
+solana_agent-17.1.9.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
+solana_agent-17.1.9.dist-info/METADATA,sha256=Svsmh7LG38ajUZRlTRlyaelmdXiF_LAQT1BslL0ESrM,4692
+solana_agent-17.1.9.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+solana_agent-17.1.9.dist-info/RECORD,,

solana_agent/interfaces/repositories/agent.py

@@ -1,33 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Optional
-
-from solana_agent.domains.agent 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/repositories/agent.py

@@ -1,99 +0,0 @@
-"""
-MongoDB implementation of the agent repository.
-"""
-from typing import List, Optional, Any
-
-from solana_agent.domains.agent 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})