agno 2.0.11__py3-none-any.whl → 2.1.1__py3-none-any.whl

agno/tools/firecrawl.py

@@ -3,7 +3,7 @@ from os import getenv
 from typing import Any, Dict, List, Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_error
 
 try:
     from firecrawl import FirecrawlApp  # type: ignore[attr-defined]
@@ -57,7 +57,7 @@ class FirecrawlTools(Toolkit):
     ):
         self.api_key: Optional[str] = api_key or getenv("FIRECRAWL_API_KEY")
         if not self.api_key:
-            logger.error("FIRECRAWL_API_KEY not set. Please set the FIRECRAWL_API_KEY environment variable.")
+            log_error("FIRECRAWL_API_KEY not set. Please set the FIRECRAWL_API_KEY environment variable.")
 
         self.formats: Optional[List[str]] = formats
         self.limit: int = limit
@@ -73,7 +73,7 @@ class FirecrawlTools(Toolkit):
         if all or enable_mapping:
             tools.append(self.map_website)
         if all or enable_search:
-            tools.append(self.search)
+            tools.append(self.search_web)
 
         super().__init__(name="firecrawl_tools", tools=tools, **kwargs)
 
@@ -121,7 +121,7 @@ class FirecrawlTools(Toolkit):
         map_result = self.app.map(url)
         return json.dumps(map_result.model_dump(), cls=CustomJSONEncoder)
 
-    def search(self, query: str, limit: Optional[int] = None):
+    def search_web(self, query: str, limit: Optional[int] = None):
         """Use this function to search for the web using Firecrawl.
 
         Args:

agno/tools/function.py

@@ -389,6 +389,9 @@ class Function(BaseModel):
         if not params_set_by_user:
             self.parameters = parameters
 
+        if strict:
+            self.process_schema_for_strict()
+
         try:
             self.entrypoint = self._wrap_callable(self.entrypoint)
         except Exception as e:
@@ -422,7 +425,45 @@ class Function(BaseModel):
             return wrapped
 
     def process_schema_for_strict(self):
-        self.parameters["additionalProperties"] = False
+        """Process the schema to make it strict mode compliant."""
+
+        def make_nested_strict(schema):
+            """Recursively ensure all object schemas have additionalProperties: false"""
+            if not isinstance(schema, dict):
+                return schema
+
+            # Make a copy to avoid modifying the original
+            result = schema.copy()
+
+            # If this is an object schema, ensure additionalProperties: false
+            if result.get("type") == "object" or "properties" in result:
+                result["additionalProperties"] = False
+
+            # If schema has no type but has other schema properties, give it a type
+            if "type" not in result:
+                if "properties" in result:
+                    result["type"] = "object"
+                    result["additionalProperties"] = False
+                elif result.get("title") and not any(
+                    key in result for key in ["properties", "items", "anyOf", "oneOf", "allOf", "enum"]
+                ):
+                    result["type"] = "string"
+
+            # Recursively process nested schemas
+            for key, value in result.items():
+                if key == "properties" and isinstance(value, dict):
+                    result[key] = {k: make_nested_strict(v) for k, v in value.items()}
+                elif key == "items" and isinstance(value, dict):
+                    # This handles array items like List[KnowledgeFilter]
+                    result[key] = make_nested_strict(value)
+                elif isinstance(value, dict):
+                    result[key] = make_nested_strict(value)
+
+            return result
+
+        # Apply strict mode to the entire schema
+        self.parameters = make_nested_strict(self.parameters)
+
         self.parameters["required"] = [
             name
             for name in self.parameters["properties"]
@@ -648,7 +689,6 @@ class FunctionCall(BaseModel):
             entrypoint_args["audios"] = self.function._audios
         if "files" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["files"] = self.function._files
-
         return entrypoint_args
 
     def _build_hook_args(self, hook: Callable, name: str, func: Callable, args: Dict[str, Any]) -> Dict[str, Any]:

agno/tools/knowledge.py

@@ -43,15 +43,15 @@ class KnowledgeTools(Toolkit):
         if enable_think or all:
             tools.append(self.think)
         if enable_search or all:
-            tools.append(self.search)
+            tools.append(self.search_knowledge)
         if enable_analyze or all:
             tools.append(self.analyze)
 
         super().__init__(
             name="knowledge_tools",
+            tools=tools,
             instructions=self.instructions,
             add_instructions=add_instructions,
-            tools=tools,
             **kwargs,
         )
 
@@ -89,7 +89,7 @@ class KnowledgeTools(Toolkit):
             log_error(f"Error recording thought: {e}")
             return f"Error recording thought: {e}"
 
-    def search(self, session_state: Dict[str, Any], query: str) -> str:
+    def search_knowledge(self, session_state: Dict[str, Any], query: str) -> str:
         """Use this tool to search the knowledge base for relevant information.
         After thinking through the question, use this tool as many times as needed to search for relevant information.
 

