agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/tools/function.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel, Field, validate_call
 
 from agno.exceptions import AgentRunException
 from agno.media import Audio, File, Image, Video
+from agno.run import RunContext
 from agno.utils.log import log_debug, log_error, log_exception, log_warning
 
 T = TypeVar("T")
@@ -122,6 +123,8 @@ class Function(BaseModel):
     _agent: Optional[Any] = None
     # The team that the function is associated with
     _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
@@ -139,6 +142,46 @@ class Function(BaseModel):
             include={"name", "description", "parameters", "strict", "requires_confirmation", "external_execution"},
         )
 
+    def model_copy(self, *, deep: bool = False) -> "Function":
+        """
+        Override model_copy to handle callable fields that can't be deep copied (pickled).
+        Callables should always be shallow copied (referenced), not deep copied.
+        """
+        # For deep copy, we need to handle callable fields specially
+        if deep:
+            # Fields that should NOT be deep copied (callables and complex objects)
+            shallow_fields = {
+                "entrypoint",
+                "pre_hook",
+                "post_hook",
+                "tool_hooks",
+                "_agent",
+                "_team",
+            }
+
+            # Create a copy with shallow references to callable fields
+            copied_data = {}
+            for field_name, field_value in self.__dict__.items():
+                if field_name in shallow_fields:
+                    # Shallow copy - just reference the same object
+                    copied_data[field_name] = field_value
+                elif field_name == "parameters":
+                    # Deep copy the parameters dict
+                    from copy import deepcopy
+
+                    copied_data[field_name] = deepcopy(field_value)
+                else:
+                    # For simple types, just copy the value
+                    copied_data[field_name] = field_value
+
+            # Create new instance with copied data
+            new_instance = self.__class__.model_construct(**copied_data)
+
+            return new_instance
+        else:
+            # For shallow copy, use the default Pydantic behavior
+            return super().model_copy(deep=False)
+
     @classmethod
     def from_callable(cls, c: Callable, name: Optional[str] = None, strict: bool = False) -> "Function":
         from inspect import getdoc, signature
@@ -156,8 +199,13 @@ class Function(BaseModel):
                 del type_hints["agent"]
             if "team" in sig.parameters and "team" in type_hints:
                 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:
                 del type_hints["images"]
@@ -167,8 +215,6 @@ 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
@@ -177,7 +223,18 @@ class Function(BaseModel):
                 for name in sig.parameters
                 if name != "return"
                 and name
-                not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files", "dependencies"]
+                not in [
+                    "agent",
+                    "team",
+                    "run_context",
+                    "session_state",
+                    "dependencies",
+                    "self",
+                    "images",
+                    "videos",
+                    "audios",
+                    "files",
+                ]
             }
 
             # Parse docstring for parameters
@@ -210,13 +267,14 @@ class Function(BaseModel):
                     not in [
                         "agent",
                         "team",
+                        "run_context",
                         "session_state",
+                        "dependencies",
                         "self",
                         "images",
                         "videos",
                         "audios",
                         "files",
-                        "dependencies",
                     ]
                 ]
             else:
@@ -229,13 +287,14 @@ class Function(BaseModel):
                     not in [
                         "agent",
                         "team",
+                        "run_context",
                         "session_state",
+                        "dependencies",
                         "self",
                         "images",
                         "videos",
                         "audios",
                         "files",
-                        "dependencies",
                     ]
                 ]
 
@@ -285,8 +344,12 @@ class Function(BaseModel):
                 del type_hints["agent"]
             if "team" in sig.parameters and "team" in type_hints:
                 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:
@@ -295,8 +358,6 @@ 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
@@ -304,13 +365,14 @@ class Function(BaseModel):
                 "return",
                 "agent",
                 "team",
+                "run_context",
                 "session_state",
+                "dependencies",
                 "self",
                 "images",
                 "videos",
                 "audios",
                 "files",
