agno 2.0.4__py3-none-any.whl → 2.0.5__py3-none-any.whl

agno/knowledge/knowledge.py

@@ -14,13 +14,13 @@ from httpx import AsyncClient
 
 from agno.db.base import BaseDb
 from agno.db.schemas.knowledge import KnowledgeRow
-from agno.db.utils import generate_deterministic_id
 from agno.knowledge.content import Content, ContentAuth, ContentStatus, FileData
 from agno.knowledge.document import Document
 from agno.knowledge.reader import Reader, ReaderFactory
 from agno.knowledge.remote_content.remote_content import GCSContent, RemoteContent, S3Content
 from agno.utils.http import async_fetch_with_retry
 from agno.utils.log import log_debug, log_error, log_info, log_warning
+from agno.utils.string import generate_id
 from agno.vectordb import VectorDb
 
 ContentDict = Dict[str, Union[str, Dict[str, str]]]
@@ -253,7 +253,7 @@ class Knowledge:
             auth=auth,
         )
         content.content_hash = self._build_content_hash(content)
-        content.id = generate_deterministic_id(content.content_hash)
+        content.id = generate_id(content.content_hash)
 
         await self._load_content(content, upsert, skip_if_exists, include, exclude)
 
@@ -304,7 +304,7 @@ class Knowledge:
             text_content: Optional text content to add directly
             metadata: Optional metadata dictionary
             topics: Optional list of topics
-            config: Optional cloud storage configuration
+            remote_content: Optional cloud storage configuration
             reader: Optional custom reader for processing the content
             include: Optional list of file patterns to include
             exclude: Optional list of file patterns to exclude
@@ -431,7 +431,7 @@ class Knowledge:
                     reader=content.reader,
                 )
                 file_content.content_hash = self._build_content_hash(file_content)
-                file_content.id = generate_deterministic_id(file_content.content_hash)
+                file_content.id = generate_id(file_content.content_hash)
 
                 await self._load_from_path(file_content, upsert, skip_if_exists, include, exclude)
         else:
@@ -680,7 +680,7 @@ class Knowledge:
                 topics=[topic],
             )
             content.content_hash = self._build_content_hash(content)
-            content.id = generate_deterministic_id(content.content_hash)
+            content.id = generate_id(content.content_hash)
 
             self._add_to_contents_db(content)
             if self._should_skip(content.content_hash, skip_if_exists):
@@ -777,7 +777,7 @@ class Knowledge:
 
             # 3. Hash content and add it to the contents database
             content_entry.content_hash = self._build_content_hash(content_entry)
-            content_entry.id = generate_deterministic_id(content_entry.content_hash)
+            content_entry.id = generate_id(content_entry.content_hash)
             self._add_to_contents_db(content_entry)
             if self._should_skip(content_entry.content_hash, skip_if_exists):
                 content_entry.status = ContentStatus.COMPLETED
@@ -859,7 +859,7 @@ class Knowledge:
 
             # 3. Hash content and add it to the contents database
             content_entry.content_hash = self._build_content_hash(content_entry)
-            content_entry.id = generate_deterministic_id(content_entry.content_hash)
+            content_entry.id = generate_id(content_entry.content_hash)
             self._add_to_contents_db(content_entry)
             if self._should_skip(content_entry.content_hash, skip_if_exists):
                 content_entry.status = ContentStatus.COMPLETED

agno/knowledge/reader/reader_factory.py

@@ -210,8 +210,8 @@ class ReaderFactory:
         if any(domain in url_lower for domain in ["youtube.com", "youtu.be"]):
             return cls.create_reader("youtube")
 
-        # Default to URL reader
-        return cls.create_reader("url")
+        # Default to website reader
+        return cls.create_reader("website")
 
     @classmethod
     def get_all_reader_keys(cls) -> List[str]:
@@ -228,7 +228,11 @@ class ReaderFactory:
                 reader_keys.append(reader_key)
 
         # Define priority order for URL readers
