agno 2.3.26__py3-none-any.whl → 2.4.0__py3-none-any.whl

agno/tools/duckduckgo.py

@@ -1,36 +1,26 @@
-import json
-from typing import Any, List, Optional
+from typing import Optional
 
-from agno.tools import Toolkit
-from agno.utils.log import log_debug
+from agno.tools.websearch import WebSearchTools
 
-try:
-    from ddgs import DDGS
-except ImportError:
-    raise ImportError("`ddgs` not installed. Please install using `pip install ddgs`")
 
-
-class DuckDuckGoTools(Toolkit):
+class DuckDuckGoTools(WebSearchTools):
     """
-    DuckDuckGo is a toolkit for searching using DuckDuckGo easily.
-    It uses the meta-search library DDGS, so it also has access to other backends.
+    DuckDuckGoTools is a convenience wrapper around WebSearchTools with the backend
+    defaulting to "duckduckgo".
     Args:
-        enable_search (bool): Enable DDGS search function.
-        enable_news (bool): Enable DDGS news function.
-        modifier (Optional[str]): A modifier to be used in the search request.
+        enable_search (bool): Enable web search function.
+        enable_news (bool): Enable news search function.
+        modifier (Optional[str]): A modifier to be prepended to search queries.
         fixed_max_results (Optional[int]): A fixed number of maximum results.
-        proxy (Optional[str]): Proxy to be used in the search request.
+        proxy (Optional[str]): Proxy to be used for requests.
         timeout (Optional[int]): The maximum number of seconds to wait for a response.
-        backend (Optional[str]): The backend to be used in the search request.
-
+        verify_ssl (bool): Whether to verify SSL certificates.
     """
 
     def __init__(
         self,
         enable_search: bool = True,
         enable_news: bool = True,
-        all: bool = False,
-        backend: str = "duckduckgo",
         modifier: Optional[str] = None,
         fixed_max_results: Optional[int] = None,
         proxy: Optional[str] = None,
@@ -38,54 +28,18 @@ class DuckDuckGoTools(Toolkit):
         verify_ssl: bool = True,
         **kwargs,
     ):
-        self.proxy: Optional[str] = proxy
-        self.timeout: Optional[int] = timeout
-        self.fixed_max_results: Optional[int] = fixed_max_results
-        self.modifier: Optional[str] = modifier
-        self.verify_ssl: bool = verify_ssl
-        self.backend: str = backend
-
-        tools: List[Any] = []
-        if all or enable_search:
-            tools.append(self.duckduckgo_search)
-        if all or enable_news:
-            tools.append(self.duckduckgo_news)
-
-        super().__init__(name="duckduckgo", tools=tools, **kwargs)
-
-    def duckduckgo_search(self, query: str, max_results: int = 5) -> str:
-        """Use this function to search DDGS for a query.
-
-        Args:
-            query(str): The query to search for.
-            max_results (optional, default=5): The maximum number of results to return.
-
-        Returns:
-            The result from DDGS.
-        """
-        actual_max_results = self.fixed_max_results or max_results
-        search_query = f"{self.modifier} {query}" if self.modifier else query
-
-        log_debug(f"Searching DDG for: {search_query} using backend: {self.backend}")
-        with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
-            results = ddgs.text(query=search_query, max_results=actual_max_results, backend=self.backend)
-
-        return json.dumps(results, indent=2)
-
-    def duckduckgo_news(self, query: str, max_results: int = 5) -> str:
-        """Use this function to get the latest news from DDGS.
-
-        Args:
-            query(str): The query to search for.
-            max_results (optional, default=5): The maximum number of results to return.
-
-        Returns:
-            The latest news from DDGS.
-        """
-        actual_max_results = self.fixed_max_results or max_results
-
-        log_debug(f"Searching DDG news for: {query} using backend: {self.backend}")
-        with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
-            results = ddgs.news(query=query, max_results=actual_max_results, backend=self.backend)
-
-        return json.dumps(results, indent=2)
+        super().__init__(
+            enable_search=enable_search,
+            enable_news=enable_news,
+            backend="duckduckgo",
+            modifier=modifier,
+            fixed_max_results=fixed_max_results,
+            proxy=proxy,
+            timeout=timeout,
+            verify_ssl=verify_ssl,
+            **kwargs,
+        )
+
+        # Backward compatibility aliases for old method names
+        self.duckduckgo_search = self.web_search
+        self.duckduckgo_news = self.search_news

agno/tools/exa.py

