Merge branch 'main' of https://github.com/kunpai/HASHIRU into auth0

.github/workflows/restore_cost_benefit.yml

@@ -0,0 +1,92 @@
+# .github/workflows/restore_cost_benefit.yml
+name: Restore src/cost_benefit.py
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  restore:
+    runs-on: ubuntu-latest
+    # allow the GITHUB_TOKEN to push a commit back
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          # you need the token available for the later push
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Recreate src/cost_benefit.py
+        run: |
+          mkdir -p src
+          cat > src/cost_benefit.py <<'PY'
+          import argparse
+          import subprocess
+          import time
+          import requests
+          
+          def detect_available_budget(runtime_env: str) -> int:
+              """
+              Return an approximate VRAM‑based budget (MB) when running locally,
+              else default to 100.
+              """
+              import torch
+              if "local" in runtime_env and torch.cuda.is_available():
+                  total_vram_mb = torch.cuda.get_device_properties(0).total_memory // (1024 ** 2)
+                  return min(total_vram_mb, 100)
+              return 100
+          
+          def get_best_model(runtime_env: str, *, use_local_only: bool = False, use_api_only: bool = False) -> dict:
+              """
+              Pick the fastest model that fits in the detected budget while
+              respecting the locality filters.
+              """
+              static_costs = {
+                  "llama3.2":  {"size": 20, "token_cost": 0.0001, "tokens_sec": 30, "type": "local"},
+                  "mistral":   {"size": 40, "token_cost": 0.0002, "tokens_sec": 50, "type": "local"},
+                  "gemini-2.0-flash":            {"size": 60, "token_cost": 0.0005, "tokens_sec": 60, "type": "api"},
+                  "gemini-2.5-pro-preview-03-25": {"size": 80, "token_cost": 0.002 , "tokens_sec": 45, "type": "api"},
+              }
+          
+              budget = detect_available_budget(runtime_env)
+              best_model, best_speed = None, -1
+          
+              for model, info in static_costs.items():
+                  if info["size"] > budget:
+                      continue
+                  if use_local_only and info["type"] != "local":
+                      continue
+                  if use_api_only and info["type"] != "api":
+                      continue
+                  if info["tokens_sec"] > best_speed:
+                      best_model, best_speed = model, info["tokens_sec"]
+          
+              chosen = best_model or "llama3.2"  # sensible default
+              return {
+                  "model": chosen,
+                  "token_cost": static_costs[chosen]["token_cost"],
+                  "tokens_sec": static_costs[chosen]["tokens_sec"],
+                  "note": None if best_model else "Defaulted because no model met the constraints",
+              }
+          PY
+
+      - name: Commit & push only when the file was missing
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        run: |
+          set -e
+          git config user.name  "HARSHIL PATEL"
+          git config user.email "hpppatel@ucdavis.edu"
+
+          # If the file is NOT in the current Git index, add‑commit‑push.
+          if ! git ls-files --error-unmatch src/cost_benefit.py >/dev/null 2>&1; then
+            git add src/cost_benefit.py
+            git commit -m "chore(ci): restore missing src/cost_benefit.py [skip ci]"
+            git push origin HEAD:main
+          else
+            echo "src/cost_benefit.py already exists in the repository – nothing to restore"
+          fi

.gitignore

@@ -15,4 +15,5 @@ results/
 *.fls
 *.fdb_latexmk
 *.synctex.gz
-secret_word.json
+secret_word.json
+src/data/

bench/benchmarking_hle.py

@@ -101,15 +101,15 @@ def benchmark_hle(num_samples=20, categories=None):
         # Send query to agent
         try:
             start_time = time.time()
