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

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/team/team.py

@@ -343,6 +343,8 @@ class Team:
     # Add a tool to search the knowledge base (aka Agentic RAG)
     # Only added if knowledge is provided.
     search_knowledge: bool = True
+    # If True, add search_knowledge instructions to the system prompt
+    add_search_knowledge_instructions: bool = True
 
     # If False, media (images, videos, audio, files) is only available to tools and not sent to the LLM
     send_media_to_model: bool = True
@@ -530,6 +532,7 @@ class Team:
         share_member_interactions: bool = False,
         get_member_information_tool: bool = False,
         search_knowledge: bool = True,
+        add_search_knowledge_instructions: bool = True,
         read_chat_history: bool = False,
         store_media: bool = True,
         store_tool_messages: bool = True,
@@ -653,6 +656,7 @@ class Team:
         self.share_member_interactions = share_member_interactions
         self.get_member_information_tool = get_member_information_tool
         self.search_knowledge = search_knowledge
+        self.add_search_knowledge_instructions = add_search_knowledge_instructions
         self.read_chat_history = read_chat_history
 
         self.store_media = store_media
@@ -5675,16 +5679,6 @@ class Team:
         if self.name is not None and self.add_name_to_context:
             additional_information.append(f"Your name is: {self.name}.")
 
-        # Add knowledge context using protocol's build_context
-        if self.knowledge is not None:
-            build_context_fn = getattr(self.knowledge, "build_context", None)
-            if callable(build_context_fn):
-                knowledge_context = build_context_fn(
-                    enable_agentic_filters=self.enable_agentic_knowledge_filters,
-                )
-                if knowledge_context:
-                    additional_information.append(knowledge_context)
-
         # 2 Build the default system message for the Agent.
         system_message_content: str = ""
         if self.members is not None and len(self.members) > 0:
@@ -5788,6 +5782,16 @@ class Team:
                 "You should ALWAYS prefer information from this conversation over the past summary.\n\n"
             )
 
+        # Add search_knowledge instructions to the system prompt
+        if self.knowledge is not None and self.search_knowledge and self.add_search_knowledge_instructions:
+            build_context_fn = getattr(self.knowledge, "build_context", None)
+            if callable(build_context_fn):
+                knowledge_context = build_context_fn(
+                    enable_agentic_filters=self.enable_agentic_knowledge_filters,
+                )
+                if knowledge_context:
+                    system_message_content += knowledge_context + "\n"
+
         if self.description is not None:
             system_message_content += f"<description>\n{self.description}\n</description>\n\n"
 
@@ -5971,16 +5975,6 @@ class Team:
         if self.name is not None and self.add_name_to_context:
             additional_information.append(f"Your name is: {self.name}.")
 
-        # Add knowledge context using protocol's build_context
-        if self.knowledge is not None:
-            build_context_fn = getattr(self.knowledge, "build_context", None)
-            if callable(build_context_fn):
-                knowledge_context = build_context_fn(
-                    enable_agentic_filters=self.enable_agentic_knowledge_filters,
-                )
-                if knowledge_context:
-                    additional_information.append(knowledge_context)
-
         # 2 Build the default system message for the Agent.
         system_message_content: str = ""
         system_message_content += "You are the leader of a team and sub-teams of AI Agents.\n"
@@ -6089,6 +6083,16 @@ class Team:
                 "You should ALWAYS prefer information from this conversation over the past summary.\n\n"
             )
 
+        # Add search_knowledge instructions to the system prompt
+        if self.knowledge is not None and self.search_knowledge and self.add_search_knowledge_instructions:
+            build_context_fn = getattr(self.knowledge, "build_context", None)
+            if callable(build_context_fn):
+                knowledge_context = build_context_fn(
+                    enable_agentic_filters=self.enable_agentic_knowledge_filters,
+                )
+                if knowledge_context:
+                    system_message_content += knowledge_context + "\n"
+
         if self.description is not None:
             system_message_content += f"<description>\n{self.description}\n</description>\n\n"
 
@@ -8359,6 +8363,8 @@ class Team:
             config["add_knowledge_to_context"] = self.add_knowledge_to_context
         if not self.search_knowledge:  # default is True
             config["search_knowledge"] = self.search_knowledge
+        if self.add_search_knowledge_instructions:
+            config["add_search_knowledge_instructions"] = self.add_search_knowledge_instructions
         if self.references_format != "json":  # default is "json"
             config["references_format"] = self.references_format
 
@@ -8717,6 +8723,7 @@ class Team:
             add_knowledge_to_context=config.get("add_knowledge_to_context", False),
             update_knowledge=config.get("update_knowledge", False),
             search_knowledge=config.get("search_knowledge", True),