@@ -27,14 +27,12 @@ class ExaTools(Toolkit):
         all (bool): Enable all tools. Overrides individual flags when True. Default is False.
         text (bool): Retrieve text content from results. Default is True.
         text_length_limit (int): Max length of text content per result. Default is 1000.
-        highlights (bool): Include highlighted snippets. Deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.
         api_key (Optional[str]): Exa API key. Retrieved from `EXA_API_KEY` env variable if not provided.
         num_results (Optional[int]): Default number of search results. Overrides individual searches if set.
         start_crawl_date (Optional[str]): Include results crawled on/after this date (`YYYY-MM-DD`).
         end_crawl_date (Optional[str]): Include results crawled on/before this date (`YYYY-MM-DD`).
         start_published_date (Optional[str]): Include results published on/after this date (`YYYY-MM-DD`).
         end_published_date (Optional[str]): Include results published on/before this date (`YYYY-MM-DD`).
-        use_autoprompt (Optional[bool]): Enable autoprompt features in queries. Deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.
         type (Optional[str]): Specify content type (e.g., article, blog, video).
         category (Optional[str]): Filter results by category. Options are "company", "research paper", "news", "pdf", "github", "tweet", "personal site", "linkedin profile", "financial report".
         include_domains (Optional[List[str]]): Restrict results to these domains.
@@ -54,7 +52,6 @@ class ExaTools(Toolkit):
         all: bool = False,
         text: bool = True,
         text_length_limit: int = 1000,
-        highlights: Optional[bool] = None,  # Deprecated
         summary: bool = False,
         api_key: Optional[str] = None,
         num_results: Optional[int] = None,
@@ -63,7 +60,6 @@ class ExaTools(Toolkit):
         end_crawl_date: Optional[str] = None,
         start_published_date: Optional[str] = None,
         end_published_date: Optional[str] = None,
-        use_autoprompt: Optional[bool] = None,
         type: Optional[str] = None,
         category: Optional[str] = None,
         include_domains: Optional[List[str]] = None,
@@ -85,23 +81,6 @@ class ExaTools(Toolkit):
         self.text: bool = text
         self.text_length_limit: int = text_length_limit
 
