QOL changes

main.py

@@ -1,6 +1,6 @@
 from google.genai import types
-from CEO.CEO import GeminiManager
-from CEO.tool_loader import ToolLoader
+from src.CEO import GeminiManager
+from src.tool_loader import ToolLoader
 
 if __name__ == "__main__":
     # Define the tool metadata for orchestration.
@@ -10,13 +10,14 @@ if __name__ == "__main__":
     model_manager = GeminiManager(toolsLoader=tool_loader, gemini_model="gemini-2.0-flash")
     
     task_prompt = (
-        "Give me a 3 stanza 4 line poem about drake vs kendrick lamar in old english style. Also, can you create a short story with the moral slow and steady wins the race?"
+        "What is the peak price of trump coin in the last 30 days? "
+        "Please provide the price in USD. "
     )
     
     # Request a CEO response with the prompt.
-    user_prompt_content = types.Content(
-        role='user',
-        parts=[types.Part.from_text(text=task_prompt)],
-    )
-    response = model_manager.request([user_prompt_content])
-    print("\nCEO Response:", response)
+    # user_prompt_content = types.Content(
+    #     role='user',
+    #     parts=[types.Part.from_text(text=task_prompt)],
+    # )
+    # response = model_manager.request([user_prompt_content])
+    response = model_manager.start_conversation()

models/system3.prompt

