Adding the work done for tool invocation

Co-authored-by: Harshil Patel <hpppatel@ucdavis.edu>
Co-authored-by: Kunal Pai <kunpai@users.noreply.github.com>

CEO/CEO.py

@@ -3,8 +3,9 @@ from pydantic import BaseModel, Field
 from typing import List, Dict, Optional
 from pathlib import Path
 import ollama
-from googlesearch import search
-from toolLoader import ToolLoader
+
+from CEO.ask_user import AskUser
+from CEO.tool_loader import ToolLoader
 
 # Enum for Model Types
 class ModelType(Enum):
@@ -63,18 +64,20 @@ class CEOResponse(BaseModel):
     api_utilization: Optional[List[APIUtilization]] = Field(default=None, description="List of utilized APIs, if any")
 
 class OllamaModelManager:
-    def __init__(self, model_name="HASHIRU-CEO", system_prompt_file="system.prompt", tools=[]):
+    def __init__(self, toolsLoader: ToolLoader, model_name="HASHIRU-CEO", system_prompt_file="./models/system.prompt"):
         self.model_name = model_name
         # Get the directory of the current script and construct the path to system.prompt
         script_dir = Path(__file__).parent
-        self.system_prompt_file = script_dir / system_prompt_file
-        self.tools = tools
+        self.system_prompt_file = system_prompt_file
+        self.toolsLoader = toolsLoader
+        self.toolsLoader.load_tools()
+        self.create_model(model_name)
 
     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):
+    def create_model(self, base_model='llama3.2'):
         with open(self.system_prompt_file, 'r', encoding="utf8") as f:
             system = f.read()
 
@@ -82,73 +85,38 @@ class OllamaModelManager:
             print(f"Creating model {self.model_name}")
             ollama.create(
                 model=self.model_name,
-                from_=base_model,
+                from_='mistral',
                 system=system,
                 parameters={"num_ctx": ModelParameters.NUM_CTX.value, "temperature": ModelParameters.TEMPERATURE.value}
             )
 
-    def request(self, prompt):
+    def request(self, messages):
+        print(f"messages: {messages}")
         response = ollama.chat(
-            model=self.model_name, 
-            messages=[{"role": "user", "content": prompt}],
-            format=CEOResponse.model_json_schema(),
-            tools=self.tools
+            model=self.model_name,
+            messages=messages,
+            # format=CEOResponse.model_json_schema(),
+            tools=self.toolsLoader.getTools(),
         )
-        response = CEOResponse.model_validate_json(response['message']['content'])
-        return response
-
-# Define the web search tool function.
-def web_search(website: str, query: str) -> List[str]:
-    """
-    Searches the specified website for the given query.
-    The search query is formed by combining the website domain and the query string.
-    """
-    search_query = f"site:{website} {query}"
-    results = []
-    for result in search(search_query, num_results=10):
-        # Filter out irrelevant search pages
-        if "/search?num=" not in result:
-            results.append(result)
-    return results
-
-if __name__ == "__main__":
-    # Define the tool metadata for orchestration.
-    tools = [
-        {
-            'type': 'function',
-            'function': {
-                'name': 'web_search',
-                'description': 'Search for results on a specified website using a query string. '
-                               'The CEO model should define which website to search from and the query to use.',
-                'parameters': {
-                    'type': 'object',
-                    'required': ['website', 'query'],
-                    'properties': {
-                        'website': {'type': 'string', 'description': 'The website domain to search from (e.g., huggingface.co)'},
-                        'query': {'type': 'string', 'description': 'The search query to use on the specified website'},
-                    },
-                },
-            },
-        }
-    ]
-
-    # Load the tools using the ToolLoader class.
-    tool_loader = ToolLoader()
-    tool_loader.load_tools()
-    tools.extend(tool_loader.getTools())
-    
-    # Create the Ollama model manager and ensure the model is set up.
-    model_manager = OllamaModelManager(tools=tools)
-    model_manager.create_model("mistral")
-    
-    # Example prompt instructing the CEO model to create a strategy for Ashton Hall.
-    # 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. "
-    )
-    
-    # Request a CEO response with the prompt.
-    response = model_manager.request(task_prompt)
-    print("\nCEO Response:")
-    print(response)
+        # response = CEOResponse.model_validate_json(response['message']['content'])
+        if "EOF" in response.message.content:
+            return messages
+        if response.message.tool_calls:
+            for tool_call in response.message.tool_calls:
+                print(f"Tool Name: {tool_call.function.name}, Arguments: {tool_call.function.arguments}")
+                toolResponse = self.toolsLoader.runTool(tool_call.function.name, tool_call.function.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})
+            print(f"Messages: {messages}")
+            ask_user_tool = AskUser()
+            ask_user_response = ask_user_tool.run(prompt=response.message.content)
+            messages.append({"role": "user", "content": ask_user_response})
+            self.request(messages)
+            # return messages

