agno 1.7.9__py3-none-any.whl → 1.7.11__py3-none-any.whl

agno/knowledge/pdf.py

@@ -2,15 +2,22 @@ from pathlib import Path
 from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Union
 
 from pydantic import Field
+from typing_extensions import TypedDict
 
 from agno.document import Document
 from agno.document.reader.pdf_reader import PDFImageReader, PDFReader
 from agno.knowledge.agent import AgentKnowledge
-from agno.utils.log import log_info, logger
+from agno.utils.log import log_error, log_info, logger
+
+
+class PDFConfig(TypedDict, total=False):
+    path: str
+    password: Optional[str]
+    metadata: Optional[Dict[str, Any]]
 
 
 class PDFKnowledgeBase(AgentKnowledge):
-    path: Optional[Union[str, Path, List[Dict[str, Union[str, Dict[str, Any]]]]]] = None
+    path: Optional[Union[str, Path, List[PDFConfig]]] = None
     formats: List[str] = [".pdf"]
     exclude_files: List[str] = Field(default_factory=list)
     reader: Union[PDFReader, PDFImageReader] = PDFReader()
@@ -24,19 +31,21 @@ class PDFKnowledgeBase(AgentKnowledge):
         if isinstance(self.path, list):
             for item in self.path:
                 if isinstance(item, dict) and "path" in item:
-                    # Handle path with metadata
                     file_path = item["path"]
                     config = item.get("metadata", {})
+                    file_password = item.get("password")
+                    if file_password is not None and not isinstance(file_password, str):
+                        file_password = None
+
                     _pdf_path = Path(file_path)  # type: ignore
                     if self._is_valid_pdf(_pdf_path):
-                        documents = self.reader.read(pdf=_pdf_path)
+                        documents = self.reader.read(pdf=_pdf_path, password=file_password)
                         if config:
                             for doc in documents:
                                 log_info(f"Adding metadata {config} to document: {doc.name}")
                                 doc.meta_data.update(config)  # type: ignore
                         yield documents
         else:
-            # Handle single path
             _pdf_path = Path(self.path)
             if _pdf_path.is_dir():
                 for _pdf in _pdf_path.glob("**/*.pdf"):
@@ -47,7 +56,19 @@ class PDFKnowledgeBase(AgentKnowledge):
 
     def _is_valid_pdf(self, path: Path) -> bool:
         """Helper to check if path is a valid PDF file."""
-        return path.exists() and path.is_file() and path.suffix == ".pdf" and path.name not in self.exclude_files
+        if not path.exists():
+            log_error(f"PDF file not found: {path}")
+            return False
+        if not path.is_file():
+            log_error(f"Path is not a file: {path}")
+            return False
+        if path.suffix != ".pdf":
+            log_error(f"File is not a PDF: {path}")
+            return False
+        if path.name in self.exclude_files:
+            log_error(f"PDF file excluded: {path}")
+            return False
+        return True
 
     @property
     async def async_document_lists(self) -> AsyncIterator[List[Document]]:
@@ -58,12 +79,15 @@ class PDFKnowledgeBase(AgentKnowledge):
         if isinstance(self.path, list):
             for item in self.path:
                 if isinstance(item, dict) and "path" in item:
-                    # Handle path with metadata
                     file_path = item["path"]
                     config = item.get("metadata", {})
+                    file_password = item.get("password")
+                    if file_password is not None and not isinstance(file_password, str):
+                        file_password = None
+
                     _pdf_path = Path(file_path)  # type: ignore
                     if self._is_valid_pdf(_pdf_path):
-                        documents = await self.reader.async_read(pdf=_pdf_path)
+                        documents = await self.reader.async_read(pdf=_pdf_path, password=file_password)
                         if config:
                             for doc in documents:
                                 log_info(f"Adding metadata {config} to document: {doc.name}")

agno/knowledge/pdf_url.py

@@ -19,18 +19,22 @@ class PDFUrlKnowledgeBase(AgentKnowledge):
 
         for item in self.urls:
             if isinstance(item, dict) and "url" in item:
-                # Handle URL with metadata
+                # Handle URL with metadata/password
                 url = item["url"]
                 config = item.get("metadata", {})
+                pdf_password = item.get("password")
+                if pdf_password is not None and not isinstance(pdf_password, str):
+                    pdf_password = None
+
                 if self._is_valid_url(url):  # type: ignore
-                    documents = self.reader.read(url=url)  # type: ignore
+                    documents = self.reader.read(url=url, password=pdf_password)  # type: ignore
                     if config:
                         for doc in documents:
                             log_info(f"Adding metadata {config} to document from URL: {url}")
                             doc.meta_data.update(config)  # type: ignore
                     yield documents
             else:
-                # Handle simple URL
+                # Handle simple URL - no password
                 if self._is_valid_url(item):  # type: ignore
                     yield self.reader.read(url=item)  # type: ignore
 
@@ -49,11 +53,15 @@ class PDFUrlKnowledgeBase(AgentKnowledge):
 
         for item in self.urls:
             if isinstance(item, dict) and "url" in item:
-                # Handle URL with metadata
+                # Handle URL with metadata/password
                 url = item["url"]
                 config = item.get("metadata", {})
+                pdf_password = item.get("password")
+                if pdf_password is not None and not isinstance(pdf_password, str):
+                    pdf_password = None
+
                 if self._is_valid_url(url):  # type: ignore
-                    documents = await self.reader.async_read(url=url)  # type: ignore
+                    documents = await self.reader.async_read(url=url, password=pdf_password)  # type: ignore
                     if config:
                         for doc in documents:
                             log_info(f"Adding metadata {config} to document from URL: {url}")

agno/knowledge/website.py

@@ -4,6 +4,7 @@ from typing import Any, AsyncIterator, Dict, Iterator, List, Optional
 from pydantic import model_validator
 
 from agno.document import Document
+from agno.document.chunking.fixed import FixedSizeChunking
 from agno.document.reader.website_reader import WebsiteReader
 from agno.knowledge.agent import AgentKnowledge
 from agno.utils.log import log_debug, log_info, logger
@@ -21,7 +22,9 @@ class WebsiteKnowledgeBase(AgentKnowledge):
     def set_reader(self) -> "WebsiteKnowledgeBase":
         if self.reader is None:
             self.reader = WebsiteReader(
-                max_depth=self.max_depth, max_links=self.max_links, chunking_strategy=self.chunking_strategy
+                max_depth=self.max_depth,
+                max_links=self.max_links,
+                chunking_strategy=self.chunking_strategy or FixedSizeChunking(),
             )
         return self
 

agno/media.py

@@ -319,6 +319,8 @@ class File(BaseModel):
     mime_type: Optional[str] = None
     # External file object (e.g. GeminiFile, must be a valid object as expected by the model you are using)
     external: Optional[Any] = None
+    format: Optional[str] = None  # E.g. `pdf`, `txt`, `csv`, `xml`, etc.
+    name: Optional[str] = None  # Name of the file, mandatory for AWS Bedrock document input
 
     @model_validator(mode="before")
     @classmethod

agno/models/aws/bedrock.py

@@ -27,6 +27,11 @@ except ImportError:
     AIOBOTO3_AVAILABLE = False
 
 
+BEDROCK_SUPPORTED_IMAGE_FORMATS = ["png", "jpeg", "webp", "gif"]
+BEDROCK_SUPPORTED_VIDEO_FORMATS = ["mp4", "mov", "mkv", "webm", "flv", "mpeg", "mpg", "wmv", "three_gp"]
+BEDROCK_SUPPORTED_FILE_FORMATS = ["pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"]
+
+
 @dataclass
 class AwsBedrock(Model):
     """
@@ -262,11 +267,16 @@ class AwsBedrock(Model):
 
                 if message.images:
                     for image in message.images:
-                        if not image.content or not image.format:
-                            raise ValueError("Image content and format are required.")
+                        if not image.content:
+                            raise ValueError("Image content is required for AWS Bedrock.")
+                        if not image.format:
+                            raise ValueError("Image format is required for AWS Bedrock.")
 
-                        if image.format not in ["png", "jpeg", "webp", "gif"]:
-                            raise ValueError(f"Unsupported image format: {image.format}")
+                        if image.format not in BEDROCK_SUPPORTED_IMAGE_FORMATS:
+                            raise ValueError(
+                                f"Unsupported image format: {image.format}. "
+                                f"Supported formats: {BEDROCK_SUPPORTED_IMAGE_FORMATS}"
+                            )
 
                         formatted_message["content"].append(
                             {
@@ -283,21 +293,16 @@ class AwsBedrock(Model):
 
                 if message.videos:
                     for video in message.videos:
-                        if not video.content or not video.format:
-                            raise ValueError("Video content and format are required.")
-
-                        if video.format not in [
-                            "mp4",
-                            "mov",
-                            "mkv",
-                            "webm",
-                            "flv",
-                            "mpeg",
-                            "mpg",
-                            "wmv",
-                            "three_gp",
-                        ]:
-                            raise ValueError(f"Unsupported video format: {video.format}")
+                        if not video.content:
+                            raise ValueError("Video content is required for AWS Bedrock.")
+                        if not video.format:
+                            raise ValueError("Video format is required for AWS Bedrock.")
+
+                        if video.format not in BEDROCK_SUPPORTED_VIDEO_FORMATS:
+                            raise ValueError(
+                                f"Unsupported video format: {video.format}. "
+                                f"Supported formats: {BEDROCK_SUPPORTED_VIDEO_FORMATS}"
+                            )
 
                         formatted_message["content"].append(
                             {
@@ -309,8 +314,33 @@ class AwsBedrock(Model):
                                 }
                             }
                         )
-                if message.files is not None and len(message.files) > 0:
-                    log_warning("File input is currently unsupported.")
+
+                if message.files:
+                    for file in message.files:
+                        if not file.content:
+                            raise ValueError("File content is required for AWS Bedrock document input.")
+                        if not file.format:
+                            raise ValueError("File format is required for AWS Bedrock document input.")
+                        if not file.name:
+                            raise ValueError("File name is required for AWS Bedrock document input.")
+
+                        if file.format not in BEDROCK_SUPPORTED_FILE_FORMATS:
+                            raise ValueError(
+                                f"Unsupported file format: {file.format}. "
+                                f"Supported formats: {BEDROCK_SUPPORTED_FILE_FORMATS}"
+                            )
+
+                        formatted_message["content"].append(
+                            {
+                                "document": {
+                                    "format": file.format,
+                                    "name": file.name,
+                                    "source": {
+                                        "bytes": file.content,
+                                    },
+                                }
+                            }
+                        )
 
                 formatted_messages.append(formatted_message)
         # TODO: Add caching: https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-call.html

agno/models/dashscope/__init__.py

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

agno/models/dashscope/dashscope.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from agno.exceptions import ModelProviderError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class DashScope(OpenAILike):
+    """
+    A class for interacting with Qwen models via DashScope API.
+
+    Attributes:
+        id (str): The model id. Defaults to "qwen-plus".
+        name (str): The model name. Defaults to "Qwen".
+        provider (str): The provider name. Defaults to "Qwen".
+        api_key (Optional[str]): The DashScope API key.
+        base_url (str): The base URL. Defaults to "https://dashscope-intl.aliyuncs.com/compatible-mode/v1".
+        enable_thinking (Optional[bool]): Enable thinking process (DashScope native parameter). Defaults to None.
+        include_thoughts (Optional[bool]): Include thinking process in response (alternative parameter). Defaults to None.
+    """
+
+    id: str = "qwen-plus"
+    name: str = "Qwen"
+    provider: str = "Dashscope"
+
+    api_key: Optional[str] = getenv("DASHSCOPE_API_KEY") or getenv("QWEN_API_KEY")
+    base_url: str = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+
+    # Thinking parameters
+    enable_thinking: Optional[bool] = None
+    include_thoughts: Optional[bool] = None
+
+    # DashScope supports structured outputs
+    supports_native_structured_outputs: bool = True
+    supports_json_schema_outputs: bool = True
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        if not self.api_key:
+            self.api_key = getenv("DASHSCOPE_API_KEY")
+            if not self.api_key:
+                raise ModelProviderError(
+                    message="DASHSCOPE_API_KEY not set. Please set the DASHSCOPE_API_KEY environment variable.",
+                    model_name=self.name,
+                    model_id=self.id,
+                )
+
+        # 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
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        params = super().get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice)
+
+        should_include_thoughts = self.enable_thinking or self.include_thoughts
+        if should_include_thoughts:
+            params["extra_body"] = {"enable_thinking": True}
+        return params

agno/models/openai/chat.py

@@ -694,6 +694,9 @@ class OpenAIChat(Model):
                 if choice_delta.tool_calls is not None:
                     model_response.tool_calls = choice_delta.tool_calls  # type: ignore
 
+                if hasattr(choice_delta, "reasoning_content") and choice_delta.reasoning_content is not None:
+                    model_response.reasoning_content = choice_delta.reasoning_content
+
                 # Add audio if present
                 if hasattr(choice_delta, "audio") and choice_delta.audio is not None:
                     try:

agno/models/openai/responses.py

@@ -78,6 +78,10 @@ class OpenAIResponses(Model):
         }
     )
 
+    def _using_reasoning_model(self) -> bool:
+        """Return True if the contextual used model is a known reasoning model."""
+        return self.id.startswith("o3") or self.id.startswith("o4-mini") or self.id.startswith("gpt-5")
+
     def _get_client_params(self) -> Dict[str, Any]:
         """
         Get client parameters for API requests.
@@ -221,7 +225,7 @@ class OpenAIResponses(Model):
             request_params["tool_choice"] = tool_choice
 
         # Handle reasoning tools for o3 and o4-mini models
