agno 2.2.10__py3-none-any.whl → 2.2.11__py3-none-any.whl

agno/os/routers/health.py

@@ -5,13 +5,13 @@ from fastapi import APIRouter
 from agno.os.schema import HealthResponse
 
 
-def get_health_router() -> APIRouter:
+def get_health_router(health_endpoint: str = "/health") -> APIRouter:
     router = APIRouter(tags=["Health"])
 
     started_time_stamp = datetime.now(timezone.utc).timestamp()
 
     @router.get(
-        "/health",
+        health_endpoint,
         operation_id="health_check",
         summary="Health Check",
         description="Check the health status of the AgentOS API. Returns a simple status indicator.",
@@ -19,7 +19,9 @@ def get_health_router() -> APIRouter:
         responses={
             200: {
                 "description": "API is healthy and operational",
-                "content": {"application/json": {"example": {"status": "ok", "instantiated_at": "1760169236.778903"}}},
+                "content": {
+                    "application/json": {"example": {"status": "ok", "instantiated_at": str(started_time_stamp)}}
+                },
             }
         },
     )

agno/os/routers/knowledge/knowledge.py

@@ -102,6 +102,8 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         text_content: Optional[str] = Form(None, description="Raw text content to process"),
         reader_id: Optional[str] = Form(None, description="ID of the reader to use for content processing"),
         chunker: Optional[str] = Form(None, description="Chunking strategy to apply during processing"),
+        chunk_size: Optional[int] = Form(None, description="Chunk size to use for processing"),
+        chunk_overlap: Optional[int] = Form(None, description="Chunk overlap to use for processing"),
         db_id: Optional[str] = Query(default=None, description="Database ID to use for content storage"),
     ):
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
@@ -172,7 +174,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         content.content_hash = content_hash
         content.id = generate_id(content_hash)
 
-        background_tasks.add_task(process_content, knowledge, content, reader_id, chunker)
+        background_tasks.add_task(process_content, knowledge, content, reader_id, chunker, chunk_size, chunk_overlap)
 
         response = ContentResponseSchema(
             id=content.id,
@@ -801,36 +803,55 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
                                     "key": "AgenticChunker",
                                     "name": "AgenticChunker",
                                     "description": "Chunking strategy that uses an LLM to determine natural breakpoints in the text",
+                                    "metadata": {"chunk_size": 5000},
                                 },
                                 "DocumentChunker": {
                                     "key": "DocumentChunker",
                                     "name": "DocumentChunker",
                                     "description": "A chunking strategy that splits text based on document structure like paragraphs and sections",
-                                },
-                                "RecursiveChunker": {
-                                    "key": "RecursiveChunker",
-                                    "name": "RecursiveChunker",
-                                    "description": "Chunking strategy that recursively splits text into chunks by finding natural break points",
-                                },
-                                "SemanticChunker": {
-                                    "key": "SemanticChunker",
-                                    "name": "SemanticChunker",
-                                    "description": "Chunking strategy that splits text into semantic chunks using chonkie",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
                                 },
                                 "FixedSizeChunker": {
                                     "key": "FixedSizeChunker",
                                     "name": "FixedSizeChunker",
                                     "description": "Chunking strategy that splits text into fixed-size chunks with optional overlap",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
+                                },
+                                "MarkdownChunker": {
+                                    "key": "MarkdownChunker",
+                                    "name": "MarkdownChunker",
+                                    "description": "A chunking strategy that splits markdown based on structure like headers, paragraphs and sections",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
+                                },
+                                "RecursiveChunker": {
+                                    "key": "RecursiveChunker",
+                                    "name": "RecursiveChunker",
+                                    "description": "Chunking strategy that recursively splits text into chunks by finding natural break points",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
                                 },
                                 "RowChunker": {
                                     "key": "RowChunker",
                                     "name": "RowChunker",
                                     "description": "RowChunking chunking strategy",
+                                    "metadata": {},
                                 },
