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

agno/app/fastapi/app.py

@@ -81,6 +81,7 @@ class FastAPIApp(BaseAPIApp):
                     workflow.app_id = self.app_id
                 if not workflow.workflow_id:
                     workflow.workflow_id = generate_id(workflow.name)
+                workflow.initialize_workflow()
 
     def get_router(self) -> APIRouter:
         return get_sync_router(agents=self.agents, teams=self.teams, workflows=self.workflows)
@@ -95,6 +96,7 @@ class FastAPIApp(BaseAPIApp):
         host: str = "localhost",
         port: int = 7777,
         reload: bool = False,
+        workers: Optional[int] = None,
         **kwargs,
     ):
         self.set_app_id()
@@ -102,4 +104,4 @@ class FastAPIApp(BaseAPIApp):
 
         log_info(f"Starting API on {host}:{port}")
 
-        uvicorn.run(app=app, host=host, port=port, reload=reload, **kwargs)
+        uvicorn.run(app=app, host=host, port=port, reload=reload, workers=workers, **kwargs)

agno/app/fastapi/async_router.py

@@ -231,7 +231,7 @@ def get_async_router(
 
         return base64_images, base64_audios, base64_videos
 
-    def team_process_file(
+    async def team_process_file(
         files: List[UploadFile],
     ):
         base64_images: List[Image] = []

agno/app/playground/app.py

@@ -87,6 +87,7 @@ class Playground:
                     workflow.app_id = self.app_id
                 if not workflow.workflow_id:
                     workflow.workflow_id = generate_id(workflow.name)
+                workflow.initialize_workflow()
 
     def set_app_id(self) -> str:
         # If app_id is already set, keep it instead of overriding with UUID

agno/document/chunking/semantic.py

@@ -14,9 +14,7 @@ except ImportError:
 class SemanticChunking(ChunkingStrategy):
     """Chunking strategy that splits text into semantic chunks using chonkie"""
 
-    def __init__(
-        self, embedder: Optional[Embedder] = None, chunk_size: int = 5000, similarity_threshold: Optional[float] = 0.5
-    ):
+    def __init__(self, embedder: Optional[Embedder] = None, chunk_size: int = 5000, similarity_threshold: float = 0.5):
         self.embedder = embedder or OpenAIEmbedder(id="text-embedding-3-small")  # type: ignore
         self.chunk_size = chunk_size
         self.similarity_threshold = similarity_threshold

agno/document/reader/markdown_reader.py

@@ -1,11 +1,9 @@
 import asyncio
 import uuid
 from pathlib import Path
-from typing import IO, Any, List, Optional, Union
+from typing import IO, Any, List, Union
 
 from agno.document.base import Document
-from agno.document.chunking.markdown import MarkdownChunking
-from agno.document.chunking.strategy import ChunkingStrategy
 from agno.document.reader.base import Reader
 from agno.utils.log import log_info, logger
 
@@ -13,9 +11,6 @@ from agno.utils.log import log_info, logger
 class MarkdownReader(Reader):
     """Reader for Markdown files"""
 
-    def __init__(self, chunking_strategy: Optional[ChunkingStrategy] = MarkdownChunking()) -> None:
-        super().__init__(chunking_strategy=chunking_strategy)
-
     def read(self, file: Union[Path, IO[Any]]) -> List[Document]:
         try:
             if isinstance(file, Path):
@@ -30,7 +25,7 @@ class MarkdownReader(Reader):
                 file.seek(0)
                 file_contents = file.read().decode("utf-8")
 
-            documents = [Document(name=file_name, id=str({uuid.uuid4()}), content=file_contents)]
+            documents = [Document(name=file_name, id=str(uuid.uuid4()), content=file_contents)]
             if self.chunk:
                 chunked_documents = []
                 for document in documents:

agno/document/reader/text_reader.py

@@ -28,7 +28,7 @@ class TextReader(Reader):
             documents = [
                 Document(
                     name=file_name,
-                    id=str({uuid.uuid4()}),
+                    id=str(uuid.uuid4()),
                     content=file_contents,
                 )
             ]
@@ -67,7 +67,7 @@ class TextReader(Reader):
 
             document = Document(
                 name=file_name,
-                id=str({uuid.uuid4()}),
+                id=str(uuid.uuid4()),
                 content=file_contents,
             )
 

agno/knowledge/agent.py

@@ -2,7 +2,7 @@ import asyncio
 from pathlib import Path
 from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Set, Tuple
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, model_validator
 
 from agno.document import Document
 from agno.document.chunking.fixed import FixedSizeChunking
@@ -24,8 +24,7 @@ class AgentKnowledge(BaseModel):
     # Number of documents to optimize the vector db on
     optimize_on: Optional[int] = 1000
 
-    chunking_strategy: ChunkingStrategy = Field(default_factory=FixedSizeChunking)
-
+    chunking_strategy: Optional[ChunkingStrategy] = None
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     valid_metadata_filters: Set[str] = None  # type: ignore
@@ -33,7 +32,7 @@ class AgentKnowledge(BaseModel):
     @model_validator(mode="after")
     def update_reader(self) -> "AgentKnowledge":
         if self.reader is not None and self.reader.chunking_strategy is None:
-            self.reader.chunking_strategy = self.chunking_strategy
+            self.reader.chunking_strategy = self.chunking_strategy or FixedSizeChunking()
         return self
 
     @property
@@ -237,7 +236,7 @@ class AgentKnowledge(BaseModel):
         self._load_init(recreate=False, upsert=upsert)
         if self.vector_db is None:
             return
-        
+
         log_info("Loading knowledge base")
         # Upsert documents if upsert is True
         if upsert and self.vector_db.upsert_available():

agno/knowledge/markdown.py

@@ -1,7 +1,10 @@
 from pathlib import Path
-from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Union
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Union, cast
+
+from pydantic import model_validator
 
 from agno.document import Document
+from agno.document.chunking.markdown import MarkdownChunking
 from agno.document.reader.markdown_reader import MarkdownReader
 from agno.knowledge.agent import AgentKnowledge
 from agno.utils.log import log_info, logger
@@ -10,11 +13,18 @@ from agno.utils.log import log_info, logger
 class MarkdownKnowledgeBase(AgentKnowledge):
     path: Optional[Union[str, Path, List[Dict[str, Union[str, Dict[str, Any]]]]]] = None
     formats: List[str] = [".md"]
-    reader: MarkdownReader = MarkdownReader()
+    reader: Optional[MarkdownReader] = None
+
+    @model_validator(mode="after")
+    def set_reader(self) -> "MarkdownKnowledgeBase":
+        if self.reader is None:
+            self.reader = MarkdownReader(chunking_strategy=self.chunking_strategy or MarkdownChunking())
+        return self
 
     @property
     def document_lists(self) -> Iterator[List[Document]]:
         """Iterate over text files and yield lists of documents."""
+        self.reader = cast(MarkdownReader, self.reader)
         if self.path is None:
             raise ValueError("Path is not set")
 
@@ -49,6 +59,7 @@ class MarkdownKnowledgeBase(AgentKnowledge):
     @property
     async def async_document_lists(self) -> AsyncIterator[List[Document]]:
         """Iterate over text files and yield lists of documents asynchronously."""
+        self.reader = cast(MarkdownReader, self.reader)
         if self.path is None:
             raise ValueError("Path is not set")
 
@@ -85,6 +96,7 @@ class MarkdownKnowledgeBase(AgentKnowledge):
         skip_existing: bool = True,
     ) -> None:
         """Load documents from a single text file with specific metadata into the vector DB."""
+        self.reader = cast(MarkdownReader, self.reader)
 
         _file_path = Path(path) if isinstance(path, str) else path
 
@@ -117,6 +129,7 @@ class MarkdownKnowledgeBase(AgentKnowledge):
         skip_existing: bool = True,
     ) -> None:
         """Load documents from a single text file with specific metadata into the vector DB."""
+        self.reader = cast(MarkdownReader, self.reader)
 
         _file_path = Path(path) if isinstance(path, str) else path
 

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

@@ -372,6 +372,17 @@ class OpenAIResponses(Model):
                     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] = {
@@ -398,27 +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:
-                if self._using_reasoning_model():
-                    # Only include prior function_call items when we are NOT using
-                    # previous_response_id. When previous_response_id is present, the
-                    # Responses API already knows about earlier output items (including
-                    # reasoning/function_call), and re-sending them can trigger validation
-                    # errors (e.g., missing required reasoning item).
-                    if previous_response_id is not None:
-                        continue
+                # 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",
@@ -719,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,
@@ -809,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,