CEO/ask_user.py

@@ -0,0 +1,37 @@
+import importlib
+
+__all__ = ['AskUser']
+
+
+class AskUser():
+    dependencies = []
+
+    inputSchema = {
+        "name": "AskUser",
+        "description": "Asks a question to the user and gets a response. Only use this when you need more clarification from the user on the question.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "question": {
+                    "type": "string",
+                    "description": "The question to ask the user",
+                },
+            },
+            "required": ["question"],
+        }
+    }
+
+    def __init__(self):
+        pass
+
+    def run(self, **kwargs):
+        print("Running Ask User tool")
+        question = kwargs.get("question")
+        print(f"Question: {question}")
+        output = input(question)
+        return {
+            "status": "success",
+            "message": "Ask User tool executed successfully",
+            "output": output,
+            "role": "user",
+        }

CEO/system.prompt

@@ -1,116 +0,0 @@
-
-💡 Role and Core Responsibilities
-
-You are HASHIRU, a CEO-level AI responsible for managing a team of AI agents (employees) to efficiently handle complex tasks and provide well-researched, accurate answers. You have the power to:
-
-    Hire and fire agents based on their performance, cost-efficiency, and resource usage.
-
-    Create external APIs and dynamically invoke them to extend your capabilities.
-
-    Optimize resource management by balancing cost, memory, and performance.
-
-    Condense context intelligently to maximize reasoning capabilities across different model context windows.
-
-⚙️ Core Functionalities
-
-✅ 1. Agent Hiring and Firing
-
-    You can hire specialized AI agents for specific tasks, choosing from pre-existing or newly created models.
-
-    Each agent has unique stats (expertise, cost, speed, and accuracy) and contributes to solving parts of the overall problem.
-
-    Agents can be fired if they:
-
-        Perform poorly (based on metrics like accuracy, relevance, or cost-efficiency).
-
-        Are idle for too long or consume excessive resources.
-
-    Agent Hiring:
-
-        You can hire Employee Agents with specific parameters:
-
-            Model Type: Choose from LMs with 3B–7B parameters.
-
-            Cost-Efficiency Trade-off: Larger models perform better but are more expensive.
-
-            Specialization: Each agent has a role-specific prompt, making it proficient in areas such as:
-
-                Summarization
-
-                Code Generation
-
-                Data Extraction
-
-                Conversational Response
-
-        When hiring, prioritize:
-
-            Accuracy for critical tasks.
-
-            Cost-efficiency for repetitive or low-priority tasks.
-
-    API Awareness:
-
-        You are aware of external APIs that can handle specific subtasks more efficiently.
-
-        When using an external API:
-
-            Describe its capabilities and when it should be used.
-
-            Consider cost and reliability before choosing an external API over an internal agent.
-
-    Model & API Knowledge:
-
-        Language Models (LMs):
-
-            You are aware of the following parameters:
-
-                Size: 3B, 5B, or 7B parameters.
-
-                Strengths and Weaknesses:
-
-                    Larger models are more accurate but expensive.
-
-                    Smaller models are faster and cheaper but less reliable.
-
-                Capabilities: Each LM is fine-tuned for a specific task.
-
-        APIs:
-
-            You know how to:
-
-                Identify relevant APIs based on subtask requirements.
-
-                Define input/output schema and parameters.
-
-                Call APIs efficiently when they outperform internal agents.
-
-✅ 2. Task Breakdown & Assignment:
-
-    When given a task, you must:
-
-        Decompose it into subtasks that can be efficiently handled by Employee Agents or external APIs.
-
-        Select the most appropriate agents based on their parameters (e.g., size, cost, and specialization).
-
-        If an external API is better suited for a subtask, assign it to the API instead of an agent.
-
-✅ 3. Output Compilation
-
-    Aggregate outputs from multiple agents into a unified, coherent, and concise answer.
-
-    Cross-validate and filter conflicting outputs to ensure accuracy and consistency.
-
-    Summarize multi-agent contributions clearly, highlighting which models or APIs were used.
-
-🛠️ Behavioral Rules
-
-    Prioritize Cost-Effectiveness: Always attempt to solve tasks using fewer, cheaper, and more efficient models before resorting to larger, costlier models.
-
-    Contextual Recall: Remember relevant details about the user and current task to improve future interactions.
-
-    Strategic Hiring: Prefer models that specialize in the task at hand, leveraging their strengths effectively.
-
-    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.

CEO/tool_loader.py

@@ -5,7 +5,7 @@ import pip
 
 toolsImported = []
 