-        url_reader_priority = ["url", "website", "firecrawl", "pdf_url", "csv_url", "youtube", "web_search"]
+        url_reader_priority = [
+            "website",
+            "firecrawl",
+            "youtube",
+        ]
 
         # Sort with URL readers in priority order, others alphabetically
         def sort_key(reader_key):

agno/knowledge/reader/web_search_reader.py

@@ -96,7 +96,7 @@ class WebSearchReader(Reader):
                     results.append(
                         {
                             "title": result.get("title", ""),
-                            "url": result.get("link", ""),
+                            "url": result.get("href", ""),
                             "description": result.get("body", ""),
                         }
                     )
@@ -136,14 +136,20 @@ class WebSearchReader(Reader):
                 self._respect_rate_limits()
 
                 results = []
-                search_results = search(query, num_results=self.max_results, stop=self.max_results)
+                # Use the basic search function without unsupported parameters
+                # The googlesearch-python library's search function only accepts basic parameters
+                search_results = search(query)
 
-                for result in search_results:
+                # Convert iterator to list and limit results
+                result_list = list(search_results)[: self.max_results]
+
+                for result in result_list:
+                    # The search function returns URLs as strings
                     results.append(
                         {
-                            "title": getattr(result, "title", ""),
-                            "url": getattr(result, "url", ""),
-                            "description": getattr(result, "description", ""),
+                            "title": "",  # Google search doesn't provide titles directly
+                            "url": result,
+                            "description": "",  # Google search doesn't provide descriptions directly
                         }
                     )
 

agno/models/message.py

@@ -121,6 +121,115 @@ class Message(BaseModel):
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "Message":
+        # Handle image reconstruction properly
+        if "images" in data and data["images"]:
+            reconstructed_images = []
+            for i, img_data in enumerate(data["images"]):
+                if isinstance(img_data, dict):
+                    # If content is base64, decode it back to bytes
+                    if "content" in img_data and isinstance(img_data["content"], str):
+                        reconstructed_images.append(
+                            Image.from_base64(
+                                img_data["content"],
+                                id=img_data.get("id"),
+                                mime_type=img_data.get("mime_type"),
+                                format=img_data.get("format"),
+                            )
+                        )
+                    else:
+                        # Regular image (filepath/url)
+                        reconstructed_images.append(Image(**img_data))
+                else:
+                    reconstructed_images.append(img_data)
+            data["images"] = reconstructed_images
+
+        # Handle audio reconstruction properly
+        if "audio" in data and data["audio"]:
+            reconstructed_audio = []
+            for i, aud_data in enumerate(data["audio"]):
+                if isinstance(aud_data, dict):
+                    # If content is base64, decode it back to bytes
+                    if "content" in aud_data and isinstance(aud_data["content"], str):
+                        reconstructed_audio.append(
+                            Audio.from_base64(
+                                aud_data["content"],
+                                id=aud_data.get("id"),
+                                mime_type=aud_data.get("mime_type"),
+                                transcript=aud_data.get("transcript"),
+                                expires_at=aud_data.get("expires_at"),
+                                sample_rate=aud_data.get("sample_rate", 24000),
+                                channels=aud_data.get("channels", 1),
+                            )
+                        )
+                    else:
+                        reconstructed_audio.append(Audio(**aud_data))
+                else:
+                    reconstructed_audio.append(aud_data)
+            data["audio"] = reconstructed_audio
+
+        # Handle video reconstruction properly
+        if "videos" in data and data["videos"]:
+            reconstructed_videos = []
+            for i, vid_data in enumerate(data["videos"]):
+                if isinstance(vid_data, dict):
+                    # If content is base64, decode it back to bytes
+                    if "content" in vid_data and isinstance(vid_data["content"], str):
+                        reconstructed_videos.append(
+                            Video.from_base64(
+                                vid_data["content"],
+                                id=vid_data.get("id"),
+                                mime_type=vid_data.get("mime_type"),
+                                format=vid_data.get("format"),
+                            )
+                        )
+                    else:
+                        reconstructed_videos.append(Video(**vid_data))
+                else:
+                    reconstructed_videos.append(vid_data)
+            data["videos"] = reconstructed_videos
+
+        if "audio_output" in data and data["audio_output"]:
+            aud_data = data["audio_output"]
+            if isinstance(aud_data, dict):
+                if "content" in aud_data and isinstance(aud_data["content"], str):
+                    data["audio_output"] = Audio.from_base64(
+                        aud_data["content"],
+                        id=aud_data.get("id"),
+                        mime_type=aud_data.get("mime_type"),
+                        transcript=aud_data.get("transcript"),
+                        expires_at=aud_data.get("expires_at"),
+                        sample_rate=aud_data.get("sample_rate", 24000),
+                        channels=aud_data.get("channels", 1),
+                    )
+                else:
+                    data["audio_output"] = Audio(**aud_data)
+
+        if "image_output" in data and data["image_output"]:
+            img_data = data["image_output"]
+            if isinstance(img_data, dict):
+                if "content" in img_data and isinstance(img_data["content"], str):
+                    data["image_output"] = Image.from_base64(
+                        img_data["content"],
+                        id=img_data.get("id"),
+                        mime_type=img_data.get("mime_type"),
+                        format=img_data.get("format"),
+                    )
+                else:
+                    data["image_output"] = Image(**img_data)
+
+        if "video_output" in data and data["video_output"]:
+            vid_data = data["video_output"]
+            if isinstance(vid_data, dict):
+                if "content" in vid_data and isinstance(vid_data["content"], str):
+                    data["video_output"] = Video.from_base64(
+                        vid_data["content"],
+                        id=vid_data.get("id"),
+                        mime_type=vid_data.get("mime_type"),
+                        format=vid_data.get("format"),
+                    )
+                else:
+                    data["video_output"] = Video(**vid_data)
+
         return cls(**data)
 
     def to_dict(self) -> Dict[str, Any]:

