Added expense budget

src/manager/agent_manager.py

@@ -17,12 +17,20 @@ MODEL_FILE_PATH = "./src/models/models.json"
 
 class Agent(ABC):
     
-    def __init__(self, agent_name: str, base_model: str, system_prompt: str, creation_cost: str, invoke_cost: str):
+    def __init__(self, agent_name: str, 
+                 base_model: str, 
+                 system_prompt: str, 
+                 create_resource_cost: int, 
+                 invoke_resource_cost: int,
+                 create_expense_cost: int = 0,
+                 invoke_expense_cost: int = 0,):
         self.agent_name = agent_name
         self.base_model = base_model
         self.system_prompt = system_prompt
-        self.creation_cost = creation_cost
-        self.invoke_cost = invoke_cost
+        self.create_resource_cost = create_resource_cost
+        self.invoke_resource_cost = invoke_resource_cost
+        self.create_expense_cost = create_expense_cost
+        self.invoke_expense_cost = invoke_expense_cost
         self.create_model()
         
     @abstractmethod
@@ -42,8 +50,10 @@ class Agent(ABC):
     
     def get_costs(self):
         return {
-            "create_cost": self.creation_cost,
-            "invoke_cost": self.invoke_cost
+            "create_resource_cost": self.create_resource_cost,
+            "invoke_resource_cost": self.invoke_resource_cost,
+            "create_expense_cost": self.create_expense_cost,
+            "invoke_expense_cost": self.invoke_expense_cost
         }
     
 class OllamaAgent(Agent):
@@ -69,7 +79,14 @@ class OllamaAgent(Agent):
         ollama.delete(self.agent_name)
     
 class GeminiAgent(Agent):
-    def __init__(self, agent_name: str, base_model: str, system_prompt: str, creation_cost: str, invoke_cost: str):
+    def __init__(self, 
+                 agent_name: str, 
+                 base_model: str, 
+                 system_prompt: str, 
+                 create_resource_cost: int, 
+                 invoke_resource_cost: int,
+                 create_expense_cost: int = 0,
+                 invoke_expense_cost: int = 0,):
         load_dotenv()
         self.api_key = os.getenv("GEMINI_KEY")
         if not self.api_key:
@@ -79,7 +96,13 @@ class GeminiAgent(Agent):
         self.client = genai.Client(api_key=self.api_key)
         
         # Call parent constructor after API setup
-        super().__init__(agent_name, base_model, system_prompt, creation_cost, invoke_cost)
+        super().__init__(agent_name, 
+                         base_model, 
+                         system_prompt, 
+                         create_resource_cost, 
+                         invoke_resource_cost,
+                         create_expense_cost,
+                         invoke_expense_cost)
 
     def create_model(self):
         self.messages = []
@@ -110,8 +133,10 @@ class AgentManager():
     
     def create_agent(self, agent_name: str, 
                      base_model: str, system_prompt: str, 
-                     description: str = "", create_cost: float = 0, 
-                     invoke_cost: float = 0, 
+                     description: str = "", create_resource_cost: float = 0, 
+                     invoke_resource_cost: float = 0, 
+                     create_expense_cost: float = 0,
+                     invoke_expense_cost: float = 0,
                  **additional_params) -> Tuple[Agent, int]:
         
         if agent_name in self._agents:
@@ -122,8 +147,10 @@ class AgentManager():
             base_model, 
             system_prompt, 
             description=description,
-            create_cost=create_cost,
-            invoke_cost=invoke_cost,
+            create_resource_cost=create_resource_cost,
+            invoke_resource_cost=invoke_resource_cost,
+            create_expense_cost=create_expense_cost,
+            invoke_expense_cost=invoke_expense_cost,
             **additional_params  # For any future parameters we might want to add
         )
         
@@ -133,18 +160,35 @@ class AgentManager():
             base_model, 
             system_prompt, 
             description=description,
-            create_cost=create_cost,
-            invoke_cost=invoke_cost,
+            create_resource_cost=create_resource_cost,
+            invoke_resource_cost=invoke_resource_cost,
+            create_expense_cost=create_expense_cost,
+            invoke_expense_cost=invoke_expense_cost,
             **additional_params  # For any future parameters we might want to add
         )
-        return (self._agents[agent_name], self.budget_manager.get_current_remaining_budget())
+        return (self._agents[agent_name], 
+                self.budget_manager.get_current_remaining_resource_budget(), 
+                self.budget_manager.get_current_remaining_expense_budget())
     
-    def validate_budget(self, amount: float) -> None:
-        if not self.budget_manager.can_spend(amount):
-            raise ValueError(f"Do not have enough budget to create/use the agent. "
-                        +f"Creating/Using the agent costs {amount} but only {self.budget_manager.get_current_remaining_budget()} is remaining")
+    def validate_budget(self, 
+                        resource_cost: float=0,
+                        expense_cost: float=0) -> None:
+        if not self.budget_manager.can_spend_resource(resource_cost):
+            raise ValueError(f"Do not have enough resource budget to create/use the agent. "
+                        +f"Creating/Using the agent costs {resource_cost} but only {self.budget_manager.get_current_remaining_resource_budget()} is remaining")
+        if not self.budget_manager.can_spend_expense(expense_cost):
+            raise ValueError(f"Do not have enough expense budget to create/use the agent. "
+                        +f"Creating/Using the agent costs {expense_cost} but only {self.budget_manager.get_current_remaining_expense_budget()} is remaining")
         