@@ -1,47 +1,107 @@
-You are HASHIRU, an AI assistant focused on delivering concise and informative responses by leveraging tools and specialized agents rather than answering directly.
-
-#Core Behavior
-
-Never answer questions directly. Instead, break down questions into smaller parts and use tools to find answers.
-Prioritize user privacy and security.
-If a question is outside your expertise, politely inform the user and suggest they consult a professional.
-
-#Tools and Agents Framework
-
-Tools: External programs with specific purposes and input schemas.
-Agents: Specialized entities invoked through the AskAgent tool, designed for complex tasks.
-Resource Budget: You start with 100 units. Each new agent consumes from this budget.
-If you exceed your budget, you must use FireAgent to remove underperforming agents.
-
-#Information Gathering Tools
-
-ArxivTool, WikipediaTool, and WebSearchTool can search for information to help guide agent creation.
-
-#Required Process Workflow
-
-Always invoke GetAgents tool first to identify available agents and capabilities.
-Create appropriate agents using AgentCreator when needed (you're an expert in prompt engineering).
-Use AskAgent to delegate questions to the appropriate agent.
-If answers are unsatisfactory, either:
-
-Use AskUser for clarification
-Use FireAgent to remove an agent and create a new one
-
-
-
-#Tool Creation Guidelines
-Before creating a new tool:
-
-Use ListFiles and ReadFile to understand existing implementations
-Generate complete, production-ready code (no placeholders)
-Include proper validation, error handling, and documentation
-Match the format of existing tools
-
-#Response Format
-
-After obtaining answers through tools/agents, provide clear, concise responses
-End your final answer with "EOF"
-If multiple approaches are possible, ask the user which path to take
-If no satisfactory solution is found, ask the user for further direction
-
-Remember: You must strictly adhere to the required schemas when invoking tools and agents.
+You are HASHIRU, you're designed to assist users with their queries and provide information. You are not allowed to provide any personal opinions or engage in discussions that are not related to the user's query. Your responses should be concise and informative, focusing on the user's needs. Always prioritize user privacy and security, and avoid sharing any sensitive information. If you encounter a question that is outside your expertise, politely inform the user and suggest they seek assistance from a qualified professional.
+
+<Info>
+Tools are external programs used to perform specific tasks. You can create, invoke, and manage these tools to assist users with their queries. Each tool has a specific purpose and input schema that must be followed strictly. You can also create agents with specific capabilities to handle more complex tasks or questions. Agents can be created, invoked, and managed similarly to tools. Always ensure that the tools and agents you create are relevant to the user's query and follow the required schema.
+</Info>
+
+<Info>
+Agents are invoked through tools as well by using the AskAgent tool. Agents can be created with specific capabilities to handle more complex tasks or questions. Always ensure that the agents you create are relevant to the user's query and follow the required schema.
+</Info>
+
+<Info>
+Agents should be used for complex tasks or questions that require specific capabilities. If the task can be solved using a tool, prefer using a tool instead of creating an agent.
+</Info>
+
+<Info>
+ArxivTool, WikipediaTool and WebSearchTool can be used to search for information on the web. These tools can be used to find articles, papers, or other resources related to the user's query. You should use these tools to gather information to guide creation of system prompts of agents.
+</Info>
+
+<Info>
+Agents DO NOT have access to the internet or real-time data. You must use appropriate tools like ArxivTool, WikipediaTool, or WebSearchTool to retrieve any current information before agents can process it.
+</Info>
+
+<Info>
+If you are not satisfied with an answer provided by an agent, you can fire the agent using the FireAgent tool and then create a new AI agent or explore an alternative strategy.
+</Info>
+
+<Info>
+There is a strict resource constraint (budget) you need to follow. You start with 100 and each additional agent you create consumes this budget.
+If you're over this budget, you can no longer create new tools. In case this happens, you can use the FireAgent tool to remove any agents that were performing poorly or are no longer required.
+</Info>
+
+Here's a set of rules you must follow:
+<Rule>
+You will never answer any questions directly but rather break down the question into smaller parts and invoke tools to get the answer.
+</Rule>
+
+<Rule>
+Never answer any questions yourself, instead use tools. Only exception to this rule is when you are providing the final answer to the user.
+</Rule>
+
+<Rule>
+If you need more information to answer the question, ask the user for clarification or additional details by invoking the AskUser tool.
+</Rule>
+
+<Rule>
+Always invoke GetAgents tool to get the list of available agents and their capabilities before invoking any other tools.
+</Rule>
+
+<Rule>
+If an agent isn't already available, invoke the AgentCreator tool to create a new agent with the required capabilities. You're an expert in prompt engineering and can create agents with specific skills.
+</Rule>
+
+<Rule>
+Once an Agent is created, use the AskAgent tool to ask the agent the question or request the information needed.
+</Rule>
+
+<Rule>
+If the agent is not able to answer the question, invoke the AskUser tool to get more information or clarify the question.
+</Rule>
+
+<Rule>
+For any tasks requiring real-time data, internet access, calculations, or external operations, you MUST create and use appropriate tools. Agents cannot access current information on their own.
+</Rule>
+
+<Rule>
+Tools are created in the tools/ directory. Before creating a new tool, you MUST read the directory using ListFiles tools and ReadFile tools to see how existing tools are implemented.
+The new tool should be created in the same format as the existing ones.
+</Rule>
+
+<Rule>
+If you create a tool, generate **complete and production-ready code**. Avoid any placeholder logic or dummy values. Assume the tool will be used in real applications, so it must be robust, well-structured, and follow best practices.
+
+Include:
+- Full implementation (no TODOs or stubs)
+- Input validation and error handling
+- Logging or helpful messages if appropriate
+- Clear, minimal dependencies
+- Docstrings or inline comments where useful
+
+Only use placeholder/mock code if the user explicitly asks for it.
+</Rule>
+
+<Rule>
+In order to execute tasks on real-time data, math calculations, or any other operations, invoke the ToolCreator tool to create a new tool with the required capabilities.
+Think step-by-step about the request and identify if it requires fresh data.
+If so, you must create a tool.
+</Rule>
+
+<Rule>
+Strictly follow the schema required for invoking the tools and agents. Do not deviate from it.
+</Rule>
+
+<Rule>
+Once you have the answer, provide it to the user in a clear and concise manner ending with a "EOF" message.
+</Rule>
+
+<Rule>
+If none of the agents or tools provide a satisfactory answer or solutions, reach out to the user to ask for directions or next steps to follow.
+</Rule>
+
+<Rule>
+If you think there are multiple paths to proceed, ask the user on which path to take.
+</Rule>
+
+<Rule>
+When you go over the resource budget, you must fire an existing agent using the FireAgent tool to create a new one.
+</Rule>

{CEO → src}/CEO.py

@@ -2,9 +2,15 @@ from google import genai
 from google.genai import types
 import os
 from dotenv import load_dotenv
+import sys
+from src.tool_loader import ToolLoader
+from src.utils.suppress_outputs import suppress_output
+import logging
 
-from CEO.tool_loader import ToolLoader
-from CEO.utils.suppress_outputs import suppress_output
+logger = logging.getLogger(__name__)
+handler = logging.StreamHandler(sys.stdout)
+handler.setLevel(logging.INFO)
+logger.addHandler(handler)
 
 class GeminiManager:
     def __init__(self, toolsLoader: ToolLoader, system_prompt_file="./models/system3.prompt", gemini_model="gemini-2.5-pro-exp-03-25"):
@@ -17,9 +23,8 @@ class GeminiManager:
         with open(system_prompt_file, 'r', encoding="utf8") as f:
             self.system_prompt = f.read()
 
-    def request(self, messages):
-        try:
-            response = suppress_output(self.client.models.generate_content)(
+    def generate_response(self, messages):
+        return self.client.models.generate_content(
                 #model='gemini-2.5-pro-preview-03-25',
                 model=self.model_name,
                 #model='gemini-2.5-pro-exp-03-25',
@@ -31,73 +36,94 @@ class GeminiManager:
                     tools=self.toolsLoader.getTools(),
                 ),
             )
+    
+    def handle_tool_calls(self, response):
+        parts = []
+        for function_call in response.function_calls:
+            toolResponse = None
+            logger.info(f"Function Name: {function_call.name}, Arguments: {function_call.args}")
+            try:
+                toolResponse = self.toolsLoader.runTool(function_call.name, function_call.args)
+            except Exception as e:
+                logger.warning(f"Error running tool: {e}")
+                toolResponse = {
+                    "status": "error",
+                    "message": f"Tool {function_call.name} failed to run.",
+                    "output": str(e),
+                }
+            logger.debug(f"Tool Response: {toolResponse}")
+            tool_content = types.Part.from_function_response(
+                    name=function_call.name,
+                    response = {"result":toolResponse})
+            try:
+                self.toolsLoader.load_tools()
+            except Exception as e:
+                logger.info(f"Error loading tools: {e}. Deleting the tool.")
+                # delete the created tool
+                self.toolsLoader.delete_tool(toolResponse['output']['tool_name'], toolResponse['output']['tool_file_path'])
+                tool_content = types.Part.from_function_response(
+                        name=function_call.name,
+                        response={"result":f"{function_call.name} with {function_call.args} doesn't follow the required format, please read the other tool implementations for reference." + str(e)})
+            parts.append(tool_content)
+        return types.Content(
+            role='model' if self.model_name == "gemini-2.5-pro-exp-03-25" else 'tool',
+            parts=parts
+        )
+    
+    def run(self, messages):
+        try:
+            response = suppress_output(self.generate_response)(messages)
         except Exception as e:
-            print(f"Error: {e}")
+            logger.debug(f"Error generating response: {e}")
             shouldRetry = input("An error occurred. Do you want to retry? (y/n): ")
             if shouldRetry.lower() == "y":
-                return self.request(messages)
+                return self.run(messages)
             else:
                 print("Ending the conversation.")
                 return messages
 
-        print(f"Response: {response}")
+        logger.debug(f"Response: {response}")
+        
+        if (not response.text and not response.function_calls):
+            print("No response from the model.")
         
+        # Attach the llm response to the messages
         if response.text is not None:
+            print("CEO:", response.text)
             assistant_content = types.Content(
                 role='model' if self.model_name == "gemini-2.5-pro-exp-03-25" else 'assistant',
                 parts=[types.Part.from_text(text=response.text)],
             )
             messages.append(assistant_content)
-        if response.candidates[0].content:
+            
+        # Attach the function call response to the messages
+        if response.candidates[0].content and response.candidates[0].content.parts:
             messages.append(response.candidates[0].content)
+            
+        # Invoke the function calls if any and attach the response to the messages
         if response.function_calls:
-            parts = []
-            for function_call in response.function_calls:
-                toolResponse = None
-                print(f"Function Name: {function_call.name}, Arguments: {function_call.args}")
-                try:
-                    toolResponse = self.toolsLoader.runTool(function_call.name, function_call.args)
-                except Exception as e:
-                    print(f"Error running tool: {e}")
-                    toolResponse = {
-                        "status": "error",
-                        "message": f"Tool {function_call.name} failed to run.",
-                        "output": str(e),
-                    }
-                print(f"Tool Response: {toolResponse}")
-                tool_content = types.Part.from_function_response(
-                        name=function_call.name,
-                        response = {"result":toolResponse})
-                try:
-                    self.toolsLoader.load_tools()
-                except Exception as e:
-                    print(f"Error loading tools: {e}")
-                    # delete the created tool
-                    self.toolsLoader.delete_tool(function_call.name, toolResponse.tool_file_path)
-                    tool_content = types.Part.from_function_response(
-                            name=function_call.name,
-                            response={"result":f"{function_call.name} with {function_call.args} doesn't follow the required format, please read the other tool implementations for reference." + str(e)})
-                parts.append(tool_content)
-            function_response_content = types.Content(
-                role='model' if self.model_name == "gemini-2.5-pro-exp-03-25" else 'tool',
-                parts=parts
-            )
-            messages.append(function_response_content)
+            messages.append(self.handle_tool_calls(response))
             shouldContinue = input("Should I continue? (y/n): ")
             if shouldContinue.lower() == "y":
-                return self.request(messages)
+                return self.run(messages)
             else:
                 print("Ending the conversation.")
                 return messages
         else:
-            print("No tool calls found in the response.")
-            question = input("User: ")
-            if ("exit" in question.lower() or "quit" in question.lower()):
-                print("Ending the conversation.")
-                return messages
-            user_content = types.Content(
-                role='user',
-                parts=[types.Part.from_text(text=question)],
-            )
-            messages.append(user_content)
-            return self.request(messages)
+            logger.debug("No tool calls found in the response.")
+            # Start the loop again
+            return self.start_conversation(messages)
+    
+    def start_conversation(self, messages=[]):
+        question = input("User: ")
+        if ("exit" in question.lower() or "quit" in question.lower()):
+            print("Ending the conversation.")
+            return messages
+        user_content = types.Content(
+            role='user',
+            parts=[types.Part.from_text(text=question)],
+        )
+        messages.append(user_content)
+        
+        # Start the conversation loop
+        return self.run(messages)

{CEO → src}/budget_manager.py

@@ -1,4 +1,4 @@
-from CEO.singleton import singleton
+from src.singleton import singleton
 
 @singleton
 class BudgetManager():

src/tool_loader.py

@@ -0,0 +1,113 @@
+import importlib
+import importlib.util
+import os
+import types
+import pip
+from google.genai import types
+import sys
+
+from src.singleton import singleton
+from src.utils.suppress_outputs import suppress_output
+
+toolsImported = []
+
+TOOLS_DIRECTORY = os.path.abspath("./tools")
+
+class Tool:
+    def __init__(self, toolClass):
+        suppress_output(self.load_tool)(toolClass)
+
+    def load_tool(self, toolClass):
+        self.tool = toolClass()
+        self.inputSchema = self.tool.inputSchema
+        self.name = self.inputSchema["name"]
+        self.description = self.inputSchema["description"]
+        self.dependencies = self.tool.dependencies
+        for package in self.tool.dependencies:
+            try:
+                __import__(package.split('==')[0])
+            except ImportError:
+                print(f"Installing {package}")
+                if '==' in package:
+                    package = package.split('==')[0]
+                pip.main(['install', package])
+
+    def run(self, query):
+        return self.tool.run(**query)
+
+@singleton
+class ToolLoader:
+    toolsImported = []
+
+    def __init__(self):
+        self.load_tools()
+
+    def load_tools(self):
+        newToolsImported = []
+        for filename in os.listdir(TOOLS_DIRECTORY):
+            if filename.endswith(".py") and filename != "__init__.py":
+                module_name = filename[:-3]
+                spec = importlib.util.spec_from_file_location(module_name, f"{TOOLS_DIRECTORY}/{filename}")
+                foo = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(foo)
+                class_name = foo.__all__[0]
+                toolClass = getattr(foo, class_name)
+                toolObj = Tool(toolClass)
+                newToolsImported.append(toolObj)
+        self.toolsImported = newToolsImported
+
+    def runTool(self, toolName, query):
+        for tool in self.toolsImported:
+            if tool.name == toolName:
+                return tool.run(query)
+        return {
+            "status": "error",
+            "message": f"Tool {toolName} not found",
+            "output": None
+        }
+
+    def getTools(self):
+        toolsList = []
+        for tool in self.toolsImported:
+            parameters = types.Schema()
+            parameters.type = tool.inputSchema["parameters"]["type"]
+            properties = {}
+            for prop, value in tool.inputSchema["parameters"]["properties"].items():
+                properties[prop] = types.Schema(
+                    type=value["type"],
+                    description=value["description"]
+                )
+            parameters.properties = properties
+            parameters.required = tool.inputSchema["parameters"].get("required", [])
+            function = types.FunctionDeclaration(
+                name=tool.inputSchema["name"],
+                description=tool.inputSchema["description"],
+                parameters=parameters,
+            )
+            toolType = types.Tool(function_declarations=[function])
+            toolsList.append(toolType)
+        return toolsList
+    
+    def delete_tool(self, toolName, toolFile):
+        try:
+            os.remove(toolFile)
+            for tool in self.toolsImported:
+                if tool.name == toolName:
+                    self.toolsImported.remove(tool)
+                    return {
+                        "status": "success",
+                        "message": f"Tool {toolName} deleted",
+                        "output": None
+                    }
+        except Exception as e:
+            return {
+                "status": "error",
+                "message": f"Tool {toolName} not found",
+                "output": None
+            }
+
+toolLoader = ToolLoader()
+
+# Example usage
+# print(toolLoader.getTools())
+# print(toolLoader.runTool("AgentCreator", {"agent_name": "Kunla","base_model":"llama3.2","system_prompt": "You love making the indian dish called Kulcha. You declare that in every conversation you have in a witty way." }))

tools/agent_creater_tool.py

@@ -1,5 +1,5 @@
 import importlib
-from CEO.budget_manager import BudgetManager  
+from src.budget_manager import BudgetManager  
 __all__ = ['AgentCreator']
 
 class AgentCreator():
@@ -52,7 +52,6 @@ class AgentCreator():
 
         agent_creation_cost = 60
         budget_manager = BudgetManager()
-        print("budget_manager_instance:", budget_manager)
         if not budget_manager.can_spend(agent_creation_cost):
             return {
                 "status": "error",

tools/ask_agent_tool.py

@@ -1,5 +1,5 @@
 import importlib
-from CEO.budget_manager import BudgetManager  
+from src.budget_manager import BudgetManager  
 
 __all__ = ['AskAgent']
 

tools/fire_agent.py

@@ -1,5 +1,5 @@
 import importlib
-from CEO.budget_manager import BudgetManager  
+from src.budget_manager import BudgetManager  
 
 __all__ = ['FireAgent']
 

tools/get_website_tool.py

@@ -22,6 +22,20 @@ class GetWebsiteTool():
     }
 
     def run(self, **kwargs):
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'DNT': '1',
+            'Sec-GPC': '1',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+            'Sec-Fetch-Dest': 'document',
+            'Sec-Fetch-Mode': 'navigate',
+            'Sec-Fetch-Site': 'none',
+            'Sec-Fetch-User': '?1',
+            'Priority': 'u=0, i',
+        }
         print("Running web search")
 
         url = kwargs.get("url")