agno/models/openai/responses.py

@@ -1088,4 +1088,10 @@ class OpenAIResponses(Model):
         metrics.output_tokens = response_usage.output_tokens or 0
         metrics.total_tokens = response_usage.total_tokens or 0
 
+        if input_tokens_details := response_usage.input_tokens_details:
+            metrics.cache_read_tokens = input_tokens_details.cached_tokens
+
+        if output_tokens_details := response_usage.output_tokens_details:
+            metrics.reasoning_tokens = output_tokens_details.reasoning_tokens
+
         return metrics

agno/os/app.py

@@ -1,11 +1,12 @@
 from contextlib import asynccontextmanager
 from functools import partial
 from os import getenv
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Set, Union
 from uuid import uuid4
 
-from fastapi import FastAPI, HTTPException
+from fastapi import APIRouter, FastAPI, HTTPException
 from fastapi.responses import JSONResponse
+from fastapi.routing import APIRoute
 from rich import box
 from rich.panel import Panel
 from starlette.middleware.cors import CORSMiddleware
@@ -30,13 +31,15 @@ from agno.os.interfaces.base import BaseInterface
 from agno.os.router import get_base_router, get_websocket_router
 from agno.os.routers.evals import get_eval_router
 from agno.os.routers.health import get_health_router
+from agno.os.routers.home import get_home_router
 from agno.os.routers.knowledge import get_knowledge_router
 from agno.os.routers.memory import get_memory_router
 from agno.os.routers.metrics import get_metrics_router
 from agno.os.routers.session import get_session_router
 from agno.os.settings import AgnoAPISettings
-from agno.os.utils import generate_id
 from agno.team.team import Team
+from agno.utils.log import logger
+from agno.utils.string import generate_id, generate_id_from_name
 from agno.workflow.workflow import Workflow
 
 