-                                "MarkdownChunker": {
-                                    "key": "MarkdownChunker",
-                                    "name": "MarkdownChunker",
-                                    "description": "A chunking strategy that splits markdown based on structure like headers, paragraphs and sections",
+                                "SemanticChunker": {
+                                    "key": "SemanticChunker",
+                                    "name": "SemanticChunker",
+                                    "description": "Chunking strategy that splits text into semantic chunks using chonkie",
+                                    "metadata": {"chunk_size": 5000},
                                 },
                             },
                             "vector_dbs": [
@@ -896,7 +917,10 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             chunker_key = chunker_info.get("key")
             if chunker_key:
                 chunkers_dict[chunker_key] = ChunkerSchema(
-                    key=chunker_key, name=chunker_info.get("name"), description=chunker_info.get("description")
+                    key=chunker_key,
+                    name=chunker_info.get("name"),
+                    description=chunker_info.get("description"),
+                    metadata=chunker_info.get("metadata", {}),
                 )
 
         vector_dbs = []
@@ -929,6 +953,8 @@ async def process_content(
     content: Content,
     reader_id: Optional[str] = None,
     chunker: Optional[str] = None,
+    chunk_size: Optional[int] = None,
+    chunk_overlap: Optional[int] = None,
 ):
     """Background task to process the content"""
 
@@ -951,7 +977,7 @@ async def process_content(
                 content.reader = reader
         if chunker and content.reader:
             # Set the chunker name on the reader - let the reader handle it internally
-            content.reader.set_chunking_strategy_from_string(chunker)
+            content.reader.set_chunking_strategy_from_string(chunker, chunk_size=chunk_size, overlap=chunk_overlap)
             log_debug(f"Set chunking strategy: {chunker}")
 
         log_debug(f"Using reader: {content.reader.__class__.__name__}")

agno/os/routers/knowledge/schemas.py

@@ -106,9 +106,10 @@ class ReaderSchema(BaseModel):
 
 
 class ChunkerSchema(BaseModel):
-    key: str = Field(..., description="Unique key for the chunker")
-    name: Optional[str] = Field(None, description="Name of the chunker")
-    description: Optional[str] = Field(None, description="Description of the chunking strategy")
+    key: str
+    name: Optional[str] = None
+    description: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
 
 
 class VectorDbSchema(BaseModel):

agno/run/agent.py

@@ -696,7 +696,17 @@ class RunOutput:
             data = data.pop("run")
 
         events = data.pop("events", None)
-        events = [run_output_event_from_dict(event) for event in events] if events else None
+        final_events = []
+        for event in events or []:
+            if "agent_id" in event:
+                event = run_output_event_from_dict(event)
+            else:
+                # Use the factory from response.py for agent events
+                from agno.run.team import team_run_output_event_from_dict
+
+                event = team_run_output_event_from_dict(event)
+            final_events.append(event)
+        events = final_events
 
         messages = data.pop("messages", None)
         messages = [Message.from_dict(message) for message in messages] if messages else None

agno/team/team.py

@@ -4271,7 +4271,7 @@ class Team:
         """Calculate session metrics"""
 
         session_messages: List[Message] = []
-        for run in session.runs:  # type: ignore
+        for run in session.runs or []:
             if run.messages is not None:
                 for m in run.messages:
                     # Skipping messages from history to avoid duplicates
@@ -7519,6 +7519,9 @@ class Team:
             session = self.db.get_session(session_id=session_id, session_type=session_type)
             return session  # type: ignore
         except Exception as e:
+            import traceback
+
+            traceback.print_exc(limit=3)
             log_warning(f"Error getting session from db: {e}")
             return None
 
@@ -7533,6 +7536,9 @@ class Team:
             session = await self.db.get_session(session_id=session_id, session_type=session_type)
             return session  # type: ignore
         except Exception as e:
+            import traceback
+
+            traceback.print_exc(limit=3)
             log_warning(f"Error getting session from db: {e}")
             return None
 
@@ -7544,6 +7550,9 @@ class Team:
                 raise ValueError("Db not initialized")
             return self.db.upsert_session(session=session)  # type: ignore
         except Exception as e:
+            import traceback
+
+            traceback.print_exc(limit=3)
             log_warning(f"Error upserting session into db: {e}")
         return None
 
@@ -7555,6 +7564,9 @@ class Team:
                 raise ValueError("Db not initialized")
             return await self.db.upsert_session(session=session)  # type: ignore
         except Exception as e:
+            import traceback
+
+            traceback.print_exc(limit=3)
             log_warning(f"Error upserting session into db: {e}")
         return None
 

agno/tools/file_generation.py

@@ -116,7 +116,7 @@ class FileGenerationTools(Toolkit):
                 file_type="json",
                 filename=filename,
                 size=len(json_content.encode("utf-8")),
-                url=f"file://{file_path}" if file_path else None,
+                filepath=file_path if file_path else None,
             )
 
             log_debug("JSON file generated successfully")
@@ -203,7 +203,7 @@ class FileGenerationTools(Toolkit):
                 file_type="csv",
                 filename=filename,
                 size=len(csv_content.encode("utf-8")),
-                url=f"file://{file_path}" if file_path else None,
+                filepath=file_path if file_path else None,
             )
 
             log_debug("CSV file generated successfully")
