agno 2.3.2__py3-none-any.whl → 2.3.4__py3-none-any.whl

agno/compression/__init__.py

@@ -0,0 +1,3 @@
+from agno.compression.manager import CompressionManager
+
+__all__ = ["CompressionManager"]

agno/compression/manager.py

@@ -0,0 +1,176 @@
+import asyncio
+from dataclasses import dataclass, field
+from textwrap import dedent
+from typing import Any, Dict, List, Optional
+
+from agno.models.base import Model
+from agno.models.message import Message
+from agno.models.utils import get_model
+from agno.utils.log import log_error, log_info, log_warning
+
+DEFAULT_COMPRESSION_PROMPT = dedent("""\
+    You are compressing tool call results to save context space while preserving critical information.
+    
+    Your goal: Extract only the essential information from the tool output.
+    
+    ALWAYS PRESERVE:
+    • Specific facts: numbers, statistics, amounts, prices, quantities, metrics
+    • Temporal data: dates, times, timestamps (use short format: "Oct 21 2025")
+    • Entities: people, companies, products, locations, organizations
+    • Identifiers: URLs, IDs, codes, technical identifiers, versions
+    • Key quotes, citations, sources (if relevant to agent's task)
+    
+    COMPRESS TO ESSENTIALS:
+    • Descriptions: keep only key attributes
+    • Explanations: distill to core insight
+    • Lists: focus on most relevant items based on agent context
+    • Background: minimal context only if critical
+    
+    REMOVE ENTIRELY:
+    • Introductions, conclusions, transitions
+    • Hedging language ("might", "possibly", "appears to")
+    • Meta-commentary ("According to", "The results show")
+    • Formatting artifacts (markdown, HTML, JSON structure)
+    • Redundant or repetitive information
+    • Generic background not relevant to agent's task
+    • Promotional language, filler words
+    
+    EXAMPLE:
+    Input: "According to recent market analysis and industry reports, OpenAI has made several significant announcements in the technology sector. The company revealed ChatGPT Atlas on October 21, 2025, which represents a new AI-powered browser application that has been specifically designed for macOS users. This browser is strategically positioned to compete with traditional search engines in the market. Additionally, on October 6, 2025, OpenAI launched Apps in ChatGPT, which includes a comprehensive software development kit (SDK) for developers. The company has also announced several initial strategic partners who will be integrating with this new feature, including well-known companies such as Spotify, the popular music streaming service, Zillow, which is a real estate marketplace platform, and Canva, a graphic design platform."
+    
+    Output: "OpenAI - Oct 21 2025: ChatGPT Atlas (AI browser, macOS, search competitor); Oct 6 2025: Apps in ChatGPT + SDK; Partners: Spotify, Zillow, Canva"
+    
+    Be concise while retaining all critical facts.
+    """)
+
+
+@dataclass
+class CompressionManager:
+    model: Optional[Model] = None
+    compress_tool_results: bool = True
+    compress_tool_results_limit: int = 3
+    compress_tool_call_instructions: Optional[str] = None
+
+    stats: Dict[str, Any] = field(default_factory=dict)
+
+    def _is_tool_result_message(self, msg: Message) -> bool:
+        return msg.role == "tool"
+
+    def should_compress(self, messages: List[Message]) -> bool:
+        if not self.compress_tool_results:
+            return False
+
+        uncompressed_tools_count = len(
+            [m for m in messages if self._is_tool_result_message(m) and m.compressed_content is None]
+        )
+        should_compress = uncompressed_tools_count >= self.compress_tool_results_limit
+
+        if should_compress:
+            log_info(f"Tool call compression threshold hit. Compressing {uncompressed_tools_count} tool results")
+
+        return should_compress
+
+    def _compress_tool_result(self, tool_result: Message) -> Optional[str]:
+        if not tool_result:
+            return None
+
+        tool_content = f"Tool: {tool_result.tool_name or 'unknown'}\n{tool_result.content}"
+
+        self.model = get_model(self.model)
+        if not self.model:
+            log_warning("No compression model available")
+            return None
+
+        compression_prompt = self.compress_tool_call_instructions or DEFAULT_COMPRESSION_PROMPT
+        compression_message = "Tool Results to Compress: " + tool_content + "\n"
+
+        try:
+            response = self.model.response(
+                messages=[
+                    Message(role="system", content=compression_prompt),
+                    Message(role="user", content=compression_message),
+                ]
+            )
+            return response.content
+        except Exception as e:
+            log_error(f"Error compressing tool result: {e}")
+            return tool_content
+
+    def compress(self, messages: List[Message]) -> None:
+        """Compress uncompressed tool results"""
+        if not self.compress_tool_results:
+            return
+
+        uncompressed_tools = [msg for msg in messages if msg.role == "tool" and msg.compressed_content is None]
+
+        if not uncompressed_tools:
+            return
+
+        # Compress uncompressed tool results
+        for tool_msg in uncompressed_tools:
+            original_len = len(str(tool_msg.content)) if tool_msg.content else 0
+            compressed = self._compress_tool_result(tool_msg)
+            if compressed:
+                tool_msg.compressed_content = compressed
+                # Track stats
+                self.stats["messages_compressed"] = self.stats.get("messages_compressed", 0) + 1
+                self.stats["original_size"] = self.stats.get("original_size", 0) + original_len
+                self.stats["compressed_size"] = self.stats.get("compressed_size", 0) + len(compressed)
+            else:
+                log_warning(f"Compression failed for {tool_msg.tool_name}")
+
+    # * Async methods *#
+    async def _acompress_tool_result(self, tool_result: Message) -> Optional[str]:
+        """Async compress a single tool result"""
+        if not tool_result:
+            return None
+
+        tool_content = f"Tool: {tool_result.tool_name or 'unknown'}\n{tool_result.content}"
+
+        self.model = get_model(self.model)
+        if not self.model:
+            log_warning("No compression model available")
+            return None
+
+        compression_prompt = self.compress_tool_call_instructions or DEFAULT_COMPRESSION_PROMPT
+        compression_message = "Tool Results to Compress: " + tool_content + "\n"
+
+        try:
+            response = await self.model.aresponse(
+                messages=[
+                    Message(role="system", content=compression_prompt),
+                    Message(role="user", content=compression_message),
+                ]
+            )
+            return response.content
+        except Exception as e:
+            log_error(f"Error compressing tool result: {e}")
+            return tool_content
+
+    async def acompress(self, messages: List[Message]) -> None:
+        """Async compress uncompressed tool results"""
+        if not self.compress_tool_results:
+            return
+
+        uncompressed_tools = [msg for msg in messages if msg.role == "tool" and msg.compressed_content is None]
+
+        if not uncompressed_tools:
+            return
+
+        # Track original sizes before compression
+        original_sizes = [len(str(msg.content)) if msg.content else 0 for msg in uncompressed_tools]
+
+        # Parallel compression using asyncio.gather
+        tasks = [self._acompress_tool_result(msg) for msg in uncompressed_tools]
+        results = await asyncio.gather(*tasks)
+
+        # Apply results and track stats
+        for msg, compressed, original_len in zip(uncompressed_tools, results, original_sizes):
+            if compressed:
+                msg.compressed_content = compressed
+                # Track stats
+                self.stats["messages_compressed"] = self.stats.get("messages_compressed", 0) + 1
+                self.stats["original_size"] = self.stats.get("original_size", 0) + original_len
+                self.stats["compressed_size"] = self.stats.get("compressed_size", 0) + len(compressed)
+            else:
+                log_warning(f"Compression failed for {msg.tool_name}")

