fixing tool calling, improve prompts, add query command

Author: Peteredwardj

src/agent.py

@@ -17,6 +17,7 @@ class AgentState(TypedDict):
     action_plan: list
     action_log: list
     task_log: list
+    process_flag: bool
 
 class ZerePyAgent:
     def __init__(self, agent_config: dict):
@@ -191,12 +192,12 @@ def observation_step(self, state: AgentState):
         print("\n=== OBSERVATION STEP ===")
         print(f"Summarizing contextual information...")
 
-        # Update AgentState context
         state["context"] = self._replenish_inputs(state["context"])
+        query = state['current_task']
 
         try:
             observation_prompt = OBSERVATION_PROMPT.format(context=state['context'], task_log=state['task_log'])
-            context_summary = self.driver_llm.invoke(observation_prompt).content
+            context_summary = self.executor_agent.invoke(observation_prompt).content
         except Exception as e:
             logger.error(f"Error generating context summary: {e}")
             context_summary = "There is currently no additional context available."
@@ -206,21 +207,20 @@ def observation_step(self, state: AgentState):
 
     def determination_step(self, state: AgentState):
         print("\n=== DETERMINATION STEP ===")
-        print("Determining next task...")
+        print("Determining task from user query...")
 
-        task = state['current_task']
+        query = state['current_task']
 
-        if task is None or task.strip() == "":
-            determination_prompt = DETERMINATION_PROMPT.format(context_summary=state['context_summary'], connection_action_list="\n\n".join(connection.__str__() for connection in self.connections.values()))
-            task = self.character_llm.invoke(determination_prompt).content
+        determination_prompt = DETERMINATION_PROMPT.format(user_query=query, connection_action_list="\n\n".join(connection.__str__() for connection in self.connections.values()))
+        task = self.character_llm.invoke(determination_prompt).content
 
         print(f"\nDETERMINED TASK: {task}")
         return {"current_task": task}
 
     def division_step(self, state: AgentState):
         print("\n=== DIVISION STEP ===")
         print(f"Creating action plan for task: {state['current_task']}")
-        division_prompt = DIVISION_PROMPT.format(current_task=state['current_task'], connection_action_list="\n\n".join(connection.__str__() for connection in self.connections.values()))
+        division_prompt = DIVISION_PROMPT.format(current_task=state['current_task'], connection_action_list="\n\n".join(connection.__str__() for connection in self.connections.values()), preferred_llm_config=str(self.llm_prefs))
         action_plan_text = self.driver_llm.invoke(division_prompt).content
         action_plan = action_plan_text.split("\n")
 
@@ -234,7 +234,7 @@ def execution_step(self, state: AgentState) -> AgentState:
 
         if not action_plan:
             print("No actions to execute")
-            return 
+            return state
 
         for action in action_plan:
             print(f"\nExecuting action: {action}")
@@ -252,34 +252,40 @@ def evaluation_step(self, state: AgentState):
         evaluation_prompt = EVALUATION_PROMPT.format(current_task=state['current_task'], action_log =  "\n".join(f"{action['action']}:\n" +f"Result: {action['result']}"for action in action_log))
         generated_task_log = self.driver_llm.invoke(evaluation_prompt).content
         print(f"Generated task log:\n{generated_task_log}")
-        state["action_plan"] = []
-        state["action_log"] = []
         state["current_task"] = state["current_task"] if self.loop_task else None
         state["task_log"].append(generated_task_log)
         state["task_log"] = state["task_log"][-3:]  #trim to the last 3 task logs
 
-        # Delay before next loop
-        logger.info(f"\n⏳ Waiting {self.loop_delay} seconds before next loop...")
+        if (not state["process_flag"]): #only clear the action log if in a loop
+            state["action_log"] = []  
+            state["action_plan"] = [] 
+            logger.info(f"\n⏳ Waiting {self.loop_delay} seconds before next loop...") # Delay before next loop
+            time.sleep(self.loop_delay)
+            
         print_h_bar()
-        time.sleep(self.loop_delay)
         return state
 
-    def process_task(self, task: str): # Process a single task
+    def process_task(self, task: str = None): # Process a single task
+        if task is None:
+            task = input("\n🔹 Enter the task to perform (e.g., 'Read the timeline, then write a tweet about it').\n\n➡️ YOUR TASK: ")
+
         state = {
             "context": {},
             "current_task": task,
             "context_summary": "",
             "action_plan": [],
             "action_log": [],
             "task_log": [],
+            "process_flag": True
         }