@@ -287,7 +287,7 @@ class FileGenerationTools(Toolkit):
                 file_type="pdf",
                 filename=filename,
                 size=len(pdf_content),
-                url=f"file://{file_path}" if file_path else None,
+                filepath=file_path if file_path else None,
             )
 
             log_debug("PDF file generated successfully")
@@ -333,7 +333,7 @@ class FileGenerationTools(Toolkit):
                 file_type="txt",
                 filename=filename,
                 size=len(content.encode("utf-8")),
-                url=f"file://{file_path}" if file_path else None,
+                filepath=file_path if file_path else None,
             )
 
             log_debug("Text file generated successfully")

agno/tools/gmail.py

@@ -141,6 +141,11 @@ class GmailTools(Toolkit):
             self.create_draft_email,
             self.send_email,
             self.send_email_reply,
+            # Label management
+            self.list_custom_labels,
+            self.apply_label,
+            self.remove_label,
+            self.delete_custom_label,
         ]
 
         super().__init__(name="gmail_tools", tools=tools, **kwargs)
@@ -161,6 +166,7 @@ class GmailTools(Toolkit):
             "get_emails_by_date",
             "get_emails_by_thread",
             "search_emails",
+            "list_custom_labels",
         ]
         modify_operations = ["mark_email_as_read", "mark_email_as_unread"]
         if any(read_operation in self.functions for read_operation in read_operations):
@@ -600,6 +606,179 @@ class GmailTools(Toolkit):
         except Exception as error:
             return f"Error marking email {message_id} as unread: {type(error).__name__}: {error}"
 