agno/db/dynamo/dynamo.py

@@ -854,6 +854,7 @@ class DynamoDb(BaseDb):
         self,
         limit: Optional[int] = None,
         page: Optional[int] = None,
+        user_id: Optional[str] = None,
     ) -> Tuple[List[Dict[str, Any]], int]:
         """Get user memories stats.
 
@@ -881,7 +882,17 @@ class DynamoDb(BaseDb):
             table_name = self._get_table("memories")
 
             # Build filter expression for user_id if provided
+            filter_expression = None
+            expression_attribute_values = {}
+            if user_id:
+                filter_expression = "user_id = :user_id"
+                expression_attribute_values[":user_id"] = {"S": user_id}
+
             scan_kwargs = {"TableName": table_name}
+            if filter_expression:
+                scan_kwargs["FilterExpression"] = filter_expression
+            if expression_attribute_values:
+                scan_kwargs["ExpressionAttributeValues"] = expression_attribute_values  # type: ignore
 
             response = self.client.scan(**scan_kwargs)
             items = response.get("Items", [])

agno/db/firestore/firestore.py

@@ -873,6 +873,7 @@ class FirestoreDb(BaseDb):
         self,
         limit: Optional[int] = None,
         page: Optional[int] = None,
+        user_id: Optional[str] = None,
     ) -> Tuple[List[Dict[str, Any]], int]:
         """Get user memories stats.
 
@@ -889,7 +890,10 @@ class FirestoreDb(BaseDb):
         try:
             collection_ref = self._get_collection(table_type="memories")
 
-            query = collection_ref.where(filter=FieldFilter("user_id", "!=", None))
+            if user_id:
+                query = collection_ref.where(filter=FieldFilter("user_id", "==", user_id))
+            else:
+                query = collection_ref.where(filter=FieldFilter("user_id", "!=", None))
 
             docs = query.stream()
 

agno/db/gcs_json/gcs_json_db.py