@@ -70,8 +73,30 @@ class AgentOS:
         fastapi_app: Optional[FastAPI] = None,
         lifespan: Optional[Any] = None,
         enable_mcp: bool = False,
+        replace_routes: bool = True,
         telemetry: bool = True,
     ):
+        """Initialize AgentOS.
+
+        Args:
+            os_id: Unique identifier for this AgentOS instance
+            name: Name of the AgentOS instance
+            description: Description of the AgentOS instance
+            version: Version of the AgentOS instance
+            agents: List of agents to include in the OS
+            teams: List of teams to include in the OS
+            workflows: List of workflows to include in the OS
+            interfaces: List of interfaces to include in the OS
+            config: Configuration file path or AgentOSConfig instance
+            settings: API settings for the OS
+            fastapi_app: Optional custom FastAPI app to use instead of creating a new one
+            lifespan: Optional lifespan context manager for the FastAPI app
+            enable_mcp: Whether to enable MCP (Model Context Protocol)
+            replace_routes: If False and using a custom fastapi_app, skip AgentOS routes that
+                          conflict with existing routes, preferring the user's custom routes.
+                          If True (default), AgentOS routes will override conflicting custom routes.
+            telemetry: Whether to enable telemetry
+        """
         if not agents and not workflows and not teams:
             raise ValueError("Either agents, teams or workflows must be provided.")
 
@@ -92,11 +117,13 @@ class AgentOS:
 
         self.interfaces = interfaces or []
 
-        self.os_id: Optional[str] = os_id
+        self.os_id = os_id
         self.name = name
         self.version = version
         self.description = description
 
+        self.replace_routes = replace_routes
+
         self.telemetry = telemetry
 
         self.enable_mcp = enable_mcp
@@ -146,7 +173,10 @@ class AgentOS:
             for workflow in self.workflows:
                 # TODO: track MCP tools in workflow members
                 if not workflow.id:
-                    workflow.id = generate_id(workflow.name)
+                    workflow.id = generate_id_from_name(workflow.name)
+
+        if not self.os_id:
+            self.os_id = generate_id(self.name) if self.name else str(uuid4())
 
         if self.telemetry:
             from agno.api.os import OSLaunch, log_os_telemetry
@@ -207,18 +237,29 @@ class AgentOS:
             else:
                 self.fastapi_app = self._make_app(lifespan=self.lifespan)
 
-        # Add routes
-        self.fastapi_app.include_router(get_base_router(self, settings=self.settings))
-        self.fastapi_app.include_router(get_websocket_router(self, settings=self.settings))
-        self.fastapi_app.include_router(get_health_router())
+        # Add routes with conflict detection
+        self._add_router(get_base_router(self, settings=self.settings))
+        self._add_router(get_websocket_router(self, settings=self.settings))
+        self._add_router(get_health_router())
+        self._add_router(get_home_router(self))
 
         for interface in self.interfaces:
             interface_router = interface.get_router()
-            self.fastapi_app.include_router(interface_router)
+            self._add_router(interface_router)
 
         self._auto_discover_databases()
         self._auto_discover_knowledge_instances()
-        self._setup_routers()
+
+        routers = [
+            get_session_router(dbs=self.dbs),
+            get_memory_router(dbs=self.dbs),
+            get_eval_router(dbs=self.dbs, agents=self.agents, teams=self.teams),
+            get_metrics_router(dbs=self.dbs),
+            get_knowledge_router(knowledge_instances=self.knowledge_instances),
+        ]
+
+        for router in routers:
+            self._add_router(router)
 
         # Mount MCP if needed
         if self.enable_mcp and self.mcp_app:
@@ -266,6 +307,94 @@ class AgentOS:
 
         return app.routes
 
