agno 2.0.6__py3-none-any.whl → 2.0.8__py3-none-any.whl

agno/tools/decorator.py

@@ -250,8 +250,10 @@ def tool(*args, **kwargs) -> Union[Function, Callable[[F], Function]]:
         if kwargs.get("stop_after_tool_call") is True:
             if "show_result" not in kwargs or kwargs.get("show_result") is None:
                 tool_config["show_result"] = True
-
-        return Function(**tool_config)
+        function = Function(**tool_config)
+        # Determine parameters for the function
+        function.process_entrypoint()
+        return function
 
     # Handle both @tool and @tool() cases
     if len(args) == 1 and callable(args[0]) and not kwargs:

agno/tools/function.py

@@ -124,6 +124,8 @@ class Function(BaseModel):
     _team: Optional[Any] = None
     # The session state that the function is associated with
     _session_state: Optional[Dict[str, Any]] = None
+    # The dependencies that the function is associated with
+    _dependencies: Optional[Dict[str, Any]] = None
 
     # Media context that the function is associated with
     _images: Optional[Sequence[Image]] = None
@@ -165,6 +167,8 @@ class Function(BaseModel):
                 del type_hints["audios"]
             if "files" in sig.parameters and "files" in type_hints:
                 del type_hints["files"]
+            if "dependencies" in sig.parameters and "dependencies" in type_hints:
+                del type_hints["dependencies"]
             # log_info(f"Type hints for {function_name}: {type_hints}")
 
             # Filter out return type and only process parameters
@@ -172,7 +176,8 @@ class Function(BaseModel):
                 name: type_hints.get(name)
                 for name in sig.parameters
                 if name != "return"
-                and name not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files"]
+                and name
+                not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files", "dependencies"]
             }
 
             # Parse docstring for parameters
@@ -201,7 +206,18 @@ class Function(BaseModel):
                 parameters["required"] = [
                     name
                     for name in parameters["properties"]
-                    if name not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files"]
+                    if name
+                    not in [
+                        "agent",
+                        "team",
+                        "session_state",
+                        "self",
+                        "images",
+                        "videos",
+                        "audios",
+                        "files",
+                        "dependencies",
+                    ]
                 ]
             else:
                 # Mark a field as required if it has no default value (this would include optional fields)
@@ -209,7 +225,18 @@ class Function(BaseModel):
                     name
                     for name, param in sig.parameters.items()
                     if param.default == param.empty
-                    and name not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files"]
+                    and name
+                    not in [
+                        "agent",
+                        "team",
+                        "session_state",
+                        "self",
+                        "images",
+                        "videos",
+                        "audios",
+                        "files",
+                        "dependencies",
+                    ]
                 ]
 
             # log_debug(f"JSON schema for {function_name}: {parameters}")
@@ -268,6 +295,8 @@ class Function(BaseModel):
                 del type_hints["audios"]
             if "files" in sig.parameters and "files" in type_hints:
                 del type_hints["files"]
+            if "dependencies" in sig.parameters and "dependencies" in type_hints:
+                del type_hints["dependencies"]
             # log_info(f"Type hints for {self.name}: {type_hints}")
 
             # Filter out return type and only process parameters
@@ -281,6 +310,7 @@ class Function(BaseModel):
                 "videos",
                 "audios",
                 "files",
+                "dependencies",
             ]
             if self.requires_user_input and self.user_input_fields:
                 if len(self.user_input_fields) == 0:
@@ -396,7 +426,8 @@ class Function(BaseModel):
         self.parameters["required"] = [
             name
             for name in self.parameters["properties"]
-            if name not in ["agent", "team", "session_state", "images", "videos", "audios", "files", "self"]
+            if name
+            not in ["agent", "team", "session_state", "images", "videos", "audios", "files", "self", "dependencies"]
         ]
 
     def _get_cache_key(self, entrypoint_args: Dict[str, Any], call_args: Optional[Dict[str, Any]] = None) -> str:
@@ -419,6 +450,8 @@ class Function(BaseModel):
             del copy_entrypoint_args["audios"]
         if "files" in copy_entrypoint_args:
             del copy_entrypoint_args["files"]
+        if "dependencies" in copy_entrypoint_args:
+            del copy_entrypoint_args["dependencies"]
         args_str = str(copy_entrypoint_args)
 
         kwargs_str = str(sorted((call_args or {}).items()))
@@ -599,6 +632,9 @@ class FunctionCall(BaseModel):
         # Check if the entrypoint has an session_state argument
         if "session_state" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["session_state"] = self.function._session_state