-        
-        state.update(self.observation_step(state))
         state.update(self.determination_step(state))
         state.update(self.division_step(state))
         state = self.execution_step(state)
         state.update(self.evaluation_step(state))
 
+        #add final_response of the last action to the state
+        state["final_response"] = state["action_log"][-1]["final_response"] if state["action_log"] else None
+        
         return state
 
     def loop(self, task=None):
@@ -303,6 +309,7 @@ def loop(self, task=None):
             "action_plan": [],
             "action_log": [],
             "task_log": [],
+            "process_flag": False
         }
         logger.info(f"\n🚀 Starting autonomous agent loop ...")
         logger.info("Press Ctrl+C at any time to stop the loop.")

src/cli.py

@@ -99,6 +99,17 @@ def _initialize_commands(self) -> None:
                 aliases=['loop', 'start']
             )
         )
+
+           # Agent query command
+        self._register_command(
+            Command(
+                name="agent-query",
+                description="Allows for testing the response of the agent.",
+                tips=["Press Ctrl+C to stop the execution"],
+                handler=self.agent_query,
+                aliases=['query', 'invoke']
+            )
+        )
 
         # List agents command
         self._register_command(
@@ -429,6 +440,26 @@ def agent_loop(self, input_list: List[str]) -> None:
             logger.info("\n🛑 Agent loop stopped by user.")
         except Exception as e:
             logger.error(f"Error in agent loop: {e}")
+    
+    def agent_query(self, input_list: List[str]) -> None:
+        """Handle agent loop command"""
+        if self.agent is None:
+            logger.info("No agent is currently loaded. Use 'load-agent' to load an agent.")
+            return
+        
+        if (isinstance(self.agent, LegacyZerePyAgent)):
+            logger.info("This command is not supported for legacy agents.")
+            return
+
+        try:
+            state = self.agent.process_task()
+            logger.debug(f"FINAL STATE: {state}")
+            logger.info(f"Final response: {state['final_response']}")
+
+        except KeyboardInterrupt:
+            logger.info("\n🛑 Agent loop stopped by user.")
+        except Exception as e:
+            logger.error(f"Error when querying agent: {e}")
 
     def list_agents(self, input_list: List[str]) -> None:
         """Handle list agents command"""

src/connections/solana_connection.py

@@ -198,7 +198,7 @@ def register_actions(self) -> None:
                 parameters=[
                     ActionParameter("ticker", True, str, "Token ticker symbol")
                 ],
-                description="Get token data by ticker symbol",
+                description="Get token data by ticker symbol/name",
             ),
             "get-token-by-address": Action(
                 name="get-token-by-address",

src/langgraph/prompts.py

@@ -4,42 +4,64 @@
                           "PREVIOUS TASKS:\n{task_log}\n\n"
                           "SUMMARY:\n")
 