+            add_search_knowledge_instructions=config.get("add_search_knowledge_instructions", True),
             references_format=config.get("references_format", "json"),
             # --- Tools ---
             tools=config.get("tools"),

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/seltz.py

@@ -0,0 +1,134 @@
+import json
+from os import getenv
+from typing import Any, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_info, logger
+
+try:
+    from seltz import Seltz
+    from seltz.exceptions import (
+        SeltzAPIError,
+        SeltzAuthenticationError,
+        SeltzConfigurationError,
+        SeltzConnectionError,
+        SeltzError,
+        SeltzRateLimitError,
+        SeltzTimeoutError,
+    )
+except ImportError as exc:
+    raise ImportError("`seltz` not installed. Please install using `pip install seltz`") from exc
+
+
+class SeltzTools(Toolkit):
+    """Toolkit for interacting with the Seltz AI-powered search API.
+
+    Args:
+        api_key: Seltz API key. If not provided, uses the `SELTZ_API_KEY` env var.
+        endpoint: Optional Seltz gRPC endpoint. If not provided, uses SDK default.
+        insecure: Use an insecure gRPC channel. Defaults to False.
+        max_documents: Default maximum number of documents to return per search.
+        show_results: Log search results for debugging.
+        enable_search: Enable search tool functionality. Defaults to True.
+        all: Enable all tools. Overrides individual flags when True. Defaults to False.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        insecure: bool = False,
+        max_documents: int = 10,
+        show_results: bool = False,
+        enable_search: bool = True,
+        all: bool = False,
+        **kwargs: Any,
+    ):
+        if max_documents <= 0:
+            raise ValueError("max_documents must be greater than 0")
+
+        self.api_key = api_key or getenv("SELTZ_API_KEY")
+        if not self.api_key:
+            logger.error("SELTZ_API_KEY not set. Please set the SELTZ_API_KEY environment variable.")
+
+        self.endpoint = endpoint
+        self.insecure = insecure
+        self.max_documents = max_documents
+        self.show_results = show_results
+
+        self.client: Optional[Seltz] = None
+        if self.api_key:
+            client_kwargs: dict[str, Any] = {"api_key": self.api_key}
+            if self.endpoint:
+                client_kwargs["endpoint"] = self.endpoint
+            if self.insecure:
+                client_kwargs["insecure"] = self.insecure
+            self.client = Seltz(**client_kwargs)
+
+        tools: List[Any] = []
+        if all or enable_search:
+            tools.append(self.search_seltz)
+
+        super().__init__(name="seltz", tools=tools, **kwargs)
+
+    def _parse_documents(self, documents: Any) -> str:
+        """Convert Seltz documents into JSON for the agent."""
+        parsed: List[dict[str, Any]] = []
+        for doc in documents or []:
+            doc_dict: dict[str, Any] = {}
+            url = getattr(doc, "url", None)
+            content = getattr(doc, "content", None)
+
+            if url is not None:
+                doc_dict["url"] = url
+            if content:
+                doc_dict["content"] = content
+            if doc_dict:
+                parsed.append(doc_dict)
+        return json.dumps(parsed, indent=4, ensure_ascii=False)
+
+    def search_seltz(self, query: str, max_documents: Optional[int] = None) -> str:
+        """Use this function to search Seltz for a query.
+
+        Args:
+            query: The query to search for.
+            max_documents: Maximum number of documents to return. Defaults to toolkit `max_documents`.
+
+        Returns:
+            str: Search results in JSON format.
+        """
+        if not query:
+            return "Error: Please provide a query to search for."
+
+        if not self.client:
+            return "Error: SELTZ_API_KEY not set. Please set the SELTZ_API_KEY environment variable."
+
+        limit = max_documents if max_documents is not None else self.max_documents
+        if limit <= 0:
+            return "Error: max_documents must be greater than 0."
+
+        try:
+            if self.show_results:
+                log_info(f"Searching Seltz for: {query}")
+
+            response = self.client.search(query, max_documents=limit)
+            result = self._parse_documents(getattr(response, "documents", []))
+
+            if self.show_results:
+                log_info(result)
+
+            return result
+        except (
+            SeltzConfigurationError,
+            SeltzAuthenticationError,
+            SeltzConnectionError,
+            SeltzTimeoutError,
+            SeltzRateLimitError,
+            SeltzAPIError,
+            SeltzError,
+        ) as exc:
+            logger.error(f"Seltz error: {exc}")
+            return f"Error: {exc}"
+        except Exception as exc:
+            logger.error(f"Failed to search Seltz: {exc}")
+            return f"Error: {exc}"