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

agno/knowledge/reader/markdown_reader.py

@@ -67,12 +67,12 @@ class MarkdownReader(Reader):
                     raise FileNotFoundError(f"Could not find file: {file}")
                 log_info(f"Reading: {file}")
                 file_name = name or file.stem
-                file_contents = file.read_text("utf-8")
+                file_contents = file.read_text(encoding=self.encoding or "utf-8")
             else:
                 log_info(f"Reading uploaded file: {file.name}")
                 file_name = name or file.name.split(".")[0]
                 file.seek(0)
-                file_contents = file.read().decode("utf-8")
+                file_contents = file.read().decode(self.encoding or "utf-8")
 
             documents = [Document(name=file_name, id=str(uuid.uuid4()), content=file_contents)]
             if self.chunk:
@@ -97,16 +97,16 @@ class MarkdownReader(Reader):
                 try:
                     import aiofiles
 
-                    async with aiofiles.open(file, "r", encoding="utf-8") as f:
+                    async with aiofiles.open(file, "r", encoding=self.encoding or "utf-8") as f:
                         file_contents = await f.read()
                 except ImportError:
                     logger.warning("aiofiles not installed, using synchronous file I/O")
-                    file_contents = file.read_text("utf-8")
+                    file_contents = file.read_text(self.encoding or "utf-8")
             else:
                 log_info(f"Reading uploaded file asynchronously: {file.name}")
                 file_name = name or file.name.split(".")[0]
                 file.seek(0)
