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

agno/db/redis/redis.py

@@ -21,9 +21,9 @@ from agno.db.redis.utils import (
 from agno.db.schemas.evals import EvalFilterType, EvalRunRecord, EvalType
 from agno.db.schemas.knowledge import KnowledgeRow
 from agno.db.schemas.memory import UserMemory
-from agno.db.utils import generate_deterministic_id
 from agno.session import AgentSession, Session, TeamSession, WorkflowSession
 from agno.utils.log import log_debug, log_error, log_info
+from agno.utils.string import generate_id
 
 try:
     from redis import Redis
@@ -71,7 +71,7 @@ class RedisDb(BaseDb):
         if id is None:
             base_seed = db_url or str(redis_client)
             seed = f"{base_seed}#{db_prefix}"
-            id = generate_deterministic_id(seed)
+            id = generate_id(seed)
 
         super().__init__(
             id=id,
@@ -300,8 +300,8 @@ class RedisDb(BaseDb):
 
         Args:
             session_id (str): The ID of the session to get.
+            session_type (SessionType): The type of session to get.
             user_id (Optional[str]): The ID of the user to filter by.
-            session_type (Optional[SessionType]): The type of session to filter by.
 
         Returns:
             Optional[Union[AgentSession, TeamSession, WorkflowSession]]: The session if found, None otherwise.

agno/db/singlestore/singlestore.py

@@ -19,9 +19,9 @@ from agno.db.singlestore.utils import (
     is_table_available,
     is_valid_table,
 )
-from agno.db.utils import generate_deterministic_id
 from agno.session import AgentSession, Session, TeamSession, WorkflowSession
 from agno.utils.log import log_debug, log_error, log_info, log_warning
+from agno.utils.string import generate_id
 
 try:
     from sqlalchemy import Index, UniqueConstraint, and_, func, update
@@ -74,7 +74,7 @@ class SingleStoreDb(BaseDb):
             base_seed = db_url or str(db_engine.url) if db_engine else "singlestore"  # type: ignore
             schema_suffix = db_schema if db_schema is not None else "ai"
             seed = f"{base_seed}#{schema_suffix}"
-            id = generate_deterministic_id(seed)
+            id = generate_id(seed)
 
         super().__init__(
             id=id,
@@ -431,8 +431,8 @@ class SingleStoreDb(BaseDb):
 
         Args:
             session_id (str): ID of the session to read.
+            session_type (SessionType): Type of session to get.
             user_id (Optional[str]): User ID to filter by. Defaults to None.
-            session_type (Optional[SessionType]): Type of session to read. Defaults to None.
             deserialize (Optional[bool]): Whether to serialize the session. Defaults to True.
 
         Returns:
@@ -496,7 +496,7 @@ class SingleStoreDb(BaseDb):
         Get all sessions in the given table. Can filter by user_id and entity_id.
 
         Args:
-            session_type (Optional[SessionType]): The type of session to filter by. Defaults to None.
+            session_type (Optional[SessionType]): The type of session to filter by.
             user_id (Optional[str]): The ID of the user to filter by.
             component_id (Optional[str]): The ID of the agent / workflow to filter by.
             session_name (Optional[str]): The name of the session to filter by.

agno/db/sqlite/sqlite.py

@@ -18,9 +18,10 @@ from agno.db.sqlite.utils import (
     is_table_available,
     is_valid_table,
 )
-from agno.db.utils import deserialize_session_json_fields, generate_deterministic_id, serialize_session_json_fields
+from agno.db.utils import deserialize_session_json_fields, serialize_session_json_fields
 from agno.session import AgentSession, Session, TeamSession, WorkflowSession
 from agno.utils.log import log_debug, log_error, log_info, log_warning
+from agno.utils.string import generate_id
 
 try:
     from sqlalchemy import Column, MetaData, Table, and_, func, select, text, update
@@ -70,7 +71,7 @@ class SqliteDb(BaseDb):
         """
         if id is None:
             seed = db_url or db_file or str(db_engine.url) if db_engine else "sqlite:///agno.db"
-            id = generate_deterministic_id(seed)
+            id = generate_id(seed)
 
         super().__init__(
             id=id,
@@ -332,8 +333,8 @@ class SqliteDb(BaseDb):
 
         Args:
             session_id (str): ID of the session to read.
+            session_type (SessionType): Type of session to get.
             user_id (Optional[str]): User ID to filter by. Defaults to None.
-            session_type (Optional[SessionType]): Type of session to read. Defaults to None.
             deserialize (Optional[bool]): Whether to serialize the session. Defaults to True.
 
         Returns:
@@ -1666,17 +1667,17 @@ class SqliteDb(BaseDb):
         if v1_table_type == "agent_sessions":
             for session in sessions:
                 self.upsert_session(session)
-            log_info(f"Migrated {len(sessions)} Agent sessions to table: {self.session_table}")
+            log_info(f"Migrated {len(sessions)} Agent sessions to table: {self.session_table_name}")
 
         elif v1_table_type == "team_sessions":
             for session in sessions:
                 self.upsert_session(session)
-            log_info(f"Migrated {len(sessions)} Team sessions to table: {self.session_table}")
+            log_info(f"Migrated {len(sessions)} Team sessions to table: {self.session_table_name}")
 
         elif v1_table_type == "workflow_sessions":
             for session in sessions:
                 self.upsert_session(session)
-            log_info(f"Migrated {len(sessions)} Workflow sessions to table: {self.session_table}")
+            log_info(f"Migrated {len(sessions)} Workflow sessions to table: {self.session_table_name}")
 
         elif v1_table_type == "memories":
             for memory in memories:

agno/db/utils.py

@@ -1,7 +1,6 @@
 """Logic shared across different database implementations"""
 
 import json
-import uuid
 from datetime import date, datetime
 from uuid import UUID
 
@@ -87,16 +86,3 @@ def deserialize_session_json_fields(session: dict) -> dict:
             session["runs"] = json.loads(session["runs"])
 
     return session
-
-
-def generate_deterministic_id(seed: str) -> str:
-    """
-    Generate a deterministic UUID5 based on a seed string.
-
-    Args:
-        seed (str): The seed string to generate the UUID from.
-
-    Returns:
-        str: A deterministic UUID5 string.
-    """
-    return str(uuid.uuid5(uuid.NAMESPACE_DNS, seed))

agno/integrations/discord/client.py

@@ -112,6 +112,7 @@ class DiscordClient:
                 # TODO Unhappy with the duplication here but it keeps MyPy from complaining
                 additional_context = dedent(f"""
                     Discord username: {message_user}
+                    Discord userid: {message_user_id} 
                     Discord url: {message_url}
                     """)
                 if self.agent:

agno/knowledge/embedder/openai.py

@@ -78,21 +78,25 @@ class OpenAIEmbedder(Embedder):
         return self.client.embeddings.create(**_request_params)
 
     def get_embedding(self, text: str) -> List[float]:
-        response: CreateEmbeddingResponse = self.response(text=text)
         try:
+            response: CreateEmbeddingResponse = self.response(text=text)
             return response.data[0].embedding
         except Exception as e:
             logger.warning(e)
             return []
 
     def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
-        response: CreateEmbeddingResponse = self.response(text=text)
+        try:
+            response: CreateEmbeddingResponse = self.response(text=text)
 
-        embedding = response.data[0].embedding
-        usage = response.usage
-        if usage:
-            return embedding, usage.model_dump()
-        return embedding, None
+            embedding = response.data[0].embedding
+            usage = response.usage
+            if usage:
+                return embedding, usage.model_dump()
+            return embedding, None
+        except Exception as e:
+            logger.warning(e)
+            return [], None
 
     async def async_get_embedding(self, text: str) -> List[float]:
         req: Dict[str, Any] = {
@@ -127,10 +131,14 @@ class OpenAIEmbedder(Embedder):
         if self.request_params:
             req.update(self.request_params)
 
-        response = await self.aclient.embeddings.create(**req)
-        embedding = response.data[0].embedding
-        usage = response.usage
-        return embedding, usage.model_dump() if usage else None
+        try:
+            response = await self.aclient.embeddings.create(**req)
+            embedding = response.data[0].embedding
+            usage = response.usage
+            return embedding, usage.model_dump() if usage else None
+        except Exception as e:
+            logger.warning(e)
+            return [], None
 
     def get_embeddings_batch(self, texts: List[str], batch_size: int = 100) -> List[List[float]]:
         """

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]]]
@@ -74,6 +74,8 @@ class Knowledge:
     async def add_contents_async(self, *args, **kwargs) -> None:
         if args and isinstance(args[0], list):
             arguments = args[0]
