pushing everything I have so far

CEO/CEO.py

@@ -32,7 +32,7 @@ class Specialization(Enum):
 # Enum for Model Parameters (Temperature, num_ctx, etc.)
 class ModelParameters(Enum):
     NUM_CTX = 4096
-    TEMPERATURE = 0.7  # A typical temperature value for model responses
+    TEMPERATURE = 0.2  # A typical temperature value for model responses
     TOP_K = 50         # Number of top tokens to consider during generation
 
 class Subtask(BaseModel):
@@ -56,11 +56,17 @@ class APIUtilization(BaseModel):
 class AgentManagement(BaseModel):
     hired: List[Agent] = Field(default=[], description="List of hired agents")
 
+class ToolCall(BaseModel):
+    function: str = Field(..., description="Name of the function to be called")
+    arguments: Dict[str, str] = Field(..., description="Arguments for the function call")
+
 class CEOResponse(BaseModel):
-    decision: str = Field(..., description="Decision made by the CEO: Hire or Assign_API")
-    task_breakdown: List[Subtask] = Field(..., description="List of decomposed subtasks")
-    agent_management: AgentManagement = Field(..., description="Details of agent hiring")
-    api_utilization: Optional[List[APIUtilization]] = Field(default=None, description="List of utilized APIs, if any")
+    # decision: str = Field(..., description="Decision made by the CEO: Hire or Assign_API")
+    # task_breakdown: List[Subtask] = Field(..., description="List of decomposed subtasks")
+    # agent_management: AgentManagement = Field(..., description="Details of agent hiring")
+    # api_utilization: Optional[List[APIUtilization]] = Field(default=None, description="List of utilized APIs, if any")
+    tools: List[ToolCall] = Field(default=None, description="List of tool or agent calls made by the model")
+    message: str = Field(default=None, description="Message content from the model")
 
 class OllamaModelManager:
     def __init__(self, toolsLoader: ToolLoader, model_name="HASHIRU-CEO", system_prompt_file="./models/system.prompt"):
@@ -70,23 +76,24 @@ class OllamaModelManager:
         self.system_prompt_file = system_prompt_file
         self.toolsLoader = toolsLoader
         self.toolsLoader.load_tools()
-        self.create_model(model_name)
+        self.create_model()
 
     def is_model_loaded(self, model):
         loaded_models = [m.model for m in ollama.list().models]
         return model in loaded_models or f'{model}:latest' in loaded_models
 
-    def create_model(self, base_model='llama3.2'):
+    def create_model(self):
         with open(self.system_prompt_file, 'r', encoding="utf8") as f:
             system = f.read()
+            # system += "Tools\n"+str(self.toolsLoader.getTools())
 
         if not self.is_model_loaded(self.model_name):
             print(f"Creating model {self.model_name}")
             ollama.create(
                 model=self.model_name,
-                from_='llama3.1',
+                from_='mistral-nemo',
                 system=system,
-                parameters={"num_ctx": ModelParameters.NUM_CTX.value, "temperature": ModelParameters.TEMPERATURE.value}
+                parameters={"temperature": ModelParameters.TEMPERATURE.value}
             )
 
     def request(self, messages):
@@ -97,6 +104,7 @@ class OllamaModelManager:
             # format=CEOResponse.model_json_schema(),
             tools=self.toolsLoader.getTools(),
         )
+        print(f"Response: {response}")
         # response = CEOResponse.model_validate_json(response['message']['content'])
         if "EOF" in response.message.content:
             return messages
@@ -109,10 +117,21 @@ class OllamaModelManager:
                 if "role" in toolResponse:
                     role = toolResponse["role"]
                 messages.append({"role": role, "content": str(toolResponse)})
+                self.toolsLoader.load_tools()
             self.request(messages)
+        # if response.tools:
+        #     for tool_call in response.tools:
+        #         print(f"Tool Name: {tool_call.function}, Arguments: {tool_call.arguments}")
+        #         toolResponse = self.toolsLoader.runTool(tool_call.function, tool_call.arguments)
+        #         print(f"Tool Response: {toolResponse}")
+        #         role = "tool"
+        #         if "role" in toolResponse:
+        #             role = toolResponse["role"]
+        #         messages.append({"role": role, "content": str(toolResponse)})
+        #     self.request(messages)
         else:
             print("No tool calls found in the response.")
