agno 2.4.3__py3-none-any.whl → 2.4.4__py3-none-any.whl

agno/db/firestore/firestore.py

@@ -1,7 +1,7 @@
 import json
 import time
 from datetime import date, datetime, timedelta, timezone
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast
 from uuid import uuid4
 
 if TYPE_CHECKING:
@@ -25,7 +25,7 @@ from agno.db.schemas.culture import CulturalKnowledge
 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 deserialize_session_json_fields, serialize_session_json_fields
+from agno.db.utils import deserialize_session_json_fields
 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
@@ -496,6 +496,29 @@ class FirestoreDb(BaseDb):
             if doc_ref is None:
                 return None
 
+            # Check if session_data is stored as JSON string (legacy) or native map.
+            # Legacy sessions stored session_data as a JSON string, but Firestore's dot notation
+            # (e.g., "session_data.session_name") only works with native maps. Using dot notation
+            # on a JSON string overwrites the entire field, causing data loss.
+            # For legacy sessions, we use read-modify-write which also migrates them to native maps.
+            current_doc = doc_ref.get()
+            if not current_doc.exists:
+                return None
+
+            current_data = current_doc.to_dict()
+            session_data = current_data.get("session_data") if current_data else None
+
+            if session_data is None or isinstance(session_data, str):
+                existing_session = self.get_session(session_id, session_type, deserialize=True)
+                if existing_session is None:
+                    return None
+                existing_session = cast(Session, existing_session)
+                if existing_session.session_data is None:
+                    existing_session.session_data = {}
+                existing_session.session_data["session_name"] = session_name
+                return self.upsert_session(existing_session, deserialize=deserialize)
+
+            # Native map format - use efficient dot notation update
             doc_ref.update({"session_data.session_name": session_name, "updated_at": int(time.time())})
 
             updated_doc = doc_ref.get()
@@ -539,50 +562,50 @@ class FirestoreDb(BaseDb):
         """
         try:
             collection_ref = self._get_collection(table_type="sessions", create_collection_if_not_found=True)
-            serialized_session_dict = serialize_session_json_fields(session.to_dict())
+            session_dict = session.to_dict()
 
             if isinstance(session, AgentSession):
                 record = {
-                    "session_id": serialized_session_dict.get("session_id"),
+                    "session_id": session_dict.get("session_id"),
                     "session_type": SessionType.AGENT.value,
-                    "agent_id": serialized_session_dict.get("agent_id"),
-                    "user_id": serialized_session_dict.get("user_id"),
-                    "runs": serialized_session_dict.get("runs"),
-                    "agent_data": serialized_session_dict.get("agent_data"),
-                    "session_data": serialized_session_dict.get("session_data"),
-                    "summary": serialized_session_dict.get("summary"),
-                    "metadata": serialized_session_dict.get("metadata"),
-                    "created_at": serialized_session_dict.get("created_at"),
+                    "agent_id": session_dict.get("agent_id"),
+                    "user_id": session_dict.get("user_id"),
+                    "runs": session_dict.get("runs"),
+                    "agent_data": session_dict.get("agent_data"),
+                    "session_data": session_dict.get("session_data"),
+                    "summary": session_dict.get("summary"),
+                    "metadata": session_dict.get("metadata"),
+                    "created_at": session_dict.get("created_at"),
                     "updated_at": int(time.time()),
                 }
 
             elif isinstance(session, TeamSession):
                 record = {
-                    "session_id": serialized_session_dict.get("session_id"),
+                    "session_id": session_dict.get("session_id"),
                     "session_type": SessionType.TEAM.value,
-                    "team_id": serialized_session_dict.get("team_id"),
-                    "user_id": serialized_session_dict.get("user_id"),
-                    "runs": serialized_session_dict.get("runs"),
-                    "team_data": serialized_session_dict.get("team_data"),
-                    "session_data": serialized_session_dict.get("session_data"),
-                    "summary": serialized_session_dict.get("summary"),
-                    "metadata": serialized_session_dict.get("metadata"),
-                    "created_at": serialized_session_dict.get("created_at"),
+                    "team_id": session_dict.get("team_id"),
+                    "user_id": session_dict.get("user_id"),
+                    "runs": session_dict.get("runs"),
+                    "team_data": session_dict.get("team_data"),
+                    "session_data": session_dict.get("session_data"),
+                    "summary": session_dict.get("summary"),
+                    "metadata": session_dict.get("metadata"),
+                    "created_at": session_dict.get("created_at"),
                     "updated_at": int(time.time()),
                 }
 
             elif isinstance(session, WorkflowSession):
                 record = {
-                    "session_id": serialized_session_dict.get("session_id"),
+                    "session_id": session_dict.get("session_id"),
                     "session_type": SessionType.WORKFLOW.value,
-                    "workflow_id": serialized_session_dict.get("workflow_id"),
-                    "user_id": serialized_session_dict.get("user_id"),
-                    "runs": serialized_session_dict.get("runs"),
-                    "workflow_data": serialized_session_dict.get("workflow_data"),
-                    "session_data": serialized_session_dict.get("session_data"),
-                    "summary": serialized_session_dict.get("summary"),
-                    "metadata": serialized_session_dict.get("metadata"),
-                    "created_at": serialized_session_dict.get("created_at"),
+                    "workflow_id": session_dict.get("workflow_id"),
+                    "user_id": session_dict.get("user_id"),
+                    "runs": session_dict.get("runs"),
+                    "workflow_data": session_dict.get("workflow_data"),
+                    "session_data": session_dict.get("session_data"),
+                    "summary": session_dict.get("summary"),
+                    "metadata": session_dict.get("metadata"),
+                    "created_at": session_dict.get("created_at"),
                     "updated_at": int(time.time()),
                 }
 

agno/db/surrealdb/models.py

@@ -292,25 +292,25 @@ def get_schema(table_type: TableType, table_name: str) -> str:
     elif table_type == "knowledge":
         return dedent(f"""
             {define_table}
-            DEFINE FIELD OVERWRITE created_at ON {table_name} TYPE datetime VALUE time::now();
+            DEFINE FIELD OVERWRITE created_at ON {table_name} TYPE datetime DEFAULT time::now();
             DEFINE FIELD OVERWRITE updated_at ON {table_name} TYPE datetime VALUE time::now();
             """)
     elif table_type == "culture":
         return dedent(f"""
             {define_table}
-            DEFINE FIELD OVERWRITE created_at ON {table_name} TYPE datetime VALUE time::now();
+            DEFINE FIELD OVERWRITE created_at ON {table_name} TYPE datetime DEFAULT time::now();
             DEFINE FIELD OVERWRITE updated_at ON {table_name} TYPE datetime VALUE time::now();
             """)
     elif table_type == "sessions":
         return dedent(f"""
             {define_table}
-            DEFINE FIELD OVERWRITE created_at ON {table_name} TYPE datetime VALUE time::now();
+            DEFINE FIELD OVERWRITE created_at ON {table_name} TYPE datetime DEFAULT time::now();
             DEFINE FIELD OVERWRITE updated_at ON {table_name} TYPE datetime VALUE time::now();
             """)
     elif table_type == "traces":
         return dedent(f"""
             {define_table}
-            DEFINE FIELD OVERWRITE created_at ON {table_name} TYPE datetime VALUE time::now();
+            DEFINE FIELD OVERWRITE created_at ON {table_name} TYPE datetime DEFAULT time::now();
             DEFINE INDEX idx_trace_id ON {table_name} FIELDS trace_id UNIQUE;
             DEFINE INDEX idx_run_id ON {table_name} FIELDS run_id;
             DEFINE INDEX idx_session_id ON {table_name} FIELDS session_id;