-DETERMINATION_PROMPT = """Based on the given context and available actions, generate a complex task that you desire to perform. Only respond with the task, and do not include any other text in your response. Your task can involve multiple chained actions. You do not need to provide any reasoning for the task. If you are given context, you may choose whether or not to use it. If you do not have context, you must still choose a task to perform.\n\n"
-                        "CONTEXT SUMMARY:\n{context_summary}"
-                        "\n\nAVAILABLE ACTIONS FOR EACH CONNECTION:\n\n" 
-                        "{connection_action_list}"
-                        "Example Outputs:\n 
-                            1. Create a funny tweet and post it on Twitter
-                            2. Search for tweets about a specific topic and reply to them"""
-
+DETERMINATION_PROMPT = """Based on the provided user query and the actions available to you, clearly state the task you need to perform. Only respond with the task, and do not include any other text in your response. Your task can involve multiple chained actions, and you can use actions to acquire information (Perplexity can be used to search for information, or if the user is asking about information pertaining to crypto, you may be able to use the associated crypto connection to retrieve the information). You do not need to provide any reasoning for the task. Your task should be clear and specific.\n\n"
+                        IF THE USER'S REQUEST IS A QUESTION AND NOT A TASK OR REQUEST THEN THE TASK IS: 'Answer the user's question: {user_query}'
+                        \n\nUSER QUERY:\n{user_query}
+                        \n\nAVAILABLE ACTIONS FOR EACH CONNECTION:\n\n
+                        {connection_action_list}
+                        """
 
 DIVISION_PROMPT = """Based on the given task and available actions, generate an action plan for the agent. Only respond with the list of steps needed (with the corresponding actions mentioned), and put each step on a new line. Only include actions that involve making requests—do not include actions like editing dialog boxes, clicking buttons, or other UI interactions.
                     
-                    TASK:
-                    {current_task}
+                    RULES:
+                    - Do not combine multiple actions into one step
+                    - Do not escape to a new line for a single step, until the step is complete
+                    - Each step should represent a single action
+                    - Be explicit about which parameters are required for each action
 
                     AVAILABLE ACTIONS FOR EACH CONNECTION:
                     {connection_action_list}
 
-                    Example :
-                    TASK: Create a funny tweet and post it on Twitter
+                    LLM Configuration: {preferred_llm_config} 
+                    Choose the appropriate LLM connection based on the configuration provided above if the task involves generating text.
+
+                    EXAMPLES:
+                    Example Task #1: Create a funny tweet and post it on Twitter
 
                     Output: 
-                    1. Generate text using openai `generate-text` with the prompt "Create a funny tweet" and the specified system prompt
-                    2. Post the generated text using `post-tweet` with the output from step 1 as the 'message' parameter
+                    1. Generate text using openai `generate-text` with parameters {{"prompt": "Create a funny tweet", "system_prompt": "You are a witty comedian"}}
+                    2. Post the generated text using `post-tweet` with parameters {{"message": "<output from step 1>"}}
+                    
+                    Example Task #2: swap 0.2 sol for zerebro
 
-                    Rules:
-                    - Do not combine multiple actions into one step
-                    - Do not escape to a new line for a single step, until the step is complete
-                    - Each step should represent a single action
-                    - Be explicit about which parameters are required for each action"""
+                    Output: 
+                    1. Find the mint address of zerebro using the `get-token-by-ticker` action with parameters {{"ticker": "zerebro"}}
+                    2. Swap 0.2 sol for zerebro using the `trade` action with parameters {{"input_token": "SOL", "output_token": "<mint address from step 1>", "amount": "0.2"}}
+                    
+                    Example Task #3: Find the current price of Solana
+
+                    Output:
+                    1. Get the mint address of Solana using the `get-token-by-ticker` action with parameters {{"ticker": "SOL"}}
+                    2. Get the price of Solana using the `get-price` action with parameters {{"mint_address": "<mint address from step 1>"}}
+
+                    Notice how you should break down the task into smaller steps and you can use previous actions and their outputs to complete the task. Make sure to include all the necessary parameters for each action.
+                    TASK:
+                    {current_task}
+                    """
 
 EXECUTION_PROMPT =  ("Before executing the following action, consider the previous action log:\n\n"
                     "ACTION LOG:\n{action_log}\n\n"
                     "Here is your preferred configurations for LLM related actions:\n\n"
                     "LLM Configuration:\n{preferred_llm_config}\n\n"
-                    "Make sure to use the exact configuration provided above for the `generate-text` action. Copy the entire configuration, including the complete system prompt.When used to create a text for a tweet, always specify it under 280 characters in the prompt\n\n"
+                    "For the 'generate-text' action, extract only the system_prompt and model from the configuration above, ignoring the provider. When generating a tweet, ensure the output remains under 280 characters."
+                    """EXECUTION FORMAT:
+                        - Always structure tool calls as: tool_name({{"param1": "value1", "param2": "value2"}})
+                        - Every parameter must be enclosed in quotes and provided as a key-value pair
+                        - Each tool requires specific parameters as defined in its function signature
+                        - Always include all required parameters for the tool being called
+                        - Parameter names in the dictionary must exactly match the function parameter names"""
                     "Refer to the 'final_response' field in the tool action log to quickly see the final response from the agent\n\n"
+                    "Important: Only execute the specified action—do not perform any additional actions beyond what is provided. For instance, if the action does not mention Twitter, do not invoke a Twitter-related tool. Follow the instructions precisely, step by step."
                     "Now, execute this action based on the prior results: {action}")
 
 EVALUATION_PROMPT = ("Based on the action log, provide a summary of what the agent did based on the main task given. Only include the most important actions and the results of those actions. Do not include any actions that are irrelevant to the task or that did not produce a meaningful result.\n\n"