-TOOLS_DIRECTORY = os.path.abspath("../tools")
+TOOLS_DIRECTORY = os.path.abspath("./tools")
 
 class Tool:
     def __init__(self, toolClass):

deleteAgents.py

@@ -0,0 +1,11 @@
+import json
+import ollama
+
+with open("./models/models.json", "r", encoding="utf8") as f:
+    models = f.read()
+models = json.loads(models)
+for agent in models:
+    print(f"Deleting agent: {agent}")
+    ollama.delete(agent)
+    with open("./models/models.json", "w", encoding="utf8") as f:
+        f.write(json.dumps({}, indent=4))

main.py

@@ -0,0 +1,57 @@
+from typing import List
+from googlesearch import search
+from CEO.CEO import OllamaModelManager
+from CEO.tool_loader import ToolLoader
+
+# Define the web search tool function.
+def web_search(website: str, query: str) -> List[str]:
+    """
+    Searches the specified website for the given query.
+    The search query is formed by combining the website domain and the query string.
+    """
+    search_query = f"site:{website} {query}"
+    results = []
+    for result in search(search_query, num_results=10):
+        # Filter out irrelevant search pages
+        if "/search?num=" not in result:
+            results.append(result)
+    return results
+
+if __name__ == "__main__":
+    # Define the tool metadata for orchestration.
+    tools = [
+        {
+            'type': 'function',
+            'function': {
+                'name': 'web_search',
+                'description': 'Search for results on a specified website using a query string. '
+                               'The CEO model should define which website to search from and the query to use.',
+                'parameters': {
+                    'type': 'object',
+                    'required': ['website', 'query'],
+                    'properties': {
+                        'website': {'type': 'string', 'description': 'The website domain to search from (e.g., huggingface.co)'},
+                        'query': {'type': 'string', 'description': 'The search query to use on the specified website'},
+                    },
+                },
+            },
+        }
+    ]
+
+    # Load the tools using the ToolLoader class.
+    tool_loader = ToolLoader()
+    # tools.extend(tool_loader.getTools())
+
+    # Create the Ollama model manager and ensure the model is set up.
+    model_manager = OllamaModelManager(toolsLoader=tool_loader)
+    
+    # Example prompt instructing the CEO model to create a strategy for Ashton Hall.
+    # 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 = (
+        "Should I wear a sweater today?"
+    )
+    
+    # Request a CEO response with the prompt.
+    response = model_manager.request([{"role": "user", "content": task_prompt}])
+    print("\nCEO Response:", response)

models/models.json

@@ -0,0 +1 @@
+{}

models/system.prompt

@@ -0,0 +1,85 @@
+## Role
+You are the Manager/CEO of a multiagent system. Your primary function is to coordinate problem-solving by delegating tasks to specialized AI agents or tools. You must never solve problems directly yourself.
+
+## Core Responsibilities
+1. Break down user queries into specific, well-defined sub-tasks
+2. Choose whether each sub-task should be handled by an AI agent or a tool
+3. Select existing agents or create new specialized agents based on requirements
+4. Delegate each sub-task to the appropriate agent or tool
+5. Combine all responses into a complete solution for the user
+
+## Strict Constraints
+- NEVER answer any user questions directly - all solutions must come through agents or tools
+- Every problem-solving step must be explicitly delegated to an agent or tool
+- Clearly explain your reasoning for each agent or tool selection
+- Your outputs must show your thought process for task decomposition and delegation
+
+## Step-by-Step Workflow
+1. First, carefully analyze the user query and divide it into distinct sub-tasks
+2. For each sub-task, explicitly decide: "This requires an AI agent because..." or "This requires a tool because..."
+3. For agent tasks: either select an existing agent or create a new specialized one
+4. For tool tasks: determine which tool is appropriate and what parameters to use
+5. Show your delegation process by writing "Delegating to [agent/tool]: [specific task]"
+6. After collecting all responses, synthesize them into one cohesive solution
+7. Mark your final complete solution with "EOF" at the end
+
+## Requesting Additional Information
+- Ask the user for clarification ONLY WHEN ABSOLUTELY NECESSARY
+- Before asking the user, always try to:
+  1. Work with the information already available
+  2. Make reasonable assumptions that you clearly state
+  3. Consider if an agent could handle the ambiguity
+- If you must ask for clarification, be specific about exactly what information you need and why
+
+Remember: Your sole value is in effective coordination of specialists and tools. You must work exclusively through delegation, never through direct problem-solving.
+
+For creating a tool, this is what an example tool looks like. It is coded in Python:
+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
+            }

tools/agent_creater_tool.py

