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

solana_agent/services/query.py

@@ -0,0 +1,223 @@
+"""
+Query service implementation.
+
+This service orchestrates the processing of user queries, coordinating
+other services to provide comprehensive responses while maintaining
+clean separation of concerns.
+"""
+from typing import Any, AsyncGenerator, Dict, Optional
+
+from solana_agent.interfaces.services.query import QueryService as QueryServiceInterface
+from solana_agent.services.agent import AgentService
+from solana_agent.services.routing import RoutingService
+from solana_agent.interfaces.providers.memory import MemoryProvider
+
+
+class QueryService(QueryServiceInterface):
+    """Service for processing user queries and coordinating response generation."""
+
+    def __init__(
+        self,
+        agent_service: AgentService,
+        routing_service: RoutingService,
+        memory_provider: Optional[MemoryProvider] = None,
+    ):
+        """Initialize the query service.
+
+        Args:
+            agent_service: Service for AI agent management
+            routing_service: Service for routing queries to appropriate agents
+            memory_provider: Optional provider for memory storage and retrieval
+        """
+        self.agent_service = agent_service
+        self.routing_service = routing_service
+        self.memory_provider = memory_provider
+
+    async def process(
+        self, user_id: str, user_text: str, timezone: str = None
+    ) -> AsyncGenerator[str, None]:  # pragma: no cover
+        """Process the user request with appropriate agent.
+
+        Args:
+            user_id: User ID
+            user_text: User query text
+            timezone: Optional user timezone
+
+        Yields:
+            Response text chunks
+        """
+        try:
+            # Handle simple greetings
+            if user_text.strip().lower() in ["test", "hello", "hi", "hey", "ping"]:
+                response = f"Hello! How can I help you today?"
+                yield response
+                # Store simple interaction in memory
+                if self.memory_provider:
+                    await self._store_conversation(user_id, user_text, response)
+                return
+
+            # Get memory context if available
+            memory_context = ""
+            if self.memory_provider:
+                memory_context = await self.memory_provider.retrieve(user_id)
+
+            # Route query to appropriate agent
+            agent_name = await self.routing_service.route_query(user_id, user_text)
+
+            # Generate response
+            full_response = ""
+            async for chunk in self.agent_service.generate_response(
+                agent_name=agent_name,
+                user_id=user_id,
+                query=user_text,
+                memory_context=memory_context
+            ):
+                yield chunk
+                full_response += chunk
+
+            # Store conversation and extract insights
+            if self.memory_provider:
+                await self._store_conversation(user_id, user_text, full_response)
+
+        except Exception as e:
+            yield f"I apologize for the technical difficulty. {str(e)}"
+            import traceback
+            print(f"Error in query processing: {str(e)}")
+            print(traceback.format_exc())
+
+    async def get_user_history(
+        self,
+        user_id: str,
+        page_num: int = 1,
+        page_size: int = 20,
+        sort_order: str = "asc"  # "asc" for oldest-first, "desc" for newest-first
+    ) -> Dict[str, Any]:
+        """Get paginated message history for a user.
+
+        Args:
+            user_id: User ID
+            page_num: Page number (starting from 1)
+            page_size: Number of messages per page
+            sort_order: Sort order ("asc" or "desc")
+
+        Returns:
+            Dictionary with paginated results and metadata:
+            {
+                "data": List of conversation entries,
+                "total": Total number of entries,
+                "page": Current page number,
+                "page_size": Number of items per page,
+                "total_pages": Total number of pages,
+                "error": Error message if any
+            }
+        """
+        if not self.memory_provider:
+            return {
+                "data": [],
+                "total": 0,
+                "page": page_num,
+                "page_size": page_size,
+                "total_pages": 0,
+                "error": "Memory provider not available"
+            }
+
+        try:
+            # Calculate skip and limit for pagination
+            skip = (page_num - 1) * page_size
+
+            # Get total count of documents
+            total = self.memory_provider.count_documents(
+                collection="conversations",
+                query={"user_id": user_id}
+            )
+
+            # Calculate total pages
+            total_pages = (total + page_size - 1) // page_size
+
+            # Get paginated results
+            conversations = self.memory_provider.find(
+                collection="conversations",
+                query={"user_id": user_id},
+                sort=[("timestamp", 1 if sort_order == "asc" else -1)],
+                skip=skip,
+                limit=page_size
+            )
+
+            # Format the results
+            formatted_conversations = []
+            for conv in conversations:
+                formatted_conversations.append({
+                    "id": str(conv.get("_id")),
+                    "user_message": conv.get("user_message"),
+                    "assistant_message": conv.get("assistant_message"),
+                    "timestamp": conv.get("timestamp").isoformat()
+                    if conv.get("timestamp") else None
+                })
+
+            return {
+                "data": formatted_conversations,
+                "total": total,
+                "page": page_num,
+                "page_size": page_size,
+                "total_pages": total_pages,
+                "error": None
+            }
+
+        except Exception as e:
+            print(f"Error retrieving user history: {str(e)}")
+            import traceback
+            print(traceback.format_exc())
+            return {
+                "data": [],
+                "total": 0,
+                "page": page_num,
+                "page_size": page_size,
+                "total_pages": 0,
+                "error": f"Error retrieving history: {str(e)}"
+            }
+
+    async def _store_conversation(
+        self, user_id: str, user_text: str, response_text: str
+    ) -> None:
+        """Store conversation history in memory provider.
+
+        Args:
+            user_id: User ID
+            user_text: User message
+            response_text: Assistant response
+        """
+        if self.memory_provider:
+            try:
+                # Truncate excessively long responses
+                truncated_response = self._truncate(response_text)
+
+                await self.memory_provider.store(
+                    user_id,
+                    [
+                        {"role": "user", "content": user_text},
+                        {"role": "assistant", "content": truncated_response},
+                    ],
+                )
+            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