-                "dependencies",
             ]
             if self.requires_user_input and self.user_input_fields:
                 if len(self.user_input_fields) == 0:
@@ -400,7 +462,7 @@ class Function(BaseModel):
     @staticmethod
     def _wrap_callable(func: Callable) -> Callable:
         """Wrap a callable with Pydantic's validate_call decorator, if relevant"""
-        from inspect import isasyncgenfunction, iscoroutinefunction
+        from inspect import isasyncgenfunction, iscoroutinefunction, signature
 
         pydantic_version = Version(version("pydantic"))
 
@@ -418,6 +480,10 @@ 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:
+            return func
         # Wrap the callable with validate_call
         else:
             wrapped = validate_call(func, config=dict(arbitrary_types_allowed=True))  # type: ignore
@@ -468,11 +534,23 @@ class Function(BaseModel):
             name
             for name in self.parameters["properties"]
             if name
-            not in ["agent", "team", "session_state", "images", "videos", "audios", "files", "self", "dependencies"]
+            not in [
+                "agent",
+                "team",
+                "run_context",
+                "session_state",
+                "dependencies",
+                "images",
+                "videos",
+                "audios",
+                "files",
+                "self",
+            ]
         ]
 
     def _get_cache_key(self, entrypoint_args: Dict[str, Any], call_args: Optional[Dict[str, Any]] = None) -> str:
         """Generate a cache key based on function name and arguments."""
+        import json
         from hashlib import md5
 
         copy_entrypoint_args = entrypoint_args.copy()
@@ -481,8 +559,12 @@ class Function(BaseModel):
             del copy_entrypoint_args["agent"]
         if "team" in copy_entrypoint_args:
             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:
@@ -491,9 +573,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)
+        # Use json.dumps with sort_keys=True to ensure consistent ordering regardless of dict key order
+        args_str = json.dumps(copy_entrypoint_args, sort_keys=True, default=str)
 
         kwargs_str = str(sorted((call_args or {}).items()))
         key_str = f"{self.name}:{args_str}:{kwargs_str}"
@@ -617,8 +698,14 @@ class FunctionCall(BaseModel):
                 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
+                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
@@ -645,8 +732,14 @@ class FunctionCall(BaseModel):
                 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
+                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
@@ -670,6 +763,9 @@ class FunctionCall(BaseModel):
         # Check if the entrypoint has an 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
+        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
@@ -702,13 +798,15 @@ class FunctionCall(BaseModel):
         # Check if the hook has an team argument
         if "team" in signature(hook).parameters:
             hook_args["team"] = self.function._team
+        # Check if the hook has an 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:
@@ -799,6 +897,9 @@ class FunctionCall(BaseModel):
                 return FunctionExecutionResult(status="success", result=cached_result)
 
         # Execute function
+        execution_result: FunctionExecutionResult
+        exception_to_raise = None
+
         try:
             # Build and execute the nested chain of hooks
             if self.function.tool_hooks is not None:
@@ -807,13 +908,16 @@ class FunctionCall(BaseModel):
             else:
                 result = self.function.entrypoint(**entrypoint_args, **self.arguments)  # type: ignore
 
-            updated_session_state = None
-            if entrypoint_args.get("session_state") is not None:
-                updated_session_state = entrypoint_args.get("session_state")
-
             # Handle generator case
             if isgenerator(result):
                 self.result = result  # Store generator directly, can't cache
+                # For generators, don't capture updated_session_state yet -
+                # session_state is passed by reference, so mutations made during
+                # generator iteration are already reflected in the original dict.
+                # Returning None prevents stale state from being merged later.
+                execution_result = FunctionExecutionResult(
+                    status="success", result=self.result, updated_session_state=None
+                )
             else:
                 self.result = result
                 # Only cache non-generator results
@@ -822,22 +926,40 @@ class FunctionCall(BaseModel):
                     cache_file = self.function._get_cache_file_path(cache_key)
                     self.function._save_to_cache(cache_file, self.result)
 