+            upsert = kwargs.get("upsert", False)
+            skip_if_exists = kwargs.get("skip_if_exists", False)
             for argument in arguments:
                 await self.add_content_async(
                     name=argument.get("name"),
@@ -85,8 +87,8 @@ class Knowledge:
                     reader=argument.get("reader"),
                     include=argument.get("include"),
                     exclude=argument.get("exclude"),
-                    upsert=argument.get("upsert", False),
-                    skip_if_exists=argument.get("skip_if_exists", False),
+                    upsert=argument.get("upsert", upsert),
+                    skip_if_exists=argument.get("skip_if_exists", skip_if_exists),
                     remote_content=argument.get("remote_content", None),
                 )
 
@@ -102,7 +104,6 @@ class Knowledge:
             upsert = kwargs.get("upsert", False)
             skip_if_exists = kwargs.get("skip_if_exists", False)
             remote_content = kwargs.get("remote_content", None)
-
             for path in paths:
                 await self.add_content_async(
                     name=name,
@@ -253,7 +254,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 +305,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 +432,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 +681,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 +778,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 +860,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/knowledge/reader/website_reader.py

@@ -106,23 +106,35 @@ class WebsiteReader(Reader):
             """
             Check if the tag matches any of the relevant tags or class names
             """
-            if tag.name in ["article", "main"]:
+            if not isinstance(tag, Tag):
+                return False
+
+            if tag.name in ["article", "main", "section"]:
+                return True
+
+            classes = tag.get("class", [])
+            content_classes = ["content", "main-content", "post-content", "entry-content", "article-body"]
+            if any(cls in content_classes for cls in classes):
                 return True
-            if any(cls in ["content", "main-content", "post-content"] for cls in tag.get("class", [])):  # type: ignore
+
+            # Check for common content IDs
+            tag_id = tag.get("id", "")
+            if tag_id in ["content", "main", "article"]:
                 return True
+
             return False
 
-        # Use a single call to 'find' with a custom function to match tags or classes
+        # Try to find main content element
         element = soup.find(match)
         if element:
+            # Remove common unwanted elements from the found content
+            for unwanted in element.find_all(["script", "style", "nav", "header", "footer"]):
+                unwanted.decompose()
             return element.get_text(strip=True, separator=" ")
 
-        # If we only have a div without specific content classes, return empty string
-        if soup.find("div") and not any(
-            soup.find(class_=class_name) for class_name in ["content", "main-content", "post-content"]
-        ):
-            return ""
-
+        # Fallback: get full page content
+        for unwanted in soup.find_all(["script", "style", "nav", "header", "footer"]):
+            unwanted.decompose()
         return soup.get_text(strip=True, separator=" ")
 
     def crawl(self, url: str, starting_depth: int = 1) -> Dict[str, str]:
@@ -164,7 +176,7 @@ class WebsiteReader(Reader):
             if (
                 current_url in self._visited
                 or not urlparse(current_url).netloc.endswith(primary_domain)
-                or current_depth > self.max_depth
+                or (current_depth > self.max_depth and current_url != url)
                 or num_links >= self.max_links
             ):
                 continue
@@ -174,13 +186,14 @@ class WebsiteReader(Reader):
 
             try:
                 log_debug(f"Crawling: {current_url}")
+
                 response = (
-                    httpx.get(current_url, timeout=self.timeout, proxy=self.proxy)
+                    httpx.get(current_url, timeout=self.timeout, proxy=self.proxy, follow_redirects=True)
                     if self.proxy
-                    else httpx.get(current_url, timeout=self.timeout)
+                    else httpx.get(current_url, timeout=self.timeout, follow_redirects=True)
                 )
-
                 response.raise_for_status()
+
                 soup = BeautifulSoup(response.content, "html.parser")
 
                 # Extract main content
@@ -213,9 +226,13 @@ class WebsiteReader(Reader):
 
             except httpx.HTTPStatusError as e:
                 # Log HTTP status errors but continue crawling other pages
-                logger.warning(f"HTTP status error while crawling {current_url}: {e}")
-                # For the initial URL, we should raise the error
-                if current_url == url and not crawler_result:
+                # Skip redirect errors (3xx) as they should be handled by follow_redirects
+                if e.response.status_code >= 300 and e.response.status_code < 400:
+                    logger.debug(f"Redirect encountered for {current_url}, skipping: {e}")
+                else:
+                    logger.warning(f"HTTP status error while crawling {current_url}: {e}")
+                # For the initial URL, we should raise the error only if it's not a redirect
+                if current_url == url and not crawler_result and not (300 <= e.response.status_code < 400):
                     raise
             except httpx.RequestError as e:
                 # Log request errors but continue crawling other pages

agno/media.py

@@ -334,11 +334,16 @@ class Video(BaseModel):
 
 
 class File(BaseModel):
+    id: Optional[str] = None
     url: Optional[str] = None
     filepath: Optional[Union[Path, str]] = None
     # Raw bytes content of a file
     content: Optional[Any] = None
     mime_type: Optional[str] = None
+
+    file_type: Optional[str] = None
+    filename: Optional[str] = None
+    size: Optional[int] = None
     # External file object (e.g. GeminiFile, must be a valid object as expected by the model you are using)
     external: Optional[Any] = None
     format: Optional[str] = None  # E.g. `pdf`, `txt`, `csv`, `xml`, etc.
@@ -364,6 +369,7 @@ class File(BaseModel):
     def valid_mime_types(cls) -> List[str]:
         return [
             "application/pdf",
+            "application/json",
             "application/x-javascript",
             "text/javascript",
             "application/x-python",
@@ -377,6 +383,29 @@ class File(BaseModel):
             "text/rtf",
         ]
 
+    @classmethod
+    def from_base64(
+        cls,
+        base64_content: str,
+        id: Optional[str] = None,
+        mime_type: Optional[str] = None,
+        filename: Optional[str] = None,
+        name: Optional[str] = None,
+        format: Optional[str] = None,
+    ) -> "File":
+        """Create File from base64 encoded content"""
+        import base64
+
+        content_bytes = base64.b64decode(base64_content)
+        return cls(
+            content=content_bytes,
+            id=id,
+            mime_type=mime_type,
+            filename=filename,
+            name=name,
+            format=format,
+        )
+
     @property
     def file_url_content(self) -> Optional[Tuple[bytes, str]]:
         import httpx
@@ -388,3 +417,44 @@ class File(BaseModel):
             return content, mime_type
         else:
             return None
+
+    def _normalise_content(self) -> Optional[Union[str, bytes]]:
+        if self.content is None:
+            return None
+        content_normalised: Union[str, bytes] = self.content
+        if content_normalised and isinstance(content_normalised, bytes):
+            from base64 import b64encode
+
+            try:
+                if self.mime_type and self.mime_type.startswith("text/"):
+                    content_normalised = content_normalised.decode("utf-8")
+                else:
+                    content_normalised = b64encode(content_normalised).decode("utf-8")
+            except UnicodeDecodeError:
+                if isinstance(self.content, bytes):
+                    content_normalised = b64encode(self.content).decode("utf-8")
+            except Exception:
+                try:
+                    if isinstance(self.content, bytes):
+                        content_normalised = b64encode(self.content).decode("utf-8")
+                except Exception:
+                    pass
+        return content_normalised
+
+    def to_dict(self) -> Dict[str, Any]:
+        content_normalised = self._normalise_content()
+
+        response_dict = {
+            "id": self.id,
+            "url": self.url,
+            "filepath": str(self.filepath) if self.filepath else None,
+            "content": content_normalised,
+            "mime_type": self.mime_type,
+            "file_type": self.file_type,
+            "filename": self.filename,
+            "size": self.size,
+            "external": self.external,
+            "format": self.format,
+            "name": self.name,
+        }
+        return {k: v for k, v in response_dict.items() if v is not None}

agno/models/aimlapi/aimlapi.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, Optional
 
@@ -24,7 +24,7 @@ class AIMLAPI(OpenAILike):
     name: str = "AIMLAPI"
     provider: str = "AIMLAPI"
 
-    api_key: Optional[str] = getenv("AIMLAPI_API_KEY")
+    api_key: Optional[str] = field(default_factory=lambda: getenv("AIMLAPI_API_KEY"))
     base_url: str = "https://api.aimlapi.com/v1"
     max_tokens: int = 4096