@@ -0,0 +1,149 @@
+"""
+Routing service implementation.
+
+This service manages query routing to appropriate agents based on
+specializations and query analysis.
+"""
+from typing import Dict, List, Optional, Any
+from solana_agent.interfaces.services.routing import RoutingService as RoutingServiceInterface
+from solana_agent.interfaces.services.agent import AgentService
+from solana_agent.interfaces.providers.llm import LLMProvider
+from solana_agent.domains.routing import QueryAnalysis
+
+
+class RoutingService(RoutingServiceInterface):
+    """Service for routing queries to appropriate agents."""
+
+    def __init__(
+        self,
+        llm_provider: LLMProvider,
+        agent_service: AgentService,
+    ):
+        """Initialize the routing service.
+
+        Args:
+            llm_provider: Provider for language model interactions
+            agent_service: Service for agent management
+        """
+        self.llm_provider = llm_provider
+        self.agent_service = agent_service
+
+    async def _analyze_query(self, query: str) -> Dict[str, Any]:
+        """Analyze a query to determine routing information.
+
+        Args:
+            query: User query to analyze
+
+        Returns:
+            Analysis results including specializations and complexity
+        """
+        prompt = f"""
+        Analyze this user query and determine:
+        1. The primary specialization needed to address it
+        2. Any secondary specializations that might be helpful
+        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.
+        """
+
+        try:
+            analysis = await self.llm_provider.parse_structured_output(
+                prompt=prompt,
+                system_prompt="Analyze user queries to determine appropriate routing.",
+                model_class=QueryAnalysis,
+                temperature=0.2
+            )
+
+            return {
+                "primary_specialization": analysis.primary_specialization,
+                "secondary_specializations": analysis.secondary_specializations,
+                "complexity_level": analysis.complexity_level,
+                "topics": analysis.topics,
+                "confidence": analysis.confidence
+            }
+        except Exception as e:
+            print(f"Error analyzing query: {e}")
+            # Return default analysis on error
+            return {
+                "primary_specialization": "general",
+                "secondary_specializations": [],
+                "complexity_level": 1,
+                "topics": [],
+                "confidence": 0.0
+            }
+
+    async def route_query(self, user_id: str, query: str) -> str:
+        """Route a query to the appropriate agent.
+
+        Args:
+            user_id: ID of the user making the query
+            query: The query text
+
+        Returns:
+            Name of the selected agent
+        """
+        # Analyze query
+        analysis = await self._analyze_query(query)
+
+        # Find best agent based on analysis
+        selected_agent = await self._find_best_ai_agent(
+            analysis["primary_specialization"],
+            analysis["secondary_specializations"]
+        )
+
+        # Return default agent if none found
+        return selected_agent or "general_ai"
+
+    async def _find_best_ai_agent(
+        self,
+        primary_specialization: str,
+        secondary_specializations: List[str],
+    ) -> Optional[str]:
+        """Find the best AI agent for a query.
+
+        Args:
+            primary_specialization: Primary specialization needed
+            secondary_specializations: Secondary specializations
+
+        Returns:
+            Name of the best matching agent, or None if no match
+        """
+        # Get all AI agents
+        ai_agents = self.agent_service.get_all_ai_agents()
+        if not ai_agents:
+            return None
+
+        # Create a list to score agents
+        agent_scores = []
+
+        for agent_id, agent in ai_agents.items():
+            # Base score
+            score = 0
+
+            # Check primary specialization
+            if agent.specialization.lower() == primary_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
+
+            agent_scores.append((agent_id, score))
+
+        # Sort by score
+        agent_scores.sort(key=lambda x: x[1], reverse=True)
+
+        # 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 ai_agents:
+            return next(iter(ai_agents.keys()))
+
+        return None