+                updated_session_state = None
+                if entrypoint_args.get("run_context") is not None:
+                    run_context = entrypoint_args.get("run_context")
+                    updated_session_state = (
+                        run_context.session_state
+                        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
+                )
+
         except AgentRunException as e:
             log_debug(f"{e.__class__.__name__}: {e}")
             self.error = str(e)
-            raise
+            exception_to_raise = e
+            execution_result = FunctionExecutionResult(status="failure", error=str(e))
         except Exception as e:
             log_warning(f"Could not run function {self.get_call_str()}")
             log_exception(e)
             self.error = str(e)
-            return FunctionExecutionResult(status="failure", error=str(e))
+            execution_result = FunctionExecutionResult(status="failure", error=str(e))
+
+        finally:
+            self._handle_post_hook()
 
-        # Execute post-hook if it exists
-        self._handle_post_hook()
+        if exception_to_raise is not None:
+            raise exception_to_raise
 
-        return FunctionExecutionResult(
-            status="success", result=self.result, updated_session_state=updated_session_state
-        )
+        return execution_result
 
     async def _handle_pre_hook_async(self):
         """Handles the async pre-hook for the function call."""
@@ -852,9 +974,15 @@ class FunctionCall(BaseModel):
                 # Check if the pre-hook has an 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
+                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
@@ -881,9 +1009,15 @@ class FunctionCall(BaseModel):
                 # Check if the post-hook has an 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
+                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:
@@ -991,6 +1125,9 @@ class FunctionCall(BaseModel):
                 return FunctionExecutionResult(status="success", result=cached_result)
 
         # Execute function
+        execution_result: FunctionExecutionResult
+        exception_to_raise = None
+
         try:
             # Build and execute the nested chain of hooks
             if self.function.tool_hooks is not None:
@@ -1013,29 +1150,47 @@ class FunctionCall(BaseModel):
                 cache_file = self.function._get_cache_file_path(cache_key)
                 self.function._save_to_cache(cache_file, self.result)
 
-            updated_session_state = None
-            if entrypoint_args.get("session_state") is not None:
-                updated_session_state = entrypoint_args.get("session_state")
+            # For generators, don't capture updated_session_state -
+            # session_state is passed by reference, so mutations made during
+            # generator iteration are already reflected in the original dict.
+            # Returning None prevents stale state from being merged later.
+            if isgenerator(self.result) or isasyncgen(self.result):
+                updated_session_state = None
+            else:
+                updated_session_state = None
+                if entrypoint_args.get("run_context") is not None:
+                    run_context = entrypoint_args.get("run_context")
+                    updated_session_state = (
+                        run_context.session_state
+                        if run_context is not None and run_context.session_state is not None
+                        else None
+                    )
+
+            execution_result = FunctionExecutionResult(
+                status="success", result=self.result, updated_session_state=updated_session_state
+            )
 
         except AgentRunException as e:
             log_debug(f"{e.__class__.__name__}: {e}")
             self.error = str(e)
-            raise
+            exception_to_raise = e
+            execution_result = FunctionExecutionResult(status="failure", error=str(e))
         except Exception as e:
             log_warning(f"Could not run function {self.get_call_str()}")
             log_exception(e)
             self.error = str(e)
-            return FunctionExecutionResult(status="failure", error=str(e))
+            execution_result = FunctionExecutionResult(status="failure", error=str(e))
 
-        # Execute post-hook if it exists
-        if iscoroutinefunction(self.function.post_hook):
-            await self._handle_post_hook_async()
-        else:
-            self._handle_post_hook()
+        finally:
+            if iscoroutinefunction(self.function.post_hook):
+                await self._handle_post_hook_async()
+            else:
+                self._handle_post_hook()
 
-        return FunctionExecutionResult(
-            status="success", result=self.result, updated_session_state=updated_session_state
-        )
+        if exception_to_raise is not None:
+            raise exception_to_raise
+
+        return execution_result
 
 
 class ToolResult(BaseModel):