-        if highlights:
-            import warnings
-
-            warnings.warn(
-                "The 'highlights' parameter is deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        if use_autoprompt:
-            import warnings
-
-            warnings.warn(
-                "The 'use_autoprompt' parameter is deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
         self.summary: bool = summary
         self.num_results: Optional[int] = num_results
         self.livecrawl: str = livecrawl

agno/tools/function.py

@@ -133,10 +133,6 @@ class Function(BaseModel):
     _team: Optional[Any] = None
     # The run context that the function is associated with
     _run_context: Optional[RunContext] = 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
@@ -150,6 +146,19 @@ class Function(BaseModel):
             include={"name", "description", "parameters", "strict", "requires_confirmation", "external_execution"},
         )
 
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Function":
+        """Reconstruct a Function from a dictionary."""
+
+        return cls(
+            name=data.get("name"),
+            description=data.get("description"),
+            parameters=data.get("parameters"),
+            strict=data.get("strict"),
+            requires_confirmation=data.get("requires_confirmation", False),
+            external_execution=data.get("external_execution", False),
+        )
+
     def model_copy(self, *, deep: bool = False) -> "Function":
         """
         Override model_copy to handle callable fields that can't be deep copied (pickled).
@@ -209,10 +218,6 @@ class Function(BaseModel):
                 del type_hints["team"]
             if "run_context" in sig.parameters and "run_context" in type_hints:
                 del type_hints["run_context"]
-            if "session_state" in sig.parameters and "session_state" in type_hints:
-                del type_hints["session_state"]
-            if "dependencies" in sig.parameters and "dependencies" in type_hints:
-                del type_hints["dependencies"]
 
             # Remove media parameters from type hints as they are injected automatically
             if "images" in sig.parameters and "images" in type_hints:
@@ -235,8 +240,6 @@ class Function(BaseModel):
                     "agent",
                     "team",
                     "run_context",
-                    "session_state",
-                    "dependencies",
                     "self",
                     "images",
                     "videos",
@@ -276,8 +279,6 @@ class Function(BaseModel):
                         "agent",
                         "team",
                         "run_context",
-                        "session_state",
-                        "dependencies",
                         "self",
                         "images",
                         "videos",
@@ -296,8 +297,6 @@ class Function(BaseModel):
                         "agent",
                         "team",
                         "run_context",
-                        "session_state",
-                        "dependencies",
                         "self",
                         "images",
                         "videos",
@@ -354,10 +353,6 @@ class Function(BaseModel):
                 del type_hints["team"]
             if "run_context" in sig.parameters and "run_context" in type_hints:
                 del type_hints["run_context"]
-            if "session_state" in sig.parameters and "session_state" in type_hints:
-                del type_hints["session_state"]
-            if "dependencies" in sig.parameters and "dependencies" in type_hints:
-                del type_hints["dependencies"]
             if "images" in sig.parameters and "images" in type_hints:
                 del type_hints["images"]
             if "videos" in sig.parameters and "videos" in type_hints:
@@ -374,8 +369,6 @@ class Function(BaseModel):
                 "agent",
                 "team",
                 "run_context",
-                "session_state",
-                "dependencies",
                 "self",
                 "images",
                 "videos",
@@ -488,10 +481,15 @@ class Function(BaseModel):
         # Don't wrap callables that are already wrapped with validate_call
         elif getattr(func, "_wrapped_for_validation", False):
             return func
-        # Don't wrap functions with session_state parameter
-        # session_state needs to be passed by reference, not copied by pydantic's validation
-        elif "session_state" in signature(func).parameters:
+
+        # Don't wrap functions with framework-injected parameters
+        # These parameters (agent, team) are
+        # injected by the framework at runtime and shouldn't be validated by Pydantic
+        sig = signature(func)
+        framework_params = {"agent", "team"}
+        if framework_params & set(sig.parameters.keys()):
             return func
+
         # Wrap the callable with validate_call
         else:
             wrapped = validate_call(func, config=dict(arbitrary_types_allowed=True))  # type: ignore
@@ -546,8 +544,6 @@ class Function(BaseModel):
                 "agent",
                 "team",
                 "run_context",
-                "session_state",
-                "dependencies",
                 "images",
                 "videos",
                 "audios",
@@ -569,10 +565,6 @@ class Function(BaseModel):
             del copy_entrypoint_args["team"]
         if "run_context" in copy_entrypoint_args:
             del copy_entrypoint_args["run_context"]
-        if "session_state" in copy_entrypoint_args:
-            del copy_entrypoint_args["session_state"]
-        if "dependencies" in copy_entrypoint_args:
-            del copy_entrypoint_args["dependencies"]
         if "images" in copy_entrypoint_args:
             del copy_entrypoint_args["images"]
         if "videos" in copy_entrypoint_args:
@@ -699,21 +691,15 @@ class FunctionCall(BaseModel):
                 from inspect import signature
 
                 pre_hook_args = {}
-                # Check if the pre-hook has and agent argument
+                # Check if the pre-hook has an agent argument
                 if "agent" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["agent"] = self.function._agent
-                # Check if the pre-hook has an team argument
+                # Check if the pre-hook has a team argument
                 if "team" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["team"] = self.function._team
-                # Check if the pre-hook has an session_state argument
+                # Check if the pre-hook has a run_context argument
                 if "run_context" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["run_context"] = self.function._run_context
-                # Check if the pre-hook has an session_state argument
-                if "session_state" in signature(self.function.pre_hook).parameters:
-                    pre_hook_args["session_state"] = self.function._session_state
-                # Check if the pre-hook has an dependencies argument
-                if "dependencies" in signature(self.function.pre_hook).parameters:
-                    pre_hook_args["dependencies"] = self.function._dependencies
                 # Check if the pre-hook has an fc argument
                 if "fc" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["fc"] = self
@@ -733,21 +719,15 @@ class FunctionCall(BaseModel):
                 from inspect import signature
 
                 post_hook_args = {}
-                # Check if the post-hook has and agent argument
+                # Check if the post-hook has an agent argument
                 if "agent" in signature(self.function.post_hook).parameters:
                     post_hook_args["agent"] = self.function._agent
-                # Check if the post-hook has an team argument
+                # Check if the post-hook has a team argument
                 if "team" in signature(self.function.post_hook).parameters:
                     post_hook_args["team"] = self.function._team
-                # Check if the post-hook has an session_state argument
+                # Check if the post-hook has a run_context argument
                 if "run_context" in signature(self.function.post_hook).parameters:
                     post_hook_args["run_context"] = self.function._run_context
-                # Check if the post-hook has an session_state argument
-                if "session_state" in signature(self.function.post_hook).parameters:
-                    post_hook_args["session_state"] = self.function._session_state
-                # Check if the post-hook has an dependencies argument
-                if "dependencies" in signature(self.function.post_hook).parameters:
-                    post_hook_args["dependencies"] = self.function._dependencies
                 # Check if the post-hook has an fc argument
                 if "fc" in signature(self.function.post_hook).parameters:
                     post_hook_args["fc"] = self
@@ -768,18 +748,12 @@ class FunctionCall(BaseModel):
         # Check if the entrypoint has an agent argument
         if "agent" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["agent"] = self.function._agent
-        # Check if the entrypoint has an team argument
+        # Check if the entrypoint has a team argument
         if "team" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["team"] = self.function._team
-        # Check if the entrypoint has an run_context argument
+        # Check if the entrypoint has a run_context argument
         if "run_context" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["run_context"] = self.function._run_context
-        # 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
@@ -803,18 +777,12 @@ class FunctionCall(BaseModel):
         # Check if the hook has an agent argument
         if "agent" in signature(hook).parameters:
             hook_args["agent"] = self.function._agent
-        # Check if the hook has an team argument
+        # Check if the hook has a team argument
         if "team" in signature(hook).parameters:
             hook_args["team"] = self.function._team
-        # Check if the hook has an run_context argument
+        # Check if the hook has a run_context argument
         if "run_context" in signature(hook).parameters:
             hook_args["run_context"] = self.function._run_context
-        # 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
         if "function_name" in signature(hook).parameters:
@@ -942,9 +910,6 @@ class FunctionCall(BaseModel):
                         if run_context is not None and run_context.session_state is not None
                         else None
                     )
-                else:
-                    if self.function._session_state is not None:
-                        updated_session_state = self.function._session_state
 
                 execution_result = FunctionExecutionResult(
                     status="success", result=self.result, updated_session_state=updated_session_state
@@ -979,18 +944,12 @@ class FunctionCall(BaseModel):
                 # Check if the pre-hook has an agent argument
                 if "agent" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["agent"] = self.function._agent
-                # Check if the pre-hook has an team argument
+                # Check if the pre-hook has a team argument
                 if "team" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["team"] = self.function._team
-                # Check if the pre-hook has an run_context argument
+                # Check if the pre-hook has a run_context argument
                 if "run_context" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["run_context"] = self.function._run_context
-                # Check if the pre-hook has an session_state argument
-                if "session_state" in signature(self.function.pre_hook).parameters:
-                    pre_hook_args["session_state"] = self.function._session_state
-                # Check if the pre-hook has an dependencies argument
-                if "dependencies" in signature(self.function.pre_hook).parameters:
-                    pre_hook_args["dependencies"] = self.function._dependencies
                 # Check if the pre-hook has an fc argument
                 if "fc" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["fc"] = self
@@ -1014,19 +973,12 @@ class FunctionCall(BaseModel):
                 # Check if the post-hook has an agent argument
                 if "agent" in signature(self.function.post_hook).parameters:
                     post_hook_args["agent"] = self.function._agent
-                # Check if the post-hook has an team argument
+                # Check if the post-hook has a team argument
                 if "team" in signature(self.function.post_hook).parameters:
                     post_hook_args["team"] = self.function._team
-                # Check if the post-hook has an run_context argument
+                # Check if the post-hook has a run_context argument
                 if "run_context" in signature(self.function.post_hook).parameters:
                     post_hook_args["run_context"] = self.function._run_context
-                # Check if the post-hook has an session_state argument
-                if "session_state" in signature(self.function.post_hook).parameters:
-                    post_hook_args["session_state"] = self.function._session_state
-                # Check if the post-hook has an dependencies argument
-                if "dependencies" in signature(self.function.post_hook).parameters:
-                    post_hook_args["dependencies"] = self.function._dependencies
-
                 # Check if the post-hook has an fc argument
                 if "fc" in signature(self.function.post_hook).parameters:
                     post_hook_args["fc"] = self

agno/tools/knowledge.py

@@ -1,9 +1,10 @@
 import json
 from textwrap import dedent
-from typing import Any, Dict, List, Optional
+from typing import Any, List, Optional
 
 from agno.knowledge.document import Document
 from agno.knowledge.knowledge import Knowledge
+from agno.run import RunContext
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error
 
@@ -55,7 +56,7 @@ class KnowledgeTools(Toolkit):
             **kwargs,
         )
 
-    def think(self, session_state: Dict[str, Any], thought: str) -> str:
+    def think(self, run_context: RunContext, thought: str) -> str:
         """Use this tool as a scratchpad to reason about the question, refine your approach, brainstorm search terms, or revise your plan.
 
         Call `Think` whenever you need to figure out what to do next, analyze the user's question, or plan your approach.
@@ -71,8 +72,10 @@ class KnowledgeTools(Toolkit):
             log_debug(f"Thought: {thought}")
 
             # Add the thought to the Agent state
+            session_state = run_context.session_state
             if session_state is None:
                 session_state = {}
+                run_context.session_state = session_state
             if "thoughts" not in session_state:
                 session_state["thoughts"] = []
             session_state["thoughts"].append(thought)
@@ -89,7 +92,7 @@ class KnowledgeTools(Toolkit):
             log_error(f"Error recording thought: {e}")
             return f"Error recording thought: {e}"
 
-    def search_knowledge(self, session_state: Dict[str, Any], query: str) -> str:
+    def search_knowledge(self, run_context: RunContext, 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.
 
@@ -111,7 +114,7 @@ class KnowledgeTools(Toolkit):
             log_error(f"Error searching knowledge base: {e}")
             return f"Error searching knowledge base: {e}"
 
-    def analyze(self, session_state: Dict[str, Any], analysis: str) -> str:
+    def analyze(self, run_context: RunContext, analysis: str) -> str:
         """Use this tool to evaluate whether the returned documents are correct and sufficient.
         If not, go back to "Think" or "Search" with refined queries.
 
@@ -125,8 +128,10 @@ class KnowledgeTools(Toolkit):
             log_debug(f"Analysis: {analysis}")
 
             # Add the thought to the Agent state
+            session_state = run_context.session_state
             if session_state is None:
                 session_state = {}
+                run_context.session_state = session_state
             if "analysis" not in session_state:
                 session_state["analysis"] = []
             session_state["analysis"].append(analysis)

agno/tools/mem0.py

@@ -2,6 +2,7 @@ import json
 from os import getenv
 from typing import Any, Dict, List, Optional, Union
 
+from agno.run import RunContext
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error, log_warning
 
@@ -68,13 +69,13 @@ class Mem0Tools(Toolkit):
     def _get_user_id(
         self,
         method_name: str,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
     ) -> str:
         """Resolve the user ID"""
         resolved_user_id = self.user_id
         if not resolved_user_id:
             try:
-                resolved_user_id = session_state.get("current_user_id")
+                resolved_user_id = run_context.user_id
             except Exception:
                 pass
         if not resolved_user_id:
@@ -85,7 +86,7 @@ class Mem0Tools(Toolkit):
 
     def add_memory(
         self,
-        session_state,
+        run_context: RunContext,
         content: Union[str, Dict[str, str]],
     ) -> str:
         """Add facts to the user's memory.
@@ -98,7 +99,7 @@ class Mem0Tools(Toolkit):
             str: JSON-encoded Mem0 response or an error message.
         """
 
-        resolved_user_id = self._get_user_id("add_memory", session_state=session_state)
+        resolved_user_id = self._get_user_id("add_memory", run_context=run_context)
         if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in add_memory:"):
             return resolved_user_id
         try:
@@ -121,12 +122,12 @@ class Mem0Tools(Toolkit):
 
     def search_memory(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         query: str,
     ) -> str:
         """Semantic search for *query* across the user's stored memories."""
 
-        resolved_user_id = self._get_user_id("search_memory", session_state=session_state)
+        resolved_user_id = self._get_user_id("search_memory", run_context=run_context)
         if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in search_memory:"):
             return resolved_user_id
         try:
@@ -151,10 +152,10 @@ class Mem0Tools(Toolkit):
             log_error(f"Error searching memory: {e}")
             return f"Error searching memory: {e}"
 
-    def get_all_memories(self, session_state: Dict[str, Any]) -> str:
+    def get_all_memories(self, run_context: RunContext) -> str:
         """Return **all** memories for the current user as a JSON string."""
 
-        resolved_user_id = self._get_user_id("get_all_memories", session_state=session_state)
+        resolved_user_id = self._get_user_id("get_all_memories", run_context=run_context)
         if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in get_all_memories:"):
             return resolved_user_id
         try:
@@ -177,10 +178,10 @@ class Mem0Tools(Toolkit):
             log_error(f"Error getting all memories: {e}")
             return f"Error getting all memories: {e}"
 
-    def delete_all_memories(self, session_state: Dict[str, Any]) -> str:
+    def delete_all_memories(self, run_context: RunContext) -> str:
         """Delete *all* memories associated with the current user"""
 
-        resolved_user_id = self._get_user_id("delete_all_memories", session_state=session_state)
+        resolved_user_id = self._get_user_id("delete_all_memories", run_context=run_context)
         if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in delete_all_memories:"):
             error_msg = resolved_user_id
             log_error(error_msg)