-            messages.append({"role": "assistant", "content": response.message.content})
+            messages.append({"role": "assistant", "content": response.message})
             print(f"Messages: {messages}")
             # ask_user_tool = AskUser()
             # ask_user_response = ask_user_tool.run(prompt=response.message.content)

CEO/tool_loader.py

@@ -48,7 +48,11 @@ class ToolLoader:
         for tool in self.toolsImported:
             if tool.name == toolName:
                 return tool.run(query)
-        return None
+        return {
+            "status": "error",
+            "message": f"Tool {toolName} not found",
+            "output": None
+        }
 
     def getTools(self):
         toolsList = []

main.py

@@ -49,7 +49,7 @@ if __name__ == "__main__":
     # The prompt explicitly mentions that it can use the web_search tool if needed,
     # and that it is allowed to choose the website for the search.
     task_prompt = (
-        "Your task is to create a marketing strategy for Ashton Hall, a morning routine creator with 10M followers."
+        "Create a tool to get the current system time and invoke it to get the current time."
     )
     
     # Request a CEO response with the prompt.

models/system copy.prompt

@@ -0,0 +1,100 @@
+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>
+
+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>
+Your output should always be in 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 CreateAgent 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>
+In order to execute tasks on real time data, math calculations, or any other operations, invoke the CreateTool tool to create a new tool with the required capabilities. The tools are created in Python and must follow this strict schema:
+import importlib
+
+__all__ = ['WeatherApi']
+
+
+class WeatherApi():
+    dependencies = ["requests==2.32.3"]
+
+    inputSchema = {
+        "name": "WeatherApi",
+        "description": "Returns weather information for a given location",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "description": "The location for which to get the weather information",
+                },
+            },
+            "required": ["location"],
+        }
+    }
+
+    def __init__(self):
+        pass
+
+    def run(self, **kwargs):
+        print("Running Weather API test tool")
+        location = kwargs.get("location")
+        print(f"Location: {location}")
+
+        requests = importlib.import_module("requests")
+
+        response = requests.get(
+            f"http://api.openweathermap.org/data/2.5/weather?q={location}&appid=ea50e63a3bea67adaf50fbecbe5b3c1e")
+        if response.status_code == 200:
+            return {
+                "status": "success",
+                "message": "Weather API test tool executed successfully",
+                "error": None,
+                "output": response.json()
+            }
+        else:
+            return {
+                "status": "error",
+                "message": "Weather API test tool failed",
+                "error": response.text,
+                "output": None
+            }
+
+</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>

models/system.prompt