solana_agent-14.0.0.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.3
+Name: solana-agent
+Version: 14.0.0
+Summary: The Future of Work
+License: MIT
+Keywords: ai,openai,ai agents,agi
+Author: Bevan Hunt
+Author-email: bevan@bevanhunt.com
+Requires-Python: >=3.12,<4.0
+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: ntplib (>=0.4.0,<0.5.0)
+Requires-Dist: openai (>=1.67.0,<2.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pinecone (>=6.0.2,<7.0.0)
+Requires-Dist: pydantic (>=2.10.6,<3.0.0)
+Requires-Dist: pymongo (>=4.11.3,<5.0.0)
+Requires-Dist: qdrant-client (>=1.13.3,<2.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: zep-cloud (>=2.7.0,<3.0.0)
+Requires-Dist: zep-python (>=2.0.2,<3.0.0)
+Project-URL: Repository, https://github.com/truemagic-coder/solana-agent
+Description-Content-Type: text/markdown
+
+# Solana Agent
+
+[![PyPI - Version](https://img.shields.io/pypi/v/solana-agent)](https://pypi.org/project/solana-agent/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-orange.svg)](https://www.python.org/downloads/)
+[![codecov](https://img.shields.io/codecov/c/github/truemagic-coder/solana-agent/main.svg)](https://codecov.io/gh/truemagic-coder/solana-agent)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/truemagic-coder/solana-agent/test.yml?branch=main)](https://github.com/truemagic-coder/solana-agent/actions/workflows/test.yml)
+
+![Solana Agent Logo](https://dl.walletbubbles.com/solana-agent-logo.png?width=200)
+
+## Technical Features
+
+* Text streaming messages by AI Agents
+* Routing based on AI Agent specializations
+* Built-in default Internet Search for AI Agents
+* Robust AI Agent tool plugins based on standard python packages
+
+## Installation
+
+You can install Solana Agent using pip:
+
+`pip install solana-agent`
+
+## Documentation
+
+Each public method has a docstring for real-time IDE hinting.
+
+## Example App
+
+```python
+from solana_agent import SolanaAgent
+
+config = {
+    "organization": {
+        "mission_statement": "To revolutionize knowledge work through AI-human collaboration that puts people first.",
+        "values": {
+            "Human-Centered": "Always prioritize human well-being and augmentation over replacement.",
+            "Transparency": "Provide clear explanations for decisions and never hide information.",
+            "Collective Intelligence": "Value diverse perspectives and combine human and AI strengths.",
+            "Continuous Learning": "Embrace feedback and continuously improve based on experience."
+        },
+        "goals": [
+            "Enable human experts to focus on high-value creative work",
+            "Reduce administrative overhead through intelligent automation",
+            "Create seamless knowledge flow across the organization"
+        ],
+        "guidance": "When making decisions, prioritize long-term user success over short-term efficiency."
+    },
+    "mongo": {
+        "connection_string": "mongodb://localhost:27017",
+        "database": "solana_agent"
+    },
+    "openai": {
+        "api_key": "your-openai-key",
+        "default_model": "gpt-4o-mini"
+    },
+    "agents": [
+        {
+            "name": "research_specialist",
+            "instructions": "You are an expert researcher who synthesizes complex information clearly.",
+            "specialization": "Research and knowledge synthesis",
+            "model": "o3-mini",
+            "tools": ["some_tool"]
+        },
+        {
+            "name": "customer_support",
+            "instructions": "You provide friendly, helpful customer support responses.",
+            "specialization": "Customer inquiries",
+            "model": "gpt-4o-mini"
+        }
+    ],
+}
+
+# Create agent with configuration
+solana_agent = SolanaAgent(config=config)
+
+# Process a query that can use tools
+async for response in solana_agent.process("user123", "What are the latest AI developments?"):
+    print(response, end="")
+```
+
+## Solana Agent Kit (plugins collection)
+
+[Solana Agent Kit](https://github.com/truemagic-coder/solana-agent-kit)
+
+## Example App
+
+[Solana Agent Example App](https://github.com/truemagic-coder/solana-agent-app)
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+

solana_agent-14.0.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+solana_agent/__init__.py,sha256=ceYeUpjIitpln8YK1r0JVJU8mzG6cRPYu-HLny3d-Tw,887
+solana_agent/adapters/__init__.py,sha256=tiEEuuy0NF3ngc_tGEcRTt71zVI58v3dYY9RvMrF2Cg,204
+solana_agent/adapters/llm_adapter.py,sha256=-MmQL71JlNJeWr16a-qZ5OzTg1_69ewgAR9ZSwXpsbw,4326
+solana_agent/adapters/mongodb_adapter.py,sha256=zvcIZ61zx45cwfjMimXC2RV_D_s6sL5b2Dz6H3HCgFc,2456
+solana_agent/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+solana_agent/client/solana_agent.py,sha256=SDspEitajVL3q2C0zlVoeE6iGTC4vWSd5vcRLZFUhXg,2600
+solana_agent/domains/__init__.py,sha256=HiC94wVPRy-QDJSSRywCRrhrFfTBeHjfi5z-QfZv46U,168
+solana_agent/domains/agents.py,sha256=S8OKtkUQ7npl8bZrSH64TZuu5bnwnMYXXx3IbKvJOuU,3005
+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=yjB3G8ItXFH3DaoRf1BB1acPnL84Pd2pbqz5W03-5Jc,5711
+solana_agent/interfaces/__init__.py,sha256=IQs1WIM1FeKP1-kY2FEfyhol_dB-I-VAe2rD6jrVF6k,355
+solana_agent/interfaces/plugins/plugins.py,sha256=TMmTXwHhmkdJpIhgADfrpGGGk7PHP7O9Qi89uA26uMI,3013
+solana_agent/interfaces/providers/data_storage.py,sha256=Qjui9ISvX_NtOUPTUyjPMNxDoYRpml-aMG8DZy_Qxzc,1509
+solana_agent/interfaces/providers/llm.py,sha256=y4OFj2Wq4XicMxArWsYBHSp6cFe3BcK9sCemfyaWV_A,887
+solana_agent/interfaces/providers/memory.py,sha256=oNOH8WZXVW8assDigIWZAWiwkxbpDiKupxA2RB6tQvQ,1010
+solana_agent/interfaces/repositories/agent.py,sha256=HZL5q7DoOj-qK5IDSShAJnu4_A75OR0xgJD_2W6Zr6k,820
+solana_agent/interfaces/services/agent.py,sha256=JHUVsxAnOsopiNilU_zDBAhJfQT_BFrtOczDL2atoZo,1407
+solana_agent/interfaces/services/query.py,sha256=6SILNgSIkUsCnhn6EqdmsfPFTieawGbNJq56a3TzgSA,307
+solana_agent/interfaces/services/routing.py,sha256=tKMK97m6U5I__F406sm60az4QInGLX_N3knc_AbMZ80,452
+solana_agent/plugins/__init__.py,sha256=coZdgJKq1ExOaj6qB810i3rEhbjdVlrkN76ozt_Ojgo,193
+solana_agent/plugins/manager.py,sha256=GWwhfMBn9THwVn7biOvVa25GLthCA1ilWIoDkt5hXNI,5084
+solana_agent/plugins/registry.py,sha256=dRKWoOEqiU7OLsjpBWf4VJfDQYZdJPjW5AKxeITmVMA,2283
+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=7FTT3WvOaBacWme7d-qaOyqAlUhf9LVLXnIiPb16FDk,3188
+solana_agent/repositories/memory.py,sha256=0wgoa2bXhpgdBgn9-i9G10PB1bMGYObxcoY9Newll40,4742
+solana_agent/services/__init__.py,sha256=ab_NXJmwYUCmCrCzuTlZ47bJZINW0Y0F5jfQ9OovidU,163
+solana_agent/services/agent.py,sha256=-IKdDNvq-T_xEkOt7q2oG0xklL07_RUrc2NT1YIle9c,11426
+solana_agent/services/query.py,sha256=N8UULC7RrxxX-mQUjporduKj7auKV899n2B9Amol_ss,7767
+solana_agent/services/routing.py,sha256=L3nZaMeX4ENYfHoc2KrOtfzhScCWfrXS5RRaUIJPwNY,4956
+solana_agent-14.0.0.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
+solana_agent-14.0.0.dist-info/METADATA,sha256=u_s6RqaKolKU180Z8LYehkw-5cuogb1XsB67a6d8aWo,4569
+solana_agent-14.0.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+solana_agent-14.0.0.dist-info/RECORD,,