@@ -324,7 +324,7 @@ def get_schema(table_type: TableType, table_name: str) -> str:
     elif table_type == "spans":
         return dedent(f"""
             {define_table}
-            DEFINE FIELD OVERWRITE created_at ON {table_name} TYPE datetime VALUE time::now();
+            DEFINE FIELD OVERWRITE created_at ON {table_name} TYPE datetime DEFAULT time::now();
             DEFINE INDEX idx_span_id ON {table_name} FIELDS span_id UNIQUE;
             DEFINE INDEX idx_trace_id ON {table_name} FIELDS trace_id;
             DEFINE INDEX idx_parent_span_id ON {table_name} FIELDS parent_span_id;

agno/db/surrealdb/surrealdb.py

@@ -287,6 +287,7 @@ class SurrealDb(BaseDb):
         where = WhereClause()
         if user_id is not None:
             where = where.and_("user_id", user_id)
+
         where_clause, where_vars = where.build()
         query = dedent(f"""
             SELECT *
@@ -295,7 +296,18 @@ class SurrealDb(BaseDb):
         """)
         vars = {"record": record, **where_vars}
         raw = self._query_one(query, vars, dict)
-        if raw is None or not deserialize:
+        if raw is None:
+            return None
+
+        # Verify session type matches
+        if session_type == SessionType.AGENT and raw.get("agent") is None:
+            return None
+        elif session_type == SessionType.TEAM and raw.get("team") is None:
+            return None
+        elif session_type == SessionType.WORKFLOW and raw.get("workflow") is None:
+            return None
+
+        if not deserialize:
             return raw
 
         return deserialize_session(session_type, raw)

agno/knowledge/chunking/markdown.py

@@ -37,6 +37,103 @@ class MarkdownChunking(ChunkingStrategy):
             if not (1 <= split_on_headings <= 6):
                 raise ValueError("split_on_headings must be between 1 and 6 when using integer value")
 
+    def _split_large_section(self, section: str) -> List[str]:
+        """
+        Split a large section into smaller chunks while preserving the heading context.
+        Each sub-chunk will include the original heading for context.
+
+        Args:
+            section: The section content to split (may start with a heading)
+
+        Returns:
+            List of chunks, each respecting chunk_size
+        """
+        if len(section) <= self.chunk_size:
+            return [section]
+
+        # Extract heading and content from the section
+        lines = section.split("\n")
+        if lines and re.match(r"^#{1,6}\s+", lines[0]):
+            heading = lines[0]
+            content_lines = lines[1:]
+        else:
+            heading = ""
+            content_lines = lines
+
+        content = "\n".join(content_lines).strip()
+
+        # If just heading and small content, return as-is
+        if not content or len(section) <= self.chunk_size:
+            return [section]
+
+        # Split content by paragraphs
+        paragraphs = re.split(r"\n\n+", content)
+
+        chunks: List[str] = []
+        current_chunk_content: List[str] = []
+        # Account for heading size in each chunk
+        heading_size = len(heading) + 2 if heading else 0  # +2 for "\n\n"
+
+        for para in paragraphs:
+            para = para.strip()
+            if not para:
+                continue
+
+            current_size = sum(len(p) for p in current_chunk_content) + len(current_chunk_content) * 2  # \n\n
+            para_size = len(para)
+
+            # Check if adding this paragraph would exceed chunk_size
+            if current_chunk_content and (heading_size + current_size + para_size + 2) > self.chunk_size:
+                # Save current chunk
+                chunk_text = (
+                    heading + "\n\n" + "\n\n".join(current_chunk_content)
+                    if heading
+                    else "\n\n".join(current_chunk_content)
+                )
+                chunks.append(chunk_text.strip())
+                current_chunk_content = []
+
+            # If single paragraph exceeds chunk_size, split it further
+            if para_size + heading_size > self.chunk_size:
+                # Save any accumulated content first
+                if current_chunk_content:
+                    chunk_text = (
+                        heading + "\n\n" + "\n\n".join(current_chunk_content)
+                        if heading
+                        else "\n\n".join(current_chunk_content)
+                    )
+                    chunks.append(chunk_text.strip())
+                    current_chunk_content = []
+
+                # Split the large paragraph by sentences or fixed size
+                available_size = self.chunk_size - heading_size
+                words = para.split()
+                current_words: List[str] = []
+                current_word_len = 0
+
+                for word in words:
+                    if current_word_len + len(word) + 1 > available_size and current_words:
+                        chunk_text = heading + "\n\n" + " ".join(current_words) if heading else " ".join(current_words)
+                        chunks.append(chunk_text.strip())
+                        current_words = []
+                        current_word_len = 0
+                    current_words.append(word)
+                    current_word_len += len(word) + 1
+
+                if current_words:
+                    current_chunk_content.append(" ".join(current_words))
+            else:
+                current_chunk_content.append(para)
+
+        # add the remaining content
+        if current_chunk_content:
+            chunk_text = (
+                heading + "\n\n" + "\n\n".join(current_chunk_content) if heading else "\n\n".join(current_chunk_content)
+            )
+            chunks.append(chunk_text.strip())
+
+        return chunks if chunks else [section]
+
     def _split_by_headings(self, content: str) -> List[str]:
         """
         Split markdown content by headings, keeping each heading with its content.
@@ -163,18 +260,22 @@ class MarkdownChunking(ChunkingStrategy):
             section_size = len(section)
 
             # When split_on_headings is True or an int, each section becomes its own chunk
+            # But if section exceeds chunk_size, split it further
             if self.split_on_headings:
-                meta_data = chunk_meta_data.copy()
-                meta_data["chunk"] = chunk_number
-                chunk_id = None
-                if document.id:
-                    chunk_id = f"{document.id}_{chunk_number}"
-                elif document.name:
-                    chunk_id = f"{document.name}_{chunk_number}"
-                meta_data["chunk_size"] = section_size
-
-                chunks.append(Document(id=chunk_id, name=document.name, meta_data=meta_data, content=section))
-                chunk_number += 1
+                # Split large sections to respect chunk_size
+                sub_chunks = self._split_large_section(section)
+                for sub_chunk in sub_chunks:
+                    meta_data = chunk_meta_data.copy()
+                    meta_data["chunk"] = chunk_number
+                    chunk_id = None
+                    if document.id:
+                        chunk_id = f"{document.id}_{chunk_number}"
+                    elif document.name:
+                        chunk_id = f"{document.name}_{chunk_number}"
+                    meta_data["chunk_size"] = len(sub_chunk)
+
+                    chunks.append(Document(id=chunk_id, name=document.name, meta_data=meta_data, content=sub_chunk))
+                    chunk_number += 1
             elif current_size + section_size <= self.chunk_size:
                 current_chunk.append(section)
                 current_size += section_size

agno/models/base.py

@@ -2109,6 +2109,7 @@ class Model(ABC):
                         tool_name=fc.function.name,
                         tool_args=fc.arguments,
                         requires_confirmation=True,
+                        external_execution_silent=fc.function.external_execution_silent,
                     )
                 )
 
@@ -2128,6 +2129,7 @@ class Model(ABC):
                         tool_args=fc.arguments,
                         requires_user_input=True,
                         user_input_schema=user_input_schema,
+                        external_execution_silent=fc.function.external_execution_silent,
                     )
                 )
 
@@ -2176,6 +2178,7 @@ class Model(ABC):
                         tool_name=fc.function.name,
                         tool_args=fc.arguments,
                         external_execution_required=True,
+                        external_execution_silent=fc.function.external_execution_silent,
                     )
                 )
 
@@ -2270,6 +2273,7 @@ class Model(ABC):
                         tool_name=fc.function.name,
                         tool_args=fc.arguments,
                         requires_confirmation=True,
+                        external_execution_silent=fc.function.external_execution_silent,
                     )
                 )
             # If the function requires user input, we yield a message to the user
@@ -2288,6 +2292,7 @@ class Model(ABC):
                         tool_args=fc.arguments,
                         requires_user_input=True,
                         user_input_schema=user_input_schema,
+                        external_execution_silent=fc.function.external_execution_silent,
                     )
                 )
             # If the function is from the user control flow tools, we handle it here
@@ -2340,6 +2345,7 @@ class Model(ABC):
                         tool_name=fc.function.name,
                         tool_args=fc.arguments,
                         external_execution_required=True,
+                        external_execution_silent=fc.function.external_execution_silent,
                     )
                 )
 

agno/models/moonshot/__init__.py

@@ -0,0 +1,3 @@
+from agno.models.moonshot.moonshot import MoonShot
+
+__all__ = ["MoonShot"]

agno/models/moonshot/moonshot.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.exceptions import ModelAuthenticationError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class MoonShot(OpenAILike):
+    """
+    A class for interacting with MoonShot models.
+
+    Attributes:
+        id (str): The model id. Defaults to "kimi-k2-thinking".
+        name (str): The model name. Defaults to "Moonshot".
+        provider (str): The provider name. Defaults to "Moonshot".
+        api_key (Optional[str]): The API key.
+        base_url (str): The base URL. Defaults to "https://api.moonshot.ai/v1".
+    """
+
+    id: str = "kimi-k2-thinking"
+    name: str = "Moonshot"
+    provider: str = "Moonshot"
+
+    api_key: Optional[str] = field(default_factory=lambda: getenv("MOONSHOT_API_KEY"))
+    base_url: str = "https://api.moonshot.ai/v1"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        # Fetch API key from env if not already set
+        if not self.api_key:
+            self.api_key = getenv("MOONSHOT_API_KEY")
+            if not self.api_key:
+                # Raise error immediately if key is missing
+                raise ModelAuthenticationError(
+                    message="MOONSHOT_API_KEY not set. Please set the MOONSHOT_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+
+        # Define base client params
+        base_params = {
+            "api_key": self.api_key,
+            "organization": self.organization,
+            "base_url": self.base_url,
+            "timeout": self.timeout,
+            "max_retries": self.max_retries,
+            "default_headers": self.default_headers,
+            "default_query": self.default_query,
+        }
+
+        # Create client_params dict with non-None values
+        client_params = {k: v for k, v in base_params.items() if v is not None}
+
+        # Add additional client params if provided
+        if self.client_params:
+            client_params.update(self.client_params)
+        return client_params

agno/models/response.py

@@ -52,6 +52,9 @@ class ToolExecution:
 
     external_execution_required: Optional[bool] = None
 
+    # If True (and external_execution_required=True), suppresses verbose paused messages
+    external_execution_silent: Optional[bool] = None
+
     @property
     def is_paused(self) -> bool:
         return bool(self.requires_confirmation or self.requires_user_input or self.external_execution_required)
@@ -84,6 +87,7 @@ class ToolExecution:
             if "user_input_schema" in data
             else None,
             external_execution_required=data.get("external_execution_required"),
+            external_execution_silent=data.get("external_execution_silent"),
             metrics=Metrics(**(data.get("metrics", {}) or {})),
             **{"created_at": data["created_at"]} if "created_at" in data else {},
         )

agno/models/utils.py

@@ -139,6 +139,11 @@ def _get_model_class(model_id: str, model_provider: str) -> Model:
 
         return MistralChat(id=model_id)
 
+    elif model_provider == "moonshot":
+        from agno.models.moonshot import MoonShot
+
+        return MoonShot(id=model_id)
+
     elif model_provider == "nebius":
         from agno.models.nebius import Nebius
 

agno/tools/decorator.py

@@ -70,6 +70,7 @@ def tool(
     requires_user_input: Optional[bool] = None,
     user_input_fields: Optional[List[str]] = None,
     external_execution: Optional[bool] = None,
+    external_execution_silent: Optional[bool] = None,
     pre_hook: Optional[Callable] = None,
     post_hook: Optional[Callable] = None,
     tool_hooks: Optional[List[Callable]] = None,
@@ -98,6 +99,7 @@ def tool(*args, **kwargs) -> Union[Function, Callable[[F], Function]]:
         requires_user_input: Optional[bool] - If True, the function will require user input before execution
         user_input_fields: Optional[List[str]] - List of fields that will be provided to the function as user input
         external_execution: Optional[bool] - If True, the function will be executed outside of the agent's context
+        external_execution_silent: Optional[bool] - If True (and external_execution=True), suppresses verbose paused messages (e.g., "I have tools to execute...")
         pre_hook: Optional[Callable] - Hook that runs before the function is executed.
         post_hook: Optional[Callable] - Hook that runs after the function is executed.
         tool_hooks: Optional[List[Callable]] - List of hooks that run before and after the function is executed.
@@ -135,6 +137,7 @@ def tool(*args, **kwargs) -> Union[Function, Callable[[F], Function]]:
             "requires_user_input",
             "user_input_fields",
             "external_execution",
+            "external_execution_silent",
             "pre_hook",
             "post_hook",
             "tool_hooks",

agno/tools/function.py

@@ -121,6 +121,9 @@ class Function(BaseModel):
     # If True, the function will be executed outside the agent's control.
     external_execution: Optional[bool] = None
 
+    # If True (and external_execution=True), the function will not produce verbose paused messages (e.g., "I have tools to execute...")
+    external_execution_silent: Optional[bool] = None
+
     # Caching configuration
     cache_results: bool = False
     cache_dir: Optional[str] = None

agno/tools/unsplash.py

@@ -0,0 +1,341 @@
+"""Unsplash Tools for searching and retrieving high-quality, royalty-free images.
+
+This toolkit provides AI agents with the ability to search for and retrieve images
+from Unsplash, a popular platform with over 4.3 million high-quality photos.
+
+Get your free API key at: https://unsplash.com/developers
+"""
+
+import json
+from os import getenv
+from typing import Any, Dict, List, Optional
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+
+class UnsplashTools(Toolkit):
+    """A toolkit for searching and retrieving images from Unsplash.
+
+    Unsplash provides access to over 4.3 million high-quality, royalty-free images
+    that can be used for various purposes. This toolkit enables AI agents to:
+    - Search for photos by keywords
+    - Get detailed information about specific photos
+    - Retrieve random photos with optional filters
+    - Track downloads (required by Unsplash API guidelines)
+
+    Example:
+        ```python
+        from agno.agent import Agent
+        from agno.models.openai import OpenAIChat
+        from agno.tools.unsplash import UnsplashTools
+
+        agent = Agent(
+            model=OpenAIChat(id="gpt-4o"),
+            tools=[UnsplashTools()],
+        )
+        agent.print_response("Find me 3 photos of mountains at sunset")
+        ```
+    """
+
+    def __init__(
+        self,
+        access_key: Optional[str] = None,
+        enable_search_photos: bool = True,
+        enable_get_photo: bool = True,
+        enable_get_random_photo: bool = True,
+        enable_download_photo: bool = False,
+        all: bool = False,
+        **kwargs: Any,
+    ):
+        """Initialize the Unsplash toolkit.
+
+        Args:
+            access_key: Unsplash API access key. If not provided, will look for
+                UNSPLASH_ACCESS_KEY environment variable.
+            enable_search_photos: Enable the search_photos tool. Default: True.
+            enable_get_photo: Enable the get_photo tool. Default: True.
+            enable_get_random_photo: Enable the get_random_photo tool. Default: True.
+            enable_download_photo: Enable the download_photo tool. Default: False.
+            all: Enable all tools. Default: False.
+            **kwargs: Additional arguments passed to the Toolkit base class.
+        """
+        self.access_key = access_key or getenv("UNSPLASH_ACCESS_KEY")
+        if not self.access_key:
+            logger.warning("No Unsplash API key provided. Set UNSPLASH_ACCESS_KEY environment variable.")
+
+        self.base_url = "https://api.unsplash.com"
+
+        tools: List[Any] = []
+        if all or enable_search_photos:
+            tools.append(self.search_photos)
+        if all or enable_get_photo:
+            tools.append(self.get_photo)
+        if all or enable_get_random_photo:
+            tools.append(self.get_random_photo)
+        if all or enable_download_photo:
+            tools.append(self.download_photo)
+
+        super().__init__(name="unsplash_tools", tools=tools, **kwargs)
+
+    def _make_request(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an authenticated request to the Unsplash API.
+
+        Args:
+            endpoint: API endpoint path (e.g., "/search/photos").
+            params: Optional query parameters.
+
+        Returns:
+            JSON response as a dictionary.
+
+        Raises:
+            Exception: If the API request fails.
+        """
+        url = f"{self.base_url}{endpoint}"
+        if params:
+            url = f"{url}?{urlencode(params)}"
+
+        headers = {
+            "Authorization": f"Client-ID {self.access_key}",
+            "Accept-Version": "v1",
+        }
+
+        request = Request(url, headers=headers)
+        with urlopen(request) as response:
+            return json.loads(response.read().decode())
+
+    def _format_photo(self, photo: Dict[str, Any]) -> Dict[str, Any]:
+        """Format photo data into a clean, consistent structure.
+
+        Args:
+            photo: Raw photo data from Unsplash API.
+
+        Returns:
+            Formatted photo dictionary with essential fields.
+        """
+        return {
+            "id": photo.get("id"),
+            "description": photo.get("description") or photo.get("alt_description"),
+            "width": photo.get("width"),
+            "height": photo.get("height"),
+            "color": photo.get("color"),
+            "created_at": photo.get("created_at"),
+            "urls": {
+                "raw": photo.get("urls", {}).get("raw"),
+                "full": photo.get("urls", {}).get("full"),
+                "regular": photo.get("urls", {}).get("regular"),
+                "small": photo.get("urls", {}).get("small"),
+                "thumb": photo.get("urls", {}).get("thumb"),
+            },
+            "author": {
+                "name": photo.get("user", {}).get("name"),
+                "username": photo.get("user", {}).get("username"),
+                "profile_url": photo.get("user", {}).get("links", {}).get("html"),
+            },
+            "links": {
+                "html": photo.get("links", {}).get("html"),
+                "download": photo.get("links", {}).get("download"),
+            },
+            "likes": photo.get("likes"),
+            "tags": [tag.get("title") for tag in photo.get("tags", [])[:5] if tag.get("title")],
+        }
+
+    def search_photos(
+        self,
+        query: str,
+        per_page: int = 10,
+        page: int = 1,
+        orientation: Optional[str] = None,
+        color: Optional[str] = None,
+    ) -> str:
+        """Search for photos on Unsplash by keyword.
+
+        Args:
+            query: The search query string (e.g., "mountain sunset", "office workspace").
+            per_page: Number of results per page (1-30). Default: 10.
+            page: Page number to retrieve. Default: 1.
+            orientation: Filter by orientation: "landscape", "portrait", or "squarish".
+            color: Filter by color: "black_and_white", "black", "white", "yellow",
+                "orange", "red", "purple", "magenta", "green", "teal", "blue".
+
+        Returns:
+            JSON string containing search results with photo details including
+            URLs, author information, and metadata.
+        """
+        if not self.access_key:
+            return "Error: No Unsplash API key provided. Set UNSPLASH_ACCESS_KEY environment variable."
+
+        if not query:
+            return "Error: Please provide a search query."
+
+        log_debug(f"Searching Unsplash for: {query}")
+
+        try:
+            params: Dict[str, Any] = {
+                "query": query,
+                "per_page": min(max(1, per_page), 30),
+                "page": max(1, page),
+            }
+
+            if orientation and orientation in ["landscape", "portrait", "squarish"]:
+                params["orientation"] = orientation
+
+            if color:
+                valid_colors = [
+                    "black_and_white",
+                    "black",
+                    "white",
+                    "yellow",
+                    "orange",
+                    "red",
+                    "purple",
+                    "magenta",
+                    "green",
+                    "teal",
+                    "blue",
+                ]
+                if color in valid_colors:
+                    params["color"] = color
+
+            response = self._make_request("/search/photos", params)
+
+            results = {
+                "total": response.get("total", 0),
+                "total_pages": response.get("total_pages", 0),
+                "photos": [self._format_photo(photo) for photo in response.get("results", [])],
+            }
+
+            return json.dumps(results, indent=2)
+
+        except Exception as e:
+            return f"Error searching Unsplash: {e}"
+
+    def get_photo(self, photo_id: str) -> str:
+        """Get detailed information about a specific photo.
+
+        Args:
+            photo_id: The unique identifier of the photo.
+
+        Returns:
+            JSON string containing detailed photo information including
+            URLs, author, metadata, EXIF data, and location if available.
+        """
+        if not self.access_key:
+            return "Error: No Unsplash API key provided. Set UNSPLASH_ACCESS_KEY environment variable."
+
+        if not photo_id:
+            return "Error: Please provide a photo ID."
+
+        log_debug(f"Getting Unsplash photo: {photo_id}")
+
+        try:
+            photo = self._make_request(f"/photos/{photo_id}")
+
+            result = self._format_photo(photo)
+
+            # Add extra details available for single photo requests
+            if photo.get("exif"):
+                result["exif"] = {
+                    "make": photo["exif"].get("make"),
+                    "model": photo["exif"].get("model"),
+                    "aperture": photo["exif"].get("aperture"),
+                    "exposure_time": photo["exif"].get("exposure_time"),
+                    "focal_length": photo["exif"].get("focal_length"),
+                    "iso": photo["exif"].get("iso"),
+                }
+
+            if photo.get("location"):
+                result["location"] = {
+                    "name": photo["location"].get("name"),
+                    "city": photo["location"].get("city"),
+                    "country": photo["location"].get("country"),
+                }
+
+            result["views"] = photo.get("views")
+            result["downloads"] = photo.get("downloads")
+
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            return f"Error getting photo: {e}"
+
+    def get_random_photo(
+        self,
+        query: Optional[str] = None,
+        orientation: Optional[str] = None,
+        count: int = 1,
+    ) -> str:
+        """Get random photo(s) from Unsplash.
+
+        Args:
+            query: Optional search query to filter random photos.
+            orientation: Filter by orientation: "landscape", "portrait", or "squarish".
+            count: Number of random photos to return (1-30). Default: 1.
+
+        Returns:
+            JSON string containing random photo(s) data.
+        """
+        if not self.access_key:
+            return "Error: No Unsplash API key provided. Set UNSPLASH_ACCESS_KEY environment variable."
+
+        log_debug(f"Getting random Unsplash photo (query={query})")
+
+        try:
+            params: Dict[str, Any] = {
+                "count": min(max(1, count), 30),
+            }
+
+            if query:
+                params["query"] = query
+
+            if orientation and orientation in ["landscape", "portrait", "squarish"]:
+                params["orientation"] = orientation
+
+            response = self._make_request("/photos/random", params)
+
+            # Response is a list when count > 1, single object when count = 1
+            if isinstance(response, list):
+                photos = [self._format_photo(photo) for photo in response]
+            else:
+                photos = [self._format_photo(response)]
+
+            return json.dumps({"photos": photos}, indent=2)
+
+        except Exception as e:
+            return f"Error getting random photo: {e}"
+
+    def download_photo(self, photo_id: str) -> str:
+        """Trigger a download event for a photo.
+
+        This is required by the Unsplash API guidelines when a photo is downloaded
+        or used. It helps photographers track the usage of their work.
+
+        Args:
+            photo_id: The unique identifier of the photo being downloaded.
+
+        Returns:
+            JSON string with the download URL.
+        """
+        if not self.access_key:
+            return "Error: No Unsplash API key provided. Set UNSPLASH_ACCESS_KEY environment variable."
+
+        if not photo_id:
+            return "Error: Please provide a photo ID."
+
+        log_debug(f"Tracking download for Unsplash photo: {photo_id}")
+
+        try:
+            response = self._make_request(f"/photos/{photo_id}/download")
+
+            return json.dumps(
+                {
+                    "photo_id": photo_id,
+                    "download_url": response.get("url"),
+                },
+                indent=2,
+            )
+
+        except Exception as e:
+            return f"Error tracking download: {e}"

agno/utils/print_response/agent.py

@@ -105,8 +105,9 @@ def print_response_stream(
                 if response_event.is_paused:  # type: ignore
                     response_event = cast(RunPausedEvent, response_event)  # type: ignore
                     response_panel = create_paused_run_output_panel(response_event)  # type: ignore
-                    panels.append(response_panel)
-                    live_log.update(Group(*panels))
+                    if response_panel is not None:
+                        panels.append(response_panel)
+                        live_log.update(Group(*panels))
                     return
 
                 if response_event.event == RunEvent.pre_hook_completed:  # type: ignore
@@ -310,8 +311,9 @@ async def aprint_response_stream(
             if isinstance(resp, tuple(get_args(RunOutputEvent))):
                 if resp.is_paused:
                     response_panel = create_paused_run_output_panel(resp)  # type: ignore
-                    panels.append(response_panel)
-                    live_log.update(Group(*panels))
+                    if response_panel is not None:
+                        panels.append(response_panel)
+                        live_log.update(Group(*panels))
                     break
 
                 if (
@@ -798,7 +800,8 @@ def build_panels(
 
     if isinstance(run_response, RunOutput) and run_response.is_paused:
         response_panel = create_paused_run_output_panel(run_response)
-        panels.append(response_panel)
+        if response_panel is not None:
+            panels.append(response_panel)
         return panels
 
     if isinstance(run_response, RunOutput) and run_response.reasoning_steps is not None:

agno/utils/response.py

@@ -80,35 +80,41 @@ def format_tool_calls(tool_calls: List[ToolExecution]) -> List[str]:
 def create_paused_run_output_panel(run_output: Union[RunPausedEvent, RunOutput]):
     from rich.text import Text
 
+    # Filter out silent tools - they don't produce verbose output
+    non_silent_tools = [tc for tc in (run_output.tools or []) if not tc.external_execution_silent]
+
+    # If all tools are silent, return None to indicate no panel should be shown
+    if not non_silent_tools:
+        return None
+
     tool_calls_content = Text("Run is paused. ")
-    if run_output.tools is not None:
-        if any(tc.requires_confirmation for tc in run_output.tools):
-            tool_calls_content.append("The following tool calls require confirmation:\n")
-        for tool_call in run_output.tools:
-            if tool_call.requires_confirmation:
-                args_str = ""
-                for arg, value in tool_call.tool_args.items() if tool_call.tool_args else {}:
-                    args_str += f"{arg}={value}, "
-                args_str = args_str.rstrip(", ")
-                tool_calls_content.append(f"• {tool_call.tool_name}({args_str})\n")
-        if any(tc.requires_user_input for tc in run_output.tools):
-            tool_calls_content.append("The following tool calls require user input:\n")
-        for tool_call in run_output.tools:
-            if tool_call.requires_user_input:
-                args_str = ""
-                for arg, value in tool_call.tool_args.items() if tool_call.tool_args else {}:
-                    args_str += f"{arg}={value}, "
-                args_str = args_str.rstrip(", ")
-                tool_calls_content.append(f"• {tool_call.tool_name}({args_str})\n")
-        if any(tc.external_execution_required for tc in run_output.tools):
-            tool_calls_content.append("The following tool calls require external execution:\n")
-        for tool_call in run_output.tools:
-            if tool_call.external_execution_required:
-                args_str = ""
-                for arg, value in tool_call.tool_args.items() if tool_call.tool_args else {}:
-                    args_str += f"{arg}={value}, "
-                args_str = args_str.rstrip(", ")
-                tool_calls_content.append(f"• {tool_call.tool_name}({args_str})\n")
+    if any(tc.requires_confirmation for tc in non_silent_tools):
+        tool_calls_content.append("The following tool calls require confirmation:\n")
+    for tool_call in non_silent_tools:
+        if tool_call.requires_confirmation:
+            args_str = ""
+            for arg, value in tool_call.tool_args.items() if tool_call.tool_args else {}:
+                args_str += f"{arg}={value}, "
+            args_str = args_str.rstrip(", ")
+            tool_calls_content.append(f"• {tool_call.tool_name}({args_str})\n")
+    if any(tc.requires_user_input for tc in non_silent_tools):
+        tool_calls_content.append("The following tool calls require user input:\n")
+    for tool_call in non_silent_tools:
+        if tool_call.requires_user_input:
+            args_str = ""
+            for arg, value in tool_call.tool_args.items() if tool_call.tool_args else {}:
+                args_str += f"{arg}={value}, "
+            args_str = args_str.rstrip(", ")
+            tool_calls_content.append(f"• {tool_call.tool_name}({args_str})\n")
+    if any(tc.external_execution_required for tc in non_silent_tools):
+        tool_calls_content.append("The following tool calls require external execution:\n")
+    for tool_call in non_silent_tools:
+        if tool_call.external_execution_required:
+            args_str = ""
+            for arg, value in tool_call.tool_args.items() if tool_call.tool_args else {}:
+                args_str += f"{arg}={value}, "
+            args_str = args_str.rstrip(", ")
+            tool_calls_content.append(f"• {tool_call.tool_name}({args_str})\n")
 
     # Create panel for response
     response_panel = create_panel(
@@ -122,6 +128,10 @@ def create_paused_run_output_panel(run_output: Union[RunPausedEvent, RunOutput])
 def get_paused_content(run_output: RunOutput) -> str:
     paused_content = ""
     for tool in run_output.tools or []:
+        # Skip silent tools - they don't produce verbose paused messages
+        if tool.external_execution_silent:
+            continue
+
         # Initialize flags for each tool
         confirmation_required = False
         user_input_required = False

agno/vectordb/lancedb/lance_db.py

@@ -282,9 +282,10 @@ class LanceDb(VectorDb):
                 meta_data.update(filters)
                 document.meta_data = meta_data
 
-            # Only embed if the document doesn't already have an embedding
+            # Only embed if the document doesn't already have a valid embedding
             # This prevents duplicate embedding when called from async_insert or async_upsert
-            if document.embedding is None:
+            # Check for both None and empty list (async embedding failures return [])
+            if document.embedding is None or (isinstance(document.embedding, list) and len(document.embedding) == 0):
                 document.embed(embedder=self.embedder)
             cleaned_content = document.content.replace("\x00", "\ufffd")
             # Include content_hash in ID to ensure uniqueness across different content hashes
@@ -363,12 +364,21 @@ class LanceDb(VectorDb):
                 else:
                     logger.warning(f"Async batch embedding failed, falling back to individual embeddings: {e}")
                     embed_tasks = [doc.async_embed(embedder=self.embedder) for doc in documents]
-                    await asyncio.gather(*embed_tasks, return_exceptions=True)
+                    results = await asyncio.gather(*embed_tasks, return_exceptions=True)
+                    # Log any embedding failures (they will be re-tried in sync insert)
+                    for i, result in enumerate(results):
+                        if isinstance(result, Exception):
+                            log_warning(f"Async embedding failed for document {i}, will retry in sync insert: {result}")
         else:
             embed_tasks = [doc.async_embed(embedder=self.embedder) for doc in documents]
-            await asyncio.gather(*embed_tasks, return_exceptions=True)
+            results = await asyncio.gather(*embed_tasks, return_exceptions=True)
+            # Log any embedding failures (they will be re-tried in sync insert)
+            for i, result in enumerate(results):
+                if isinstance(result, Exception):
+                    log_warning(f"Async embedding failed for document {i}, will retry in sync insert: {result}")
 
         # Use sync insert to avoid sync/async table synchronization issues
+        # Sync insert will re-embed any documents that failed async embedding
         self.insert(content_hash, documents, filters)
 
     def upsert_available(self) -> bool:
@@ -414,13 +424,25 @@ class LanceDb(VectorDb):
                     if is_rate_limit:
                         raise e
                     else:
+                        logger.warning(f"Async batch embedding failed, falling back to individual embeddings: {e}")
                         embed_tasks = [doc.async_embed(embedder=self.embedder) for doc in documents]
-                        await asyncio.gather(*embed_tasks, return_exceptions=True)
+                        results = await asyncio.gather(*embed_tasks, return_exceptions=True)
+                        # Log any embedding failures (they will be re-tried in sync upsert)
+                        for i, result in enumerate(results):
+                            if isinstance(result, Exception):
+                                log_warning(
+                                    f"Async embedding failed for document {i}, will retry in sync upsert: {result}"
+                                )
             else:
                 embed_tasks = [doc.async_embed(embedder=self.embedder) for doc in documents]
-                await asyncio.gather(*embed_tasks, return_exceptions=True)
+                results = await asyncio.gather(*embed_tasks, return_exceptions=True)
+                # Log any embedding failures (they will be re-tried in sync upsert)
+                for i, result in enumerate(results):
+                    if isinstance(result, Exception):
+                        log_warning(f"Async embedding failed for document {i}, will retry in sync upsert: {result}")
 
         # Use sync upsert for reliability
+        # Sync upsert (via insert) will re-embed any documents that failed async embedding
         self.upsert(content_hash=content_hash, documents=documents, filters=filters)
 
     def search(
@@ -897,7 +919,7 @@ class LanceDb(VectorDb):
 
             # Get all documents and filter in Python (LanceDB doesn't support JSON operators)
             total_count = self.table.count_rows()
-            results = self.table.search().select(["id", "payload"]).limit(total_count).to_pandas()
+            results = self.table.search().select(["id", "payload", "vector"]).limit(total_count).to_pandas()
 
             if results.empty:
                 logger.debug("No documents found")

agno/workflow/workflow.py

@@ -3822,6 +3822,7 @@ class Workflow:
         stream_events: Optional[bool] = None,
         background: Optional[bool] = False,
         background_tasks: Optional[Any] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
     ) -> WorkflowRunOutput: ...
 
     @overload
@@ -3841,6 +3842,7 @@ class Workflow:
         stream_events: Optional[bool] = None,
         background: Optional[bool] = False,
         background_tasks: Optional[Any] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
     ) -> Iterator[WorkflowRunOutputEvent]: ...
 
     def run(
@@ -3859,6 +3861,7 @@ class Workflow:
         stream_events: Optional[bool] = None,
         background: Optional[bool] = False,
         background_tasks: Optional[Any] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ) -> Union[WorkflowRunOutput, Iterator[WorkflowRunOutputEvent]]:
         """Execute the workflow synchronously with optional streaming"""
@@ -3938,6 +3941,7 @@ class Workflow:
             session_state=session_state,
             workflow_id=self.id,
             workflow_name=self.name,
+            dependencies=dependencies,
         )
 
         # Execute workflow agent if configured
@@ -4005,6 +4009,7 @@ class Workflow:
         background: Optional[bool] = False,
         websocket: Optional[WebSocket] = None,
         background_tasks: Optional[Any] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
     ) -> WorkflowRunOutput: ...
 
     @overload
@@ -4025,6 +4030,7 @@ class Workflow:
         background: Optional[bool] = False,
         websocket: Optional[WebSocket] = None,
         background_tasks: Optional[Any] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
     ) -> AsyncIterator[WorkflowRunOutputEvent]: ...
 
     def arun(  # type: ignore
@@ -4044,6 +4050,7 @@ class Workflow:
         background: Optional[bool] = False,
         websocket: Optional[WebSocket] = None,
         background_tasks: Optional[Any] = None,
+        dependencies: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ) -> Union[WorkflowRunOutput, AsyncIterator[WorkflowRunOutputEvent]]:
         """Execute the workflow synchronously with optional streaming"""
@@ -4109,6 +4116,7 @@ class Workflow:
             session_id=session_id,
             user_id=user_id,
             session_state=session_state,
+            dependencies=dependencies,
         )
 
         log_debug(f"Async Workflow Run Start: {self.name}", center=True)

{agno-2.4.3.dist-info → agno-2.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.4.3
+Version: 2.4.4
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com
@@ -531,7 +531,7 @@ https://github.com/user-attachments/assets/feb23db8-15cc-4e88-be7c-01a21a03ebf6
 
 ## Getting Started
 
-1. Follow the [getting started guide](https://github.com/agno-agi/agno/tree/main/cookbook/00_getting_started)
+1. Follow the [quickstart guide](https://github.com/agno-agi/agno/tree/main/cookbook/00_quickstart)
 2. Browse the [cookbook](https://github.com/agno-agi/agno/tree/main/cookbook) for real-world examples
 3. Read the [docs](https://docs.agno.com) to go deeper
 

{agno-2.4.3.dist-info → agno-2.4.4.dist-info}/RECORD

@@ -49,7 +49,7 @@ agno/db/dynamo/dynamo.py,sha256=NPPvVCjUVdmSU9EtzkWy80KSfDODfONyfXv8tNeYLpE,1106
 agno/db/dynamo/schemas.py,sha256=NbVLIEqe2D5QYhS9JAAPqK4RdADN3G6fBJbULzGtPKM,18507
 agno/db/dynamo/utils.py,sha256=z-s0FAWfiGJPT_k68rlArP5SnaXlW8ycnGi9dh4Nehc,28005
 agno/db/firestore/__init__.py,sha256=lYAJjUs4jMxJFty1GYZw464K35zeuBlcoFR9uuIQYtI,79
-agno/db/firestore/firestore.py,sha256=cK0yoiRSBgbcRG5OhK99JRcX1Cot5wniVJrEASK7_8A,95261
+agno/db/firestore/firestore.py,sha256=ZGua4k6_nh9vVApMNYD8983Ppf8ctkfvnL16sdikHmo,96256
 agno/db/firestore/schemas.py,sha256=dri9lGHxs-IsqvsgL_noFoeAVn9iZflMPsqHkNdA-DM,6123
 agno/db/firestore/utils.py,sha256=lshztynSRxYUQxA1LTCPZlugaW4VKOB5TtKjQ1BQ94s,14194
 agno/db/gcs_json/__init__.py,sha256=aTR4o3aFrzfANHtRw7nX9uc5_GsY52ch0rmoo7uXuc4,76
@@ -103,9 +103,9 @@ agno/db/sqlite/sqlite.py,sha256=0GQR3FS9UlDxFQs1VF_t5OXhw7FBccfL6CO8JZE7CKY,1765
 agno/db/sqlite/utils.py,sha256=PZp-g4oUf6Iw1kuDAmOpIBtfyg4poKiG_DxXP4EonFI,15721
 agno/db/surrealdb/__init__.py,sha256=C8qp5-Nx9YnSmgKEtGua-sqG_ntCXONBw1qqnNyKPqI,75
 agno/db/surrealdb/metrics.py,sha256=oKDRyjRQ6KR3HaO8zDHQLVMG7-0NDkOFOKX5I7mD5FA,10336
-agno/db/surrealdb/models.py,sha256=IUIpdd50MxznOB-hMstEcEHHVlWhll2FNQqVhM-9zIU,12889
+agno/db/surrealdb/models.py,sha256=BDs5yk1N3G6XGPDz3OYEwuGDkli5MwZHSRCTaFwbK8w,12899
 agno/db/surrealdb/queries.py,sha256=s__yJSFIx387IEflcDdti7T5j6H9NX_-zIj13F9CN9s,2051
-agno/db/surrealdb/surrealdb.py,sha256=9qFoa7OTnS8XIqCpqPfKGCXK2-dFPy7LuX_bSeQvjrQ,76749
+agno/db/surrealdb/surrealdb.py,sha256=RpjWArgMSzRE5MCclGVh-0d3T2bYmIIRB-1mJwHhgSo,77128
 agno/db/surrealdb/utils.py,sha256=PcZo_cTy-jI59I-XhzAomRLdV9-m0irtO4C-AYGSghs,5405
 agno/eval/__init__.py,sha256=RmiGpnwGm1dL9DpPMvzrXzFc1jRr111B361rTICVvXE,1173
 agno/eval/accuracy.py,sha256=20rxNKjH3_Y6lMPRlrnKiIBlJLfKMsCN8JiJZ9jGofk,33775
@@ -136,7 +136,7 @@ agno/knowledge/chunking/agentic.py,sha256=WeQ5ORe_CxsGYg0udOXjvwBo95hnpPZHVpFj-b
 agno/knowledge/chunking/code.py,sha256=YLdHL3muYz9MhDqxXPW7MGfqEph4KIZu6_RXPp6KUIc,3569
 agno/knowledge/chunking/document.py,sha256=uCHbPdZR4ILbm9RkpuVu8zw4dPIH0jd1XIRELOixRlI,6454
 agno/knowledge/chunking/fixed.py,sha256=Mz0QgxqVNSaOYPtzihLz6yJdz19zCZ8zLRXIREjgTb8,2371
-agno/knowledge/chunking/markdown.py,sha256=bVXyly0ywbCWrpaaiHocgcE0vAWCt3e9H8iDqnMXMak,10524
+agno/knowledge/chunking/markdown.py,sha256=5hiHuvuGJq0UBk7gwnFV5Q84MumXD39UNcY4qlzH1fk,14665
 agno/knowledge/chunking/recursive.py,sha256=PXeq-RF9nJ8alV771q0jEyl1C2QPMVFUTOiJSU0nStw,2357
 agno/knowledge/chunking/row.py,sha256=yFGKMsHd2Ml0fkJLksw8ULUpWXmbSXIQwnwlKHVPP40,1426
 agno/knowledge/chunking/semantic.py,sha256=_PVDvmtJhpoamtpn-kHq54rwLgrbScEky5yqUbBc6JQ,7267
@@ -213,12 +213,12 @@ agno/memory/strategies/base.py,sha256=bHtkZ27U9VXKezdaSWLJZELjK97GcpQUBefSa8BYpp
 agno/memory/strategies/summarize.py,sha256=4M9zWTsooC3EtHpZoC7Z-yFaQgQoebRMNfZPitdsvB0,7307
 agno/memory/strategies/types.py,sha256=b3N5jOG_dM4AxT7vGagFIc9sqUUjxFtRHSoH4_AhEx8,1225
 agno/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agno/models/base.py,sha256=W9NXmhGrqA_q1Wx97WrEUFk6YcxMu9miaZJH_8Z52d4,129282
+agno/models/base.py,sha256=YdyK6vqGEw35H7Q_TV8aRehF942Orkl0GFG_TG5TDo8,129816
 agno/models/defaults.py,sha256=1_fe4-ZbNriE8BgqxVRVi4KGzEYxYKYsz4hn6CZNEEM,40
 agno/models/message.py,sha256=5bZOFdZuhsQw06nNppvFJq-JGI4lqQt4sVhdjfEFBZM,19976
 agno/models/metrics.py,sha256=bQJ5DMoFcrb2EyA2VUm4u9HVGbgTKO5F1o2A_t_7hqI,4913
-agno/models/response.py,sha256=CWwWYyKCuUOECcafpUik3JHo1xGqpMFlmiJ0WyuDYT8,7756
-agno/models/utils.py,sha256=jxAIIG2y7KBypwFlc87GzFnvogRpGLfd-wwr6KXZIj8,7269
+agno/models/response.py,sha256=xZQ-2L5tciX70hTbniSp2XLt9OTBuasW4_lsWMGGfoM,7976
+agno/models/utils.py,sha256=FKzRbNm_hO_gdICBO-x4KWL6OkWIeipn07PeerUDR1M,7397
 agno/models/aimlapi/__init__.py,sha256=XQcFRvt4qJ8ol9nCC0XKEkVEDivdNf3nZNoJZMZ5m8M,78
 agno/models/aimlapi/aimlapi.py,sha256=ELPv8RuEc6qUq4JxWEJVRITsK71rzUxw6_cP3Zd8Vz0,2179
 agno/models/anthropic/__init__.py,sha256=nbReX3p17JCwfrMDR9hR7-OaEFZm80I7dng93dl-Fhw,77
@@ -269,6 +269,8 @@ agno/models/meta/llama.py,sha256=JvyuXtN7Em55U_uRy9cHEx5iw8FgbnQRPo32_1GsMxg,189
 agno/models/meta/llama_openai.py,sha256=B9kmyy9QlhZaa13N0b6UixHffxJPz4I4ds4a8ML0lyA,2653
 agno/models/mistral/__init__.py,sha256=6CP9TDn8oRUjtGBk1McvSQHrjY935vB6msGPlXBhkSw,86
 agno/models/mistral/mistral.py,sha256=FpyYp9zlnKuXVKBDhHSMNnHZTE-8m2w5h6ohoTlT6AE,16845
+agno/models/moonshot/__init__.py,sha256=epY4CBZyC5fw1ouUwqHZ1Xth1weMhPD3xUtTJuVUaOU,75
+agno/models/moonshot/moonshot.py,sha256=SzLgckZlyqkaXdIPBFnozIdTSLZFhZ-b9DVpX8ceFVM,2054
 agno/models/n1n/__init__.py,sha256=CymyKzTZWr-klifwaxzGTMDSVaPxBVtKOHQ-4VaPiWg,55
 agno/models/n1n/n1n.py,sha256=UW7MPHNAU0sfMTaHh7HIYcWVSuc_-I16KrrlsqF1I2U,1977
 agno/models/nebius/__init__.py,sha256=gW2yvxIfV2gxxOnBtTP8MCpI9AvMbIE6VTw-gY01Uvg,67
@@ -444,7 +446,7 @@ agno/tools/crawl4ai.py,sha256=5N6NJR5pSrNu0_zE__r4uA3cuTZDXUTLpq_wER0A5-k,6648
 agno/tools/csv_toolkit.py,sha256=1_G0cZJw1LBdXV0DZdHz-gzlQJCRocv9urU4g2WxBhw,7573
 agno/tools/dalle.py,sha256=WqkAquL3wLIUzLWbPBhdmT_JWVkyQadXJvb6R5zhuHk,4136
 agno/tools/daytona.py,sha256=I03Ddgvh6SJ5h5shpxw0lnDKq7ltMsUJK0kmnT2b0Mo,18446
-agno/tools/decorator.py,sha256=m49Gt-J4tpc-gjhwnMOdw4qvgYu2j4qGCrrZ91QP7ug,9728
+agno/tools/decorator.py,sha256=E6r_g4cOVEK-M0IvEb-RKzzceM6ngcjVwpa4Gc9FS_M,9986
 agno/tools/desi_vocal.py,sha256=dTeIaD7pabaZxPG9IxtQhaVpC6-A3-4hX4xIt5C7kA4,3661
 agno/tools/discord.py,sha256=KkqArWVMtwpqOC-fQ7MxHAOAL9-G0CqlXUWgjQNgvOA,5819
 agno/tools/docker.py,sha256=pk1OXW3Pk318gMoFjV2vXGA0HBc93DLs8eftOM7eRIQ,25837
@@ -460,7 +462,7 @@ agno/tools/file.py,sha256=8aqXQraboSseAj2nDJG-eTORYmTZ-I4uG5uRCGoOaf0,10285
 agno/tools/file_generation.py,sha256=OxJNeEGpqf_SxemvET54Gi_j6uT1xMWFbjbQOnTSdoY,14006
 agno/tools/financial_datasets.py,sha256=NiXwyiYIFCawI8rR7JLJNIfwoQlranUeCcABHKhLHfw,9190
 agno/tools/firecrawl.py,sha256=axrrM7bvXBRkX8cBUtfrJ_G0YIeSQWaCTDAgRuhFsNk,5623
-agno/tools/function.py,sha256=vNkdpBNcz5FivVEwv6430B235_E1zGCnyN-CEB_vXY0,49619
+agno/tools/function.py,sha256=Il_UxQ1xHCqr9q24b8UfYjQbtdESE32nJDVSUzsSGyc,49809
 agno/tools/giphy.py,sha256=_wOCWVnMdFByE9Yoz4Pf2MoKxSjkUTiPJZ928_BNe2M,3070
 agno/tools/github.py,sha256=wct6P00YzF3zgWoV2c5aHeXX_2dgb9LqRwJAboi6QXw,70286
 agno/tools/gmail.py,sha256=m_7SY4oz2sP0RSJyNItZ_h5VeyI86J8840_p5Nz_2So,37073
@@ -522,6 +524,7 @@ agno/tools/toolkit.py,sha256=_F5b63jQJqVTspGlaZGqbCZMrfJCNc7buTPr9dL7g_8,17662
 agno/tools/trafilatura.py,sha256=AK2Q_0jqwOqL8-0neMI6ZjuUt-w0dGvW-w8zE6FrZVs,14792
 agno/tools/trello.py,sha256=y2fc60ITCIXBOk4TX3w70YjkMvM9SMKsEYpfXOKWtOI,8546
 agno/tools/twilio.py,sha256=XUbUhFJdLxP3nlNx2UdS9aHva-HSIGHD01cHHuE9Rfg,6752
+agno/tools/unsplash.py,sha256=7nG1nAco2y1oBTnupqx4eD4usDi9LQoHiTI0VDISAFc,12253
 agno/tools/user_control_flow.py,sha256=uL2p7j4N8DR_t5Hby6p8gBar9Wj1RVgiZ5mKXynv0Oo,4494
 agno/tools/valyu.py,sha256=HBPYVthZRHK6BWsmkHCUz9iC9P8IgdBMrbAmGsp6nR0,8669
 agno/tools/visualization.py,sha256=YxAQHzOV0N8yZij-Kq2eIC92oQUeKx9k9pfgOcNDcnI,16683
@@ -586,7 +589,7 @@ agno/utils/pprint.py,sha256=aTg3gfib3x3VK3E-xJrbBeufK7s77ebTVtWoa2VrYgU,7762
 agno/utils/prompts.py,sha256=wQU85SshxCDvZL1vD4rMWSnLhjQZCLXBL3HpOpiirXo,5811
 agno/utils/reasoning.py,sha256=pW5y674EjJ-R6IX8Fyxi_vN9xLG5dLkujPpcfSVL1jU,3862
 agno/utils/remote.py,sha256=MG-Dj2nzTvdOZke3T-wr9UcsCMIJPcTS-BP8_FSv6gc,688
-agno/utils/response.py,sha256=6gfo3NdpzQJx0W8Ts4HBbJ69ZqqHuM7pJi1RD4zWF6g,6870
+agno/utils/response.py,sha256=5g14L1P3lQ9G_jh90J9cmxFE5HMZLQbPSGYV1EbfP_E,7159
 agno/utils/response_iterator.py,sha256=MgtadrOuMcw2vJcVvhJdMKRzpVddhLWUIkGFbBz7ZCQ,379
 agno/utils/safe_formatter.py,sha256=zLrW6O-nGUZvXoDkZOTgVpjeUFTmMUj8pk3FLvW_XjM,809
 agno/utils/serialize.py,sha256=XvQA_KSkVd5qI1QuZwdQpCsl1IOKddFu52Jl6WQASqU,904
@@ -610,7 +613,7 @@ agno/utils/models/openai_responses.py,sha256=63f2UgDFCzrr6xQITrGtn42UUHQBcZFUUFM
 agno/utils/models/schema_utils.py,sha256=L6TkraMClI471H6xYy7V81lhHR4qQloVKCN0bF4Ajw0,5047
 agno/utils/models/watsonx.py,sha256=fe6jN0hBvOCQurqjS6_9PIwDHt-4kVod9qW236Zs6DU,1496
 agno/utils/print_response/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agno/utils/print_response/agent.py,sha256=Ej6l6sn4ZfwpPjF3JbEj6K88_pvJIiMwahLsXHK77RU,40263
+agno/utils/print_response/agent.py,sha256=GCC0i-NRYaJzJ2x8B1igVaZ1-hDv_4E1GbvvgiG9xdc,40424
 agno/utils/print_response/team.py,sha256=8uu0mfqnkTEDR1Jo6AYNUWHXtQZPh1apkzVh7MQj5Kc,88763
 agno/utils/print_response/workflow.py,sha256=pZ7DmJaLx0FWNzXJCKs6gplmA0XAzqxZK1nLQNfePW0,78707
 agno/vectordb/__init__.py,sha256=P0QP9PUC4j2JtWIfYJX7LeC-oiPuh_QsUaOaP1ZY_dI,64
@@ -629,7 +632,7 @@ agno/vectordb/clickhouse/index.py,sha256=_YW-8AuEYy5kzOHi0zIzjngpQPgJOBdSrn9BfEL
 agno/vectordb/couchbase/__init__.py,sha256=dKZkcQLFN4r2_NIdXby4inzAAn4BDMlb9T2BW_i0_gQ,93
 agno/vectordb/couchbase/couchbase.py,sha256=SDyNQGq_wD5mkUIQGkYtR7AZCUxf7fIw50YmI0N1T5U,65636
 agno/vectordb/lancedb/__init__.py,sha256=tb9qvinKyWMTLjJYMwW_lhYHFvrfWTfHODtBfMj-NLE,111
-agno/vectordb/lancedb/lance_db.py,sha256=z603icggxlrCa8wNnDPRitVp-pkVGHbfLHOHmfrUhYs,39752
+agno/vectordb/lancedb/lance_db.py,sha256=G1wCwM_oex78i2gUsRiHsL83qzmWacLQvYZ5933BWl8,41587
 agno/vectordb/langchaindb/__init__.py,sha256=BxGs6tcEKTiydbVJL3P5djlnafS5Bbgql3u1k6vhW2w,108
 agno/vectordb/langchaindb/langchaindb.py,sha256=AS-Jrh7gXKYkSHFiXKiD0kwL-FUFz10VbYksm8UEBAU,6391
 agno/vectordb/lightrag/__init__.py,sha256=fgQpA8pZW-jEHI91SZ_xgmROmv14oKdwCQZ8LpyipaE,84
@@ -669,9 +672,9 @@ agno/workflow/router.py,sha256=6rwsdOXNQX2OKcm_p2nOvqyWUnnVdiwRCZNnYwkQ7N8,31320
 agno/workflow/step.py,sha256=AgSugOOoWidfZGFtR5PMpgWSBpIeUQB45vmaUDnV7E8,77919
 agno/workflow/steps.py,sha256=p1RdyTZIKDYOPdxU7FbsX_vySWehPWaobge76Q_UDac,26462
 agno/workflow/types.py,sha256=t4304WCKB19QFdV3ixXZICcU8wtBza4EBCIz5Ve6MSQ,18035
-agno/workflow/workflow.py,sha256=7n29-5Xs4WFfbHnNwuTs2U7TW3QdT69mWARf0jbRj6M,218201
-agno-2.4.3.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-agno-2.4.3.dist-info/METADATA,sha256=-bF2-AoKVtmOiJiZI1bz36DyXCY7dMJCc3KhPH1YtWQ,22239
-agno-2.4.3.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-agno-2.4.3.dist-info/top_level.txt,sha256=MKyeuVesTyOKIXUhc-d_tPa2Hrh0oTA4LM0izowpx70,5
-agno-2.4.3.dist-info/RECORD,,
+agno/workflow/workflow.py,sha256=S4Iwx3LtpeE_XZ61slYvnM90BdnGhW6Gfax_BKEUG68,218609
+agno-2.4.4.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+agno-2.4.4.dist-info/METADATA,sha256=ULxZRXgBJ7i2ZJQ61KZSeaSt8ySYUX7DsY8YHs42ooQ,22229
+agno-2.4.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+agno-2.4.4.dist-info/top_level.txt,sha256=MKyeuVesTyOKIXUhc-d_tPa2Hrh0oTA4LM0izowpx70,5
+agno-2.4.4.dist-info/RECORD,,

{agno-2.4.3.dist-info → agno-2.4.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any