agno 2.4.3__tar.gz → 2.4.4__tar.gz

{agno-2.4.3 → agno-2.4.4}/PKG-INFO

@@ -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 → agno-2.4.4}/README.md

@@ -98,7 +98,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 → agno-2.4.4}/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-2.4.3 → agno-2.4.4}/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-2.4.3 → agno-2.4.4}/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-2.4.3 → agno-2.4.4}/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-2.4.3 → agno-2.4.4}/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-2.4.4/agno/models/moonshot/__init__.py

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

agno-2.4.4/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-2.4.3 → agno-2.4.4}/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-2.4.3 → agno-2.4.4}/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-2.4.3 → agno-2.4.4}/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-2.4.3 → agno-2.4.4}/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