+        # Check if the entrypoint has an dependencies argument
+        if "dependencies" in signature(self.function.entrypoint).parameters:  # type: ignore
+            entrypoint_args["dependencies"] = self.function._dependencies
         # Check if the entrypoint has an fc argument
         if "fc" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["fc"] = self
@@ -629,6 +665,9 @@ class FunctionCall(BaseModel):
         # Check if the hook has an session_state argument
         if "session_state" in signature(hook).parameters:
             hook_args["session_state"] = self.function._session_state
+        # Check if the hook has an dependencies argument
+        if "dependencies" in signature(hook).parameters:
+            hook_args["dependencies"] = self.function._dependencies
 
         if "name" in signature(hook).parameters:
             hook_args["name"] = name

agno/tools/mcp.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, List, Literal, Optional, Union
 
 from agno.tools import Toolkit
 from agno.tools.function import Function
-from agno.utils.log import log_debug, log_info, log_warning, logger
+from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.mcp import get_entrypoint_for_tool
 
 try:
@@ -102,7 +102,7 @@ class MCPTools(Toolkit):
         transport: Literal["stdio", "sse", "streamable-http"] = "stdio",
         server_params: Optional[Union[StdioServerParameters, SSEClientParams, StreamableHTTPClientParams]] = None,
         session: Optional[ClientSession] = None,
-        timeout_seconds: int = 5,
+        timeout_seconds: int = 10,
         client=None,
         include_tools: Optional[list[str]] = None,
         exclude_tools: Optional[list[str]] = None,
@@ -338,12 +338,13 @@ class MCPTools(Toolkit):
                     self.functions[f.name] = f
                     log_debug(f"Function: {f.name} registered with {self.name}")
                 except Exception as e:
-                    logger.error(f"Failed to register tool {tool.name}: {e}")
+                    log_error(f"Failed to register tool {tool.name}: {e}")
 
             log_debug(f"{self.name} initialized with {len(filtered_tools)} tools")
             self._initialized = True
+
         except Exception as e:
-            logger.error(f"Failed to get MCP tools: {e}")
+            log_error(f"Failed to get MCP tools: {e}")
             raise
 
 
@@ -372,6 +373,7 @@ class MultiMCPTools(Toolkit):
         client=None,
         include_tools: Optional[list[str]] = None,
         exclude_tools: Optional[list[str]] = None,
+        allow_partial_failure: bool = False,
         **kwargs,
     ):
         """
@@ -387,6 +389,7 @@ class MultiMCPTools(Toolkit):
             timeout_seconds: Timeout in seconds for managing timeouts for Client Session if Agent or Tool doesn't respond.
             include_tools: Optional list of tool names to include (if None, includes all).
             exclude_tools: Optional list of tool names to exclude (if None, excludes none).
+            allow_partial_failure: If True, allows toolkit to initialize even if some MCP servers fail to connect. If False, any failure will raise an exception.
         """
         super().__init__(name="MultiMCPTools", **kwargs)
 
@@ -445,12 +448,16 @@ class MultiMCPTools(Toolkit):
                     self.server_params_list.append(StreamableHTTPClientParams(url=url))
 
         self._async_exit_stack = AsyncExitStack()
+        self._successful_connections = 0
+
         self._initialized = False
         self._connection_task = None
         self._active_contexts: list[Any] = []
         self._used_as_context_manager = False
 
         self._client = client
+        self._initialized = False
+        self.allow_partial_failure = allow_partial_failure
 
         def cleanup():
             """Cancel active connections"""
@@ -511,39 +518,53 @@ class MultiMCPTools(Toolkit):
         if self._initialized:
             return
 
+        server_connection_errors = []
+
         for server_params in self.server_params_list:
-            # Handle stdio connections
-            if isinstance(server_params, StdioServerParameters):
-                stdio_transport = await self._async_exit_stack.enter_async_context(stdio_client(server_params))
-                self._active_contexts.append(stdio_transport)
-                read, write = stdio_transport
-                session = await self._async_exit_stack.enter_async_context(
-                    ClientSession(read, write, read_timeout_seconds=timedelta(seconds=self.timeout_seconds))
-                )
-                self._active_contexts.append(session)
-                await self.initialize(session)
-            # Handle SSE connections
-            elif isinstance(server_params, SSEClientParams):
-                client_connection = await self._async_exit_stack.enter_async_context(
-                    sse_client(**asdict(server_params))
-                )
-                self._active_contexts.append(client_connection)
-                read, write = client_connection
-                session = await self._async_exit_stack.enter_async_context(ClientSession(read, write))
-                self._active_contexts.append(session)
-                await self.initialize(session)
-            # Handle Streamable HTTP connections
-            elif isinstance(server_params, StreamableHTTPClientParams):
-                client_connection = await self._async_exit_stack.enter_async_context(
-                    streamablehttp_client(**asdict(server_params))
-                )
-                self._active_contexts.append(client_connection)
-                read, write = client_connection[0:2]
-                session = await self._async_exit_stack.enter_async_context(ClientSession(read, write))
-                self._active_contexts.append(session)
-                await self.initialize(session)
+            try:
+                # Handle stdio connections
+                if isinstance(server_params, StdioServerParameters):
+                    stdio_transport = await self._async_exit_stack.enter_async_context(stdio_client(server_params))
+                    read, write = stdio_transport
+                    session = await self._async_exit_stack.enter_async_context(
+                        ClientSession(read, write, read_timeout_seconds=timedelta(seconds=self.timeout_seconds))
+                    )
+                    await self.initialize(session)
+                    self._successful_connections += 1
 
-        self._initialized = True
+                # Handle SSE connections
+                elif isinstance(server_params, SSEClientParams):
+                    client_connection = await self._async_exit_stack.enter_async_context(
+                        sse_client(**asdict(server_params))
+                    )
+                    read, write = client_connection
+                    session = await self._async_exit_stack.enter_async_context(ClientSession(read, write))
+                    await self.initialize(session)
+                    self._successful_connections += 1
+
+                # Handle Streamable HTTP connections
+                elif isinstance(server_params, StreamableHTTPClientParams):
+                    client_connection = await self._async_exit_stack.enter_async_context(
+                        streamablehttp_client(**asdict(server_params))
+                    )
+                    read, write = client_connection[0:2]
+                    session = await self._async_exit_stack.enter_async_context(ClientSession(read, write))
+                    await self.initialize(session)
+                    self._successful_connections += 1
+
+            except Exception as e:
+                if not self.allow_partial_failure:
+                    raise ValueError(f"MCP connection failed: {e}")
+
+                log_error(f"Failed to initialize MCP server with params {server_params}: {e}")
+                server_connection_errors.append(str(e))
+                continue
+
+        if self._successful_connections == 0 and server_connection_errors:
+            raise ValueError(f"All MCP connections failed: {server_connection_errors}")
+
+        if not self._initialized and self._successful_connections > 0:
+            self._initialized = True
 
     async def close(self) -> None:
         """Close the MCP connections and clean up resources"""
@@ -563,6 +584,8 @@ class MultiMCPTools(Toolkit):
     ):
         """Exit the async context manager."""
         await self._async_exit_stack.aclose()
+        self._initialized = False
+        self._successful_connections = 0
 
     async def initialize(self, session: ClientSession) -> None:
         """Initialize the MCP toolkit by getting available tools from the MCP server"""
@@ -602,10 +625,10 @@ class MultiMCPTools(Toolkit):
                     self.functions[f.name] = f
                     log_debug(f"Function: {f.name} registered with {self.name}")
                 except Exception as e:
-                    logger.error(f"Failed to register tool {tool.name}: {e}")
+                    log_error(f"Failed to register tool {tool.name}: {e}")
 
-            log_debug(f"{self.name} initialized with {len(filtered_tools)} tools")
+            log_debug(f"{self.name} initialized with {len(filtered_tools)} tools from one MCP server")
             self._initialized = True
         except Exception as e:
-            logger.error(f"Failed to get MCP tools: {e}")
+            log_error(f"Failed to get MCP tools: {e}")
             raise

agno/tools/memori.py

@@ -1,7 +1,6 @@
 import json
 from typing import Any, Dict, List, Optional
 
-from agno.agent import Agent
 from agno.tools.toolkit import Toolkit
 from agno.utils.log import log_debug, log_error, log_info, log_warning
 
@@ -122,7 +121,6 @@ class MemoriTools(Toolkit):
 
     def search_memory(
         self,
-        agent: Agent,
         query: str,
         limit: Optional[int] = None,
     ) -> str:
@@ -180,7 +178,7 @@ class MemoriTools(Toolkit):
             log_error(f"Error searching memory: {e}")
             return json.dumps({"success": False, "error": f"Memory search error: {str(e)}"})
 