+    @authenticate
+    def list_custom_labels(self) -> str:
+        """
+        List only user-created custom labels (filters out system labels) in a numbered format.
+
+        Returns:
+            str: A numbered list of custom labels only
+        """
+        try:
+            results = self.service.users().labels().list(userId="me").execute()  # type: ignore
+            labels = results.get("labels", [])
+
+            # Filter out only user-created labels
+            custom_labels = [label["name"] for label in labels if label.get("type") == "user"]
+
+            if not custom_labels:
+                return "No custom labels found.\nCreate labels using apply_label function!"
+
+            # Create numbered list
+            numbered_labels = [f"{i}. {name}" for i, name in enumerate(custom_labels, 1)]
+            return f"Your Custom Labels ({len(custom_labels)} total):\n\n" + "\n".join(numbered_labels)
+
+        except HttpError as e:
+            return f"Error fetching labels: {e}"
+        except Exception as e:
+            return f"Unexpected error: {type(e).__name__}: {e}"
+
+    @authenticate
+    def apply_label(self, context: str, label_name: str, count: int = 10) -> str:
+        """
+        Find emails matching a context (search query) and apply a label, creating it if necessary.
+
+        Args:
+            context (str): Gmail search query (e.g., 'is:unread category:promotions')
+            label_name (str): Name of the label to apply
+            count (int): Maximum number of emails to process
+        Returns:
+            str: Summary of labeled emails
+        """
+        try:
+            # Fetch messages matching context
+            results = self.service.users().messages().list(userId="me", q=context, maxResults=count).execute()  # type: ignore
+
+            messages = results.get("messages", [])
+            if not messages:
+                return f"No emails found matching: '{context}'"
+
+            # Check if label exists, create if not
+            labels = self.service.users().labels().list(userId="me").execute().get("labels", [])  # type: ignore
+            label_id = None
+            for label in labels:
+                if label["name"].lower() == label_name.lower():
+                    label_id = label["id"]
+                    break
+
+            if not label_id:
+                label = (
+                    self.service.users()  # type: ignore
+                    .labels()
+                    .create(
+                        userId="me",
+                        body={"name": label_name, "labelListVisibility": "labelShow", "messageListVisibility": "show"},
+                    )
+                    .execute()
+                )
+                label_id = label["id"]
+
+            # Apply label to all matching messages
+            for msg in messages:
+                self.service.users().messages().modify(  # type: ignore
+                    userId="me", id=msg["id"], body={"addLabelIds": [label_id]}
+                ).execute()  # type: ignore
+
+            return f"Applied label '{label_name}' to {len(messages)} emails matching '{context}'."
+
+        except HttpError as e:
+            return f"Error applying label '{label_name}': {e}"
+        except Exception as e:
+            return f"Unexpected error: {type(e).__name__}: {e}"
+
+    @authenticate
+    def remove_label(self, context: str, label_name: str, count: int = 10) -> str:
+        """
+        Remove a label from emails matching a context (search query).
+
+        Args:
+            context (str): Gmail search query (e.g., 'is:unread category:promotions')
+            label_name (str): Name of the label to remove
+            count (int): Maximum number of emails to process
+        Returns:
+            str: Summary of emails with label removed
+        """
+        try:
+            # Get all labels to find the target label
+            labels = self.service.users().labels().list(userId="me").execute().get("labels", [])  # type: ignore
+            label_id = None
+
+            for label in labels:
+                if label["name"].lower() == label_name.lower():
+                    label_id = label["id"]
+                    break
+
+            if not label_id:
+                return f"Label '{label_name}' not found."
+
+            # Fetch messages matching context that have this label
+            results = (
+                self.service.users()  # type: ignore
+                .messages()
+                .list(userId="me", q=f"{context} label:{label_name}", maxResults=count)
+                .execute()
+            )
+
+            messages = results.get("messages", [])
+            if not messages:
+                return f"No emails found matching: '{context}' with label '{label_name}'"
+
+            # Remove label from all matching messages
+            removed_count = 0
+            for msg in messages:
+                self.service.users().messages().modify(  # type: ignore
+                    userId="me", id=msg["id"], body={"removeLabelIds": [label_id]}
+                ).execute()  # type: ignore
+                removed_count += 1
+
+            return f"Removed label '{label_name}' from {removed_count} emails matching '{context}'."
+
+        except HttpError as e:
+            return f"Error removing label '{label_name}': {e}"
+        except Exception as e:
+            return f"Unexpected error: {type(e).__name__}: {e}"
+
+    @authenticate
+    def delete_custom_label(self, label_name: str, confirm: bool = False) -> str:
+        """
+        Delete a custom label (with safety confirmation).
+
+        Args:
+            label_name (str): Name of the label to delete
+            confirm (bool): Must be True to actually delete the label
+        Returns:
+            str: Confirmation message or warning
+        """
+        if not confirm:
+            return f"LABEL DELETION REQUIRES CONFIRMATION. This will permanently delete the label '{label_name}' from all emails. Set confirm=True to proceed."
+
+        try:
+            # Get all labels to find the target label
+            labels = self.service.users().labels().list(userId="me").execute().get("labels", [])  # type: ignore
+            target_label = None
+
+            for label in labels:
+                if label["name"].lower() == label_name.lower():
+                    target_label = label
+                    break
+
+            if not target_label:
+                return f"Label '{label_name}' not found."
+
+            # Check if it's a system label using the type field
+            if target_label.get("type") != "user":
+                return f"Cannot delete system label '{label_name}'. Only user-created labels can be deleted."
+
+            # Delete the label
+            self.service.users().labels().delete(userId="me", id=target_label["id"]).execute()  # type: ignore
+
+            return f"Successfully deleted label '{label_name}'. This label has been removed from all emails."
+
+        except HttpError as e:
+            return f"Error deleting label '{label_name}': {e}"
+        except Exception as e:
+            return f"Unexpected error: {type(e).__name__}: {e}"
+
     def _validate_email_params(self, to: str, subject: str, body: str) -> None:
         """Validate email parameters."""
         if not to: