Updated costs based on resource usage and actual api costs (created by HASHIRU AI)

src/manager/manager.py

@@ -140,8 +140,13 @@ class GeminiManager:
                         role = "user"
                         if isinstance(message["content"], tuple):
                             path = message["content"][0]
-                            file = self.client.files.upload(file=path)
-                            formatted_history.append(file)
+                            try:
+                                file = self.client.files.upload(file=path)
+                                formatted_history.append(file)
+                            except Exception as e:
+                                logger.error(f"Error uploading file: {e}")
+                                formatted_history.append(
+                                    types.Part.from_text(text="Error uploading file: "+str(e)))
                             continue
                         else:
                             parts = [types.Part.from_text(text=message.get("content", ""))]
@@ -197,19 +202,22 @@ class GeminiManager:
         return results
     
     def run(self, messages):
-        if self.use_memory:
-            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.use_memory:
+                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):

src/tools/default_tools/agent_cost_manager.py

@@ -16,59 +16,59 @@ class AgentCostManager():
 
     costs = {
         "llama3.2": {
-            "description": "3 Billion parameter model",
-            "create_resource_cost": 10,
-            "invoke_resource_cost": 10,
+            "description": "1 Billion parameter model",
+            "create_resource_cost": 14,
+            "invoke_resource_cost": 15,
         },
         "mistral": {
             "description": "7 Billion parameter model",
-            "create_resource_cost": 20,
-            "invoke_resource_cost": 50,
+            "create_resource_cost": 75,
+            "invoke_resource_cost": 40,
         },
         "deepseek-r1": {
             "description": "7 Billion reasoning model",
-            "create_resource_cost": 20,
-            "invoke_resource_cost": 50,
+            "create_resource_cost": 28,
+            "invoke_resource_cost": 35,
         },
         "gemini-2.5-flash-preview-04-17": {
             "description": "Adaptive thinking, cost efficiency",
-            "create_expense_cost": 20,
-            "invoke_expense_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_expense_cost": 20,
-            "invoke_expense_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_expense_cost": 20,
-            "invoke_expense_cost": 50
+            "create_expense_cost": 0.005,
+            "invoke_expense_cost": 0.00017
         },
         "gemini-2.0-flash-lite": {
             "description": "Cost efficiency and low latency",
-            "create_expense_cost": 20,
-            "invoke_expense_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_expense_cost": 20,
-            "invoke_expense_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_expense_cost": 20,
-            "invoke_expense_cost": 50
+            "create_expense_cost": 0.005,
+            "invoke_expense_cost": 0.00017
         },
         "gemini-1.5-pro": {
             "description": "Complex reasoning tasks requiring more intelligence",
-            "create_expense_cost": 20,
-            "invoke_expense_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_expense_cost": 20,
-            "invoke_expense_cost": 50
+            "create_expense_cost": 0.005,
+            "invoke_expense_cost": 0.000635
         }
     }
 

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",