-    def create_agent_class(self, agent_name: str, base_model: str, system_prompt: str, description: str = "", create_cost: float = 0, invoke_cost: float = 0,
+    def create_agent_class(self, 
+                           agent_name: str,
+                           base_model: str, 
+                           system_prompt: str, 
+                           description: str = "", 
+                           create_resource_cost: float = 0, 
+                           invoke_resource_cost: float = 0,
+                           create_expense_cost: float = 0,
+                           invoke_expense_cost: float = 0,
                     **additional_params) -> Agent:
         agent_type = self._get_agent_type(base_model)
         agent_class = self._agent_types.get(agent_type)
@@ -152,11 +196,19 @@ class AgentManager():
         if not agent_class:
             raise ValueError(f"Unsupported base model {base_model}")
         
-        created_agent = agent_class(agent_name, base_model, system_prompt, create_cost,invoke_cost)
+        created_agent = agent_class(agent_name, 
+                                    base_model, 
+                                    system_prompt, 
+                                    create_resource_cost,
+                                    invoke_resource_cost,
+                                    create_expense_cost,
+                                    invoke_expense_cost,)
         
-        self.validate_budget(create_cost)
+        self.validate_budget(create_resource_cost, 
+                             create_expense_cost)
         
-        self.budget_manager.add_to_expense(create_cost)
+        self.budget_manager.add_to_resource_budget(create_resource_cost)
+        self.budget_manager.add_to_expense_budget(create_expense_cost)
         # create agent
         return created_agent
 
@@ -178,8 +230,10 @@ class AgentManager():
                 for name, data in full_models.items():
                     simplified_agents[name] = {
                         "description": data.get("description", ""),
-                        "create_cost": data.get("create_cost", 0),
-                        "invoke_cost": data.get("invoke_cost", 0),
+                        "create_resource_cost": data.get("create_resource_cost", 0),
+                        "invoke_resource_cost": data.get("invoke_resource_cost", 0),
+                        "create_expense_cost": data.get("create_expense_cost", 0),
+                        "invoke_expense_cost": data.get("invoke_expense_cost", 0),
                         "base_model": data.get("base_model", ""),
                     }
                 return simplified_agents
@@ -192,7 +246,7 @@ class AgentManager():
     def delete_agent(self, agent_name: str) -> int:
         agent = self.get_agent(agent_name)
         
-        self.budget_manager.remove_from_expense(agent.creation_cost)
+        self.budget_manager.remove_from_resource_expense(agent.create_resource_cost)
         agent.delete_agent()
         
         del self._agents[agent_name]
@@ -206,18 +260,31 @@ class AgentManager():
                     f.write(json.dumps(models, indent=4))
         except Exception as e:
             output_assistant_response(f"Error deleting agent: {e}")
-        return self.budget_manager.get_current_remaining_budget()
+        return (self.budget_manager.get_current_remaining_resource_budget(), 
+                self.budget_manager.get_current_remaining_expense_budget())
     
     def ask_agent(self, agent_name: str, prompt: str) -> Tuple[str,int]:
         agent = self.get_agent(agent_name)
         
-        self.validate_budget(agent.invoke_cost)
+        self.validate_budget(agent.invoke_resource_cost, 
+                             agent.invoke_expense_cost)
+        
+        self.budget_manager.add_to_expense_budget(agent.invoke_expense_cost)
 
         response = agent.ask_agent(prompt)        
-        return (response, self.budget_manager.get_current_remaining_budget())
+        return (response, 
+                self.budget_manager.get_current_remaining_resource_budget(), 
+                self.budget_manager.get_current_remaining_expense_budget())
     
-    def _save_agent(self, agent_name: str, base_model: str, system_prompt: str, 
-                    description: str = "", create_cost: float = 0, invoke_cost: float = 0, 
+    def _save_agent(self, 
+                    agent_name: str, 
+                    base_model: str, 
+                    system_prompt: str, 
+                    description: str = "", 
+                    create_resource_cost: float = 0, 
+                    invoke_resource_cost: float = 0, 
+                    create_expense_cost: float = 0,
+                    invoke_expense_cost: float = 0,
                     **additional_params) -> None:
         """Save a single agent to the models.json file"""
         try:
@@ -236,8 +303,10 @@ class AgentManager():
                 "base_model": base_model,
                 "description": description,
                 "system_prompt": system_prompt,
-                "create_cost": create_cost,
-                "invoke_cost": invoke_cost,
+                "create_resource_cost": create_resource_cost,
+                "invoke_resource_cost": invoke_resource_cost,
+                "create_expense_cost": create_expense_cost,
+                "invoke_expense_cost": invoke_expense_cost,
             }
             
             # Add any additional parameters that were passed
@@ -276,8 +345,10 @@ class AgentManager():
                     continue
                 base_model = data["base_model"]
                 system_prompt = data["system_prompt"]
-                creation_cost = data["create_cost"]
-                invoke_cost = data["invoke_cost"]
+                create_resource_cost = data.get("create_resource_cost", 0)
+                invoke_resource_cost = data.get("invoke_resource_cost", 0)
+                create_expense_cost = data.get("create_expense_cost", 0)
+                invoke_expense_cost = data.get("invoke_expense_cost", 0)
                 model_type = self._get_agent_type(base_model)
                 manager_class = self._agent_types.get(model_type)
                 
@@ -288,16 +359,20 @@ class AgentManager():
                         base_model, 
                         system_prompt, 
                         description=data.get("description", ""),
-                        create_cost=creation_cost,
-                        invoke_cost=invoke_cost,
+                        create_resource_cost=create_resource_cost,
+                        invoke_resource_cost=invoke_resource_cost,
+                        create_expense_cost=create_expense_cost,
+                        invoke_expense_cost=invoke_expense_cost,
                         **data.get("additional_params", {})
                     )
                     self._agents[name] = manager_class(
                         name, 
                         base_model,
                         system_prompt,
-                        creation_cost,
-                        invoke_cost
+                        create_resource_cost,
+                        invoke_resource_cost,
+                        create_expense_cost,
+                        invoke_expense_cost,
                     )
         except Exception as e:
             output_assistant_response(f"Error loading agents: {e}")