-            response = client.predict(
-                messages=[{"role": "user", "content": prompt}],
-                api_name="/run"
+            response, history = client.predict(
+                message={"text": prompt, "files": []},
+                api_name="/chat"
             )
             end_time = time.time()
 
             target_answer_phrase = sample.get('answer', '').strip()
 
-            agent_final_response_content = get_last_assistant_content(response)
+            agent_final_response_content = get_last_assistant_content(history)
 
             is_correct = False
 
@@ -125,7 +125,7 @@ def benchmark_hle(num_samples=20, categories=None):
                 "category": category,
                 "input": prompt,
                 "target_output": sample.get('answer', ''),
-                "agent_full_response": response,
+                "agent_full_response": history,
                 "agent_final_response": agent_final_response_content,
                 "response_time": end_time - start_time,
                 "is_correct": is_correct

bench/benchmarking_paper_reviews.py

@@ -64,25 +64,26 @@ def benchmark_paper_reviews(
     for idx, row in df.iterrows():
         paper_id = row[id_col]
         title = row["Title"]
-        prompt = "Create THREE agents with different personalities, expertise, and review styles. " \
+        prompt = "Create THREE agents with relevant personalities, expertise, and review styles. " \
                 "Each agent should provide a review of the paper, and recommend Accept/Reject for ICLR 2023. " \
                 "The review should be detailed and include strengths and weaknesses. " \
-                "You can use ArxivTool and WikipediaTool to get more information. " \
+                "You MUST use ArxivTool and WikipediaTool to get more information about novelty and correctness. " \
+                "GIVE A FINAL DECISION in the form of \"FINAL DECISION: <Accept/Reject>\". " \
                 "The paper title is: " + title + "\n\n" + row[text_col]
         print(f"[{idx+1}/{len(df)}] Paper ID: {paper_id}")
 
         try:
             start = time.time()
-            resp = client.predict(
-                messages=[{"role":"user","content": prompt}],
-                api_name="/run"
+            resp, history = client.predict(
+                message={"text": prompt, "files": []},
+                api_name="/chat"
             )
             elapsed = time.time() - start
 
             result = {
                 "paper_id": paper_id,
                 "prompt_snippet": prompt[:200],
-                "agent_review": resp,
+                "agent_review": history,
                 "ground_truth": row["Decision"],
                 "response_time": elapsed
             }
@@ -91,7 +92,7 @@ def benchmark_paper_reviews(
             with open(out_path, "a") as f:
                 f.write(json.dumps(result) + "\n")
 
-            print(f" → {elapsed:.2f}s, review length {len(resp)} chars")
+            print(f" → {elapsed:.2f}s, review length {len(history)} chars")
             results.append(result)
 
             # small delay
@@ -105,6 +106,6 @@ def benchmark_paper_reviews(
 if __name__ == "__main__":
     # example usage: adjust path & sample count as needed
     benchmark_paper_reviews(
-        csv_path="ICLR_2023.csv",
+        csv_path="bench/data/ICLR_2023.csv",
         num_samples=1
     )

paper/conference_101719.tex

@@ -8,6 +8,15 @@
 \usepackage{textcomp}
 \usepackage{xcolor}
 \usepackage{hyperref}
+\usepackage{longtable}
+\usepackage{tabularx}
+\usepackage{tcolorbox}
+\tcbuselibrary{skins}
+
+% Define styles for user and assistant boxes
+\newtcolorbox{userbox}{colback=blue!5,colframe=blue!40!black,title=User}
+\newtcolorbox{assistantbox}{colback=gray!10,colframe=black,title=Assistant}
+
 \def\BibTeX{{\rm B\kern-.05em{\sc i\kern-.025em b}\kern-.08em
     T\kern-.1667em\lower.7ex\hbox{E}\kern-.125emX}}
 \begin{document}
@@ -184,6 +193,19 @@ To enable HASHIRU agents to learn from past interactions and rectify previous er
 
 Memory retrieval is based on semantic similarity between the current context (e.g., task description, recent actions, error messages) and the stored memory entries. We utilize embeddings generated by the \textbf{all-MiniLM-L6-v2} model \cite{wang2020minilmdeepselfattentiondistillation} to represent both the query and the stored memories in a high-dimensional vector space. Relevance is determined by calculating the \textbf{cosine similarity} between the query embedding and each memory embedding. Memories exceeding a predefined similarity threshold are retrieved and provided to the CEO agent (or relevant Employee agents) as contextual information. This allows the system to draw upon past experiences, understand why previous approaches failed, and potentially adjust its strategy to avoid repeating mistakes, thereby improving performance and efficiency over time.
 
+\section{Case Studies}
+\label{sec:casestudies}
+This section presents two case studies demonstrating HASHIRU's self-improvement capabilities in practical settings. We highlight two instances where HASHIRU enhanced its own architecture and functionality: (1) by generating a comprehensive cost model for base models suitable for specialized agent creation, and (2) by autonomously integrating new tools for the CEO agent.
+
+\subsection{Case Study 1: Self-Generating the Cost Model for Agent Specialization}
+\label{sec:casestudy1_costmodel}
+An accurate cost model is essential for optimizing resource allocation and ensuring the efficiency of specialized agents within HASHIRU. Traditionally, constructing this model involves manual research into local model performance relative to hardware (e.g., 16~GiB VRAM) and the API costs of cloud-hosted alternatives. HASHIRU automated this labor-intensive process by leveraging its web search capabilities to autonomously identify and incorporate the necessary cost data into its internal model. The results were successfully committed to the codebase\footnote{\url{https://github.com/kunpai/HASHIRU/commit/70dc268b121cbd7c50c6691645d8a99912766965}}.
+
+\subsection{Case Study 2: Autonomous Tool Integration for the CEO Agent}
+\label{sec:casestudy2_tools}
+Extending the CEO agent's capabilities through tool integration is vital for broadening HASHIRU's operational scope. Manual tool development typically requires detailed analysis of existing tool schemas and diligent code implementation. HASHIRU streamlined this process by employing a few-shot learning approach, using an existing tool as a template to guide the autonomous creation of new tools~\cite{brown2020language}. The newly generated tools were directly integrated into the codebase\footnote{\url{https://github.com/kunpai/HASHIRU/commit/193e10b2b00917256b7cc01cb3aa5ac7b6a6c174}}.
+
+
 \section{Experimental Setup}
 \label{sec:experiments}
 
@@ -250,4 +272,208 @@ We evaluate using quantitative and qualitative metrics:
 \bibliography{references}
 \bibliographystyle{plain}
 
+\appendix
+\section{Examples of HASHIRU in Action}
+\label{sec:examples}
+In this section, we provide examples of how HASHIRU operates in practice, demonstrating its dynamic management, hybrid intelligence, memory and autonomous tool creation capabilities.
+
+\subsection{Example 1: Memory}
+\begin{figure}[h]
+    \centering
+    \begin{minipage}{0.45\textwidth}
+    \begin{userbox}
+    I am vegetarian.
+    \end{userbox}
+    
+    \begin{assistantbox}
+    Okay, I'll keep that in mind. I'll store this preference in my memory.
+    
+    \texttt{Invoking MemoryManager with \{`memory': `The user is vegetarian.', `action': `add\_memory', `key': `vegetarian'\}}
+    
+    I have stored that you are vegetarian. How can I help you today?
+    \end{assistantbox}
+    
+    \begin{userbox}
+    Give me a bacon pasta recipe.
+    \end{userbox}
+    
+    \begin{assistantbox}
+    Memories
+    
+    Memories: [`The user is vegetarian.']
+    
+    My apologies, but I cannot provide a bacon pasta recipe since you are vegetarian. Would you like a vegetarian pasta recipe instead?
+    \end{assistantbox}
+    \end{minipage}
+    \caption{HASHIRU enforcing a stored dietary preference in dialogue using its Memory Function.}
+    \label{fig:memory_example}
+    \end{figure}
+
+\begin{figure}[ht]
+    \centering
+    \begin{minipage}
+    {0.45\textwidth}
+    \begin{userbox}
+        I can eat bacon actually
+        \end{userbox}
+        
+        \begin{assistantbox}
+        Memories
+        
+        Memories: [’The user is vegetarian.’]
+        
+        I see. My apologies for the confusion. I had a conflicting memory that you were vegetarian. I will remove that memory and proceed with finding a bacon pasta recipe.
+        
+        \texttt{Invoking MemoryManager with \{'action': 'delete\_memory', 'key': 'The user is vegetarian.'\}}
+        
+        OK, I have removed the memory. Now I will search for a bacon pasta recipe.
+        
+        \texttt{Invoking GoogleSearchTool with \{'query': 'bacon pasta recipe'\}}
+        
+        Here are some bacon pasta recipes I found:
+        \begin{itemize}
+            \item \href{https://www.sprinklesandsprouts.com/garlic-bacon-pasta/}{Garlic Bacon Pasta}
+            \item \href{https://www.theburntbuttertable.com/creamy-bacon-pasta-sauce/}{Creamy Bacon Pasta Sauce}
+            \item \dots
+        \end{itemize}
+        
+        Would you like me to get the content of any of these websites?
+        \end{assistantbox}
+    \end{minipage}
+    \caption{HASHIRU updating and deleting its memory based on user input. Continuation of Figure \ref{fig:memory_example}.}
+    \label{fig:memory_example2}
+\end{figure}
+
+\subsection{Example 2: Novelty Assessment via Coordinated Tool Use}
+
+\begin{figure}[h]
+    \centering
+    \begin{minipage}{0.95\textwidth}
+    
+    \begin{userbox}
+    Is this idea novel: ``a dynamically managed, resource-aware hierarchical multi-agent system that prioritizes cost-efficient local models, integrates autonomous tool creation, and employs an internal economic model to balance performance, adaptability, and stability in intelligent task coordination''?
+    \end{userbox}
+    
+    \begin{assistantbox}
+    To determine if the idea is novel, I will break it down into smaller parts and search for each part. Then I will combine the results to see if the whole idea is novel.
+    
+    Here's the breakdown:
+    \begin{itemize}
+        \item Dynamically managed multi-agent system
+        \item Resource-aware hierarchical multi-agent system
+        \item Cost-efficient local models in multi-agent systems
+        \item Autonomous tool creation in multi-agent systems
+        \item Internal economic model for multi-agent systems
+    \end{itemize}
+    
+    I will use the \texttt{GoogleSearchTool} to search for each of these parts.
+    
+    \texttt{Invoking GoogleSearchTool with \{'query': 'dynamically managed multi-agent system'\}}
+    
+    \texttt{Invoking GoogleSearchTool with \{'query': 'resource-aware hierarchical multi-agent system'\}}
+    
+    \texttt{Invoking GoogleSearchTool with \{'query': 'cost-efficient local models in multi-agent systems'\}}
+    
+    \texttt{Invoking GoogleSearchTool with \{'query': 'autonomous tool creation in multi-agent systems'\}}
+    
+    \texttt{Invoking GoogleSearchTool with \{'query': 'internal economic model for multi-agent systems'\}}
+    
+    The search results indicate that each of the individual components of the idea has been explored in existing research. However, the novelty lies in the specific combination and integration of these elements.
+    
+    To further assess the novelty, I will use the \texttt{ArxivTool} to search for papers that combine multiple aspects of the idea.
+    
+    \texttt{Invoking ArxivTool with \{'query': 'dynamically managed resource-aware hierarchical multi-agent system'\}}
+    
+    \texttt{Invoking ArxivTool with \{'query': 'multi-agent system autonomous tool creation economic model'\}}
+    
+    The ArxivTool results show some papers that touch on combinations of these concepts, but none seem to address the entire idea as presented. Specifically, the combination of dynamic management, resource-awareness, hierarchical structure, cost-efficient local models, autonomous tool creation, and an internal economic model appears to be a novel synthesis.
+    
+    \textbf{Therefore, based on the search results, the idea seems novel.}
+    \end{assistantbox}
+    \caption{HASHIRU assessing the novelty of a complex idea by breaking it down into components and searching for each part.}
+    \end{minipage}
+    \label{fig:novelty_assessment}
+\end{figure}
+
+\clearpage
+\twocolumn
+    
+\begin{figure}
+    \centering
+    \begin{minipage}{0.95\textwidth}
+    \begin{userbox}
+        Which papers mention the ideas?
+        \end{userbox}
+        
+        \begin{assistantbox}
+        To provide a comprehensive answer, I will analyze the summaries of the papers returned by the ArxivTool and GoogleSearchTool to identify which papers mention the key ideas in your prompt.
+        
+        \textbf{The key ideas are:}
+        \begin{itemize}
+            \item Dynamically managed
+            \item Resource-aware
+            \item Hierarchical
+            \item Cost-efficient local models
+            \item Autonomous tool creation
+            \item Internal economic model
+        \end{itemize}
+        
+        I will go through each paper and identify which of these ideas are mentioned.
+        
+        \texttt{Invoking ArxivTool with \{'query': 'dynamically managed resource-aware hierarchical multi-agent system'\}} \\
+        \texttt{Invoking ArxivTool with \{'query': 'multi-agent system autonomous tool creation economic model'\}}
+        
+        \textbf{ArxivTool Results (Query: ``dynamically managed resource-aware hierarchical multi-agent system'')}
+        
+        \begin{itemize}
+            \item \textit{Hierarchical stock assessment methods improve management performance in multi-species, data-limited fisheries} \\
+            Hierarchical: Yes \\
+            Dynamically managed: Implied through ``management performance''
+            
+            \item \textit{Hierarchical Reinforcement Learning for Optimal Agent Grouping in Cooperative Systems} \\
+            Hierarchical: Yes \\
+            Dynamically managed: Yes, through ``dynamic and optimal policy adjustments.''
+            
+            \item \textit{Efficient Hierarchical Storage Management Framework Empowered by Reinforcement Learning} \\
+            Hierarchical: Yes \\
+            Cost-efficient local models: Implied through ``efficient'' \\
+            Dynamically managed: Yes, through ``dynamic migration policy''
+            
+            \item \textit{Autonomous Deep Agent} \\
+            Hierarchical: Yes \\
+            Autonomous tool creation: Yes, via ``Autonomous API \& Tool Creation (AATC) system'' \\
+            Dynamically managed: Yes, ``dynamically decomposes high-level objectives''
+            
+            \item \textit{Adaptive Network Intervention for Complex Systems: A Hierarchical Graph Reinforcement Learning Approach} \\
+            Hierarchical: Yes \\
+            Dynamically managed: Yes, through ``dynamic networks''
+        \end{itemize}
+        
+        \textbf{ArxivTool Results (Query: ``multi-agent system autonomous tool creation economic model'')}
+        
+        \begin{itemize}
+            \item \textit{Autonomics: an autonomous and intelligent economic platform and next generation money tool} \\
+            Autonomous tool creation: Implied \\
+            Internal economic model: Yes
+            
+            \item \textit{From Single Agent to Multi-Agent: Improving Traffic Signal Control} \\
+            No relevant keywords mentioned.
+            
+            \item \textit{Autonomous Deep Agent} \\
+            Hierarchical: Yes \\
+            Autonomous tool creation: Yes
+            
+            \item \textit{Beyond the Sum: Unlocking AI Agents Potential Through Market Forces} \\
+            Internal economic model: Yes
+            
+            \item \textit{Particle-Hole Creation in Condensed Matter: A Conceptual Framework for Modeling Money-Debt Dynamics in Economics} \\
+            Internal economic model: Yes
+        \end{itemize}
+        
+        \end{assistantbox}
+        \caption{Continuation of Figure \ref{fig:novelty_assessment}. HASHIRU analyzing the summaries of the papers returned by the ArxivTool and GoogleSearchTool to identify which papers mention the key ideas in the user prompt.}
+    \end{minipage}
+
+\end{figure}
+
 \end{document}

requirements.txt

@@ -51,7 +51,7 @@ protobuf==5.29.4
 pyarrow==20.0.0
 pyasn1==0.6.1
 pyasn1_modules==0.4.2
-pydantic==2.11.2
+pydantic==2.10.6
 pydantic_core==2.33.1
 pydub==0.25.1
 Pygments==2.19.1

src/cost_benefit.py

@@ -4,35 +4,30 @@ import time
 import requests
 
 def detect_available_budget(runtime_env: str) -> int:
+    """
+    Return an approximate VRAM‑based budget (MB) when running locally,
+    else default to 100.
+    """
     import torch
     if "local" in runtime_env and torch.cuda.is_available():
         total_vram_mb = torch.cuda.get_device_properties(0).total_memory // (1024 ** 2)
         return min(total_vram_mb, 100)
-    else:
-        return 100
+    return 100
 
-
-def get_best_model(runtime_env: str, use_local_only=False, use_api_only=False) -> dict:
-    # Model info (cost, tokens/sec, type)
+def get_best_model(runtime_env: str, *, use_local_only: bool = False, use_api_only: bool = False) -> dict:
+    """
+    Pick the fastest model that fits in the detected budget while
+    respecting the locality filters.
+    """
     static_costs = {
-        "llama3.2": {"size": 20, "token_cost": 0.0001, "tokens_sec": 30, "type": "local"},
-        "mistral": {"size": 40, "token_cost": 0.0002, "tokens_sec": 50, "type": "local"},
-        "gemini-2.0-flash": {"size": 60, "token_cost": 0.0005, "tokens_sec": 60, "type": "api"},
-        "gemini-2.5-pro-preview-03-25": {"size": 80, "token_cost": 0.002, "tokens_sec": 45, "type": "api"}
+        "llama3.2":  {"size": 20, "token_cost": 0.0001, "tokens_sec": 30, "type": "local"},
+        "mistral":   {"size": 40, "token_cost": 0.0002, "tokens_sec": 50, "type": "local"},
+        "gemini-2.0-flash":            {"size": 60, "token_cost": 0.0005, "tokens_sec": 60, "type": "api"},
+        "gemini-2.5-pro-preview-03-25": {"size": 80, "token_cost": 0.002 , "tokens_sec": 45, "type": "api"},
     }
 
-    def detect_available_budget(runtime_env: str) -> int:
-        import torch
-        if "local" in runtime_env and torch.cuda.is_available():
-            total_vram_mb = torch.cuda.get_device_properties(0).total_memory // (1024 ** 2)
-            return min(total_vram_mb, 100)
-        else:
-            return 100
-
     budget = detect_available_budget(runtime_env)
-
-    best_model = None
-    best_speed = -1
+    best_model, best_speed = None, -1
 
     for model, info in static_costs.items():
         if info["size"] > budget:
@@ -42,19 +37,12 @@ def get_best_model(runtime_env: str, use_local_only=False, use_api_only=False) -
         if use_api_only and info["type"] != "api":
             continue
         if info["tokens_sec"] > best_speed:
-            best_model = model
-            best_speed = info["tokens_sec"]
-
-    if not best_model:
-        return {
-            "model": "llama3.2",
-            "token_cost": static_costs["llama3.2"]["token_cost"],
-            "tokens_sec": static_costs["llama3.2"]["tokens_sec"],
-            "note": "Defaulted due to no models fitting filters"
-        }
+            best_model, best_speed = model, info["tokens_sec"]
 
+    chosen = best_model or "llama3.2"  # sensible default
     return {
-        "model": best_model,
-        "token_cost": static_costs[best_model]["token_cost"],
-        "tokens_sec": static_costs[best_model]["tokens_sec"]
+        "model": chosen,
+        "token_cost": static_costs[chosen]["token_cost"],
+        "tokens_sec": static_costs[chosen]["tokens_sec"],
+        "note": None if best_model else "Defaulted because no model met the constraints",
     }

src/manager/agent_manager.py

@@ -8,6 +8,7 @@ from src.manager.utils.streamlit_interface import output_assistant_response
 from google import genai
 from google.genai import types
 from google.genai.types import *
+from groq import Groq
 import os
 from dotenv import load_dotenv
 from src.manager.budget_manager import BudgetManager
@@ -15,75 +16,114 @@ from src.manager.budget_manager import BudgetManager
 MODEL_PATH = "./src/models/"
 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
     def create_model(self) -> None:
         """Create and Initialize agent"""
         pass
-    
+
     @abstractmethod
     def ask_agent(self, prompt: str) -> str:
         """ask agent a question"""
         pass
-    
+
     @abstractmethod
-    def delete_agent(self) ->None:
+    def delete_agent(self) -> None:
         """delete agent"""
         pass
-    
+
+    @abstractmethod
+    def get_type(self) -> None:
+        """get agent type"""
+        pass
+
     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):
-    
+    type = "local"
+
     def create_model(self):
         ollama_response = ollama.create(
-            model = self.agent_name,
-            from_ = self.base_model,
-            system = self.system_prompt,
-            stream = False
+            model=self.agent_name,
+            from_=self.base_model,
+            system=self.system_prompt,
+            stream=False
         )
-    
+
     def ask_agent(self, prompt):
         output_assistant_response(f"Asked Agent {self.agent_name} a question")
         agent_response = ollama.chat(
             model=self.agent_name,
             messages=[{"role": "user", "content": prompt}],
         )
-        output_assistant_response(f"Agent {self.agent_name} answered with {agent_response.message.content}")
+        output_assistant_response(
+            f"Agent {self.agent_name} answered with {agent_response.message.content}")
         return agent_response.message.content
-    
+
     def delete_agent(self):
         ollama.delete(self.agent_name)
-    
+
+    def get_type(self):
+        return self.type
+
+
 class GeminiAgent(Agent):
-    def __init__(self, agent_name: str, base_model: str, system_prompt: str, creation_cost: str, invoke_cost: str):
+    type = "cloud"
+
+    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:
-            raise ValueError("Google API key is required for Gemini models. Set GOOGLE_API_KEY environment variable or pass api_key parameter.")
-        
+            raise ValueError(
+                "Google API key is required for Gemini models. Set GOOGLE_API_KEY environment variable or pass api_key parameter.")
+
         # Initialize the Gemini API
         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 = []
-    
+
     def ask_agent(self, prompt):
         response = self.client.models.generate_content(
             model=self.base_model,
@@ -93,70 +133,175 @@ class GeminiAgent(Agent):
             )
         )
         return response.text
-    
+
     def delete_agent(self):
         self.messages = []
+
+    def get_type(self):
+        return self.type
+
+
+class GroqAgent(Agent):
+    type = "cloud"
+
+    def __init__(
+        self,
+        agent_name: str,
+        base_model: str = "llama-3.3-70b-versatile",
+        system_prompt: str = "system.prompt",
+    ):
+        self.agent_name = agent_name
+        self.base_model = base_model
+        # load API key from environment
+        api_key = os.getenv("GROQ_API_KEY")
+        self.client = Groq(api_key=api_key)
+        # read system prompt content
+        with open(system_prompt, 'r') as f:
+            self.system_instruction = f.read()
+
+    def create_model(self) -> None:
+        # Groq models are available by name; no creation step
+        pass
+
+    def ask_agent(self, prompt: str) -> str:
+        messages = [
+            {"role": "system", "content": self.system_instruction},
+            {"role": "user", "content": prompt},
+        ]
+        response = self.client.chat.completions.create(
+            messages=messages,
+            model=self.base_model,
+        )
+        result = response.choices[0].message.content
+        print(result)
+        return result
+
+    def delete_agent(self) -> None:
+        # No delete support for Groq
+        pass
+
+    def get_type(self):
+        return self.type
+
+
 @singleton
 class AgentManager():
     budget_manager: BudgetManager = BudgetManager()
+    is_creation_enabled: bool = True
+    is_cloud_invocation_enabled: bool = True
+    is_local_invocation_enabled: bool = True
+
     def __init__(self):
         self._agents: Dict[str, Agent] = {}
-        self._agent_types ={
+        self._agent_types = {
             "ollama": OllamaAgent,
-            "gemini": GeminiAgent
+            "gemini": GeminiAgent,
+            "groq": GroqAgent,
         }
-        
+
         self._load_agents()
-    
-    def create_agent(self, agent_name: str, 
-                     base_model: str, system_prompt: str, 
-                     description: str = "", create_cost: float = 0, 
-                     invoke_cost: float = 0, 
-                 **additional_params) -> Tuple[Agent, int]:
-        
+
+    def set_creation_mode(self, status: bool):
+        self.is_creation_enabled = status
+        if status:
+            output_assistant_response("Agent creation mode is enabled.")
+        else:
+            output_assistant_response("Agent creation mode is disabled.")
+
+    def set_cloud_invocation_mode(self, status: bool):
+        self.is_cloud_invocation_enabled = status
+        if status:
+            output_assistant_response("Cloud invocation mode is enabled.")
+        else:
+            output_assistant_response("Cloud invocation mode is disabled.")
+
+    def set_local_invocation_mode(self, status: bool):
+        self.is_local_invocation_enabled = status
+        if status:
+            output_assistant_response("Local invocation mode is enabled.")
+        else:
+            output_assistant_response("Local invocation mode is disabled.")
+
+    def create_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) -> Tuple[Agent, int]:
+        if not self.is_creation_enabled:
+            raise ValueError("Agent creation mode is disabled.")
+
         if agent_name in self._agents:
             raise ValueError(f"Agent {agent_name} already exists")
-        
+
         self._agents[agent_name] = self.create_agent_class(
-            agent_name, 
-            base_model, 
-            system_prompt, 
+            agent_name,
+            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
         )
-        
-        #save agent to file
+
+        # save agent to file
         self._save_agent(
-            agent_name, 
-            base_model, 
-            system_prompt, 
+            agent_name,
+            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())
-    
-    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 create_agent_class(self, agent_name: str, base_model: str, system_prompt: str, description: str = "", create_cost: float = 0, invoke_cost: float = 0,
-                    **additional_params) -> Agent:
+        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,
+                        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_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)
-        
+
         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)
-        
-        self.validate_budget(create_cost)
-        
-        self.budget_manager.add_to_expense(create_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_resource_cost,
+                             create_expense_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
 
@@ -165,21 +310,23 @@ class AgentManager():
         if agent_name not in self._agents:
             raise ValueError(f"Agent {agent_name} does not exists")
         return self._agents[agent_name]
-        
+
     def list_agents(self) -> dict:
         """Return agent information (name, description, costs)"""
         try:
             if os.path.exists(MODEL_FILE_PATH):
                 with open(MODEL_FILE_PATH, "r", encoding="utf8") as f:
                     full_models = json.loads(f.read())
-                    
+
                 # Create a simplified version with only the description and costs
                 simplified_agents = {}
                 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
@@ -188,116 +335,154 @@ class AgentManager():
         except Exception as e:
             output_assistant_response(f"Error listing agents: {e}")
             return {}
-    
+
     def delete_agent(self, agent_name: str) -> int:
-        agent = self.get_agent(agent_name)
-        
-        self.budget_manager.remove_from_expense(agent.creation_cost)
+        agent: Agent = self.get_agent(agent_name)
+
+        self.budget_manager.remove_from_resource_expense(
+            agent.create_resource_cost)
         agent.delete_agent()
-        
+
         del self._agents[agent_name]
         try:
             if os.path.exists(MODEL_FILE_PATH):
                 with open(MODEL_FILE_PATH, "r", encoding="utf8") as f:
                     models = json.loads(f.read())
-                    
+
                 del models[agent_name]
                 with open(MODEL_FILE_PATH, "w", encoding="utf8") as f:
                     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()
-    
-    def ask_agent(self, agent_name: str, prompt: str) -> Tuple[str,int]:
-        agent = self.get_agent(agent_name)
-        
-        self.validate_budget(agent.invoke_cost)
-
-        response = agent.ask_agent(prompt)        
-        return (response, self.budget_manager.get_current_remaining_budget())
-    
-    def _save_agent(self, agent_name: str, base_model: str, system_prompt: str, 
-                    description: str = "", create_cost: float = 0, invoke_cost: float = 0, 
+        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: Agent = self.get_agent(agent_name)
+        print(agent.get_type())
+        print(agent_name)
+        print(self.is_local_invocation_enabled,
+              self.is_cloud_invocation_enabled)
+        if not self.is_local_invocation_enabled and agent.get_type() == "local":
+            raise ValueError("Local invocation mode is disabled.")
+
+        if not self.is_cloud_invocation_enabled and agent.get_type() == "cloud":
+            raise ValueError("Cloud invocation mode is disabled.")
+
+        n_tokens = len(prompt.split())/1000
+
+        self.validate_budget(agent.invoke_resource_cost,
+                             agent.invoke_expense_cost*n_tokens)
+
+        self.budget_manager.add_to_expense_budget(
+            agent.invoke_expense_cost*n_tokens)
+
+        response = agent.ask_agent(prompt)
+        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_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:
             # Ensure the directory exists
             os.makedirs(MODEL_PATH, exist_ok=True)
-            
+
             # Read existing models file or create empty dict if it doesn't exist
             try:
                 with open(MODEL_FILE_PATH, "r", encoding="utf8") as f:
                     models = json.loads(f.read())
             except (FileNotFoundError, json.JSONDecodeError):
                 models = {}
-            
+
             # Update the models dict with the new agent
             models[agent_name] = {
                 "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
             for key, value in additional_params.items():
                 models[agent_name][key] = value
-            
+
             # Write the updated models back to the file
             with open(MODEL_FILE_PATH, "w", encoding="utf8") as f:
                 f.write(json.dumps(models, indent=4))
-                
+
         except Exception as e:
             output_assistant_response(f"Error saving agent {agent_name}: {e}")
 
-    def _get_agent_type(self, base_model)->str:
+    def _get_agent_type(self, base_model) -> str:
 
         if base_model == "llama3.2":
             return "ollama"
         elif base_model == "mistral":
             return "ollama"
+        elif base_model == "deepseek-r1":
+            return "ollama"
         elif "gemini" in base_model:
             return "gemini"
+        elif "groq" in base_model:
+            return "groq"
         else:
             return "unknown"
-    
+
     def _load_agents(self) -> None:
         """Load agent configurations from disk"""
         try:
             if not os.path.exists(MODEL_FILE_PATH):
                 return
-                
+
             with open(MODEL_FILE_PATH, "r", encoding="utf8") as f:
                 models = json.loads(f.read())
-            
+
             for name, data in models.items():
                 if name in self._agents:
                     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)
-                
+
                 if manager_class:
                     # Create the agent with the appropriate manager class
                     self._agents[name] = self.create_agent_class(
-                        name, 
-                        base_model, 
-                        system_prompt, 
+                        name,
+                        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, 
+                        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}")
+            output_assistant_response(f"Error loading agents: {e}")

src/manager/budget_manager.py

@@ -4,48 +4,96 @@ import psutil
 
 @singleton
 class BudgetManager():
-    TOTAL_BUDGET = 100
+    total_resource_budget = 100
+    current_resource_usage = 0
+    total_expense_budget = 10
     current_expense = 0
     is_budget_initialized = False
+    is_resource_budget_enabled = True
+    is_expense_budget_enabled = True
+    
     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_resource_budget_status(self, status: bool):
+        self.is_enabled = status
+        if status:
+            print("Budget manager is enabled.")
+        else:
+            print("Budget manager is disabled.")
+    
+    def set_expense_budget_status(self, status: bool):
+        self.is_expense_budget_enabled = status
+        if status:
+            print("Expense budget manager is enabled.")
+        else:
+            print("Expense budget manager is disabled.")
         
-    def set_total_budget(self)-> int:
+    def calculate_total_budget(self)-> int:
         total_mem = 0
+        gpu_mem = 0
+        ram_mem = 0
         if torch.cuda.is_available():
             gpu_index = torch.cuda.current_device()
             gpu_name = torch.cuda.get_device_name(gpu_index)
             total_vram = torch.cuda.get_device_properties(gpu_index).total_memory
-            total_mem = total_vram /1024 ** 3
+            gpu_mem = total_vram /1024 ** 3
             print(f"GPU detected: {gpu_name}")
-            print(f"Total VRAM: {total_mem:.2f} GB")
-        else:
-            mem = psutil.virtual_memory()
-            total_mem = mem.total/ 1024 ** 3
-            print("No GPU detected. Using CPU.")
-            print(f"Total RAM: {total_mem:.2f} GB")
+            print(f"Total VRAM: {gpu_mem:.2f} GB")
+        mem = psutil.virtual_memory()
+        ram_mem = mem.total/ 1024 ** 3
+        print("No GPU detected. Using CPU.")
+        print(f"Total RAM: {ram_mem:.2f} GB")
+        total_mem = gpu_mem + ram_mem
         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):
+        if not self.is_resource_budget_enabled:
+            return True
+        return True if self.current_resource_usage + cost <= self.total_resource_budget else False
+        
+    def add_to_resource_budget(self, cost):
+        if not self.is_resource_budget_enabled:
+            return
+        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 not self.is_resource_budget_enabled:
+            return
+        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):
+        if not self.is_expense_budget_enabled:
+            return True
+        return True if self.current_expense + cost <= self.total_expense_budget else False
+    
+    def add_to_expense_budget(self, cost):
+        if not self.is_expense_budget_enabled:
+            return
+        if not self.can_spend_expense(cost):
+            raise Exception("No expense budget remaining")
+        self.current_expense += cost

src/manager/llm_models.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from google import genai
 from google.genai import types
 from mistralai import Mistral
+from groq import Groq
 from src.manager.utils.streamlit_interface import output_assistant_response
 
 
@@ -136,3 +137,42 @@ class MistralModelManager(AbstractModelManager):
     def delete(self):
         # Implement model deletion logic (if applicable)
         self.model = None
+
+class GroqModelManager(AbstractModelManager):
+    def __init__(self, api_key, model_name="llama-3.3-70b-versatile", system_prompt_file="system.prompt"):
+        super().__init__(model_name, system_prompt_file)
+        self.client = Groq(api_key=api_key)
+
+    def is_model_loaded(self, model):
+        # Groq models are referenced by name; assume always available if name matches
+        return model == self.model_name
+
+    def create_model(self, base_model=None, context_window=4096, temperature=0):
+        # Groq does not require explicit creation; no-op
+        if not self.is_model_loaded(self.model_name):
+            output_assistant_response(f"Model {self.model_name} is not available on Groq.")
+
+    def request(self, prompt, temperature=0, context_window=4096):
+        # Read system instruction
+        with open(self.system_prompt_file, 'r') as f:
+            system_instruction = f.read()
+
+        # Build messages
+        messages = [
+            {"role": "system", "content": system_instruction},
+            {"role": "user", "content": prompt}
+        ]
+
+        # Send request
+        response = self.client.chat.completions.create(
+            messages=messages,
+            model=self.model_name,
+            temperature=temperature
+        )
+
+        # Extract and return content
+        return response.choices[0].message.content
+
+    def delete(self):
+        # No deletion support for Groq-managed models
+        output_assistant_response(f"Deletion not supported for Groq model {self.model_name}.")

src/manager/manager.py

@@ -1,9 +1,13 @@
+from enum import Enum, auto
+from typing import List
 from google import genai
 from google.genai import types
 from google.genai.types import *
 import os
 from dotenv import load_dotenv
 import sys
+from src.manager.agent_manager import AgentManager
+from src.manager.budget_manager import BudgetManager
 from src.manager.tool_manager import ToolManager
 from src.manager.utils.suppress_outputs import suppress_output
 import logging
@@ -11,6 +15,7 @@ import gradio as gr
 from sentence_transformers import SentenceTransformer
 import torch
 from src.tools.default_tools.memory_manager import MemoryManager
+from pathlib import Path
 
 logger = logging.getLogger(__name__)
 handler = logging.StreamHandler(sys.stdout)
@@ -18,30 +23,59 @@ handler = logging.StreamHandler(sys.stdout)
 logger.addHandler(handler)
 
 
+class Mode(Enum):
+    ENABLE_AGENT_CREATION = auto()
+    ENABLE_LOCAL_AGENTS = auto()
+    ENABLE_CLOUD_AGENTS = auto()
+    ENABLE_TOOL_CREATION = auto()
+    ENABLE_TOOL_INVOCATION = auto()
+    ENABLE_RESOURCE_BUDGET = auto()
+    ENABLE_ECONOMY_BUDGET = auto()
+    ENABLE_MEMORY = auto()
+
+
 class GeminiManager:
-    def __init__(self, toolsLoader: ToolManager = None,
-                 system_prompt_file="./src/models/system4.prompt",
+    def __init__(self, system_prompt_file="./src/models/system4.prompt",
                  gemini_model="gemini-2.5-pro-exp-03-25",
-                 local_only=False, allow_tool_creation=True,
-                 cloud_only=False, use_economy=True):
+                 modes: List[Mode] = []):
         load_dotenv()
-        self.toolsLoader: ToolManager = toolsLoader
-        if not toolsLoader:
-            self.toolsLoader: ToolManager = ToolManager()
+        self.budget_manager = BudgetManager()
+
+        self.toolsLoader: ToolManager = ToolManager()
 
-        self.local_only = local_only
-        self.allow_tool_creation = allow_tool_creation
-        self.cloud_only = cloud_only
-        self.use_economy = use_economy
+        self.agentManager: AgentManager = AgentManager()
 
         self.API_KEY = os.getenv("GEMINI_KEY")
         self.client = genai.Client(api_key=self.API_KEY)
-        self.toolsLoader.load_tools()
         self.model_name = gemini_model
         self.memory_manager = MemoryManager()
         with open(system_prompt_file, 'r', encoding="utf8") as f:
             self.system_prompt = f.read()
         self.messages = []
+        self.set_modes(modes)
+
+    def get_current_modes(self):
+        return [mode.name for mode in self.modes]
+
+    def set_modes(self, modes: List[Mode]):
+        self.modes = modes
+        self.budget_manager.set_resource_budget_status(
+            self.check_mode(Mode.ENABLE_RESOURCE_BUDGET))
+        self.budget_manager.set_expense_budget_status(
+            self.check_mode(Mode.ENABLE_ECONOMY_BUDGET))
+        self.toolsLoader.set_creation_mode(
+            self.check_mode(Mode.ENABLE_TOOL_CREATION))
+        self.toolsLoader.set_invocation_mode(
+            self.check_mode(Mode.ENABLE_TOOL_INVOCATION))
+        self.agentManager.set_creation_mode(
+            self.check_mode(Mode.ENABLE_AGENT_CREATION))
+        self.agentManager.set_local_invocation_mode(
+            self.check_mode(Mode.ENABLE_LOCAL_AGENTS))
+        self.agentManager.set_cloud_invocation_mode(
+            self.check_mode(Mode.ENABLE_CLOUD_AGENTS))
+
+    def check_mode(self, mode: Mode):
+        return mode in self.modes
 
     def generate_response(self, messages):
         tools = self.toolsLoader.getTools()
@@ -99,7 +133,8 @@ class GeminiManager:
                 name=function_call.name,
                 response={"result": toolResponse})
             try:
-                self.toolsLoader.load_tools()
+                if function_call.name == "ToolCreator" or function_call.name == "ToolDeletor":
+                    self.toolsLoader.load_tools()
             except Exception as e:
                 logger.info(f"Error loading tools: {e}. Deleting the tool.")
                 yield {
@@ -131,13 +166,36 @@ class GeminiManager:
             # Skip thinking messages (messages with metadata)
             if not (message.get("role") == "assistant" and "metadata" in message):
                 role = "model"
-                parts = [types.Part.from_text(text=message.get("content", ""))]
                 match message.get("role"):
                     case "user":
                         role = "user"
+                        if isinstance(message["content"], tuple):
+                            path = message["content"][0]
+                            try:
+                                image_bytes = open(path, "rb").read()
+                                parts = [
+                                    types.Part.from_bytes(
+                                        data=image_bytes,
+                                        mime_type="image/png",
+                                    ),
+                                ]
+                            except Exception as e:
+                                logger.error(f"Error uploading file: {e}")
+                                parts = [types.Part.from_text(
+                                    text="Error uploading file: "+str(e))]
+                            formatted_history.append(
+                                types.Content(
+                                    role=role,
+                                    parts=parts
+                                ))
+                            continue
+                        else:
+                            parts = [types.Part.from_text(
+                                text=message.get("content", ""))]
                     case "memories":
-                        role = "user"
-                        parts = [types.Part.from_text(text="Relevant memories: "+message.get("content", ""))]
+                        role = "model"
+                        parts = [types.Part.from_text(
+                            text="Relevant memories: "+message.get("content", ""))]
                     case "tool":
                         role = "tool"
                         formatted_history.append(
@@ -150,6 +208,8 @@ class GeminiManager:
                         continue
                     case _:
                         role = "model"
+                        parts = [types.Part.from_text(
+                            text=message.get("content", ""))]
                 formatted_history.append(types.Content(
                     role=role,
                     parts=parts
@@ -164,35 +224,46 @@ class GeminiManager:
             return []
         top_k = min(k, len(memories))
         # Semantic Retrieval with GPU
-        device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        print(f"Using device: {device}")
+        if torch.cuda.is_available():
+            device = 'cuda'
+        elif torch.backends.mps.is_available() and torch.backends.mps.is_built():
+            device = 'mps'
+        else:
+            device = 'cpu'
         model = SentenceTransformer('all-MiniLM-L6-v2', device=device)
-        doc_embeddings = model.encode(memories, convert_to_tensor=True, device=device)
-        query_embedding = model.encode(query, convert_to_tensor=True, device=device)
-        similarity_scores = model.similarity(query_embedding, doc_embeddings)[0]
+        doc_embeddings = model.encode(
+            memories, convert_to_tensor=True, device=device)
+        query_embedding = model.encode(
+            query, convert_to_tensor=True, device=device)
+        similarity_scores = model.similarity(
+            query_embedding, doc_embeddings)[0]
         scores, indices = torch.topk(similarity_scores, k=top_k)
         results = []
         for score, idx in zip(scores, indices):
-            print(memories[idx], f"(Score: {score:.4f})")
             if score >= threshold:
                 results.append(memories[idx])
         return results
-    
+
     def run(self, messages):
-        memories = self.get_k_memories(messages[-1]['content'], k=5, threshold=0.1)
-        if len(memories) > 0:
-            messages.append({
-                "role": "memories",
-                "content": f"{memories}",
-            })
-            messages.append({
-                "role": "assistant",
-                "content": f"Memories: {memories}",
-                "metadata": {"title": "Memories"}
-            })
-            yield messages
+        try:
+            if self.check_mode(Mode.ENABLE_MEMORY) and len(messages) > 0:
+                memories = self.get_k_memories(
+                    messages[-1]['content'], k=5, threshold=0.1)
+                if len(memories) > 0:
+                    messages.append({
+                        "role": "memories",
+                        "content": f"{memories}",
+                    })
+                    messages.append({
+                        "role": "assistant",
+                        "content": f"Memories: {memories}",
+                        "metadata": {"title": "Memories"}
+                    })
+                    yield messages
+        except Exception as e:
+            pass
         yield from self.invoke_manager(messages)
-    
+
     def invoke_manager(self, messages):
         chat_history = self.format_chat_history(messages)
         logger.debug(f"Chat history: {chat_history}")
@@ -201,11 +272,12 @@ class GeminiManager:
         except Exception as e:
             messages.append({
                 "role": "assistant",
-                "content": f"Error generating response: {e}"
+                "content": f"Error generating response: {str(e)}",
+                "metadata": {"title": "Error generating response"}
             })
-            logger.error(f"Error generating response", e)
+            logger.error(f"Error generating response{e}")
             yield messages
-            return
+            return messages
         logger.debug(f"Response: {response}")
 
         if (not response.text and not response.function_calls):
@@ -214,6 +286,8 @@ class GeminiManager:
                 "content": "No response from the model.",
                 "metadata": {"title": "No response from the model."}
             })
+            yield messages
+            return messages
 
         # Attach the llm response to the messages
         if response.text is not None and response.text != "":
@@ -235,9 +309,8 @@ class GeminiManager:
         if response.function_calls:
             for call in self.handle_tool_calls(response):
                 yield messages + [call]
-                if (call.get("role") == "tool" 
-                    or (call.get("role") == "assistant" and call.get("metadata", {}).get("status") == "done")):
+                if (call.get("role") == "tool"
+                        or (call.get("role") == "assistant" and call.get("metadata", {}).get("status") == "done")):
                     messages.append(call)
             yield from self.invoke_manager(messages)
-            return
         yield messages

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)
@@ -52,11 +55,30 @@ class Tool:
 class ToolManager:
     toolsImported: List[Tool] = []
     budget_manager: BudgetManager = BudgetManager()
+    is_creation_enabled: bool = True
+    is_invocation_enabled: bool = True
 
     def __init__(self):
         self.load_tools()
-
-        output_assistant_response(f"Budget Remaining: {self.budget_manager.get_current_remaining_budget()}")
+        self._output_budgets()
+    
+    def set_creation_mode(self, status: bool):
+        self.is_creation_enabled = status
+        if status:
+            output_assistant_response("Tool creation mode is enabled.")
+        else:
+            output_assistant_response("Tool creation mode is disabled.")
+    
+    def set_invocation_mode(self, status: bool):
+        self.is_invocation_enabled = status
+        if status:
+            output_assistant_response("Tool invocation mode is enabled.")
+        else:
+            output_assistant_response("Tool invocation mode is disabled.")
+    
+    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_expense_budget()}")
 
     def load_tools(self):
         newToolsImported = []
@@ -71,18 +93,28 @@ 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()}")
+        if not self.is_invocation_enabled:
+            raise Exception("Tool invocation mode is disabled")
+        if toolName == "ToolCreator":
+            if not self.is_creation_enabled:
+                raise Exception("Tool creation mode is disabled")
+        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 +151,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,51 +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.
+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>  
-**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.  
+<Info>
+**Core Mechanisms: Tools and Agents**
 
-**Tool Creation & Reuse**
+* **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 and require you to invoke tools and provide them with the necessary information.
 
-* 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:
+**Tool Management: Creation and Reuse**
 
-  * 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.
+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 & Reuse**
+**Agent Lifecycle Management: Reuse, Creation, and Retirement**
 
-* Always start with `GetAgents` to discover available agents.
-* 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.
+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.
 
-**Budget & Cost**
+**Handling Ambiguity and User Interaction**
 
-* Start with 100 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.
+* 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.
 
-**Memory**
+**Budget and Cost Management: Resource vs. Expense Costs**
 
-* **Immediately** record any user preference, personal context, or error-resolution detail via `MemoryManager.add_memory` before proceeding with subtasks.
-* Confirm and delete obsolete memories via `MemoryManager.delete_memory` (always validate the index first).
-* Only store memories that are relevant to the current conversation or future interactions.
-</Info>
+You operate under two distinct budget categories:
 
-Here’s what you must do:
+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.
 
-* 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 or context, call `MemoryManager.add_memory` to store it**.
-* 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, consolidate their outputs into a concise, clear final answer—this is the only time you present information directly to the user.
+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,58 @@ class AgentCostManager():
     costs = {
         "llama3.2": {
             "description": "3 Billion parameter model",
-            "create_cost": 10,
-            "invoke_cost": 10,
+            "create_resource_cost": 50,
+            "invoke_resource_cost": 30,
         },
         "mistral": {
             "description": "7 Billion parameter model",
-            "create_cost": 20,
-            "invoke_cost": 50,
+            "create_resource_cost": 75,
+            "invoke_resource_cost": 40,
+        },
+        "deepseek-r1": {
+            "description": "7 Billion reasoning model",
+            "create_resource_cost": 28,
+            "invoke_resource_cost": 35,
         },
         "gemini-2.5-flash-preview-04-17": {
             "description": "Adaptive thinking, cost efficiency",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 0.005,
+            "invoke_expense_cost": 0.00017
         },
         "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": 0.005,
+            "invoke_expense_cost": 0.0001275
         },
         "gemini-2.0-flash": {
             "description": "Next generation features, speed, thinking, realtime streaming, and multimodal generation",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 0.005,
+            "invoke_expense_cost": 0.00017
         },
         "gemini-2.0-flash-lite": {
             "description": "Cost efficiency and low latency",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 0.005,
+            "invoke_expense_cost": 0.00017
         },
         "gemini-1.5-flash": {
             "description": "Fast and versatile performance across a diverse variety of tasks",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 0.005,
+            "invoke_expense_cost": 0.00017
         },
         "gemini-1.5-flash-8b": {
             "description": "High volume and lower intelligence tasks",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 0.005,
+            "invoke_expense_cost": 0.00017
         },
         "gemini-1.5-pro": {
             "description": "Complex reasoning tasks requiring more intelligence",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 0.005,
+            "invoke_expense_cost": 0.0001275
         },
         "gemini-2.0-flash-live-001": {
             "description": "Low-latency bidirectional voice and video interactions",
-            "create_cost": 20,
-            "invoke_cost": 50
+            "create_expense_cost": 0.005,
+            "invoke_expense_cost": 0.000635
         }
     }
 

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/google_search_tool.py

@@ -8,7 +8,7 @@ class GoogleSearchTool():
 
     inputSchema = {
         "name": "GoogleSearchTool",
-        "description": "Provides a list of URLs from google search results based on a query string.",
+        "description": "Provides a list of URLs from google search results based on a query string. Use the urls then to get the content of the page.",
         "parameters": {
             "type": "object",
             "properties": {

src/tools/default_tools/memory_manager.py

@@ -2,6 +2,7 @@
 __all__ = ['MemoryManager']
 
 import json
+import os
 
 
 class MemoryManager():
@@ -9,7 +10,7 @@ class MemoryManager():
 
     inputSchema = {
         "name": "MemoryManager",
-        "description": "Updates, retrieves, or deletes the memory of an AI agent.",
+        "description": "Updates, retrieves, or deletes the memory for a user. Only store important information such as user preferences, error solutions, and other information that can help you improve your performance.",
         "parameters": {
             "type": "object",
             "properties":{
@@ -43,11 +44,13 @@ class MemoryManager():
         return memory_list
 
     def update_memories(self, memories):
-        # save the memory to src/data/memory.json
+        os.makedirs("src/data", exist_ok=True)
+            # Save the memory to src/data/memory.json
         with open("src/data/memory.json", "w") as f:
             json.dump(memories, f, indent=4)
 
 
+
     def run(self, **kwargs):
         # save it to src/data/memory.json
         action = kwargs.get("action")

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/default_tools/tool_deletor.py

@@ -33,7 +33,7 @@ class ToolDeletor():
         if not file_path.startswith("src/tools/user_tools/"):
             return {
                 "status": "error",
-                "message": "File path must start with tools/",
+                "message": "File path must start with src/tools/user_tools/",
                 "output": None
             }
         os = importlib.import_module("os")

src/tools/user_tools/get_website_tool.py

@@ -1,4 +1,7 @@
 import importlib
+from collections import defaultdict
+import re
+import time
 
 __all__ = ['GetWebsiteTool']
 
@@ -8,7 +11,7 @@ class GetWebsiteTool():
 
     inputSchema = {
         "name": "GetWebsiteTool",
-        "description": "Returns the content of a website based on a query string.",
+        "description": "Returns a summary of the content of a website based on a query string.",
         "parameters": {
             "type": "object",
             "properties": {
@@ -21,6 +24,57 @@ class GetWebsiteTool():
         }
     }
 
+    def summarize_text(self, text):
+        # Clean the text more thoroughly
+        text = re.sub(r'\[[0-9]*\]', ' ', text)
+        text = re.sub(r'\s+', ' ', text)
+        text = re.sub(r'[^a-zA-Z0-9.\s]', '', text) # Remove special characters except periods
+
+        # Tokenize into sentences
+        sentences = re.split(r'(?<=[.!?])\s+', text)
+        sentences = [s.strip() for s in sentences if s]
+
+        # Calculate word frequencies
+        word_frequencies = defaultdict(int)
+        for sentence in sentences:
+            words = sentence.lower().split()
+            for word in words:
+                word_frequencies[word] += 1
+
+        # Normalize word frequencies
+        total_words = sum(word_frequencies.values())
+        if total_words > 0:
+            for word in word_frequencies:
+                word_frequencies[word] /= total_words
+
+        # Calculate sentence scores based on word frequencies, sentence length, and coherence
+        sentence_scores = {}
+        for i, sentence in enumerate(sentences):
+            score = 0
+            words = sentence.lower().split()
+            for word in words:
+                score += word_frequencies[word]
+
+            # Consider sentence length
+            sentence_length_factor = 1 - abs(len(words) - 15) / 15  # Prefer sentences around 15 words
+            score += sentence_length_factor * 0.1
+
+            # Add a coherence score
+            if i > 0 and sentences[i-1] in sentence_scores:
+                previous_sentence_words = sentences[i-1].lower().split()
+                common_words = set(words) & set(previous_sentence_words)
+                coherence_score = len(common_words) / len(words)
+                score += coherence_score * 0.1
+
+            sentence_scores[sentence] = score
+
+        # Get the top 3 sentences with the highest scores
+        ranked_sentences = sorted(sentence_scores, key=sentence_scores.get, reverse=True)[:3]
+
+        # Generate the summary
+        summary = ". ".join(ranked_sentences) + "."
+        return summary
+
     def run(self, **kwargs):
         headers = {
             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0',
@@ -46,7 +100,7 @@ class GetWebsiteTool():
                 "message": "Missing required parameters: 'url'",
                 "output": None
             }
-        
+
         output = None
         requests = importlib.import_module("requests")
         bs4 = importlib.import_module("bs4")
@@ -57,17 +111,16 @@ class GetWebsiteTool():
                 # Parse the content using BeautifulSoup
                 soup = BeautifulSoup(response.content, 'html.parser')
                 # Extract text from the parsed HTML
-                output = soup.get_text()
+                text = soup.get_text()
+
+                # Summarize the text
+                output = self.summarize_text(text)
             else:
                 return {
                     "status": "error",
                     "message": f"Failed to fetch content from {url}. Status code: {response.status_code}",
                     "output": None
                 }
-            
-            # truncate the results to avoid excessive output
-            if len(output) > 1000:
-                output = output[:1000] + "... (truncated)"
 
             return {
                 "status": "success",

src/tools/user_tools/python_sandbox_tool.py

@@ -0,0 +1,74 @@
+
+import subprocess
+import sys
+import os
+import tempfile
+
+__all__ = ['PythonSandboxTool']
+
+class PythonSandboxTool():
+    dependencies = []
+
+    inputSchema = {
+        "name": "PythonSandboxTool",
+        "description": "Executes Python code in a sandbox environment.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "code": {
+                    "type": "string",
+                    "description": "The Python code to execute."
+                }
+            },
+            "required": ["code"]
+        }
+    }
+
+    def run(self, **kwargs):
+        code = kwargs.get("code")
+        if not code:
+            return {"status": "error", "message": "Missing required parameter: 'code'", "output": None}
+
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a temporary file inside the directory
+            with tempfile.NamedTemporaryFile(suffix='.py', mode='w', delete=False, dir=tmpdir) as temp_file:
+                temp_file.write(code)
+                temp_file_name = temp_file.name
+
+            # Construct the command to execute the Python code
+            command = [sys.executable, temp_file_name]
+
+            try:
+                # Execute the command in a subprocess
+                process = subprocess.run(
+                    command,
+                    capture_output=True,
+                    text=True,
+                    timeout=10,  # Timeout after 10 seconds
+                    check=False  # Do not raise an exception on non-zero exit code
+                )
+
+                # Get the output and error messages
+                stdout = process.stdout
+                stderr = process.stderr
+
+                # Check the return code
+                return_code = process.returncode
+
+                # Prepare the result
+                result = {
+                    "stdout": stdout,
+                    "stderr": stderr,
+                    "return_code": return_code
+                }
+
+                # Return the result
+                return {"status": "success", "message": "Python code executed successfully.", "output": result}
+
+            except subprocess.TimeoutExpired:
+                return {"status": "error", "message": "Python code execution timed out.", "output": None}
+            except Exception as e:
+                return {"status": "error", "message": f"Python code execution failed: {str(e)}", "output": None}
+
+

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):