+    def _get_existing_route_paths(self) -> Dict[str, List[str]]:
+        """Get all existing route paths and methods from the FastAPI app.
+
+        Returns:
+            Dict[str, List[str]]: Dictionary mapping paths to list of HTTP methods
+        """
+        if not self.fastapi_app:
+            return {}
+
+        existing_paths: Dict[str, Any] = {}
+        for route in self.fastapi_app.routes:
+            if isinstance(route, APIRoute):
+                path = route.path
+                methods = list(route.methods) if route.methods else []
+                if path in existing_paths:
+                    existing_paths[path].extend(methods)
+                else:
+                    existing_paths[path] = methods
+        return existing_paths
+
+    def _add_router(self, router: APIRouter) -> None:
+        """Add a router to the FastAPI app, avoiding route conflicts.
+
+        Args:
+            router: The APIRouter to add
+        """
+        if not self.fastapi_app:
+            return
+
+        # Get existing routes
+        existing_paths = self._get_existing_route_paths()
+
+        # Check for conflicts
+        conflicts = []
+        conflicting_routes = []
+
+        for route in router.routes:
+            if isinstance(route, APIRoute):
+                full_path = route.path
+                route_methods = list(route.methods) if route.methods else []
+
+                if full_path in existing_paths:
+                    conflicting_methods: Set[str] = set(route_methods) & set(existing_paths[full_path])
+                    if conflicting_methods:
+                        conflicts.append({"path": full_path, "methods": list(conflicting_methods), "route": route})
+                        conflicting_routes.append(route)
+
+        if conflicts and self._app_set:
+            if self.replace_routes:
+                # Log warnings but still add all routes (AgentOS routes will override)
+                for conflict in conflicts:
+                    methods_str = ", ".join(conflict["methods"])  # type: ignore
+                    logger.warning(
+                        f"Route conflict detected: {methods_str} {conflict['path']} - "
+                        f"AgentOS route will override existing custom route"
+                    )
+
+                # Remove conflicting routes
+                for route in self.fastapi_app.routes:
+                    for conflict in conflicts:
+                        if isinstance(route, APIRoute):
+                            if route.path == conflict["path"] and list(route.methods) == list(conflict["methods"]):
+                                self.fastapi_app.routes.pop(self.fastapi_app.routes.index(route))
+
+                self.fastapi_app.include_router(router)
+
+            else:
+                # Skip conflicting AgentOS routes, prefer user's existing routes
+                for conflict in conflicts:
+                    methods_str = ", ".join(conflict["methods"])  # type: ignore
+                    logger.debug(
+                        f"Skipping conflicting AgentOS route: {methods_str} {conflict['path']} - "
+                        f"Using existing custom route instead"
+                    )
+
+                # Create a new router without the conflicting routes
+                filtered_router = APIRouter()
+                for route in router.routes:
+                    if route not in conflicting_routes:
+                        filtered_router.routes.append(route)
+
+                # Use the filtered router if it has any routes left
+                if filtered_router.routes:
+                    self.fastapi_app.include_router(filtered_router)
+        else:
+            # No conflicts, add router normally
+            self.fastapi_app.include_router(router)
+
     def _get_telemetry_data(self) -> Dict[str, Any]:
         """Get the telemetry data for the OS"""
         return {
@@ -293,18 +422,25 @@ class AgentOS:
     def _auto_discover_databases(self) -> None:
         """Auto-discover the databases used by all contextual agents, teams and workflows."""
         dbs = {}
+        knowledge_dbs = {}  # Track databases specifically used for knowledge
 
         for agent in self.agents or []:
             if agent.db:
                 dbs[agent.db.id] = agent.db
             if agent.knowledge and agent.knowledge.contents_db:
-                dbs[agent.knowledge.contents_db.id] = agent.knowledge.contents_db
+                knowledge_dbs[agent.knowledge.contents_db.id] = agent.knowledge.contents_db
+                # Also add to general dbs if it's used for both purposes
+                if agent.knowledge.contents_db.id not in dbs:
+                    dbs[agent.knowledge.contents_db.id] = agent.knowledge.contents_db
 
         for team in self.teams or []:
             if team.db:
                 dbs[team.db.id] = team.db
             if team.knowledge and team.knowledge.contents_db:
-                dbs[team.knowledge.contents_db.id] = team.knowledge.contents_db
+                knowledge_dbs[team.knowledge.contents_db.id] = team.knowledge.contents_db
+                # Also add to general dbs if it's used for both purposes
+                if team.knowledge.contents_db.id not in dbs:
+                    dbs[team.knowledge.contents_db.id] = team.knowledge.contents_db
 
         for workflow in self.workflows or []:
             if workflow.db:
@@ -317,6 +453,7 @@ class AgentOS:
                 dbs[interface.team.db.id] = interface.team.db
 
         self.dbs = dbs
+        self.knowledge_dbs = knowledge_dbs
 
     def _auto_discover_knowledge_instances(self) -> None:
         """Auto-discover the knowledge instances used by all contextual agents, teams and workflows."""
@@ -381,16 +518,17 @@ class AgentOS:
         if knowledge_config.dbs is None:
             knowledge_config.dbs = []
 
-        multiple_dbs: bool = len(self.dbs.keys()) > 1
+        multiple_knowledge_dbs: bool = len(self.knowledge_dbs.keys()) > 1
         dbs_with_specific_config = [db.db_id for db in knowledge_config.dbs]
 
-        for db_id in self.dbs.keys():
+        # Only add databases that are actually used for knowledge contents
+        for db_id in self.knowledge_dbs.keys():
             if db_id not in dbs_with_specific_config:
                 knowledge_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=KnowledgeDomainConfig(
-                            display_name="Knowledge" if not multiple_dbs else "Knowledge in database " + db_id
+                            display_name="Knowledge" if not multiple_knowledge_dbs else "Knowledge in database " + db_id
                         ),
                     )
                 )