@@ -635,13 +635,14 @@ class GcsJsonDb(BaseDb):
             raise e
 
     def get_user_memory_stats(
-        self, limit: Optional[int] = None, page: Optional[int] = None
+        self, limit: Optional[int] = None, page: Optional[int] = None, user_id: Optional[str] = None
     ) -> Tuple[List[Dict[str, Any]], int]:
         """Get user memory statistics.
 
         Args:
             limit (Optional[int]): Maximum number of results to return.
             page (Optional[int]): Page number for pagination.
+            user_id (Optional[str]): User ID for filtering.
 
         Returns:
             Tuple[List[Dict[str, Any]], int]: List of user memory statistics and total count.
@@ -652,7 +653,9 @@ class GcsJsonDb(BaseDb):
 
             for memory in memories:
                 memory_user_id = memory.get("user_id")
-
+                # filter by user_id if provided
+                if user_id is not None and memory_user_id != user_id:
+                    continue
                 if memory_user_id:
                     if memory_user_id not in user_stats:
                         user_stats[memory_user_id] = {

agno/db/in_memory/in_memory_db.py

@@ -520,13 +520,14 @@ class InMemoryDb(BaseDb):
             raise e
 
     def get_user_memory_stats(
-        self, limit: Optional[int] = None, page: Optional[int] = None
+        self, limit: Optional[int] = None, page: Optional[int] = None, user_id: Optional[str] = None
     ) -> Tuple[List[Dict[str, Any]], int]:
         """Get user memory statistics.
 
         Args:
             limit (Optional[int]): Maximum number of stats to return.
             page (Optional[int]): Page number for pagination.
+            user_id (Optional[str]): User ID for filtering.
 
         Returns:
             Tuple[List[Dict[str, Any]], int]: List of user memory statistics and total count.
@@ -539,7 +540,9 @@ class InMemoryDb(BaseDb):
 
             for memory in self._memories:
                 memory_user_id = memory.get("user_id")
-
+                # filter by user_id if provided
+                if user_id is not None and memory_user_id != user_id:
+                    continue
                 if memory_user_id:
                     if memory_user_id not in user_stats:
                         user_stats[memory_user_id] = {

agno/db/json/json_db.py

@@ -633,13 +633,14 @@ class JsonDb(BaseDb):
             raise e
 
     def get_user_memory_stats(
-        self, limit: Optional[int] = None, page: Optional[int] = None
+        self, limit: Optional[int] = None, page: Optional[int] = None, user_id: Optional[str] = None
     ) -> Tuple[List[Dict[str, Any]], int]:
         """Get user memory statistics.
 
         Args:
             limit (Optional[int]): The maximum number of user stats to return.
             page (Optional[int]): The page number.
+            user_id (Optional[str]): User ID for filtering.
 
         Returns:
             Tuple[List[Dict[str, Any]], int]: A list of dictionaries containing user stats and total count.
@@ -650,6 +651,9 @@ class JsonDb(BaseDb):
 
             for memory in memories:
                 memory_user_id = memory.get("user_id")
+                # filter by user_id if provided
+                if user_id is not None and memory_user_id != user_id:
+                    continue
                 if memory_user_id:
                     if memory_user_id not in user_stats:
                         user_stats[memory_user_id] = {

agno/db/migrations/manager.py

@@ -23,7 +23,7 @@ class MigrationManager:
     def latest_schema_version(self) -> Version:
         return self.available_versions[-1][1]
 
-    async def up(self, target_version: Optional[str] = None, table_type: Optional[str] = None):
+    async def up(self, target_version: Optional[str] = None, table_type: Optional[str] = None, force: bool = False):
         """Handle executing an up migration.
 
         Args:
@@ -70,7 +70,7 @@ class MigrationManager:
                 continue
 
             # If the target version is less or equal to the current version, no migrations needed
-            if _target_version <= current_version:
+            if _target_version <= current_version and not force:
                 log_warning(
                     f"Skipping up migration: the version of table '{table_name}' ({current_version}) is less or equal to the target version ({_target_version})."
                 )
@@ -123,7 +123,7 @@ class MigrationManager:
             log_error(f"Error running migration to version {version}: {e}")
             raise
 
-    async def down(self, target_version: str, table_type: Optional[str] = None):
+    async def down(self, target_version: str, table_type: Optional[str] = None, force: bool = False):
         """Handle executing a down migration.
 
         Args:
@@ -156,7 +156,7 @@ class MigrationManager:
             else:
                 current_version = packaging_version.parse(self.db.get_latest_schema_version(table_name))
 
-            if _target_version >= current_version:
+            if _target_version >= current_version and not force:
                 log_warning(
                     f"Skipping down migration: the version of table '{table_name}' ({current_version}) is less or equal to the target version ({_target_version})."
                 )