-    def record_conversation(self, agent: Agent, content: str) -> str:
+    def record_conversation(self, content: str) -> str:
         """
         Add important information or facts to memory.
 
@@ -222,7 +220,6 @@ class MemoriTools(Toolkit):
 
     def get_memory_stats(
         self,
-        agent: Agent,
     ) -> str:
         """
         Get statistics about the memory system.
@@ -340,52 +337,3 @@ class MemoriTools(Toolkit):
         except Exception as e:
             log_error(f"Failed to disable memory system: {e}")
             return False
-
-
-def create_memori_search_tool(memori_toolkit: MemoriTools):
-    """
-    Create a standalone memory search function for use with Agno agents.
-
-    This is a convenience function that creates a memory search tool similar
-    to the pattern shown in the Memori example code.
-
-    Args:
-        memori_toolkit: An initialized MemoriTools instance
-
-    Returns:
-        Callable: A memory search function that can be used as an agent tool
-
-    Example:
-        ```python
-        memori_tools = MemoriTools(database_connect="sqlite:///memory.db")
-        search_tool = create_memori_search_tool(memori_tools)
-
-        agent = Agent(
-            model=OpenAIChat(),
-            tools=[search_tool],
-            description="Agent with memory search capability"
-        )
-        ```
-    """
-
-    def search_memory(query: str) -> str:
-        """
-        Search the agent's memory for past conversations and information.
-
-        Args:
-            query: What to search for in memory
-
-        Returns:
-            str: Search results or error message
-        """
-        try:
-            if not query.strip():
-                return "Please provide a search query"
-
-            result = memori_toolkit._memory_tool.execute(query=query.strip())
-            return str(result) if result else "No relevant memories found"
-
-        except Exception as e:
-            return f"Memory search error: {str(e)}"
-
-    return search_memory

agno/utils/events.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional
+from typing import Any, Dict, List, Optional
 
 from agno.media import Audio, Image
 from agno.models.message import Citations
@@ -76,6 +76,7 @@ def create_team_run_completed_event(from_run_response: TeamRunOutput) -> TeamRun
         content_type=from_run_response.content_type,  # type: ignore
         reasoning_content=from_run_response.reasoning_content,  # type: ignore
         citations=from_run_response.citations,  # type: ignore
+        model_provider_data=from_run_response.model_provider_data,  # type: ignore
         images=from_run_response.images,  # type: ignore
         videos=from_run_response.videos,  # type: ignore
         audio=from_run_response.audio,  # type: ignore
@@ -100,6 +101,7 @@ def create_run_completed_event(from_run_response: RunOutput) -> RunCompletedEven
         content_type=from_run_response.content_type,  # type: ignore
         reasoning_content=from_run_response.reasoning_content,  # type: ignore
         citations=from_run_response.citations,  # type: ignore
+        model_provider_data=from_run_response.model_provider_data,  # type: ignore
         images=from_run_response.images,  # type: ignore
         videos=from_run_response.videos,  # type: ignore
         audio=from_run_response.audio,  # type: ignore
@@ -343,6 +345,7 @@ def create_run_output_content_event(
     content_type: Optional[str] = None,
     reasoning_content: Optional[str] = None,
     redacted_reasoning_content: Optional[str] = None,
+    model_provider_data: Optional[Dict[str, Any]] = None,
     citations: Optional[Citations] = None,
     response_audio: Optional[Audio] = None,
     image: Optional[Image] = None,
@@ -364,6 +367,7 @@ def create_run_output_content_event(
         additional_input=from_run_response.additional_input,
         reasoning_steps=from_run_response.reasoning_steps,
         reasoning_messages=from_run_response.reasoning_messages,
+        model_provider_data=model_provider_data,
     )
 
 
@@ -374,6 +378,7 @@ def create_team_run_output_content_event(
     reasoning_content: Optional[str] = None,
     redacted_reasoning_content: Optional[str] = None,
     citations: Optional[Citations] = None,
+    model_provider_data: Optional[Dict[str, Any]] = None,
     response_audio: Optional[Audio] = None,
     image: Optional[Image] = None,
 ) -> TeamRunContentEvent:
@@ -388,6 +393,7 @@ def create_team_run_output_content_event(
         content_type=content_type or "str",
         reasoning_content=thinking_combined,
         citations=citations,
+        model_provider_data=model_provider_data,
         response_audio=response_audio,
         image=image,
         references=from_run_response.references,  # type: ignore