agno 2.2.10__py3-none-any.whl → 2.2.12__py3-none-any.whl

agno/tools/parallel.py

@@ -0,0 +1,314 @@
+import json
+from os import getenv
+from typing import Any, Dict, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_error
+
+try:
+    from parallel import Parallel as ParallelClient
+except ImportError:
+    raise ImportError("`parallel-web` not installed. Please install using `pip install parallel-web`")
+
+
+class CustomJSONEncoder(json.JSONEncoder):
+    """Custom JSON encoder that handles non-serializable types by converting them to strings."""
+
+    def default(self, obj):
+        try:
+            return super().default(obj)
+        except TypeError:
+            return str(obj)
+
+
+class ParallelTools(Toolkit):
+    """
+    ParallelTools provides access to Parallel's web search and extraction APIs.
+
+    Parallel offers powerful APIs optimized for AI agents:
+    - Search API: AI-optimized web search that returns relevant excerpts tailored for LLMs
+    - Extract API: Extract content from specific URLs in clean markdown format, handling JavaScript-heavy pages and PDFs
+
+    Args:
+        api_key (Optional[str]): Parallel API key. If not provided, will use PARALLEL_API_KEY environment variable.
+        enable_search (bool): Enable Search API functionality. Default is True.
+        enable_extract (bool): Enable Extract API functionality. Default is True.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
+        max_results (int): Default maximum number of results for search operations. Default is 10.
+        max_chars_per_result (int): Default maximum characters per result for search operations. Default is 10000.
+        beta_version (str): Beta API version header. Default is "search-extract-2025-10-10".
+        mode (Optional[str]): Default search mode. Options: "one-shot" or "agentic". Default is None.
+        include_domains (Optional[List[str]]): Default domains to restrict results to. Default is None.
+        exclude_domains (Optional[List[str]]): Default domains to exclude from results. Default is None.
+        max_age_seconds (Optional[int]): Default cache age threshold (minimum 600). Default is None.
+        timeout_seconds (Optional[float]): Default timeout for content retrieval. Default is None.
+        disable_cache_fallback (Optional[bool]): Default cache fallback behavior. Default is None.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        enable_search: bool = True,
+        enable_extract: bool = True,
+        all: bool = False,
+        max_results: int = 10,
+        max_chars_per_result: int = 10000,
+        beta_version: str = "search-extract-2025-10-10",
+        mode: Optional[str] = None,
+        include_domains: Optional[List[str]] = None,
+        exclude_domains: Optional[List[str]] = None,
+        max_age_seconds: Optional[int] = None,
+        timeout_seconds: Optional[float] = None,
+        disable_cache_fallback: Optional[bool] = None,
+        **kwargs,
+    ):
+        self.api_key: Optional[str] = api_key or getenv("PARALLEL_API_KEY")
+        if not self.api_key:
+            log_error("PARALLEL_API_KEY not set. Please set the PARALLEL_API_KEY environment variable.")
+
+        self.max_results = max_results
+        self.max_chars_per_result = max_chars_per_result
+        self.beta_version = beta_version
+        self.mode = mode
+        self.include_domains = include_domains
+        self.exclude_domains = exclude_domains
+        self.max_age_seconds = max_age_seconds
+        self.timeout_seconds = timeout_seconds
+        self.disable_cache_fallback = disable_cache_fallback
+
+        self.parallel_client = ParallelClient(
+            api_key=self.api_key, default_headers={"parallel-beta": self.beta_version}
+        )
+
+        tools: List[Any] = []
+        if all or enable_search:
+            tools.append(self.parallel_search)
+        if all or enable_extract:
+            tools.append(self.parallel_extract)
+
+        super().__init__(name="parallel_tools", tools=tools, **kwargs)
+
+    def parallel_search(
+        self,
+        objective: Optional[str] = None,
+        search_queries: Optional[List[str]] = None,
+        max_results: Optional[int] = None,
+        max_chars_per_result: Optional[int] = None,
+    ) -> str:
+        """Use this function to search the web using Parallel's Search API with a natural language objective.
+        You must provide at least one of objective or search_queries.
+
+        Args:
+            objective (Optional[str]): Natural-language description of what the web search is trying to find.
+            search_queries (Optional[List[str]]): Traditional keyword queries with optional search operators.
+            max_results (Optional[int]): Upper bound on results returned. Overrides constructor default.
+            max_chars_per_result (Optional[int]): Upper bound on total characters per url for excerpts.
+
+        Returns:
+            str: A JSON formatted string containing the search results with URLs, titles, publish dates, and relevant excerpts.
+        """
+        try:
+            if not objective and not search_queries:
+                return json.dumps({"error": "Please provide at least one of: objective or search_queries"}, indent=2)
+
+            # Use instance defaults if not provided
+            final_max_results = max_results if max_results is not None else self.max_results
+
+            search_params: Dict[str, Any] = {
+                "max_results": final_max_results,
+            }
+
+            # Add objective if provided
+            if objective:
+                search_params["objective"] = objective
+
+            # Add search_queries if provided
+            if search_queries:
+                search_params["search_queries"] = search_queries
+
+            # Add mode from constructor default
+            if self.mode:
+                search_params["mode"] = self.mode
+
+            # Add excerpts configuration
+            excerpts_config: Dict[str, Any] = {}
+            final_max_chars = max_chars_per_result if max_chars_per_result is not None else self.max_chars_per_result
+            if final_max_chars is not None:
+                excerpts_config["max_chars_per_result"] = final_max_chars
+
+            if excerpts_config:
+                search_params["excerpts"] = excerpts_config
+
+            # Add source_policy from constructor defaults
+            source_policy: Dict[str, Any] = {}
+            if self.include_domains:
+                source_policy["include_domains"] = self.include_domains
+            if self.exclude_domains:
+                source_policy["exclude_domains"] = self.exclude_domains
+
+            if source_policy:
+                search_params["source_policy"] = source_policy
+
+            # Add fetch_policy from constructor defaults
+            fetch_policy: Dict[str, Any] = {}
+            if self.max_age_seconds is not None:
+                fetch_policy["max_age_seconds"] = self.max_age_seconds
+            if self.timeout_seconds is not None:
+                fetch_policy["timeout_seconds"] = self.timeout_seconds
+            if self.disable_cache_fallback is not None:
+                fetch_policy["disable_cache_fallback"] = self.disable_cache_fallback
+
+            if fetch_policy:
+                search_params["fetch_policy"] = fetch_policy
+
+            search_result = self.parallel_client.beta.search(**search_params)
+
+            # Use model_dump() if available, otherwise convert to dict
+            try:
+                if hasattr(search_result, "model_dump"):
+                    return json.dumps(search_result.model_dump(), cls=CustomJSONEncoder)
+            except Exception:
+                pass
+
+            # Manually format the results
+            formatted_results: Dict[str, Any] = {
+                "search_id": getattr(search_result, "search_id", ""),
+                "results": [],
+            }
+
+            if hasattr(search_result, "results") and search_result.results:
+                results_list: List[Dict[str, Any]] = []
+                for result in search_result.results:
+                    formatted_result: Dict[str, Any] = {
+                        "title": getattr(result, "title", ""),
+                        "url": getattr(result, "url", ""),
+                        "publish_date": getattr(result, "publish_date", ""),
+                        "excerpt": getattr(result, "excerpt", ""),
+                    }
+                    results_list.append(formatted_result)
+                formatted_results["results"] = results_list
+
+            if hasattr(search_result, "warnings"):
+                formatted_results["warnings"] = search_result.warnings
+
+            if hasattr(search_result, "usage"):
+                formatted_results["usage"] = search_result.usage
+
+            return json.dumps(formatted_results, cls=CustomJSONEncoder, indent=2)
+
+        except Exception as e:
+            log_error(f"Error searching Parallel for objective '{objective}': {e}")
+            return json.dumps({"error": f"Search failed: {str(e)}"}, indent=2)
+
+    def parallel_extract(
+        self,
+        urls: List[str],
+        objective: Optional[str] = None,
+        search_queries: Optional[List[str]] = None,
+        excerpts: bool = True,
+        max_chars_per_excerpt: Optional[int] = None,
+        full_content: bool = False,
+        max_chars_for_full_content: Optional[int] = None,
+    ) -> str:
+        """Use this function to extract content from specific URLs using Parallel's Extract API.
+
+        Args:
+            urls (List[str]): List of public URLs to extract content from.
+            objective (Optional[str]): Search focus to guide content extraction.
+            search_queries (Optional[List[str]]): Keywords for targeting relevant content.
+            excerpts (bool): Include relevant text snippets.
+            max_chars_per_excerpt (Optional[int]): Upper bound on total characters per url. Only used when excerpts is True.
+            full_content (bool): Include complete page text.
+            max_chars_for_full_content (Optional[int]): Limit on characters per url. Only used when full_content is True.
+
+        Returns:
+            str: A JSON formatted string containing extracted content with titles, publish dates, excerpts and/or full content.
+        """
+        try:
+            if not urls:
+                return json.dumps({"error": "Please provide at least one URL to extract"}, indent=2)
+
+            extract_params: Dict[str, Any] = {
+                "urls": urls,
+            }
+
+            # Add objective if provided
+            if objective:
+                extract_params["objective"] = objective
+
+            # Add search_queries if provided
+            if search_queries:
+                extract_params["search_queries"] = search_queries
+
+            # Add excerpts configuration
+            if excerpts and max_chars_per_excerpt is not None:
+                extract_params["excerpts"] = {"max_chars_per_result": max_chars_per_excerpt}
+            else:
+                extract_params["excerpts"] = excerpts
+
+            # Add full_content configuration
+            if full_content and max_chars_for_full_content is not None:
+                extract_params["full_content"] = {"max_chars_per_result": max_chars_for_full_content}
+            else:
+                extract_params["full_content"] = full_content
+
+            # Add fetch_policy from constructor defaults
+            fetch_policy: Dict[str, Any] = {}
+            if self.max_age_seconds is not None:
+                fetch_policy["max_age_seconds"] = self.max_age_seconds
+            if self.timeout_seconds is not None:
+                fetch_policy["timeout_seconds"] = self.timeout_seconds
+            if self.disable_cache_fallback is not None:
+                fetch_policy["disable_cache_fallback"] = self.disable_cache_fallback
+
+            if fetch_policy:
+                extract_params["fetch_policy"] = fetch_policy
+
+            extract_result = self.parallel_client.beta.extract(**extract_params)
+
+            # Use model_dump() if available, otherwise convert to dict
+            try:
+                if hasattr(extract_result, "model_dump"):
+                    return json.dumps(extract_result.model_dump(), cls=CustomJSONEncoder)
+            except Exception:
+                pass
+
+            # Manually format the results
+            formatted_results: Dict[str, Any] = {
+                "extract_id": getattr(extract_result, "extract_id", ""),
+                "results": [],
+                "errors": [],
+            }
+
+            if hasattr(extract_result, "results") and extract_result.results:
+                results_list: List[Dict[str, Any]] = []
+                for result in extract_result.results:
+                    formatted_result: Dict[str, Any] = {
+                        "url": getattr(result, "url", ""),
+                        "title": getattr(result, "title", ""),
+                        "publish_date": getattr(result, "publish_date", ""),
+                    }
+
+                    if excerpts and hasattr(result, "excerpts"):
+                        formatted_result["excerpts"] = result.excerpts
+
+                    if full_content and hasattr(result, "full_content"):
+                        formatted_result["full_content"] = result.full_content
+
+                    results_list.append(formatted_result)
+                formatted_results["results"] = results_list
+
+            if hasattr(extract_result, "errors") and extract_result.errors:
+                formatted_results["errors"] = extract_result.errors
+
+            if hasattr(extract_result, "warnings"):
+                formatted_results["warnings"] = extract_result.warnings
+
+            if hasattr(extract_result, "usage"):
+                formatted_results["usage"] = extract_result.usage
+
+            return json.dumps(formatted_results, cls=CustomJSONEncoder, indent=2)
+
+        except Exception as e:
+            log_error(f"Error extracting from Parallel: {e}")
+            return json.dumps({"error": f"Extract failed: {str(e)}"}, indent=2)

agno/utils/agent.py

@@ -8,7 +8,7 @@ from agno.models.response import ModelResponse
 from agno.run.agent import RunEvent, RunInput, RunOutput, RunOutputEvent
 from agno.run.team import RunOutputEvent as TeamRunOutputEvent
 from agno.run.team import TeamRunOutput
-from agno.session import AgentSession, TeamSession
+from agno.session import AgentSession, TeamSession, WorkflowSession
 from agno.utils.events import (
     create_memory_update_completed_event,
     create_memory_update_started_event,
@@ -457,7 +457,12 @@ def scrub_history_messages_from_run_output(run_response: Union[RunOutput, TeamRu
 
 def get_run_output_util(
     entity: Union["Agent", "Team"], run_id: str, session_id: Optional[str] = None
-) -> Optional[Union[RunOutput, TeamRunOutput]]:
+) -> Optional[
+    Union[
+        RunOutput,
+        TeamRunOutput,
+    ]
+]:
     """
     Get a RunOutput from the database.
 
@@ -473,13 +478,13 @@ def get_run_output_util(
         if session is not None:
             run_response = session.get_run(run_id=run_id)
             if run_response is not None:
-                return run_response
+                return run_response  # type: ignore
             else:
                 log_warning(f"RunOutput {run_id} not found in Session {session_id}")
     elif entity.cached_session is not None:
         run_response = entity.cached_session.get_run(run_id=run_id)
         if run_response is not None:
-            return run_response
+            return run_response  # type: ignore
         else:
             log_warning(f"RunOutput {run_id} not found in Session {entity.cached_session.session_id}")
             return None
@@ -501,7 +506,7 @@ async def aget_run_output_util(
         if session is not None:
             run_response = session.get_run(run_id=run_id)
             if run_response is not None:
-                return run_response
+                return run_response  # type: ignore
             else:
                 log_warning(f"RunOutput {run_id} not found in Session {session_id}")
     elif entity.cached_session is not None:
@@ -535,10 +540,10 @@ def get_last_run_output_util(
             for run_output in reversed(session.runs):
                 if entity.__class__.__name__ == "Agent":
                     if hasattr(run_output, "agent_id") and run_output.agent_id == entity.id:
-                        return run_output
+                        return run_output  # type: ignore
                 elif entity.__class__.__name__ == "Team":
                     if hasattr(run_output, "team_id") and run_output.team_id == entity.id:
-                        return run_output
+                        return run_output  # type: ignore
         else:
             log_warning(f"No run responses found in Session {session_id}")
 
@@ -550,10 +555,10 @@ def get_last_run_output_util(
         for run_output in reversed(entity.cached_session.runs):
             if entity.__class__.__name__ == "Agent":
                 if hasattr(run_output, "agent_id") and run_output.agent_id == entity.id:
-                    return run_output
+                    return run_output  # type: ignore
             elif entity.__class__.__name__ == "Team":
                 if hasattr(run_output, "team_id") and run_output.team_id == entity.id:
-                    return run_output
+                    return run_output  # type: ignore
     return None
 
 
@@ -575,10 +580,10 @@ async def aget_last_run_output_util(
             for run_output in reversed(session.runs):
                 if entity.__class__.__name__ == "Agent":
                     if hasattr(run_output, "agent_id") and run_output.agent_id == entity.id:
-                        return run_output
+                        return run_output  # type: ignore
                 elif entity.__class__.__name__ == "Team":
                     if hasattr(run_output, "team_id") and run_output.team_id == entity.id:
-                        return run_output
+                        return run_output  # type: ignore
         else:
             log_warning(f"No run responses found in Session {session_id}")
 
@@ -590,16 +595,16 @@ async def aget_last_run_output_util(
         for run_output in reversed(entity.cached_session.runs):
             if entity.__class__.__name__ == "Agent":
                 if hasattr(run_output, "agent_id") and run_output.agent_id == entity.id:
-                    return run_output
+                    return run_output  # type: ignore
             elif entity.__class__.__name__ == "Team":
                 if hasattr(run_output, "team_id") and run_output.team_id == entity.id:
-                    return run_output
+                    return run_output  # type: ignore
     return None
 
 
 def set_session_name_util(
     entity: Union["Agent", "Team"], session_id: str, autogenerate: bool = False, session_name: Optional[str] = None
-) -> Union[AgentSession, TeamSession]:
+) -> Union[AgentSession, TeamSession, WorkflowSession]:
     """Set the session name and save to storage"""
     if entity._has_async_db():
         raise ValueError("Async database not supported for sync functions")
@@ -629,7 +634,7 @@ def set_session_name_util(
 
 async def aset_session_name_util(
     entity: Union["Agent", "Team"], session_id: str, autogenerate: bool = False, session_name: Optional[str] = None
-) -> Union[AgentSession, TeamSession]:
+) -> Union[AgentSession, TeamSession, WorkflowSession]:
     """Set the session name and save to storage"""
     session = await entity.aget_session(session_id=session_id)  # type: ignore
 
@@ -796,7 +801,7 @@ def get_chat_history_util(entity: Union["Agent", "Team"], session_id: str) -> Li
     if session is None:
         raise Exception("Session not found")
 
-    return session.get_chat_history()
+    return session.get_chat_history()  # type: ignore
 
 
 async def aget_chat_history_util(entity: Union["Agent", "Team"], session_id: str) -> List[Message]:
@@ -812,4 +817,4 @@ async def aget_chat_history_util(entity: Union["Agent", "Team"], session_id: str
     if session is None:
         raise Exception("Session not found")
 
-    return session.get_chat_history()
+    return session.get_chat_history()  # type: ignore

agno/utils/gemini.py

@@ -225,12 +225,13 @@ def convert_schema(
     if schema_type is None or schema_type == "null":
         return None
     description = schema_dict.get("description", None)
+    title = schema_dict.get("title", None)
     default = schema_dict.get("default", None)
 
     # Handle enum types
     if "enum" in schema_dict:
         enum_values = schema_dict["enum"]
-        return Schema(type=GeminiType.STRING, enum=enum_values, description=description, default=default)
+        return Schema(type=GeminiType.STRING, enum=enum_values, description=description, default=default, title=title)
 
     if schema_type == "object":
         # Handle regular objects with properties
@@ -250,6 +251,10 @@ def convert_schema(
                     if is_nullable:
                         converted_schema.nullable = True
                     properties[key] = converted_schema
+                else:
+                    properties[key] = Schema(
+                        title=prop_def.get("title", None), description=prop_def.get("description", None)
+                    )
 
             required = schema_dict.get("required", [])
 
@@ -260,9 +265,10 @@ def convert_schema(
                     required=required,
                     description=description,
                     default=default,
+                    title=title,
                 )
             else:
-                return Schema(type=GeminiType.OBJECT, description=description, default=default)
+                return Schema(type=GeminiType.OBJECT, description=description, default=default, title=title)
 
         # Handle Dict types (objects with additionalProperties but no properties)
         elif "additionalProperties" in schema_dict:
@@ -305,11 +311,11 @@ def convert_schema(
                 )
             else:
                 # additionalProperties is false or true
-                return Schema(type=GeminiType.OBJECT, description=description, default=default)
+                return Schema(type=GeminiType.OBJECT, description=description, default=default, title=title)
 
         # Handle empty objects
         else:
-            return Schema(type=GeminiType.OBJECT, description=description, default=default)
+            return Schema(type=GeminiType.OBJECT, description=description, default=default, title=title)
 
     elif schema_type == "array" and "items" in schema_dict:
         if not schema_dict["items"]:  # Handle empty {}
@@ -325,6 +331,7 @@ def convert_schema(
             items=items,
             min_items=min_items,
             max_items=max_items,
+            title=title,
         )
 
     elif schema_type == "string":
@@ -332,6 +339,7 @@ def convert_schema(
             "type": GeminiType.STRING,
             "description": description,
             "default": default,
+            "title": title,
         }
         if "format" in schema_dict:
             schema_kwargs["format"] = schema_dict["format"]
@@ -342,6 +350,7 @@ def convert_schema(
             "type": schema_type.upper(),
             "description": description,
             "default": default,
+            "title": title,
         }
         if "maximum" in schema_dict:
             schema_kwargs["maximum"] = schema_dict["maximum"]
@@ -373,6 +382,7 @@ def convert_schema(
                 any_of=any_of,
                 description=description,
                 default=default,
+                title=title,
             )
     else:
         if isinstance(schema_type, list):
@@ -384,7 +394,7 @@ def convert_schema(
         # Only convert to uppercase if schema_type is not empty
         if schema_type:
             schema_type = schema_type.upper()
-            return Schema(type=schema_type, description=description, default=default)
+            return Schema(type=schema_type, description=description, default=default, title=title)
         else:
             # If we get here with an empty type and no other handlers matched,
             # something is wrong with the schema

agno/utils/knowledge.py

@@ -1,10 +1,11 @@
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional, Union
 
+from agno.filters import FilterExpr
 from agno.utils.log import log_info
 
 
 def get_agentic_or_user_search_filters(
-    filters: Optional[Dict[str, Any]], effective_filters: Optional[Dict[str, Any]]
+    filters: Optional[Dict[str, Any]], effective_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]]
 ) -> Dict[str, Any]:
     """Helper function to determine the final filters to use for the search.
 
@@ -15,7 +16,7 @@ def get_agentic_or_user_search_filters(
     Returns:
         Dict[str, Any]: The final filters to use for the search.
     """
-    search_filters = {}
+    search_filters = None
 
     # If agentic filters exist and manual filters (passed by user) do not, use agentic filters
     if filters and not effective_filters:
@@ -23,7 +24,13 @@ def get_agentic_or_user_search_filters(
 
     # If both agentic filters exist and manual filters (passed by user) exist, use manual filters (give priority to user and override)
     if filters and effective_filters:
-        search_filters = effective_filters
+        if isinstance(effective_filters, dict):
+            search_filters = effective_filters
+        elif isinstance(effective_filters, list):
+            # If effective_filters is a list (likely List[FilterExpr]), convert both filters and effective_filters to a dict if possible, otherwise raise
+            raise ValueError(
+                "Merging dict and list of filters is not supported; effective_filters should be a dict for search compatibility."
+            )
 
     log_info(f"Filters used by Agent: {search_filters}")
-    return search_filters
+    return search_filters or {}

agno/utils/log.py

@@ -108,6 +108,7 @@ workflow_logger: AgnoLogger = build_logger(WORKFLOW_LOGGER_NAME, source_type="wo
 # Set the default logger to the agent logger
 logger: AgnoLogger = agent_logger
 
+
 debug_on: bool = False
 debug_level: Literal[1, 2] = 1
 

agno/utils/models/claude.py

@@ -68,6 +68,8 @@ def _format_image_for_message(image: Image) -> Optional[Dict[str, Any]]:
     }
 
     try:
+        img_type = None
+
         # Case 0: Image is an Anthropic uploaded file
         if image.content is not None and hasattr(image.content, "id"):
             content_bytes = image.content
@@ -80,7 +82,6 @@ def _format_image_for_message(image: Image) -> Optional[Dict[str, Any]]:
             import os
             from urllib.parse import urlparse
 
-            img_type = None
             if image.url:
                 parsed_url = urlparse(image.url)
                 _, ext = os.path.splitext(parsed_url.path)

agno/utils/print_response/agent.py

@@ -10,6 +10,7 @@ from rich.markdown import Markdown
 from rich.status import Status
 from rich.text import Text
 
+from agno.filters import FilterExpr
 from agno.media import Audio, File, Image, Video
 from agno.models.message import Message
 from agno.reasoning.step import ReasoningStep
@@ -35,7 +36,7 @@ def print_response_stream(
     files: Optional[Sequence[File]] = None,
     stream_events: bool = False,
     stream_intermediate_steps: bool = False,
-    knowledge_filters: Optional[Dict[str, Any]] = None,
+    knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
     debug_mode: Optional[bool] = None,
     markdown: bool = False,
     show_message: bool = True,
@@ -227,7 +228,7 @@ async def aprint_response_stream(
     files: Optional[Sequence[File]] = None,
     stream_events: bool = False,
     stream_intermediate_steps: bool = False,
-    knowledge_filters: Optional[Dict[str, Any]] = None,
+    knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
     debug_mode: Optional[bool] = None,
     markdown: bool = False,
     show_message: bool = True,
@@ -505,7 +506,7 @@ def print_response(
     images: Optional[Sequence[Image]] = None,
     videos: Optional[Sequence[Video]] = None,
     files: Optional[Sequence[File]] = None,
-    knowledge_filters: Optional[Dict[str, Any]] = None,
+    knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
     debug_mode: Optional[bool] = None,
     markdown: bool = False,
     show_message: bool = True,
@@ -621,7 +622,7 @@ async def aprint_response(
     images: Optional[Sequence[Image]] = None,
     videos: Optional[Sequence[Video]] = None,
     files: Optional[Sequence[File]] = None,
-    knowledge_filters: Optional[Dict[str, Any]] = None,
+    knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
     debug_mode: Optional[bool] = None,
     markdown: bool = False,
     show_message: bool = True,