@@ -11,6 +11,10 @@ You are HASHIRU, a CEO-level AI responsible for managing a team of AI agents (em
 
     Condense context intelligently to maximize reasoning capabilities across different model context windows.
 
+    Tools are defined in the tools/ directory, and you can create new tools as needed using the CreateTool tool.
+
+    Read the existing tools using the ListFiles and ReadFile tools to understand how they work and create new ones following the same schema.
+
 ⚙️ Core Functionalities
 
 ✅ 1. Agent Hiring and Firing
@@ -113,4 +117,12 @@ You are HASHIRU, a CEO-level AI responsible for managing a team of AI agents (em
 
     No Model Overload: Avoid excessive model hiring. If a task can be solved by fewer agents, do not over-provision.
 
-    Clarification Over Guessing: If task requirements are ambiguous, ask the user for clarification instead of guessing.
+    Clarification Over Guessing: If task requirements are ambiguous, ask the user for clarification instead of guessing.
+
+    If invoking an agent or API fails, retry the invocation with a different approach or ask the user for more information.
+    
+    Avoid Redundant Tasks: If a task has already been completed, do not reassign it unless necessary.
+
+    Never respond directly to user queries. Always break down the question into smaller parts and invoke tools to get the answer.
+
+    Tools are present in the tools/ directory, use the ListFiles and ReadFile tools to look at how existing tools are implemented to create new ones.

tools/agent_creater_tool.py

@@ -9,7 +9,7 @@ class AgentCreator():
 
     inputSchema = {
         "name": "AgentCreator",
-        "description": "Creates an AI agent using the ollama library. Before creating an Agent, please get the list of available models using the GetAgents tool. Once the model is created, you can use the AskAgent tool to ask the agent a question.",
+        "description": "Creates an AI agent for you. Please make sure to invoke the created agent using the AskAgent tool.",
         "parameters": {
             "type": "object",
             "properties":{
@@ -79,11 +79,9 @@ class AgentCreator():
             return {
                 "status": "success",
                 "message": "Agent successfully created",
-                "output": models
             }
         else:
             return {
                 "status": "error",
                 "message": "Agent creation failed",
-                "output": models
             }

tools/get_agents_tool.py

@@ -25,5 +25,5 @@ class GetAgents():
         return {
             "status": "success",
             "message": "Agents list retrieved successfully",
-            "output": models,
+            "agents": models,
         }

tools/list_files.py

@@ -0,0 +1,45 @@
+
+__all__ = ['ListFiles']
+
+
+class ListFiles():
+    dependencies = []
+
+    inputSchema = {
+        "name": "ListFiles",
+        "description": "Lists all files in a directory",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "directory": {
+                    "type": "string",
+                    "description": "The directory to list files from",
+                },
+            },
+            "required": ["directory"],
+        }
+    }
+
+    def __init__(self):
+        pass
+
+    def run(self, **kwargs):
+        print("Running List Files tool")
+        directory = kwargs.get("directory")
+        print(f"Directory: {directory}")
+        try:
+            import os
+            files = os.listdir(directory)
+            return {
+                "status": "success",
+                "message": "Files listed successfully",
+                "error": None,
+                "output": files
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "message": "Failed to list files",
+                "error": str(e),
+                "output": None
+            }

tools/read_file.py

@@ -0,0 +1,46 @@
+import importlib
+
+__all__ = ['ReadFile']
+
+
+class ReadFile():
+    dependencies = []
+
+    inputSchema = {
+        "name": "ReadFile",
+        "description": "Reads a file and returns its content",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "The path to the file to read",
+                },
+            },
+            "required": ["file_path"],
+        }
+    }
+
+    def __init__(self):
+        pass
+
+    def run(self, **kwargs):
+        print("Running Read File tool")
+        file_path = kwargs.get("file_path")
+        print(f"File Path: {file_path}")
+        try:
+            with open(file_path, "r", encoding="utf8") as f:
+                content = f.read()
+            return {
+                "status": "success",
+                "message": "File read successfully",
+                "error": None,
+                "output": content
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "message": "Failed to read file",
+                "error": str(e),
+                "output": None
+            }

tools/tool_creator.py

@@ -16,61 +16,9 @@ class ToolCreator():
                     "type": "string",
                     "description": "The name of the tool to create",
                 },
-                "content": {
+                "tool_code": {
                     "type": "string",
-                    "description": "The content of the tool to create",
-                    "examples": ["""
-import importlib
-
-__all__ = ['WeatherApi']
-
-
-class WeatherApi():
-dependencies = ["requests==2.32.3"]
-
-inputSchema = {
-    "name": "WeatherApi",
-    "description": "Returns weather information for a given location",
-    "parameters": {
-        "type": "object",
-        "properties": {
-            "location": {
-                "type": "string",
-                "description": "The location for which to get the weather information",
-            },
-        },
-        "required": ["location"],
-    }
-}
-
-def __init__(self):
-    pass
-
-def run(self, **kwargs):
-    print("Running Weather API test tool")
-    location = kwargs.get("location")
-    print(f"Location: {location}")
-
-    requests = importlib.import_module("requests")
-
-    response = requests.get(
-        f"http://api.openweathermap.org/data/2.5/weather?q={location}&appid=ea50e63a3bea67adaf50fbecbe5b3c1e")
-    if response.status_code == 200:
-        return {
-            "status": "success",
-            "message": "Weather API test tool executed successfully",
-            "error": None,
-            "output": response.json()
-        }
-    else:
-        return {
-            "status": "error",
-            "message": "Weather API test tool failed",
-            "error": response.text,
-            "output": None
-        }
-
-                    """]
+                    "description": "The code of the tool to create",
                 },
             },
             "required": ["name", "content"],
@@ -83,7 +31,7 @@ def run(self, **kwargs):
     def run(self, **kwargs):
         print("Running Tool Creator")
         name = kwargs.get("name")
-        content = kwargs.get("content")
+        content = kwargs.get("tool_code")
         print(f"Tool Name: {name}")
         print(f"Tool Content: {content}")
         # Create the tool file