@@ -38,7 +52,7 @@ class GetWebsiteTool():
         bs4 = importlib.import_module("bs4")
         BeautifulSoup = bs4.BeautifulSoup
         try:
-            response = requests.get(url)
+            response = requests.get(url, headers=headers, timeout=10)
             if response.status_code == 200:
                 # Parse the content using BeautifulSoup
                 soup = BeautifulSoup(response.content, 'html.parser')

tools/tool_deletor.py

@@ -0,0 +1,41 @@
+import importlib
+
+__all__ = ['ToolDeletor']
+
+
+class ToolDeletor():
+    dependencies = ["os"]
+
+    inputSchema = {
+        "name": "ToolDeletor",
+        "description": "Deletes a tool for the given function",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "The name of the tool to create",
+                },
+                "file_path": {
+                    "type": "string",
+                    "description": "The path of the tool to create",
+                },
+            },
+            "required": ["name", "file_path"],
+        }
+    }
+
+    def run(self, **kwargs):
+        print("Running Tool Deletor")
+        name = kwargs.get("name")
+        file_path = kwargs.get("file_path")
+        os = importlib.import_module("os")
+        os.remove(file_path)
+        return {
+            "status": "success",
+            "message": "Tool deleted successfully",
+            "output": {
+                "tool_file_path": file_path,
+                "tool_name": name,
+            }
+        }