agno 2.0.1__tar.gz → 2.0.3__tar.gz

{agno-2.0.1 → agno-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.0.1
+Version: 2.0.3
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com

{agno-2.0.1 → agno-2.0.3}/agno/agent/agent.py

@@ -4518,7 +4518,8 @@ class Agent:
         session = self.get_session(session_id=session_id)  # type: ignore
 
         if session is None:
-            raise Exception("Session not found")
+            log_warning(f"Session {session_id} not found")
+            return []
 
         # Only filter by agent_id if this is part of a team
         return session.get_messages_from_last_n_runs(

{agno-2.0.1 → agno-2.0.3}/agno/knowledge/chunking/fixed.py

@@ -7,7 +7,7 @@ from agno.knowledge.document.base import Document
 class FixedSizeChunking(ChunkingStrategy):
     """Chunking strategy that splits text into fixed-size chunks with optional overlap"""
 
-    def __init__(self, chunk_size: int = 100, overlap: int = 0):
+    def __init__(self, chunk_size: int = 5000, overlap: int = 0):
         # overlap must be less than chunk size
         if overlap >= chunk_size:
             raise ValueError(f"Invalid parameters: overlap ({overlap}) must be less than chunk size ({chunk_size}).")

{agno-2.0.1 → agno-2.0.3}/agno/knowledge/reader/base.py

@@ -19,6 +19,7 @@ class Reader:
     name: Optional[str] = None
     description: Optional[str] = None
     max_results: int = 5  # Maximum number of results to return (useful for search-based readers)
+    encoding: Optional[str] = None
 
     def __init__(
         self,
@@ -29,6 +30,7 @@ class Reader:
         name: Optional[str] = None,
         description: Optional[str] = None,
         max_results: int = 5,
+        encoding: Optional[str] = None,
         **kwargs,
     ) -> None:
         self.chunk = chunk
@@ -40,6 +42,7 @@ class Reader:
         self.name = name
         self.description = description
         self.max_results = max_results
+        self.encoding = encoding
 
     def set_chunking_strategy_from_string(self, strategy_name: str, **kwargs) -> None:
         """Set the chunking strategy from a string name."""

{agno-2.0.1 → agno-2.0.3}/agno/knowledge/reader/csv_reader.py

@@ -47,7 +47,7 @@ class CSVReader(Reader):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
                 logger.info(f"Reading: {file}")
-                file_content = file.open(newline="", mode="r", encoding="utf-8")
+                file_content = file.open(newline="", mode="r", encoding=self.encoding or "utf-8")
             else:
                 logger.info(f"Reading retrieved file: {name or file.name}")
                 file.seek(0)

{agno-2.0.1 → agno-2.0.3}/agno/knowledge/reader/json_reader.py

@@ -43,7 +43,7 @@ class JSONReader(Reader):
                     raise FileNotFoundError(f"Could not find file: {path}")
                 log_info(f"Reading: {path}")
                 json_name = name or path.name.split(".")[0]
-                json_contents = json.loads(path.read_text("utf-8"))
+                json_contents = json.loads(path.read_text(self.encoding or "utf-8"))
 
             elif isinstance(path, BytesIO):
                 json_name = name or path.name.split(".")[0]

{agno-2.0.1 → agno-2.0.3}/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-2.0.1 → agno-2.0.3}/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-2.0.1 → agno-2.0.3}/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-2.0.3/agno/knowledge/reranker/__init__.py

@@ -0,0 +1,3 @@
+from agno.knowledge.reranker.base import Reranker
+
+__all__ = ["Reranker"]

{agno-2.0.1 → agno-2.0.3}/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-2.0.1 → agno-2.0.3}/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-2.0.1 → agno-2.0.3}/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-2.0.1 → agno-2.0.3}/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-2.0.1 → agno-2.0.3}/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
 
 
@@ -256,23 +257,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 +389,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 +399,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 +490,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 +879,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 +919,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 +1036,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-2.0.1 → agno-2.0.3}/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-2.0.1 → agno-2.0.3}/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)}")