solana-agent 17.1.10__tar.gz → 18.0.0__tar.gz

{solana_agent-17.1.10 → solana_agent-18.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solana-agent
-Version: 17.1.10
+Version: 18.0.0
 Summary: Agentic IQ
 License: MIT
 Keywords: ai,openai,ai agents,agi

{solana_agent-17.1.10 → solana_agent-18.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "solana-agent"
-version = "17.1.10"
+version = "18.0.0"
 description = "Agentic IQ"
 authors = ["Bevan Hunt <bevan@bevanhunt.com>"]
 license = "MIT"

{solana_agent-17.1.10 → solana_agent-18.0.0}/solana_agent/interfaces/plugins/plugins.py

@@ -34,7 +34,7 @@ class Tool(ABC):
         pass
 
     @abstractmethod
-    def execute(self, **params) -> Dict[str, Any]:
+    async def execute(self, **params) -> Dict[str, Any]:
         """Execute the tool with the given parameters."""
         pass
 
@@ -118,7 +118,7 @@ class PluginManager(ABC):
         pass
 
     @abstractmethod
-    def execute_tool(self, tool_name: str, **kwargs) -> Dict[str, Any]:
+    async def execute_tool(self, tool_name: str, **kwargs) -> Dict[str, Any]:
         """Execute a tool with the given parameters."""
         pass
 

{solana_agent-17.1.10 → solana_agent-18.0.0}/solana_agent/interfaces/services/agent.py

@@ -53,7 +53,7 @@ class AgentService(ABC):
         pass
 
     @abstractmethod
-    def execute_tool(self, agent_name: str, tool_name: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+    async def execute_tool(self, agent_name: str, tool_name: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
         """Execute a tool on behalf of an agent."""
         pass
 

{solana_agent-17.1.10 → solana_agent-18.0.0}/solana_agent/plugins/manager.py

@@ -111,7 +111,7 @@ class PluginManager(PluginManagerInterface):
             for plugin in self._plugins.values()
         ]
 
-    def execute_tool(self, tool_name: str, **kwargs) -> Dict[str, Any]:
+    async def execute_tool(self, tool_name: str, **kwargs) -> Dict[str, Any]:
         """Execute a tool with the given parameters.
 
         Args:
@@ -126,7 +126,7 @@ class PluginManager(PluginManagerInterface):
             return {"status": "error", "message": f"Tool {tool_name} not found"}
 
         try:
-            return tool.execute(**kwargs)
+            return await tool.execute(**kwargs)
         except Exception as e:
             return {"status": "error", "message": str(e)}
 

{solana_agent-17.1.10 → solana_agent-18.0.0}/solana_agent/plugins/registry.py

@@ -42,15 +42,17 @@ class ToolRegistry(ToolRegistryInterface):
                 f"Error: Tool {tool_name} is not registered. Available tools: {list(self._tools.keys())}")
             return False
 
+        # Initialize agent's tool list if not exists
         if agent_name not in self._agent_tools:
-            self._agent_tools[agent_name] = []
+            self._agent_tools[agent_name] = [tool_name]
+        elif tool_name not in self._agent_tools[agent_name]:
+            # Add new tool to existing list
+            self._agent_tools[agent_name] = [
+                *self._agent_tools[agent_name], tool_name]
 
-        if tool_name not in self._agent_tools[agent_name]:
-            self._agent_tools[agent_name].append(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]}")
+        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]}")
 
         return True
 

{solana_agent-17.1.10 → solana_agent-18.0.0}/solana_agent/plugins/tools/auto_tool.py

@@ -41,7 +41,7 @@ class AutoTool(Tool):
         # Override in subclasses
         return {}
 
-    def execute(self, **params) -> Dict[str, Any]:
+    async def execute(self, **params) -> Dict[str, Any]:
         """Execute the tool with the provided parameters."""
         # Override in subclasses
         raise NotImplementedError("Tool must implement execute method")

{solana_agent-17.1.10 → solana_agent-18.0.0}/solana_agent/services/agent.py

@@ -145,7 +145,7 @@ 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]:
+    async 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."""
 
         if not self.tool_registry:
@@ -165,7 +165,7 @@ class AgentService(AgentServiceInterface):
             }
 
         try:
-            result = tool.execute(**parameters)
+            result = await tool.execute(**parameters)
             return result
         except Exception as e:
             import traceback
@@ -241,8 +241,6 @@ 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,
@@ -260,42 +258,23 @@ 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_calls" in data:  # Now looking for tool_calls array
-                            tool_results = []
-                            async for tool_result in self._handle_multiple_tool_calls(
+                        if "tool_call" in data:
+                            # Process tool call with existing method
+                            response_text = await self._handle_tool_call(
                                 agent_name=agent_name,
                                 json_chunk=json_buffer
-                            ):
-                                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."
+                            )
+
+                            system_prompt = self.get_agent_system_prompt(agent_name) + \
+                                "\n DO NOT make any tool calls or return JSON."
 
                             # Collect all processed text first
                             processed_text = ""
                             async for processed_chunk in self.llm_provider.generate_text(
-                                prompt=process_prompt,
-                                system_prompt=summary_system_prompt,
+                                prompt=response_text,
+                                system_prompt=system_prompt,
                             ):
                                 processed_text += processed_chunk
                                 # For text output, yield chunks as they come
@@ -388,6 +367,30 @@ 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 = await 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
@@ -399,94 +402,27 @@ class AgentService(AgentServiceInterface):
         available_tool_names = [tool.get("name", "") for tool in tools]
         tools_json = json.dumps(tools, indent=2)
 
-        # Create tool example if search is available
-        tool_example = ""
-        if "search_internet" in available_tool_names:
-            tool_example = """
-    For latest news query:
-    {
-        "tool_calls": [{
-            "name": "search_internet",
-            "parameters": {
-                "query": "latest Solana blockchain news March 2025"
-            }
-        }]
-    }"""
-
         return f"""
     AVAILABLE TOOLS:
     {tools_json}
     
     TOOL USAGE FORMAT:
     {{
-        "tool_calls": [{{
+        "tool_call": {{
             "name": "<one_of:{', '.join(available_tool_names)}>",
             "parameters": {{
                 // parameters as specified in tool definition above
             }}
-        }}]
+        }}
     }}
     
-    {tool_example if tool_example else ''}
-    
     RESPONSE RULES:
     1. For tool usage:
        - Only use tools from the AVAILABLE TOOLS list above
        - Follow the exact parameter format shown in the tool definition
-       - Include "March 2025" in any search queries for current information
     
     2. Format Requirements:
        - Return ONLY the JSON object for tool calls
        - 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)}"