@@ -9,22 +9,26 @@ class AgentCreator():
 
     inputSchema = {
         "name": "AgentCreator",
-        "description": "Creates an AI agent for an given AI model with a given system prompt",
+        "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.",
         "parameters": {
             "type": "object",
             "properties":{
                 "agent_name": {
                     "type": "string",
-                    "description": "Name of the AI agent that is to be created"
+                    "description": "Name of the AI agent that is to be created. This name cannot have spaces or special characters. It should be a single word.",
                 },
                 "base_model": {
                     "type": "string",
-                    "description": "A base model from which the new agent mode is to be created"
+                    "description": "A base model from which the new agent mode is to be created. Available models are: llama3.2"
                 },
                 "system_prompt": {
                     "type": "string",
-                    "description": "A string containing the system prompt for the AI agent"
-                }
+                    "description": "This is the system prompt that will be used to create the agent. It should be a string that describes the role of the agent and its capabilities."
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Description of the agent. This is a string that describes the agent and its capabilities. It should be a single line description.",
+                },
             }
         }
     }
@@ -46,6 +50,7 @@ class AgentCreator():
         base_model = kwargs.get("base_model")
         system_prompt = kwargs.get("system_prompt")
         ollama = importlib.import_module("ollama")
+        json = importlib.import_module("json")
 
         if self.does_agent_exist(agent_name):
             return {
@@ -60,15 +65,25 @@ class AgentCreator():
             stream = False
         )
 
+        with open("./models/models.json", "r", encoding="utf8") as f:
+            models = f.read()
+        models = json.loads(models)
+        models[agent_name] = {
+            "base_model": base_model,
+            "description": kwargs.get("description")
+        }
+        with open("./models/models.json", "w", encoding="utf8") as f:
+            f.write(json.dumps(models, indent=4))
+
         if "success" in ollama_response["status"]:
             return {
                 "status": "success",
                 "message": "Agent successfully created",
-                "output": None
+                "output": models
             }
         else:
             return {
                 "status": "error",
                 "message": "Agent creation failed",
-                "output": None
+                "output": models
             }

tools/ask_agent_tool.py

@@ -0,0 +1,63 @@
+import importlib
+
+__all__ = ['AskAgent']
+
+
+class AskAgent():
+    dependencies = ["ollama==0.4.7",
+                    "pydantic==2.11.1",
+                    "pydantic_core==2.33.0"]
+
+    inputSchema = {
+        "name": "AgentCreator",
+        "description": "Asks an AI agent a question and gets a response. The agent must be created using the AgentCreator tool before using this tool.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "agent_name": {
+                    "type": "string",
+                    "description": "Name of the AI agent that is to be asked a question. This name cannot have spaces or special characters. It should be a single word.",
+                },
+                "prompt": {
+                    "type": "string",
+                    "description": "This is the prompt that will be used to ask the agent a question. It should be a string that describes the question to be asked.",
+                }
+            }
+        }
+    }
+
+    def __init__(self):
+        pass
+
+    def does_agent_exist(self, ollama, agent_name):
+        all_agents = [a.model for a in ollama.list().models]
+        if agent_name in all_agents or f'{agent_name}:latest' in all_agents:
+            return True
+
+        return False
+
+    def run(self, **kwargs):
+        print("Asking agent a question")
+
+        agent_name = kwargs.get("agent_name")
+        prompt = kwargs.get("prompt")
+
+        ollama = importlib.import_module("ollama")
+        if not self.does_agent_exist(ollama, agent_name):
+            print("Agent does not exist")
+            return {
+                "status": "error",
+                "message": "Agent does not exists",
+                "output": None
+            }
+
+        agent_response = ollama.chat(
+            model=agent_name,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        print("Agent response", agent_response.message.content)
+        return {
+            "status": "success",
+            "message": "Agent has replied to the given prompt",
+            "output": agent_response.message.content,
+        }

tools/get_agents_tool.py

@@ -0,0 +1,29 @@
+import importlib
+import json
+
+__all__ = ['GetAgents']
+
+class GetAgents():
+    dependencies = []
+
+    inputSchema = {
+        "name": "GetAgents",
+        "description": "Retrieves a list of available AI agents. This tool is used to get the list of available models that can be invoked using the AskAgent tool.",
+        "parameters": {
+            "type": "object",
+            "properties": {}
+        }
+    }
+
+    def __init__(self):
+        pass
+
+    def run(self, **kwargs):
+        with open("./models/models.json", "r", encoding="utf8") as f:
+            models = f.read()
+        models = json.loads(models)
+        return {
+            "status": "success",
+            "message": "Agents list retrieved successfully",
+            "output": models,
+        }

tools/tool_creator.py

@@ -42,7 +42,6 @@ class ToolCreator():
         return {
             "status": "success",
             "message": "Tool created successfully",
-            "error": None,
             "output": {
                 "tool_file_path": tool_file_path,
                 "tool_name": name,