-                file_contents = file.read().decode("utf-8")
+                file_contents = file.read().decode(self.encoding or "utf-8")
 
             document = Document(
                 name=file_name,

agno/knowledge/reader/s3_reader.py

@@ -74,18 +74,6 @@ class S3Reader(Reader):
                 obj_name = s3_object.name.split("/")[-1]
                 temporary_file = Path("storage").joinpath(obj_name)
                 s3_object.download(temporary_file)
-
-                # TODO: Before we were using textract here. Needed?
-                # s3_object.download(temporary_file)
-                # doc_content = textract.process(temporary_file)
-                # documents = [
-                #     Document(
-                #         name=doc_name,
-                #         id=doc_name,
-                #         content=doc_content.decode("utf-8"),
-                #     )
-                # ]
-
                 documents = TextReader().read(file=temporary_file, name=doc_name)
 
                 temporary_file.unlink()

agno/knowledge/reader/text_reader.py

@@ -39,12 +39,12 @@ class TextReader(Reader):
                     raise FileNotFoundError(f"Could not find file: {file}")
                 log_info(f"Reading: {file}")
                 file_name = name or file.stem
-                file_contents = file.read_text("utf-8")
+                file_contents = file.read_text(self.encoding or "utf-8")
             else:
                 file_name = name or file.name.split(".")[0]
                 log_info(f"Reading uploaded file: {file_name}")
                 file.seek(0)
-                file_contents = file.read().decode("utf-8")
+                file_contents = file.read().decode(self.encoding or "utf-8")
 
             documents = [
                 Document(
@@ -75,16 +75,16 @@ class TextReader(Reader):
                 try:
                     import aiofiles
 
-                    async with aiofiles.open(file, "r", encoding="utf-8") as f:
+                    async with aiofiles.open(file, "r", encoding=self.encoding or "utf-8") as f:
                         file_contents = await f.read()
                 except ImportError:
                     logger.warning("aiofiles not installed, using synchronous file I/O")
-                    file_contents = file.read_text("utf-8")
+                    file_contents = file.read_text(self.encoding or "utf-8")
             else:
                 log_info(f"Reading uploaded file asynchronously: {file.name}")
                 file_name = name or file.name.split(".")[0]
                 file.seek(0)
-                file_contents = file.read().decode("utf-8")
+                file_contents = file.read().decode(self.encoding or "utf-8")
 
             document = Document(
                 name=file_name,

agno/models/base.py

@@ -1228,7 +1228,7 @@ class Model(ABC):
             function_execution_result=function_execution_result,
         )
         yield ModelResponse(
-            content=f"{function_call.get_call_str()} completed in {function_call_timer.elapsed:.4f}s.",
+            content=f"{function_call.get_call_str()} completed in {function_call_timer.elapsed:.4f}s. ",
             tool_executions=[
                 ToolExecution(
                     tool_call_id=function_call_result.tool_call_id,
@@ -1632,7 +1632,7 @@ class Model(ABC):
                 function_execution_result=function_execution_result,
             )
             yield ModelResponse(
-                content=f"{function_call.get_call_str()} completed in {function_call_timer.elapsed:.4f}s.",
+                content=f"{function_call.get_call_str()} completed in {function_call_timer.elapsed:.4f}s. ",
                 tool_executions=[
                     ToolExecution(
                         tool_call_id=function_call_result.tool_call_id,

agno/models/cerebras/cerebras.py

@@ -45,7 +45,7 @@ class Cerebras(Model):
     supports_json_schema_outputs: bool = True
 
     # Request parameters
-    parallel_tool_calls: bool = False
+    parallel_tool_calls: Optional[bool] = None
     max_completion_tokens: Optional[int] = None
     repetition_penalty: Optional[float] = None
     temperature: Optional[float] = None
@@ -166,7 +166,6 @@ class Cerebras(Model):
                     "type": "function",
                     "function": {
                         "name": tool["function"]["name"],
-                        "strict": True,  # Ensure strict adherence to expected outputs
                         "description": tool["function"]["description"],
                         "parameters": tool["function"]["parameters"],
                     },
@@ -174,7 +173,10 @@ class Cerebras(Model):
                 for tool in tools
             ]
             # Cerebras requires parallel_tool_calls=False for llama-4-scout-17b-16e-instruct
-            request_params["parallel_tool_calls"] = self.parallel_tool_calls
+            if self.id == "llama-4-scout-17b-16e-instruct":
+                request_params["parallel_tool_calls"] = False
+            elif self.parallel_tool_calls is not None:
+                request_params["parallel_tool_calls"] = self.parallel_tool_calls
 
         # Handle response format for structured outputs
         if response_format is not None:

agno/models/cerebras/cerebras_openai.py

@@ -16,7 +16,7 @@ class CerebrasOpenAI(OpenAILike):
     name: str = "CerebrasOpenAI"
     provider: str = "CerebrasOpenAI"
 
-    parallel_tool_calls: bool = False
+    parallel_tool_calls: Optional[bool] = None
     base_url: str = "https://api.cerebras.ai/v1"
     api_key: Optional[str] = getenv("CEREBRAS_API_KEY", None)
 
@@ -44,7 +44,6 @@ class CerebrasOpenAI(OpenAILike):
                     "type": "function",
                     "function": {
                         "name": tool["function"]["name"],
-                        "strict": True,  # Ensure strict adherence to expected outputs
                         "description": tool["function"]["description"],
                         "parameters": tool["function"]["parameters"],
                     },
@@ -52,7 +51,10 @@ class CerebrasOpenAI(OpenAILike):
                 for tool in tools
             ]
             # Cerebras requires parallel_tool_calls=False for llama-4-scout-17b-16e-instruct
-            request_params["parallel_tool_calls"] = self.parallel_tool_calls
+            if self.id == "llama-4-scout-17b-16e-instruct":
+                request_params["parallel_tool_calls"] = False
+            elif self.parallel_tool_calls is not None:
+                request_params["parallel_tool_calls"] = self.parallel_tool_calls
 
         if request_params:
             log_debug(f"Calling {self.provider} with request parameters: {request_params}", log_level=2)

agno/models/google/gemini.py

@@ -87,7 +87,7 @@ class Gemini(Model):
     presence_penalty: Optional[float] = None
     frequency_penalty: Optional[float] = None
     seed: Optional[int] = None
-    response_modalities: Optional[list[str]] = None  # "Text" and/or "Image"
+    response_modalities: Optional[list[str]] = None  # "TEXT", "IMAGE", and/or "AUDIO"
     speech_config: Optional[dict[str, Any]] = None
     cached_content: Optional[Any] = None
     thinking_budget: Optional[int] = None  # Thinking budget for Gemini 2.5 models
@@ -817,11 +817,21 @@ class Gemini(Model):
                                 model_response.content += content_str
 
                 if hasattr(part, "inline_data") and part.inline_data is not None:
-                    if model_response.images is None:
-                        model_response.images = []
-                    model_response.images.append(
-                        Image(id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type)
-                    )
+                    # Handle audio responses (for TTS models)
+                    if part.inline_data.mime_type and part.inline_data.mime_type.startswith("audio/"):
+                        # Store raw bytes data
+                        model_response.audio = Audio(
+                            id=str(uuid4()),
+                            content=part.inline_data.data,
+                            mime_type=part.inline_data.mime_type,
+                        )
+                    # Image responses
+                    else:
+                        if model_response.images is None:
+                            model_response.images = []
+                        model_response.images.append(
+                            Image(id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type)
+                        )
 
                 # Extract function call if present
                 if hasattr(part, "function_call") and part.function_call is not None:
@@ -929,11 +939,23 @@ class Gemini(Model):
                                 model_response.content += text_content
 
                     if hasattr(part, "inline_data") and part.inline_data is not None:
-                        if model_response.images is None:
-                            model_response.images = []
-                        model_response.images.append(
-                            Image(id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type)
-                        )
+                        # Audio responses
+                        if part.inline_data.mime_type and part.inline_data.mime_type.startswith("audio/"):
+                            # Store raw bytes audio data
+                            model_response.audio = Audio(
+                                id=str(uuid4()),
+                                content=part.inline_data.data,
+                                mime_type=part.inline_data.mime_type,
+                            )
+                        # Image responses
+                        else:
+                            if model_response.images is None:
+                                model_response.images = []
+                            model_response.images.append(
+                                Image(
+                                    id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type
+                                )
+                            )
 
                     # Extract function call if present
                     if hasattr(part, "function_call") and part.function_call is not None:

agno/models/litellm/chat.py

@@ -47,7 +47,7 @@ class LiteLLM(Model):
         super().__post_init__()
 
         # Set up API key from environment variable if not already set
-        if not self.api_key:
+        if not self.client and not self.api_key:
             self.api_key = getenv("LITELLM_API_KEY")
             if not self.api_key:
                 # Check for other present valid keys, e.g. OPENAI_API_KEY if self.id is an OpenAI model

agno/models/openai/chat.py

@@ -70,6 +70,7 @@ class OpenAIChat(Model):
     service_tier: Optional[str] = None  # "auto" | "default" | "flex" | "priority", defaults to "auto" when not set
     extra_headers: Optional[Any] = None
     extra_query: Optional[Any] = None
+    extra_body: Optional[Any] = None
     request_params: Optional[Dict[str, Any]] = None
     role_map: Optional[Dict[str, str]] = None
 
@@ -191,6 +192,7 @@ class OpenAIChat(Model):
             "top_p": self.top_p,
             "extra_headers": self.extra_headers,
             "extra_query": self.extra_query,
+            "extra_body": self.extra_body,
             "metadata": self.metadata,
             "service_tier": self.service_tier,
         }
@@ -270,6 +272,7 @@ class OpenAIChat(Model):
                 "user": self.user,
                 "extra_headers": self.extra_headers,
                 "extra_query": self.extra_query,
+                "extra_body": self.extra_body,
                 "service_tier": self.service_tier,
             }
         )

agno/models/openai/responses.py

@@ -20,9 +20,10 @@ from agno.utils.models.schema_utils import get_response_schema_for_provider
 try:
     from openai import APIConnectionError, APIStatusError, AsyncOpenAI, OpenAI, RateLimitError
     from openai.types.responses.response import Response
+    from openai.types.responses.response_reasoning_item import ResponseReasoningItem
     from openai.types.responses.response_stream_event import ResponseStreamEvent
     from openai.types.responses.response_usage import ResponseUsage
-except (ImportError, ModuleNotFoundError) as e:
+except ImportError as e:
     raise ImportError("`openai` not installed. Please install using `pip install openai -U`") from e
 
 
@@ -55,6 +56,9 @@ class OpenAIResponses(Model):
     truncation: Optional[Literal["auto", "disabled"]] = None
     user: Optional[str] = None
     service_tier: Optional[Literal["auto", "default", "flex", "priority"]] = None
+    extra_headers: Optional[Any] = None
+    extra_query: Optional[Any] = None
+    extra_body: Optional[Any] = None
     request_params: Optional[Dict[str, Any]] = None
 
     # Client parameters
@@ -201,6 +205,9 @@ class OpenAIResponses(Model):
             "truncation": self.truncation,
             "user": self.user,
             "service_tier": self.service_tier,
+            "extra_headers": self.extra_headers,
+            "extra_query": self.extra_query,
+            "extra_body": self.extra_body,
         }
         # Populate the reasoning parameter
         base_params = self._set_reasoning_request_param(base_params)
@@ -256,23 +263,36 @@ class OpenAIResponses(Model):
 
         # Handle reasoning tools for o3 and o4-mini models
         if self._using_reasoning_model() and messages is not None:
-            request_params["store"] = True
-
-            # Check if the last assistant message has a previous_response_id to continue from
-            previous_response_id = None
-            for msg in reversed(messages):
-                if (
-                    msg.role == "assistant"
-                    and hasattr(msg, "provider_data")
-                    and msg.provider_data
-                    and "response_id" in msg.provider_data
-                ):
-                    previous_response_id = msg.provider_data["response_id"]
-                    log_debug(f"Using previous_response_id: {previous_response_id}")
-                    break
+            if self.store is False:
+                request_params["store"] = False
+
+                # Add encrypted reasoning content to include if not already present
+                include_list = request_params.get("include", []) or []
+                if "reasoning.encrypted_content" not in include_list:
+                    include_list.append("reasoning.encrypted_content")
+                    if request_params.get("include") is None:
+                        request_params["include"] = include_list
+                    elif isinstance(request_params["include"], list):
+                        request_params["include"].extend(include_list)
 
-            if previous_response_id:
-                request_params["previous_response_id"] = previous_response_id
+            else:
+                request_params["store"] = True
+
+                # Check if the last assistant message has a previous_response_id to continue from
+                previous_response_id = None
+                for msg in reversed(messages):
+                    if (
+                        msg.role == "assistant"
+                        and hasattr(msg, "provider_data")
+                        and msg.provider_data
+                        and "response_id" in msg.provider_data
+                    ):
+                        previous_response_id = msg.provider_data["response_id"]
+                        log_debug(f"Using previous_response_id: {previous_response_id}")
+                        break
+
+                if previous_response_id:
+                    request_params["previous_response_id"] = previous_response_id
 
         # Add additional request params if provided
         if self.request_params:
@@ -375,7 +395,7 @@ class OpenAIResponses(Model):
 
         return formatted_tools
 
-    def _format_messages(self, messages: List[Message]) -> List[Dict[str, Any]]:
+    def _format_messages(self, messages: List[Message]) -> List[Union[Dict[str, Any], ResponseReasoningItem]]:
         """
         Format a message into the format expected by OpenAI.
 
@@ -385,22 +405,23 @@ class OpenAIResponses(Model):
         Returns:
             Dict[str, Any]: The formatted message.
         """
-        formatted_messages: List[Dict[str, Any]] = []
+        formatted_messages: List[Union[Dict[str, Any], ResponseReasoningItem]] = []
 
         if self._using_reasoning_model():
             # Detect whether we're chaining via previous_response_id. If so, we should NOT
             # re-send prior function_call items; the Responses API already has the state and
             # expects only the corresponding function_call_output items.
             previous_response_id: Optional[str] = None
-            for msg in reversed(messages):
-                if (
-                    msg.role == "assistant"
-                    and hasattr(msg, "provider_data")
-                    and msg.provider_data
-                    and "response_id" in msg.provider_data
-                ):
-                    previous_response_id = msg.provider_data["response_id"]
-                    break
+            if self.store is not False:
+                for msg in reversed(messages):
+                    if (
+                        msg.role == "assistant"
+                        and hasattr(msg, "provider_data")
+                        and msg.provider_data
+                        and "response_id" in msg.provider_data
+                    ):
+                        previous_response_id = msg.provider_data["response_id"]
+                        break
 
         # Build a mapping from function_call id (fc_*) → call_id (call_*) from prior assistant tool_calls
         fc_id_to_call_id: Dict[str, str] = {}
@@ -475,6 +496,12 @@ class OpenAIResponses(Model):
                 content = message.content if message.content is not None else ""
                 formatted_messages.append({"role": self.role_map[message.role], "content": content})
 
+                if self.store is False and hasattr(message, "provider_data") and message.provider_data is not None:
+                    if message.provider_data.get("reasoning_output") is not None:
+                        reasoning_output = ResponseReasoningItem.model_validate(
+                            message.provider_data["reasoning_output"]
+                        )
+                        formatted_messages.append(reasoning_output)
         return formatted_messages
 
     def invoke(
@@ -858,7 +885,7 @@ class OpenAIResponses(Model):
 
         # Add role
         model_response.role = "assistant"
-        reasoning_summary: str = ""
+        reasoning_summary: Optional[str] = None
 
         for output in response.output:
             # Add content
@@ -898,8 +925,14 @@ class OpenAIResponses(Model):
                 model_response.extra = model_response.extra or {}
                 model_response.extra.setdefault("tool_call_ids", []).append(output.call_id)
 
-            # Add reasoning summary
+            # Handle reasoning output items
             elif output.type == "reasoning":
+                # Save encrypted reasoning content for ZDR mode
+                if self.store is False:
+                    if model_response.provider_data is None:
+                        model_response.provider_data = {}
+                    model_response.provider_data["reasoning_output"] = output.model_dump(exclude_none=True)
+
                 if reasoning_summaries := getattr(output, "summary", None):
                     for summary in reasoning_summaries:
                         if isinstance(summary, dict):
@@ -1009,19 +1042,27 @@ class OpenAIResponses(Model):
         elif stream_event.type == "response.completed":
             model_response = ModelResponse()
 
-            # Add reasoning summary
-            if self.reasoning_summary is not None:
+            # Handle reasoning output items
+            if self.reasoning_summary is not None or self.store is False:
                 summary_text: str = ""
                 for out in getattr(stream_event.response, "output", []) or []:
                     if getattr(out, "type", None) == "reasoning":
-                        summaries = getattr(out, "summary", None)
-                        if summaries:
-                            for s in summaries:
-                                text_val = s.get("text") if isinstance(s, dict) else getattr(s, "text", None)
-                                if text_val:
-                                    if summary_text:
-                                        summary_text += "\n\n"
-                                    summary_text += text_val
+                        # In ZDR mode (store=False), store reasoning data for next request
+                        if self.store is False and hasattr(out, "encrypted_content"):
+                            if model_response.provider_data is None:
+                                model_response.provider_data = {}
+                            # Store the complete output item
+                            model_response.provider_data["reasoning_output"] = out.model_dump(exclude_none=True)
+                        if self.reasoning_summary is not None:
+                            summaries = getattr(out, "summary", None)
+                            if summaries:
+                                for s in summaries:
+                                    text_val = s.get("text") if isinstance(s, dict) else getattr(s, "text", None)
+                                    if text_val:
+                                        if summary_text:
+                                            summary_text += "\n\n"
+                                        summary_text += text_val
+
                 if summary_text:
                     model_response.reasoning_content = summary_text
 

agno/models/response.py

@@ -29,11 +29,15 @@ class ToolExecution:
     result: Optional[str] = None
     metrics: Optional[Metrics] = None
 
+    # In the case where a tool call creates a run of an agent/team/workflow
+    child_run_id: Optional[str] = None
+
     # If True, the agent will stop executing after this tool call.
     stop_after_tool_call: bool = False
 
     created_at: int = int(time())
 
+    # User control flow requirements
     requires_confirmation: Optional[bool] = None
     confirmed: Optional[bool] = None
     confirmation_note: Optional[str] = None
@@ -66,6 +70,7 @@ class ToolExecution:
             tool_args=data.get("tool_args"),
             tool_call_error=data.get("tool_call_error"),
             result=data.get("result"),
+            child_run_id=data.get("child_run_id"),
             stop_after_tool_call=data.get("stop_after_tool_call", False),
             requires_confirmation=data.get("requires_confirmation"),
             confirmed=data.get("confirmed"),

agno/models/siliconflow/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.siliconflow.siliconflow import Siliconflow
+
+__all__ = [
+    "Siliconflow",
+]

agno/models/siliconflow/siliconflow.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Optional
+
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class Siliconflow(OpenAILike):
+    """
+    A class for interacting with Siliconflow API.
+
+    Attributes:
+        id (str): The id of the Siliconflow model to use. Default is "Qwen/QwQ-32B".
+        name (str): The name of this chat model instance. Default is "Siliconflow".
+        provider (str): The provider of the model. Default is "Siliconflow".
+        api_key (str): The api key to authorize request to Siliconflow.
+        base_url (str): The base url to which the requests are sent. Defaults to "https://api.siliconflow.cn/v1".
+    """
+
+    id: str = "Qwen/QwQ-32B"
+    name: str = "Siliconflow"
+    provider: str = "Siliconflow"
+    api_key: Optional[str] = getenv("SILICONFLOW_API_KEY")
+    base_url: str = "https://api.siliconflow.com/v1"

agno/os/app.py

@@ -27,8 +27,9 @@ from agno.os.config import (
     SessionDomainConfig,
 )
 from agno.os.interfaces.base import BaseInterface
-from agno.os.router import get_base_router
+from agno.os.router import get_base_router, get_websocket_router
 from agno.os.routers.evals import get_eval_router
+from agno.os.routers.health import get_health_router
 from agno.os.routers.knowledge import get_knowledge_router
 from agno.os.routers.memory import get_memory_router
 from agno.os.routers.metrics import get_metrics_router
@@ -208,6 +209,8 @@ class AgentOS:
 
         # Add routes
         self.fastapi_app.include_router(get_base_router(self, settings=self.settings))
+        self.fastapi_app.include_router(get_websocket_router(self, settings=self.settings))
+        self.fastapi_app.include_router(get_health_router())
 
         for interface in self.interfaces:
             interface_router = interface.get_router()

agno/os/auth.py

@@ -1,7 +1,5 @@
-from typing import Optional
-
-from fastapi import Header, HTTPException
-from fastapi.security import HTTPBearer
+from fastapi import Depends, HTTPException
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 
 from agno.os.settings import AgnoAPISettings
 
@@ -20,23 +18,16 @@ def get_authentication_dependency(settings: AgnoAPISettings):
         A dependency function that can be used with FastAPI's Depends()
     """
 
-    def auth_dependency(authorization: Optional[str] = Header(None)) -> bool:
+    def auth_dependency(credentials: HTTPAuthorizationCredentials = Depends(security)) -> bool:
         # If no security key is set, skip authentication entirely
         if not settings or not settings.os_security_key:
             return True
 
         # If security is enabled but no authorization header provided, fail
-        if not authorization:
+        if not credentials:
             raise HTTPException(status_code=401, detail="Authorization header required")
 
-        # Check if the authorization header starts with "Bearer "
-        if not authorization.startswith("Bearer "):
-            raise HTTPException(
-                status_code=401, detail="Invalid authorization header format. Expected 'Bearer <token>'"
-            )
-
-        # Extract the token from the authorization header
-        token = authorization[7:]  # Remove "Bearer " prefix
+        token = credentials.credentials
 
         # Verify the token
         if token != settings.os_security_key:
@@ -45,3 +36,22 @@ def get_authentication_dependency(settings: AgnoAPISettings):
         return True
 
     return auth_dependency
+
+
+def validate_websocket_token(token: str, settings: AgnoAPISettings) -> bool:
+    """
+    Validate a bearer token for WebSocket authentication.
+
+    Args:
+        token: The bearer token to validate
+        settings: The API settings containing the security key
+
+    Returns:
+        True if the token is valid or authentication is disabled, False otherwise
+    """
+    # If no security key is set, skip authentication entirely
+    if not settings or not settings.os_security_key:
+        return True
+
+    # Verify the token matches the configured security key
+    return token == settings.os_security_key

agno/os/interfaces/slack/router.py

@@ -10,7 +10,7 @@ from agno.utils.log import log_info
 
 
 def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None) -> APIRouter:
-    @router.post("/slack/events")
+    @router.post("/events")
     async def slack_events(request: Request, background_tasks: BackgroundTasks):
         body = await request.body()
         timestamp = request.headers.get("X-Slack-Request-Timestamp")

agno/os/interfaces/whatsapp/router.py

@@ -167,6 +167,8 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
                         )
                         await _send_whatsapp_message(phone_number, response.content)  # type: ignore
                 await _send_whatsapp_message(phone_number, response.content)  # type: ignore
+            else:
+                await _send_whatsapp_message(phone_number, response.content)  # type: ignore
 
         except Exception as e:
             log_error(f"Error processing message: {str(e)}")