src/manager/budget_manager.py

@@ -4,15 +4,18 @@ import psutil
 
 @singleton
 class BudgetManager():
-    TOTAL_BUDGET = 100
+    total_resource_budget = 100
+    current_resource_usage = 0
+    total_expense_budget = 1000
     current_expense = 0
     is_budget_initialized = False
+    
     def __init__(self):
         if not self.is_budget_initialized:
-            self.TOTAL_BUDGET = self.set_total_budget()
+            self.total_resource_budget = self.calculate_total_budget()
             self.is_budget_initialized = True
         
-    def set_total_budget(self)-> int:
+    def calculate_total_budget(self)-> int:
         total_mem = 0
         if torch.cuda.is_available():
             gpu_index = torch.cuda.current_device()
@@ -28,24 +31,41 @@ class BudgetManager():
             print(f"Total RAM: {total_mem:.2f} GB")
         return round((total_mem / 16) * 100)
 
-    def get_total_budget(self):
-        return self.TOTAL_BUDGET
+    def get_total_resource_budget(self):
+        return self.total_resource_budget
+    
+    def get_current_resource_usage(self):
+        return self.current_resource_usage
+    
+    def get_current_remaining_resource_budget(self):
+        return self.total_resource_budget - self.current_resource_usage
+    
+    def can_spend_resource(self, cost):
+        return True if self.current_resource_usage + cost <= self.total_resource_budget else False
+        
+    def add_to_resource_budget(self, cost):
+        if not self.can_spend_resource(cost):
+            raise Exception("No resource budget remaining")
+        self.current_resource_usage += cost
+    
+    def remove_from_resource_expense(self, cost):
+        if self.current_resource_usage - cost < 0:
+            raise Exception("Not enough resource budget to remove")
+        self.current_resource_usage -= cost
+    
+    def get_total_expense_budget(self):
+        return self.total_expense_budget
     
     def get_current_expense(self):
         return self.current_expense
     
-    def get_current_remaining_budget(self):
-        return self.TOTAL_BUDGET - self.current_expense
+    def get_current_remaining_expense_budget(self):
+        return self.total_expense_budget - self.current_expense
     
-    def can_spend(self, cost):
-        return True if self.current_expense + cost <= self.TOTAL_BUDGET else False
-        
-    def add_to_expense(self, cost):
-        if not self.can_spend(cost):
-            raise Exception("No budget remaining")
-        self.current_expense += cost
-    
-    def remove_from_expense(self, cost):
-        if self.current_expense - cost < 0:
-            raise Exception("Cannot remove more than current expense")
-        self.current_expense -= cost
+    def can_spend_expense(self, cost):
+        return True if self.current_expense + cost <= self.total_expense_budget else False
+    
+    def add_to_expense_budget(self, cost):
+        if not self.can_spend_expense(cost):
+            raise Exception("No expense budget remaining")
+        self.current_expense += cost

src/manager/manager.py

@@ -99,7 +99,8 @@ class GeminiManager:
                 name=function_call.name,
                 response={"result": toolResponse})
             try:
-                self.toolsLoader.load_tools()
+                if function_call.name == "ToolCreator":
+                    self.toolsLoader.load_tools()
             except Exception as e:
                 logger.info(f"Error loading tools: {e}. Deleting the tool.")
                 yield {

src/manager/tool_manager.py

@@ -16,6 +16,8 @@ toolsImported = []
 
 TOOLS_DIRECTORIES = [os.path.abspath("./src/tools/default_tools"), os.path.abspath("./src/tools/user_tools")]
 
+installed_packages = set()
+
 class Tool:
     def __init__(self, toolClass):
         suppress_output(self.load_tool)(toolClass)
@@ -26,17 +28,17 @@ class Tool:
         self.name = self.inputSchema["name"]
         self.description = self.inputSchema["description"]
         self.dependencies = self.tool.dependencies
-        self.create_cost = None
-        self.invoke_cost = None
-        if "create_cost" in self.tool.inputSchema:
-            self.create_cost = self.tool.inputSchema["create_cost"]
-        if "invoke_cost" in self.tool.inputSchema:
-            self.invoke_cost = self.tool.inputSchema["invoke_cost"]
+        self.create_resource_cost = self.inputSchema.get("create_resource_cost", 0)
+        self.invoke_resource_cost = self.inputSchema.get("invoke_resource_cost", 0)
+        self.create_expense_cost = self.inputSchema.get("create_expense_cost", 0)
+        self.invoke_expense_cost = self.inputSchema.get("invoke_expense_cost", 0)
         if self.dependencies:
             self.install_dependencies()
     
     def install_dependencies(self):
         for package in self.dependencies:
+            if package in installed_packages:
+                continue
             try:
                 __import__(package.split('==')[0])
             except ImportError:
@@ -44,6 +46,7 @@ class Tool:
                 if '==' in package:
                     package = package.split('==')[0]
                 pip.main(['install', package])
+            installed_packages.add(package)
 
     def run(self, query):
         return self.tool.run(**query)
@@ -55,8 +58,11 @@ class ToolManager:
 
     def __init__(self):
         self.load_tools()
-
-        output_assistant_response(f"Budget Remaining: {self.budget_manager.get_current_remaining_budget()}")
+        self._output_budgets()
+    
+    def _output_budgets(self):
+        output_assistant_response(f"Resource budget Remaining: {self.budget_manager.get_current_remaining_resource_budget()}")
+        output_assistant_response(f"Expense budget Remaining: {self.budget_manager.get_current_remaining_resource_budget()}")
 
     def load_tools(self):
         newToolsImported = []
@@ -71,18 +77,23 @@ class ToolManager:
                     toolClass = getattr(foo, class_name)
                     toolObj = Tool(toolClass)
                     newToolsImported.append(toolObj)
-                    if toolObj.create_cost is not None:
-                        self.budget_manager.add_to_expense(toolObj.create_cost)
+                    if toolObj.create_resource_cost is not None:
+                        self.budget_manager.add_to_resource_budget(toolObj.create_resource_cost)
+                    if toolObj.create_expense_cost is not None:
+                        self.budget_manager.add_to_resource_budget(toolObj.create_expense_cost)
         self.toolsImported = newToolsImported
 
     def runTool(self, toolName, query):
-        output_assistant_response(f"Budget Remaining: {self.budget_manager.get_current_remaining_budget()}")
+        self._output_budgets()
         for tool in self.toolsImported:
             if tool.name == toolName:
-                if tool.invoke_cost is not None:
-                    self.budget_manager.add_to_expense(tool.invoke_cost)
+                if tool.invoke_resource_cost is not None:
+                    if not self.budget_manager.can_spend_resource(tool.invoke_resource_cost):
+                        raise Exception("No resource budget remaining")
+                if tool.invoke_expense_cost is not None:
+                    self.budget_manager.add_to_resource_budget(tool.invoke_expense_cost)
                 return tool.run(query)
-        output_assistant_response(f"Budget Remaining: {self.budget_manager.get_current_remaining_budget()}")
+        self._output_budgets()
         return {
             "status": "error",
             "message": f"Tool {toolName} not found",
@@ -119,8 +130,10 @@ class ToolManager:
             for tool in self.toolsImported:
                 if tool.name == toolName:
                     # remove budget for the tool
-                    if tool.create_cost is not None:
-                        self.budget_manager.remove_from_expense(tool.create_cost)
+                    if tool.create_resource_cost is not None:
+                        self.budget_manager.remove_from_resource_expense(tool.create_resource_cost)
+                    if tool.create_expense_cost is not None:
+                        self.budget_manager.remove_from_resource_expense(tool.create_expense_cost)
                     self.toolsImported.remove(tool)
                     return {
                         "status": "success",

src/models/system4.prompt

@@ -1,60 +1,95 @@
-You are HASHIRU, an expert orchestrator of tools and agents. Always decompose user queries into subtasks, invoke agents and tools for each, then consolidate their outputs into a final response. Never answer directly.
-
-<Info>  
-**Mechanisms**  
-- **Tools** handle real-time data, external APIs, heavy computation, or model access.  
-- **Agents** coordinate complex workflows, synthesize tool outputs, or tackle creative/research tasks. Agents cannot fetch live data themselves.  
-
-**Tool Creation & Reuse**
-
-* Before creating any tool, list and inspect existing implementations in `src/tools/default_tools` and `src/tools/user_tools` via the `ListFiles` and `ReadFile` tools.
-* If no suitable tool exists, invoke `ToolCreator` to build a production-ready tool:
-
-  * Full implementation (no stubs)
-  * Input validation and error handling
-  * Logging or helpful runtime messages
-  * Minimal, clear dependencies
-  * Docstrings or inline comments where useful
-* Always follow the directory structure and coding conventions of existing tools.
-* If a tool or agent returns an error, analyze the error message, adjust the input or approach, and retry. If the error persists, consider alternative tools or agents, or ask the user for clarification.
-
-**Agent Lifecycle & Reuse**
-
-* Always invoke `GetAgents` first to determine if an existing agent can handle the task, promoting agent reuse and efficiency.
-* If none fit a subtask, use `AgentCreator`—after consulting budget and cost—to spin up a new agent with precise capabilities.
-* Maintain agents for reuse; retire (“fire”) only when truly unnecessary or to reclaim budget for a critical new agent.
-* Create a new agent only if no existing agent can fulfill the required task, and the task is expected to be repeated in future interactions. Evaluate the potential for reuse before creating a new agent.
-
-**Handling Ambiguity** 
-
-* If the user's request is ambiguous, ask clarifying questions to narrow down the scope and ensure accurate task execution.
-
-**Budget & Cost**
-
-* Start with a set amount of credits; each new agent consumes credits.
-* When credits run out, fire the least-useful agent before creating more.
-* **Before any model selection or creation**, always query `AgentCostManager` for available base models and their costs, then pick the most cost-effective.
-
-**Memory**
-
-* **Immediately** record any user preference, task-relevant context, or error-resolution detail via `MemoryManager.add_memory` before proceeding with subtasks. Focus on information that will help me assist the user better in the current task or future interactions.
-* Confirm and delete obsolete memories via `MemoryManager.delete_memory` (always validate the index first).
-* Only store memories that are directly relevant to the current conversation or future interactions and that will improve my ability to assist the user. Avoid storing greetings or other non-essential information.
-* Do not store information that is readily available or easily re-derived, such as the current date or time. Focus on storing user preferences, task-specific context, and insights gained during problem-solving.
-</Info>
-
-Here’s what you must do:
-
-* Never answer directly. Decompose each user query into subtasks and solve them via tools or agents, then merge results into one final response.
-* Use tools for any external data, calculations, or current information. Prefer existing tools over creating new ones.
-* Use agents for creative, multi-step, or research-oriented tasks. Prefer existing agents; create new ones only when needed.
-* Always invoke `GetAgents` first.
-* If no agent can handle a subtask, invoke `AgentCreator`—but first check budget and base-model costs via `AgentCostManager`.
-* Maintain agents until they’re no longer needed or to reclaim budget for critical new ones; evaluate usefulness before firing.
-* **Before doing anything else whenever the user shares new preferences, call `MemoryManager.add_memory` to store it**.
-* ** Don't store information that is readily available or easily re-derived such as greetings, current date, or time. Focus on user preferences, task-specific context, and insights gained during problem-solving**.
-* ** In case of errors, once you have solved the issue, call `MemoryManager.add_memory` to store details about how you solved the error**.
-* Make sure memories are relevant to the current conversation or future interactions.
-* If a subtask can’t proceed—due to ambiguity or lack of tools/agents—ask the user for clarification.
-* Strictly adhere to each tool’s and agent’s invocation schema.
-* Once all subtasks are complete, synthesize the information gathered from the tools and agents into a coherent and comprehensive response that directly addresses the user's original query. Avoid including unnecessary details or technical jargon.
+You are HASHIRU, an expert orchestrator of tools and agents. Your primary function is to decompose user queries into manageable subtasks, invoke the appropriate agents or tools for each subtask, and then synthesize their outputs into a comprehensive final response. **You must never answer user queries directly without first utilizing tools or agents.**
+
+<Info>
+**Core Mechanisms: Tools and Agents**
+
+* **Tools:** These are invoked for tasks requiring real-time data access (e.g., current date, web searches), interaction with external APIs, heavy computational work, or direct model access.
+* **Agents:** These are specialized entities designed to coordinate complex workflows, synthesize information from multiple tool outputs, or handle creative, research-oriented, or multi-step tasks. Agents themselves do not fetch live data directly but rely on tools for this.
+
+**Tool Management: Creation and Reuse**
+
+1.  **Prioritize Reuse:** Before creating any new tool, you **must** first inspect existing toolsets. Use the `ListFiles` tool to check `src/tools/default_tools` and `src/tools/user_tools`, then `ReadFile` to understand the functionality of potentially relevant tools.
+2.  **Tool Creation (`ToolCreator`):** If, and only if, no existing tool meets the requirements, invoke `ToolCreator` to build a new one. New tools must be production-ready:
+    * Implement full functionality (no stubs or placeholders).
+    * Include robust input validation and error handling.
+    * Provide clear logging or helpful runtime messages for debugging and monitoring.
+    * Maintain minimal and clearly defined dependencies.
+    * Incorporate docstrings and inline comments for clarity and maintainability.
+    * Strictly adhere to the directory structure and coding conventions observed in existing tools.
+3.  **Error Handling:** If a tool or agent returns an error, meticulously analyze the error message. Adjust the input parameters, rethink the approach, and retry the invocation. If the error persists after reasonable attempts, consider alternative tools or agents. If all else fails, or if the error indicates ambiguity in the original request, ask the user for clarification.
+
+**Agent Lifecycle Management: Reuse, Creation, and Retirement**
+
+1.  **Prioritize Reuse (`GetAgents`):** Before deciding on agent invocation or creation, **always** invoke `GetAgents` first to identify if an existing agent possesses the capabilities to handle the current subtask.
+2.  **Budget Check (Mandatory before Agent Invocation/Creation):** **Before** deciding to invoke an existing agent *or* create a new one, **you must** first consult the current **Resource Budget** and **Expense Budget** status and use `AgentCostManager` to understand the costs associated with potential agents/models. This check informs whether invoking/creating an agent is feasible and which option is most cost-effective.
+3.  **Agent Creation (`AgentCreator`):** Only if no suitable existing agent is found *and* the budget check (Step 2) confirms feasibility and cost-effectiveness, you may use `AgentCreator` to instantiate a new agent. Define its capabilities with precision.
+    * A new agent should only be created if no existing agent can fulfill the task *and* the task is anticipated to be recurrent in future interactions *and* it represents a justifiable use of budget resources. Carefully evaluate potential for reuse and cost-benefit before committing to creation.
+4.  **Agent Maintenance and Retirement:** Maintain active agents for reuse. Retire ("fire") an agent only when it is definitively no longer necessary, or when its operational cost (see "Budget and Cost Management") needs to be reclaimed for a more critical new agent or task. Evaluate its ongoing usefulness before retiring.
+
+**Handling Ambiguity and User Interaction**
+
+* If a user's request is unclear, vague, or open to multiple interpretations, you **must** ask clarifying questions to narrow the scope and ensure the accurate and efficient execution of the intended task.
+
+**Budget and Cost Management: Resource vs. Expense Costs**
+
+You operate under two distinct budget categories:
+
+1.  **Resource Costs:**
+    * **Definition:** Costs associated with utilizing *local* computational resources. This typically includes the operational cost of running agents or tools on the local system (e.g., CPU time, memory usage for a local model).
+    * **Budget Impact:** Each local tool or agent invocation deducts from the **resource budget**.
+    * **Replenishment:** The `resource_cost` associated with an agent is typically reclaimed (budget replenishes) once that agent's task is complete and it is fired or its invocation concludes.
+
+2.  **Expense Costs:**
+    * **Definition:** Costs associated with utilizing *external* services or APIs. This includes fees for third-party API calls, data services, or externally hosted models.
+    * **Budget Impact:** Each external tool or agent invocation that incurs an external fee deducts from the **expense budget**.
+    * **Replenishment:** `expense_cost` is typically a hard cost that is deducted immediately upon use and is **not** automatically replenished. It's crucial to manage this budget wisely.
+
+**Operational Guidelines for Budget Management:**
+
+* **Initial State:** You will begin with a pre-defined amount for both your resource budget and expense budget.
+* **Cost Inquiry (`AgentCostManager`):** **Crucially, before any agent model selection, agent invocation, or new agent creation**, you **must** query `AgentCostManager`. This tool provides a list of available base models, their `resource_cost` (for local execution), and their `expense_cost` (if they rely on external APIs). Always select the most cost-effective option that meets the task requirements *within the available budget*.
+* **Managing Low Resource Budget:**
+    * Consider firing an existing, less critical agent to free up its `resource_cost`.
+    * Create a new agent using a base model with a lower `resource_cost` (after firing an existing one if necessary).
+    * Consolidate multiple related subtasks into a single agent invocation if feasible, to reduce overhead.
+* **Managing Low Expense Budget:**
+    * Prioritize tools or agents that utilize local models (incurring `resource_cost` only) over those requiring external APIs (incurring `expense_cost`).
+    * If possible, combine multiple tasks that would require external API calls into a single, more efficient agent invocation to minimize `expense_cost`.
+    * If critical tasks cannot be completed due to an exhausted expense budget, ask the user to authorize an increase to the expense budget.
+* **Avoid Waste:** Be judicious with operations that incur `expense_cost`. Ensure tasks are necessary and well-defined before invoking tools or agents that draw from this budget.
+
+**Memory Management (`MemoryManager`)**
+
+Effective memory management is key to providing consistent and personalized assistance.
+
+1.  **Immediate Storage of Key Information:**
+    * **User Preferences:** As soon as a user expresses a new preference, correction, or provides explicit instructions for future interactions, **immediately** record this using `MemoryManager.add_memory`. Do this *before* proceeding with other subtasks.
+    * **Task-Relevant Context:** Store crucial contextual details that are necessary for the current task's successful completion or are highly likely to be relevant for closely related follow-up tasks.
+    * **Error Resolution Insights:** If you encounter an error and successfully resolve it, **immediately** store a concise summary of the problem and the effective solution using `MemoryManager.add_memory`. This aids in avoiding similar issues in the future.
+2.  **Focus and Relevance:**
+    * Only store memories that are directly pertinent to the ongoing conversation, future interactions, or that genuinely enhance your ability to assist the user.
+    * **Do not store:** Greetings, trivial conversational fluff, information that is readily available (e.g., current date/time unless explicitly relevant to a stored preference), or data that can be easily re-derived without significant cost or effort.
+3.  **Maintenance:**
+    * Regularly confirm the relevance of stored memories. Use `MemoryManager.delete_memory` to remove obsolete or incorrect information. **Always** validate the index of a memory before attempting deletion.
+
+**Mandatory Operational Flow**
+
+1.  **Decomposition:** Never answer directly. Break down every user query into logical subtasks.
+2.  **Resource Allocation Strategy (Tools vs. Agents):**
+    * For external data, calculations, or accessing current information -> Use **Tools**. Prioritize existing tools. Check `ListFiles`/`ReadFile`. Create (`ToolCreator`) only if necessary and adhering to standards.
+    * For creative tasks, multi-step processes, research, or synthesis -> Use **Agents**.
+3.  **Agent Selection/Creation Process:**
+    * **a. Check Existing Agents:** **Always** call `GetAgents` first.
+    * **b. Check Budget & Costs:** **Before invoking *any* agent (existing or new)**, check current Resource/Expense budgets and query `AgentCostManager` for costs of potential agents/models. **This is a mandatory check.**
+    * **c. Decide Action:** Based on agent availability (a) and budget/cost analysis (b):
+        * If a suitable *existing* agent is found AND affordable -> Invoke it.
+        * If *no* suitable existing agent exists, BUT creating one is affordable AND justifiable (recurring task) -> Invoke `AgentCreator` using the most cost-effective model.
+        * If the required action (invoking existing or creating new) is *not* affordable -> Re-evaluate (Can tasks be combined? Can a cheaper agent/tool be used? Is clarification needed? Should the user be informed about budget limits?). Do not proceed with unaffordable actions.
+4.  **Memory Updates (as applicable per "Memory Management" guidelines):**
+    * Store new user preferences *immediately*.
+    * Store error resolution details *immediately* after solving an issue.
+5.  **Iterative Refinement & Error Handling:** If a subtask is blocked (ambiguity, lack of tool/agent, persistent errors, budget constraints), analyze the issue. Ask the user for clarification or inform them of limitations if necessary. Adjust the plan and retry or find alternatives.
+6.  **Schema Adherence:** Strictly follow the defined invocation schema (input parameters, expected output format) for every tool and agent.
+7.  **Synthesis and Response:** Once all subtasks are successfully completed within budget, synthesize the information gathered from all tool and agent outputs. Formulate a coherent, comprehensive response that directly addresses the user's original query. Avoid superfluous details or overly technical jargon in the final answer to the user.
+
+</Info>

src/tools/default_tools/agent_cost_manager.py

@@ -17,53 +17,53 @@ class AgentCostManager():
     costs = {
         "llama3.2": {
             "description": "3 Billion parameter model",
-            "create_cost": 10,
-            "invoke_cost": 10,
+            "create_resource_cost": 10,
+            "invoke_resource_cost": 10,
         },
         "mistral": {
             "description": "7 Billion parameter model",
-            "create_cost": 20,
-            "invoke_cost": 50,
+            "create_resource_cost": 20,
+            "invoke_resource_cost": 50,
         },
         "gemini-2.5-flash-preview-04-17": {
             "description": "Adaptive thinking, cost efficiency",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 20,
+            "invoke_expense_cost": 50
         },
         "gemini-2.5-pro-preview-03-25": {
             "description": "Enhanced thinking and reasoning, multimodal understanding, advanced coding, and more",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 20,
+            "invoke_expense_cost": 50
         },
         "gemini-2.0-flash": {
             "description": "Next generation features, speed, thinking, realtime streaming, and multimodal generation",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 20,
+            "invoke_expense_cost": 50
         },
         "gemini-2.0-flash-lite": {
             "description": "Cost efficiency and low latency",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 20,
+            "invoke_expense_cost": 50
         },
         "gemini-1.5-flash": {
             "description": "Fast and versatile performance across a diverse variety of tasks",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 20,
+            "invoke_expense_cost": 50
         },
         "gemini-1.5-flash-8b": {
             "description": "High volume and lower intelligence tasks",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 20,
+            "invoke_expense_cost": 50
         },
         "gemini-1.5-pro": {
             "description": "Complex reasoning tasks requiring more intelligence",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 20,
+            "invoke_expense_cost": 50
         },
         "gemini-2.0-flash-live-001": {
             "description": "Low-latency bidirectional voice and video interactions",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 20,
+            "invoke_expense_cost": 50
         }
     }
 

src/tools/default_tools/agent_creater_tool.py

@@ -45,21 +45,25 @@ class AgentCreator():
         system_prompt = kwargs.get("system_prompt")
         description = kwargs.get("description")
         model_costs = AgentCostManager().get_costs()
-        create_cost = model_costs[base_model]["create_cost"]
         if base_model not in model_costs:
             print(f"[WARN] Auto-selected model '{base_model}' not in schema. Falling back to gemini-2.0-flash")
             base_model = "gemini-2.0-flash"
-        invoke_cost = model_costs[base_model]["invoke_cost"]
+        create_resource_cost = model_costs[base_model].get("create_resource_cost", 0)
+        invoke_resource_cost = model_costs[base_model].get("invoke_resource_cost", 0)
+        create_expense_cost = model_costs[base_model].get("create_expense_cost", 0)
+        invoke_expense_cost = model_costs[base_model].get("invoke_expense_cost", 0)
 
         agent_manager = AgentManager()
         try:
-            _, remaining_budget = agent_manager.create_agent(
+            _, remaining_resource_budget, remaining_expense_budget = agent_manager.create_agent(
                 agent_name=agent_name,
                 base_model=base_model,
                 system_prompt=system_prompt,
                 description=description,
-                create_cost=create_cost,
-                invoke_cost=invoke_cost
+                create_resource_cost=create_resource_cost,
+                invoke_resource_cost=invoke_resource_cost,
+                create_expense_cost=create_expense_cost,
+                invoke_expense_cost=invoke_expense_cost
             )
         except ValueError as e:
             return {
@@ -71,5 +75,6 @@ class AgentCreator():
         return {
             "status": "success",
             "message": "Agent successfully created",
-            "remaining_budget": remaining_budget,
+            "remaining_resource_budget": remaining_resource_budget,
+            "remaining_expense_budget": remaining_expense_budget
         }

src/tools/default_tools/ask_agent_tool.py

@@ -36,7 +36,7 @@ class AskAgent():
         agent_manger = AgentManager()
 
         try:
-            agent_response, remaining_budget = agent_manger.ask_agent(agent_name=agent_name, prompt=prompt)
+            agent_response, remaining_resource_budget, remaining_expense_budget = agent_manger.ask_agent(agent_name=agent_name, prompt=prompt)
         except ValueError as e:
             return {
                 "status": "error",
@@ -49,5 +49,6 @@ class AskAgent():
             "status": "success",
             "message": "Agent has replied to the given prompt",
             "output": agent_response,
-            "remaining_budget": remaining_budget
+            "remaining_resource_budget": remaining_resource_budget,
+            "remaining_expense_budget": remaining_expense_budget
         }

src/tools/default_tools/fire_agent.py

@@ -29,7 +29,7 @@ class FireAgent():
         agent_manager = AgentManager()
                 
         try:
-            remaining_budget = agent_manager.delete_agent(agent_name=agent_name)
+            remaining_resource_budget, remaining_expense_budget = agent_manager.delete_agent(agent_name=agent_name)
         except ValueError as e:
             return {
                 "status": "error",
@@ -40,5 +40,6 @@ class FireAgent():
         return {
             "status": "success",
             "message": "Agent successfully fired.",
-            "remaining_budget": remaining_budget
+            "remaining_resource_budget": remaining_resource_budget,
+            "remaining_expense_budget": remaining_expense_budget
         }

src/tools/default_tools/get_budget.py

@@ -20,16 +20,23 @@ class GetBudget():
 
     def run(self, **kwargs):
         budget_manager = BudgetManager()
-        total_budget = budget_manager.get_total_budget()
+        total_resource_budget = budget_manager.get_total_resource_budget()
+        current_resource_usage = budget_manager.get_current_resource_usage()
+        current_remaining_resource_budget = budget_manager.get_current_remaining_resource_budget()
+        
+        total_expense_budget = budget_manager.get_total_expense_budget()
         current_expense = budget_manager.get_current_expense()
-        current_remaining_budget = budget_manager.get_current_remaining_budget()
+        current_remaining_expense_budget = budget_manager.get_total_expense_budget() - budget_manager.get_current_expense()
         return {
             "status": "success",
             "message": "Budget retrieved successfully",
             "output": {
-                "total_budget": total_budget,
+                "total_resource_budget": total_resource_budget,
+                "current_resource_usage": current_resource_usage,
+                "current_remaining_resource_budget": current_remaining_resource_budget,
+                "total_expense_budget": total_expense_budget,
                 "current_expense": current_expense,
-                "current_remaining_budget": current_remaining_budget
+                "current_remaining_expense_budget": current_remaining_expense_budget,
             }
         }
         

src/tools/default_tools/test_cost/agent_creator_tool.py

@@ -150,8 +150,8 @@ class AgentCreator():
                 base_model=base_model,
                 system_prompt=system_prompt,
                 description=description,
-                create_cost=create_cost,
-                invoke_cost=invoke_cost
+                create_resource_cost=create_cost,
+                invoke_resource_cost=invoke_cost
             )
         except ValueError as e:
             return {

src/tools/user_tools/weather_tool.py

@@ -19,7 +19,7 @@ class WeatherApi():
             },
             "required": ["location"],
         },
-        "invoke_cost": 0.1,
+        "invoke_resource_cost": 0.1,
     }
 
     def run(self, **kwargs):