agno/tools/searxng.py

@@ -21,7 +21,7 @@ class Searxng(Toolkit):
         self.fixed_max_results = fixed_max_results
 
         tools: List[Any] = [
-            self.search,
+            self.search_web,
             self.image_search,
             self.it_search,
             self.map_search,
@@ -33,7 +33,7 @@ class Searxng(Toolkit):
 
         super().__init__(name="searxng", tools=tools, **kwargs)
 
-    def search(self, query: str, max_results: int = 5) -> str:
+    def search_web(self, query: str, max_results: int = 5) -> str:
         """Use this function to search the web.
 
         Args:

agno/tools/serper.py

@@ -44,7 +44,7 @@ class SerperTools(Toolkit):
 
         tools: List[Any] = []
         if all or enable_search:
-            tools.append(self.search)
+            tools.append(self.search_web)
         if all or enable_search_news:
             tools.append(self.search_news)
         if all or enable_search_scholar:
@@ -97,7 +97,7 @@ class SerperTools(Toolkit):
             log_error(f"Serper API error: {str(e)}")
             return {"success": False, "error": str(e)}
 
-    def search(
+    def search_web(
         self,
         query: str,
         num_results: Optional[int] = None,

agno/tools/spider.py

@@ -42,7 +42,7 @@ class SpiderTools(Toolkit):
 
         tools: List[Any] = []
         if enable_search or all:
-            tools.append(self.search)
+            tools.append(self.search_web)
         if enable_scrape or all:
             tools.append(self.scrape)
         if enable_crawl or all:
@@ -50,7 +50,7 @@ class SpiderTools(Toolkit):
 
         super().__init__(name="spider", tools=tools, **kwargs)
 
-    def search(self, query: str, max_results: int = 5) -> str:
+    def search_web(self, query: str, max_results: int = 5) -> str:
         """Use this function to search the web.
         Args:
             query (str): The query to search the web with.

agno/tools/workflow.py

@@ -2,7 +2,7 @@ import json
 from textwrap import dedent
 from typing import Any, Dict, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error
@@ -10,8 +10,8 @@ from agno.workflow.workflow import Workflow, WorkflowRunOutput
 
 
 class RunWorkflowInput(BaseModel):
-    input_data: str
-    additional_data: Optional[Dict[str, Any]] = None
+    input_data: str = Field(..., description="The input data for the workflow.")
+    additional_data: Optional[Dict[str, Any]] = Field(default=None, description="The additional data for the workflow.")
 
 
 class WorkflowTools(Toolkit):
@@ -131,8 +131,7 @@ class WorkflowTools(Toolkit):
         """Use this tool to execute the workflow with the specified inputs and parameters.
         After thinking through the requirements, use this tool to run the workflow with appropriate inputs.
         Args:
-            input_data: The input data for the workflow (use a `str` for a simple input)
-            additional_data: The additional data for the workflow. This is a dictionary of key-value pairs that will be passed to the workflow. E.g. {"topic": "food", "style": "Humour"}
+            input_data: The input data for the workflow.
         """
         try:
             log_debug(f"Running workflow with input: {input.input_data}")

agno/utils/events.py

@@ -11,6 +11,8 @@ from agno.run.agent import (
     OutputModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
     ParserModelResponseStartedEvent,
+    PreHookCompletedEvent,
+    PreHookStartedEvent,
     ReasoningCompletedEvent,
     ReasoningStartedEvent,
     ReasoningStepEvent,
@@ -19,6 +21,7 @@ from agno.run.agent import (
     RunContentEvent,
     RunContinuedEvent,
     RunErrorEvent,
+    RunInput,
     RunOutput,
     RunPausedEvent,
     RunStartedEvent,
@@ -31,6 +34,8 @@ from agno.run.team import OutputModelResponseCompletedEvent as TeamOutputModelRe
 from agno.run.team import OutputModelResponseStartedEvent as TeamOutputModelResponseStartedEvent
 from agno.run.team import ParserModelResponseCompletedEvent as TeamParserModelResponseCompletedEvent
 from agno.run.team import ParserModelResponseStartedEvent as TeamParserModelResponseStartedEvent
+from agno.run.team import PreHookCompletedEvent as TeamPreHookCompletedEvent
+from agno.run.team import PreHookStartedEvent as TeamPreHookStartedEvent
 from agno.run.team import ReasoningCompletedEvent as TeamReasoningCompletedEvent
 from agno.run.team import ReasoningStartedEvent as TeamReasoningStartedEvent
 from agno.run.team import ReasoningStepEvent as TeamReasoningStepEvent
@@ -39,7 +44,7 @@ from agno.run.team import RunCompletedEvent as TeamRunCompletedEvent
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import RunErrorEvent as TeamRunErrorEvent
 from agno.run.team import RunStartedEvent as TeamRunStartedEvent
-from agno.run.team import TeamRunOutput
+from agno.run.team import TeamRunInput, TeamRunOutput
 from agno.run.team import ToolCallCompletedEvent as TeamToolCallCompletedEvent
 from agno.run.team import ToolCallStartedEvent as TeamToolCallStartedEvent
 
@@ -177,6 +182,66 @@ def create_run_cancelled_event(from_run_response: RunOutput, reason: str) -> Run
     )
 
 
+def create_pre_hook_started_event(
+    from_run_response: RunOutput, pre_hook_name: Optional[str] = None, run_input: Optional[RunInput] = None
+) -> PreHookStartedEvent:
+    from copy import deepcopy
+
+    return PreHookStartedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        pre_hook_name=pre_hook_name,
+        run_input=deepcopy(run_input),
+    )
+
+
+def create_team_pre_hook_started_event(
+    from_run_response: TeamRunOutput, pre_hook_name: Optional[str] = None, run_input: Optional[TeamRunInput] = None
+) -> TeamPreHookStartedEvent:
+    from copy import deepcopy
+
+    return TeamPreHookStartedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        pre_hook_name=pre_hook_name,
+        run_input=deepcopy(run_input),
+    )
+
+
+def create_pre_hook_completed_event(
+    from_run_response: RunOutput, pre_hook_name: Optional[str] = None, run_input: Optional[RunInput] = None
+) -> PreHookCompletedEvent:
+    from copy import deepcopy
+
+    return PreHookCompletedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        pre_hook_name=pre_hook_name,
+        run_input=deepcopy(run_input),
+    )
+
+
+def create_team_pre_hook_completed_event(
+    from_run_response: TeamRunOutput, pre_hook_name: Optional[str] = None, run_input: Optional[TeamRunInput] = None
+) -> TeamPreHookCompletedEvent:
+    from copy import deepcopy
+
+    return TeamPreHookCompletedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        pre_hook_name=pre_hook_name,
+        run_input=deepcopy(run_input),
+    )
+
+
 def create_memory_update_started_event(from_run_response: RunOutput) -> MemoryUpdateStartedEvent:
     return MemoryUpdateStartedEvent(
         session_id=from_run_response.session_id,

agno/utils/hooks.py

@@ -0,0 +1,57 @@
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from agno.guardrails.base import BaseGuardrail
+from agno.utils.log import log_warning
+
+
+def normalize_hooks(
+    hooks: Optional[Union[List[Callable[..., Any]], List[BaseGuardrail]]],
+    async_mode: bool = False,
+) -> Optional[List[Callable[..., Any]]]:
+    """Normalize hooks to a list format"""
+    result_hooks: List[Callable[..., Any]] = []
+
+    if hooks is not None:
+        for hook in hooks:
+            if isinstance(hook, BaseGuardrail):
+                if async_mode:
+                    result_hooks.append(hook.async_check)
+                else:
+                    result_hooks.append(hook.check)
+            else:
+                # Check if the hook is async and used within sync methods
+                if not async_mode:
+                    import asyncio
+
+                    if asyncio.iscoroutinefunction(hook):
+                        raise ValueError(
+                            f"Cannot use {hook.__name__} (an async hook) with `run()`. Use `arun()` instead."
+                        )
+
+                result_hooks.append(hook)
+    return result_hooks if result_hooks else None
+
+
+def filter_hook_args(hook: Callable[..., Any], all_args: Dict[str, Any]) -> Dict[str, Any]:
+    """Filter arguments to only include those that the hook function accepts."""
+    import inspect
+
+    try:
+        sig = inspect.signature(hook)
+        accepted_params = set(sig.parameters.keys())
+
+        has_var_keyword = any(param.kind == inspect.Parameter.VAR_KEYWORD for param in sig.parameters.values())
+
+        # If the function has **kwargs, pass all arguments
+        if has_var_keyword:
+            return all_args
+
+        # Otherwise, filter to only include accepted parameters
+        filtered_args = {key: value for key, value in all_args.items() if key in accepted_params}
+
+        return filtered_args
+
+    except Exception as e:
+        log_warning(f"Could not inspect hook signature, passing all arguments: {e}")
+        # If signature inspection fails, pass all arguments as fallback
+        return all_args

agno/utils/media.py

@@ -6,6 +6,8 @@ from typing import List
 
 import httpx
 
+from agno.utils.log import log_info, log_warning
+
 
 class SampleDataFileExtension(str, Enum):
     DOCX = "docx"
@@ -30,7 +32,7 @@ def download_image(url: str, output_path: str) -> bool:
         # Check if the response contains image content
         content_type = response.headers.get("Content-Type")
         if not content_type or not content_type.startswith("image"):
-            print(f"URL does not point to an image. Content-Type: {content_type}")
+            log_warning(f"URL does not point to an image. Content-Type: {content_type}")
             return False
 
         path = Path(output_path)
@@ -42,14 +44,14 @@ def download_image(url: str, output_path: str) -> bool:
                 if chunk:
                     file.write(chunk)
 
-        print(f"Image successfully downloaded and saved to '{output_path}'.")
+        log_info(f"Image successfully downloaded and saved to '{output_path}'.")
         return True
 
     except httpx.HTTPError as e:
-        print(f"Error downloading the image: {e}")
+        log_warning(f"Error downloading the image: {e}")
         return False
     except IOError as e:
-        print(f"Error saving the image to '{output_path}': {e}")
+        log_warning(f"Error saving the image to '{output_path}': {e}")
         return False
 
 
@@ -109,7 +111,7 @@ def save_base64_data(base64_data: str, output_path: str) -> bool:
         with open(path, "wb") as file:
             file.write(decoded_data)
 
-        print(f"Data successfully saved to '{path}'.")
+        log_info(f"Data successfully saved to '{path}'.")
         return True
     except Exception as e:
         raise Exception(f"An unexpected error occurred while saving data to '{output_path}': {e}")
@@ -131,25 +133,25 @@ def wait_for_media_ready(url: str, timeout: int = 120, interval: int = 5, verbos
     max_attempts = timeout // interval
 
     if verbose:
-        print("Media generated! Waiting for upload to complete...")
+        log_info("Media generated! Waiting for upload to complete...")
 
     for attempt in range(max_attempts):
         try:
             response = httpx.head(url, timeout=10)
             response.raise_for_status()
             if verbose:
-                print(f"Media ready: {url}")
+                log_info(f"Media ready: {url}")
             return True
         except httpx.HTTPError:
             pass
 
         if verbose and (attempt + 1) % 3 == 0:
-            print(f"Still processing... ({(attempt + 1) * interval}s elapsed)")
+            log_info(f"Still processing... ({(attempt + 1) * interval}s elapsed)")
 
         time.sleep(interval)
 
     if verbose:
-        print(f"Timeout waiting for media. Try this URL later: {url}")
+        log_warning(f"Timeout waiting for media. Try this URL later: {url}")
     return False
 
 

agno/utils/print_response/agent.py

@@ -78,6 +78,8 @@ def print_response_stream(
         if render:
             live_log.update(Group(*panels))
 
+        input_content = get_text_from_message(input)
+
         for response_event in agent.run(
             input=input,
             session_id=session_id,
@@ -106,6 +108,10 @@ def print_response_stream(
                     live_log.update(Group(*panels))
                     return
 
+                if response_event.event == RunEvent.pre_hook_completed:  # type: ignore
+                    if response_event.run_input is not None:  # type: ignore
+                        input_content = get_text_from_message(response_event.run_input.input_content)  # type: ignore
+
                 if (
                     response_event.event == RunEvent.tool_call_started  # type: ignore
                     and hasattr(response_event, "tool")
@@ -157,9 +163,8 @@ def print_response_stream(
             panels = [status]
             if show_message:
                 # Convert message to a panel
-                message_content = get_text_from_message(input)
                 message_panel = create_panel(
-                    content=Text(message_content, style="green"),
+                    content=Text(input_content, style="green"),
                     title="Message",
                     border_style="cyan",
                 )
@@ -282,6 +287,8 @@ async def aprint_response_stream(
             **kwargs,
         )
 
+        input_content = get_text_from_message(input)
+
         async for resp in result:  # type: ignore
             if isinstance(resp, tuple(get_args(RunOutputEvent))):
                 if resp.is_paused:
@@ -297,6 +304,10 @@ async def aprint_response_stream(
                 ):
                     accumulated_tool_calls.append(resp.tool)
 
+                if resp.event == RunEvent.pre_hook_completed:  # type: ignore
+                    if resp.run_input is not None:  # type: ignore
+                        input_content = get_text_from_message(resp.run_input.input_content)  # type: ignore
+
                 if resp.event == RunEvent.run_content:  # type: ignore
                     if isinstance(resp.content, str):
                         # Don't accumulate text content, parser_model will replace it
@@ -338,12 +349,11 @@ async def aprint_response_stream(
 
             panels = [status]
 
-            if input and show_message:
+            if input_content and show_message:
                 render = True
                 # Convert message to a panel
-                message_content = get_text_from_message(input)
                 message_panel = create_panel(
-                    content=Text(message_content, style="green"),
+                    content=Text(input_content, style="green"),
                     title="Message",
                     border_style="cyan",
                 )
@@ -545,6 +555,20 @@ def print_response(
         )
         response_timer.stop()
 
+        if run_response.input is not None and run_response.input.input_content != input:
+            # Input was modified during the run
+            panels = [status]
+            if show_message:
+                # Convert message to a panel
+                message_content = get_text_from_message(run_response.input.input_content)
+                message_panel = create_panel(
+                    content=Text(message_content, style="green"),
+                    title="Message",
+                    border_style="cyan",
+                )
+                panels.append(message_panel)  # type: ignore
+                live_log.update(Group(*panels))
+
         additional_panels = build_panels(
             run_response=run_response,
             output_schema=agent.output_schema,  # type: ignore
@@ -649,6 +673,20 @@ async def aprint_response(
         )
         response_timer.stop()
 
+        if run_response.input is not None and run_response.input.input_content != input:
+            # Input was modified during the run
+            panels = [status]
+            if show_message:
+                # Convert message to a panel
+                message_content = get_text_from_message(run_response.input.input_content)
+                message_panel = create_panel(
+                    content=Text(message_content, style="green"),
+                    title="Message",
+                    border_style="cyan",
+                )
+                panels.append(message_panel)  # type: ignore
+                live_log.update(Group(*panels))
+
         additional_panels = build_panels(
             run_response=run_response,
             output_schema=agent.output_schema,  # type: ignore