-        if (self.id.startswith("o3") or self.id.startswith("o4-mini")) and messages is not None:
+        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
@@ -352,6 +356,33 @@ class OpenAIResponses(Model):
             Dict[str, Any]: The formatted message.
         """
         formatted_messages: List[Dict[str, Any]] = []
+
+        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
+
+        # Build a mapping from function_call id (fc_*) → call_id (call_*) from prior assistant tool_calls
+        fc_id_to_call_id: Dict[str, str] = {}
+        for msg in messages:
+            tool_calls = getattr(msg, "tool_calls", None)
+            if tool_calls:
+                for tc in tool_calls:
+                    fc_id = tc.get("id")
+                    call_id = tc.get("call_id") or fc_id
+                    if isinstance(fc_id, str) and isinstance(call_id, str):
+                        fc_id_to_call_id[fc_id] = call_id
+
         for message in messages:
             if message.role in ["user", "system"]:
                 message_dict: Dict[str, Any] = {
@@ -378,18 +409,32 @@ class OpenAIResponses(Model):
 
                 formatted_messages.append(message_dict)
 
+            # Tool call result
             elif message.role == "tool":
                 if message.tool_call_id and message.content is not None:
+                    function_call_id = message.tool_call_id
+                    # Normalize: if a fc_* id was provided, translate to its corresponding call_* id
+                    if isinstance(function_call_id, str) and function_call_id in fc_id_to_call_id:
+                        call_id_value = fc_id_to_call_id[function_call_id]
+                    else:
+                        call_id_value = function_call_id
                     formatted_messages.append(
-                        {"type": "function_call_output", "call_id": message.tool_call_id, "output": message.content}
+                        {"type": "function_call_output", "call_id": call_id_value, "output": message.content}
                     )
+            # Tool Calls
             elif message.tool_calls is not None and len(message.tool_calls) > 0:
+                # Only skip re-sending prior function_call items when we have a previous_response_id
+                # (reasoning models). For non-reasoning models, we must include the prior function_call
+                # so the API can associate the subsequent function_call_output by call_id.
+                if self._using_reasoning_model() and previous_response_id is not None:
+                    continue
+
                 for tool_call in message.tool_calls:
                     formatted_messages.append(
                         {
                             "type": "function_call",
-                            "id": tool_call["id"],
-                            "call_id": tool_call["call_id"],
+                            "id": tool_call.get("id"),
+                            "call_id": tool_call.get("call_id", tool_call.get("id")),
                             "name": tool_call["function"]["name"],
                             "arguments": tool_call["function"]["arguments"],
                             "status": "completed",
@@ -690,7 +735,8 @@ class OpenAIResponses(Model):
                 model_response.tool_calls.append(
                     {
                         "id": output.id,
-                        "call_id": output.call_id,
+                        # Store additional call_id from OpenAI responses
+                        "call_id": output.call_id or output.id,
                         "type": "function",
                         "function": {
                             "name": output.name,
@@ -780,8 +826,8 @@ class OpenAIResponses(Model):
             item = stream_event.item
             if item.type == "function_call":
                 tool_use = {
-                    "id": item.id,
-                    "call_id": item.call_id,
+                    "id": getattr(item, "id", None),
+                    "call_id": getattr(item, "call_id", None) or getattr(item, "id", None),
                     "type": "function",
                     "function": {
                         "name": item.name,

agno/models/qwen/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.dashscope.dashscope import DashScope as Qwen
+
+__all__ = [
+    "Qwen",
+]

agno/run/response.py

@@ -420,6 +420,9 @@ class RunResponse:
         messages = data.pop("messages", None)
         messages = [Message.model_validate(message) for message in messages] if messages else None
 
+        citations = data.pop("citations", None)
+        citations = Citations.model_validate(citations) if citations else None
+
         tools = data.pop("tools", [])
         tools = [ToolExecution.from_dict(tool) for tool in tools] if tools else None
 
@@ -441,6 +444,7 @@ class RunResponse:
 
         return cls(
             messages=messages,
+            citations=citations,
             tools=tools,
             images=images,
             audio=audio,

agno/run/team.py

@@ -416,6 +416,9 @@ class TeamRunResponse:
         response_audio = data.pop("response_audio", None)
         response_audio = AudioResponse.model_validate(response_audio) if response_audio else None
 
+        citations = data.pop("citations", None)
+        citations = Citations.model_validate(citations) if citations else None
+
         # To make it backwards compatible
         if "event" in data:
             data.pop("event")
@@ -428,6 +431,7 @@ class TeamRunResponse:
             videos=videos,
             audio=audio,
             response_audio=response_audio,
+            citations=citations,
             tools=tools,
             events=events,
             **data,