@@ -441,29 +579,6 @@ class AgentOS:
 
         return evals_config
 
-    def _setup_routers(self) -> None:
-        """Add all routers to the FastAPI app."""
-        if not self.dbs or not self.fastapi_app:
-            return
-
-        routers = [
-            get_session_router(dbs=self.dbs),
-            get_memory_router(dbs=self.dbs),
-            get_eval_router(dbs=self.dbs, agents=self.agents, teams=self.teams),
-            get_metrics_router(dbs=self.dbs),
-            get_knowledge_router(knowledge_instances=self.knowledge_instances),
-        ]
-
-        for router in routers:
-            self.fastapi_app.include_router(router)
-
-    def set_os_id(self) -> str:
-        # If os_id is already set, keep it instead of overriding with UUID
-        if self.os_id is None:
-            self.os_id = str(uuid4())
-
-        return self.os_id
-
     def serve(
         self,
         app: Union[str, FastAPI],
@@ -485,13 +600,18 @@ class AgentOS:
         from rich.align import Align
         from rich.console import Console, Group
 
-        aligned_endpoint = Align.center(f"[bold cyan]{public_endpoint}[/bold cyan]")
-        connection_endpoint = f"\n\n[bold dark_orange]Running on:[/bold dark_orange] http://{host}:{port}"
+        panel_group = []
+        panel_group.append(Align.center(f"[bold cyan]{public_endpoint}[/bold cyan]"))
+        panel_group.append(
+            Align.center(f"\n\n[bold dark_orange]OS running on:[/bold dark_orange] http://{host}:{port}")
+        )
+        if bool(self.settings.os_security_key):
+            panel_group.append(Align.center("\n\n[bold chartreuse3]:lock: Security Enabled[/bold chartreuse3]"))
 
         console = Console()
         console.print(
             Panel(
-                Group(aligned_endpoint, connection_endpoint),
+                Group(*panel_group),
                 title="AgentOS",
                 expand=False,
                 border_style="dark_orange",