agno 1.8.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

agno/tools/function.py

@@ -1,13 +1,14 @@
 from dataclasses import dataclass
 from functools import partial
 from importlib.metadata import version
-from typing import Any, Callable, Dict, List, Literal, Optional, Type, TypeVar, get_type_hints
+from typing import Any, Callable, Dict, List, Literal, Optional, Sequence, Type, TypeVar, get_type_hints
 
 from docstring_parser import parse
 from packaging.version import Version
 from pydantic import BaseModel, Field, validate_call
 
 from agno.exceptions import AgentRunException
+from agno.media import Audio, File, Image, Video
 from agno.utils.log import log_debug, log_error, log_exception, log_warning
 
 T = TypeVar("T")
@@ -84,8 +85,6 @@ class Function(BaseModel):
     entrypoint: Optional[Callable] = None
     # If True, the entrypoint processing is skipped and the Function is used as is.
     skip_entrypoint_processing: bool = False
-    # If True, the arguments are sanitized before being passed to the function. (Deprecated)
-    sanitize_arguments: bool = False
     # If True, the function call will show the result along with sending it to the model.
     show_result: bool = False
     # If True, the agent will stop after the function call.
@@ -123,6 +122,14 @@ class Function(BaseModel):
     _agent: Optional[Any] = None
     # The team that the function is associated with
     _team: Optional[Any] = None
+    # The session state that the function is associated with
+    _session_state: Optional[Dict[str, Any]] = None
+
+    # Media context that the function is associated with
+    _images: Optional[Sequence[Image]] = None
+    _videos: Optional[Sequence[Video]] = None
+    _audios: Optional[Sequence[Audio]] = None
+    _files: Optional[Sequence[File]] = None
 
     def to_dict(self) -> Dict[str, Any]:
         return self.model_dump(
@@ -143,17 +150,29 @@ class Function(BaseModel):
             type_hints = get_type_hints(c)
 
             # If function has an the agent argument, remove the agent parameter from the type hints
-            if "agent" in sig.parameters:
+            if "agent" in sig.parameters and "agent" in type_hints:
                 del type_hints["agent"]
-            if "team" in sig.parameters:
+            if "team" in sig.parameters and "team" in type_hints:
                 del type_hints["team"]
+            if "session_state" in sig.parameters and "session_state" in type_hints:
+                del type_hints["session_state"]
+            # 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"]
+            if "videos" in sig.parameters and "videos" in type_hints:
+                del type_hints["videos"]
+            if "audios" in sig.parameters and "audios" in type_hints:
+                del type_hints["audios"]
+            if "files" in sig.parameters and "files" in type_hints:
+                del type_hints["files"]
             # log_info(f"Type hints for {function_name}: {type_hints}")
 
             # Filter out return type and only process parameters
             param_type_hints = {
                 name: type_hints.get(name)
                 for name in sig.parameters
-                if name != "return" and name not in ["agent", "team", "self"]
+                if name != "return"
+                and name not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files"]
             }
 
             # Parse docstring for parameters
@@ -180,14 +199,17 @@ class Function(BaseModel):
             # See: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas#all-fields-must-be-required
             if strict:
                 parameters["required"] = [
-                    name for name in parameters["properties"] if name not in ["agent", "team", "self"]
+                    name
+                    for name in parameters["properties"]
+                    if name not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files"]
                 ]
             else:
                 # Mark a field as required if it has no default value (this would include optional fields)
                 parameters["required"] = [
                     name
                     for name, param in sig.parameters.items()
-                    if param.default == param.empty and name != "self" and name not in ["agent", "team"]
+                    if param.default == param.empty
+                    and name not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files"]
                 ]
 
             # log_debug(f"JSON schema for {function_name}: {parameters}")
@@ -232,14 +254,34 @@ class Function(BaseModel):
             type_hints = get_type_hints(self.entrypoint)
 
             # If function has an the agent argument, remove the agent parameter from the type hints
-            if "agent" in sig.parameters:
+            if "agent" in sig.parameters and "agent" in type_hints:
                 del type_hints["agent"]
-            if "team" in sig.parameters:
+            if "team" in sig.parameters and "team" in type_hints:
                 del type_hints["team"]
+            if "session_state" in sig.parameters and "session_state" in type_hints:
+                del type_hints["session_state"]
+            if "images" in sig.parameters and "images" in type_hints:
+                del type_hints["images"]
+            if "videos" in sig.parameters and "videos" in type_hints:
+                del type_hints["videos"]
+            if "audios" in sig.parameters and "audios" in type_hints:
+                del type_hints["audios"]
+            if "files" in sig.parameters and "files" in type_hints:
+                del type_hints["files"]
             # log_info(f"Type hints for {self.name}: {type_hints}")
 
             # Filter out return type and only process parameters
-            excluded_params = ["return", "agent", "team", "self"]
+            excluded_params = [
+                "return",
+                "agent",
+                "team",
+                "session_state",
+                "self",
+                "images",
+                "videos",
+                "audios",
+                "files",
+            ]
             if self.requires_user_input and self.user_input_fields:
                 if len(self.user_input_fields) == 0:
                     excluded_params.extend(list(type_hints.keys()))
@@ -352,7 +394,9 @@ class Function(BaseModel):
     def process_schema_for_strict(self):
         self.parameters["additionalProperties"] = False
         self.parameters["required"] = [
-            name for name in self.parameters["properties"] if name not in ["agent", "team", "self"]
+            name
+            for name in self.parameters["properties"]
+            if name not in ["agent", "team", "session_state", "images", "videos", "audios", "files", "self"]
         ]
 
     def _get_cache_key(self, entrypoint_args: Dict[str, Any], call_args: Optional[Dict[str, Any]] = None) -> str:
@@ -365,6 +409,16 @@ class Function(BaseModel):
             del copy_entrypoint_args["agent"]
         if "team" in copy_entrypoint_args:
             del copy_entrypoint_args["team"]
+        if "session_state" in copy_entrypoint_args:
+            del copy_entrypoint_args["session_state"]
+        if "images" in copy_entrypoint_args:
+            del copy_entrypoint_args["images"]
+        if "videos" in copy_entrypoint_args:
+            del copy_entrypoint_args["videos"]
+        if "audios" in copy_entrypoint_args:
+            del copy_entrypoint_args["audios"]
+        if "files" in copy_entrypoint_args:
+            del copy_entrypoint_args["files"]
         args_str = str(copy_entrypoint_args)
 
         kwargs_str = str(sorted((call_args or {}).items()))
@@ -425,6 +479,13 @@ class FunctionExecutionResult(BaseModel):
     result: Optional[Any] = None
     error: Optional[str] = None
 
+    updated_session_state: Optional[Dict[str, Any]] = None
+
+    # New fields for media artifacts
+    images: Optional[List[Image]] = None
+    videos: Optional[List[Video]] = None
+    audios: Optional[List[Audio]] = None
+
 
 class FunctionCall(BaseModel):
     """Model for Function Calls"""
@@ -480,6 +541,9 @@ 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 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 fc argument
                 if "fc" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["fc"] = self
@@ -505,6 +569,9 @@ 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 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 fc argument
                 if "fc" in signature(self.function.post_hook).parameters:
                     post_hook_args["fc"] = self
@@ -528,9 +595,23 @@ 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 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 fc argument
         if "fc" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["fc"] = self
+
+        # Check if the entrypoint has media arguments
+        if "images" in signature(self.function.entrypoint).parameters:  # type: ignore
+            entrypoint_args["images"] = self.function._images
+        if "videos" in signature(self.function.entrypoint).parameters:  # type: ignore
+            entrypoint_args["videos"] = self.function._videos
+        if "audios" in signature(self.function.entrypoint).parameters:  # type: ignore
+            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]:
@@ -544,6 +625,9 @@ 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 session_state argument
+        if "session_state" in signature(hook).parameters:
+            hook_args["session_state"] = self.function._session_state
 
         if "name" in signature(hook).parameters:
             hook_args["name"] = name
@@ -641,10 +725,11 @@ class FunctionCall(BaseModel):
                 execution_chain = self._build_nested_execution_chain(entrypoint_args=entrypoint_args)
                 result = execution_chain(self.function.name, self.function.entrypoint, self.arguments or {})
             else:
-                arguments = entrypoint_args
-                if self.arguments is not None:
-                    arguments.update(self.arguments)
-                result = self.function.entrypoint(**arguments)
+                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):
@@ -670,7 +755,9 @@ class FunctionCall(BaseModel):
         # Execute post-hook if it exists
         self._handle_post_hook()
 
-        return FunctionExecutionResult(status="success", result=self.result)
+        return FunctionExecutionResult(
+            status="success", result=self.result, updated_session_state=updated_session_state
+        )
 
     async def _handle_pre_hook_async(self):
         """Handles the async pre-hook for the function call."""
@@ -685,6 +772,9 @@ 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 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 fc argument
                 if "fc" in signature(self.function.pre_hook).parameters:
                     pre_hook_args["fc"] = self
@@ -711,6 +801,10 @@ 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 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 fc argument
                 if "fc" in signature(self.function.post_hook).parameters:
                     post_hook_args["fc"] = self
@@ -839,6 +933,10 @@ 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")
+
         except AgentRunException as e:
             log_debug(f"{e.__class__.__name__}: {e}")
             self.error = str(e)
@@ -855,4 +953,15 @@ class FunctionCall(BaseModel):
         else:
             self._handle_post_hook()
 
-        return FunctionExecutionResult(status="success", result=self.result)
+        return FunctionExecutionResult(
+            status="success", result=self.result, updated_session_state=updated_session_state
+        )
+
+
+class ToolResult(BaseModel):
+    """Result from a tool that can include media artifacts."""
+
+    content: str
+    images: Optional[List[Image]] = None
+    videos: Optional[List[Video]] = None
+    audios: Optional[List[Audio]] = None

agno/tools/giphy.py

@@ -1,13 +1,14 @@
-import os
 import uuid
+from os import getenv
 from typing import Any, List, Optional, Union
 
 import httpx
 
 from agno.agent import Agent
-from agno.media import ImageArtifact
+from agno.media import Image
 from agno.team.team import Team
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import logger
 
 
@@ -16,6 +17,8 @@ class GiphyTools(Toolkit):
         self,
         api_key: Optional[str] = None,
         limit: int = 1,
+        enable_search_gifs: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """Initialize Giphy tools.
@@ -23,27 +26,29 @@ class GiphyTools(Toolkit):
         Args:
             api_key: Giphy API key. Defaults to GIPHY_API_KEY environment variable.
             limit: Number of GIFs to return. Defaults to 1.
-            search_gifs: Whether to enable GIF search functionality. Defaults to True.
+            enable_search_gifs: Whether to enable GIF search functionality. Defaults to True.
+            all: Enable all functions. Defaults to False.
         """
-        self.api_key = api_key or os.getenv("GIPHY_API_KEY")
+        self.api_key = api_key or getenv("GIPHY_API_KEY")
         if not self.api_key:
             logger.error("No Giphy API key provided")
 
         self.limit: int = limit
 
         tools: List[Any] = []
-        tools.append(self.search_gifs)
+        if all or enable_search_gifs:
+            tools.append(self.search_gifs)
 
         super().__init__(name="giphy_tools", tools=tools, **kwargs)
 
-    def search_gifs(self, agent: Union[Agent, Team], query: str) -> str:
+    def search_gifs(self, agent: Union[Agent, Team], query: str) -> ToolResult:
         """Find a GIPHY gif
 
         Args:
             query (str): A text description of the required gif.
 
         Returns:
-            result (str): A string containing urls of GIFs found
+            ToolResult: Contains the found GIF images or error message.
         """
 
         base_url = "https://api.giphy.com/v1/gifs/search"
@@ -60,6 +65,8 @@ class GiphyTools(Toolkit):
             # Extract the GIF URLs
             data = response.json()
             gif_urls = []
+            image_artifacts = []
+
             for gif in data.get("data", []):
                 images = gif.get("images", {})
                 original_image = images["original"]
@@ -69,13 +76,18 @@ class GiphyTools(Toolkit):
                 alt_text = gif["alt_text"]
                 gif_urls.append(gif_url)
 
-                agent.add_image(ImageArtifact(id=media_id, url=gif_url, alt_text=alt_text, revised_prompt=query))
+                # Create ImageArtifact for the GIF
+                image_artifact = Image(id=media_id, url=gif_url, alt_text=alt_text, revised_prompt=query)
+                image_artifacts.append(image_artifact)
 
-            return f"These are the found gifs {gif_urls}"
+            if image_artifacts:
+                return ToolResult(content=f"Found {len(gif_urls)} GIF(s): {gif_urls}", images=image_artifacts)
+            else:
+                return ToolResult(content="No gifs found")
 
         except httpx.HTTPStatusError as e:
             logger.error(f"HTTP error occurred: {e.response.status_code} - {e.response.text}")
+            return ToolResult(content=f"HTTP error occurred: {e.response.status_code}")
         except Exception as e:
             logger.error(f"An error occurred: {e}")
-
-        return "No gifs found"
+            return ToolResult(content=f"An error occurred: {e}")

agno/tools/github.py

@@ -7,7 +7,6 @@ from agno.utils.log import log_debug, logger
 
 try:
     from github import Auth, Github, GithubException
-    from github.GithubObject import NotSet
 
 except ImportError:
     raise ImportError("`PyGithub` not installed. Please install using `pip install pygithub`")
@@ -18,45 +17,6 @@ class GithubTools(Toolkit):
         self,
         access_token: Optional[str] = None,
         base_url: Optional[str] = None,
-        search_repositories: bool = True,
-        list_repositories: bool = False,
-        get_repository: bool = False,
-        get_pull_request: bool = False,
-        get_pull_request_changes: bool = False,
-        create_issue: bool = False,
-        create_repository: bool = False,
-        delete_repository: bool = False,
-        get_repository_languages: bool = False,
-        list_branches: bool = False,
-        get_pull_request_count: bool = False,
-        get_repository_stars: bool = False,
-        get_pull_requests: bool = False,
-        get_pull_request_comments: bool = False,
-        create_pull_request_comment: bool = False,
-        edit_pull_request_comment: bool = False,
-        get_pull_request_with_details: bool = False,
-        get_repository_with_stats: bool = False,
-        list_issues: bool = False,
-        get_issue: bool = False,
-        comment_on_issue: bool = False,
-        close_issue: bool = False,
-        reopen_issue: bool = False,
-        assign_issue: bool = False,
-        label_issue: bool = False,
-        list_issue_comments: bool = False,
-        edit_issue: bool = False,
-        create_pull_request: bool = False,
-        create_file: bool = False,
-        get_file_content: bool = False,
-        update_file: bool = True,
-        delete_file: bool = False,
-        get_directory_content: bool = False,
-        get_branch_content: bool = False,
-        create_branch: bool = False,
-        set_default_branch: bool = False,
-        search_code: bool = False,
-        search_issues_and_prs: bool = False,
-        create_review_request: bool = False,
         **kwargs,
     ):
         self.access_token = access_token or getenv("GITHUB_ACCESS_TOKEN")
@@ -64,85 +24,47 @@ class GithubTools(Toolkit):
 
         self.g = self.authenticate()
 
-        tools: List[Any] = []
-        if search_repositories:
-            tools.append(self.search_repositories)
-        if list_repositories:
-            tools.append(self.list_repositories)
-        if get_repository:
-            tools.append(self.get_repository)
-        if get_pull_request:
-            tools.append(self.get_pull_request)
-        if get_pull_request_changes:
-            tools.append(self.get_pull_request_changes)
-        if create_issue:
-            tools.append(self.create_issue)
-        if create_repository:
-            tools.append(self.create_repository)
-        if delete_repository:
-            tools.append(self.delete_repository)
-        if list_branches:
-            tools.append(self.list_branches)
-        if get_repository_languages:
-            tools.append(self.get_repository_languages)
-        if get_pull_request_count:
-            tools.append(self.get_pull_request_count)
-        if get_repository_stars:
-            tools.append(self.get_repository_stars)
-        if get_pull_requests:
-            tools.append(self.get_pull_requests)
-        if get_pull_request_comments:
-            tools.append(self.get_pull_request_comments)
-        if create_pull_request_comment:
-            tools.append(self.create_pull_request_comment)
-        if edit_pull_request_comment:
-            tools.append(self.edit_pull_request_comment)
-        if get_pull_request_with_details:
-            tools.append(self.get_pull_request_with_details)
-        if get_repository_with_stats:
-            tools.append(self.get_repository_with_stats)
-        if list_issues:
-            tools.append(self.list_issues)
-        if get_issue:
-            tools.append(self.get_issue)
-        if comment_on_issue:
-            tools.append(self.comment_on_issue)
-        if close_issue:
-            tools.append(self.close_issue)
-        if reopen_issue:
-            tools.append(self.reopen_issue)
-        if assign_issue:
-            tools.append(self.assign_issue)
-        if label_issue:
-            tools.append(self.label_issue)
-        if list_issue_comments:
-            tools.append(self.list_issue_comments)
-        if edit_issue:
-            tools.append(self.edit_issue)
-        if create_pull_request:
-            tools.append(self.create_pull_request)
-        if create_file:
-            tools.append(self.create_file)
-        if get_file_content:
-            tools.append(self.get_file_content)
-        if update_file:
-            tools.append(self.update_file)
-        if delete_file:
-            tools.append(self.delete_file)
-        if get_directory_content:
-            tools.append(self.get_directory_content)
-        if get_branch_content:
-            tools.append(self.get_branch_content)
-        if create_branch:
-            tools.append(self.create_branch)
-        if set_default_branch:
-            tools.append(self.set_default_branch)
-        if search_code:
-            tools.append(self.search_code)
-        if search_issues_and_prs:
-            tools.append(self.search_issues_and_prs)
-        if create_review_request:
-            tools.append(self.create_review_request)
+        tools: List[Any] = [
+            self.search_repositories,
+            self.list_repositories,
+            self.get_repository,
+            self.get_pull_request,
+            self.get_pull_request_changes,
+            self.create_issue,
+            self.create_repository,
+            self.delete_repository,
+            self.list_branches,
+            self.get_repository_languages,
+            self.get_pull_request_count,
+            self.get_repository_stars,
+            self.get_pull_requests,
+            self.get_pull_request_comments,
+            self.create_pull_request_comment,
+            self.edit_pull_request_comment,
+            self.get_pull_request_with_details,
+            self.get_repository_with_stats,
+            self.list_issues,
+            self.get_issue,
+            self.comment_on_issue,
+            self.close_issue,
+            self.reopen_issue,
+            self.assign_issue,
+            self.label_issue,
+            self.list_issue_comments,
+            self.edit_issue,
+            self.create_pull_request,
+            self.create_file,
+            self.get_file_content,
+            self.update_file,
+            self.delete_file,
+            self.get_directory_content,
+            self.get_branch_content,
+            self.create_branch,
+            self.set_default_branch,
+            self.search_code,
+            self.search_issues_and_prs,
+            self.create_review_request,
+        ]
 
         super().__init__(name="github", tools=tools, **kwargs)
 
@@ -428,7 +350,7 @@ class GithubTools(Toolkit):
             logger.error(f"Error getting pull request changes: {e}")
             return json.dumps({"error": str(e)})
 
-    def create_issue(self, repo_name: str, title: str, body: Optional[str] = NotSet) -> str:
+    def create_issue(self, repo_name: str, title: str, body: Optional[str] = None) -> str:
         """Create an issue in a repository.
 
         Args:
@@ -442,7 +364,7 @@ class GithubTools(Toolkit):
         log_debug(f"Creating issue in repository: {repo_name}")
         try:
             repo = self.g.get_repo(repo_name)
-            issue = repo.create_issue(title=title, body=body)
+            issue = repo.create_issue(title=title, body=body)  # type: ignore
             issue_info = {
                 "id": issue.id,
                 "number": issue.number,
@@ -697,8 +619,8 @@ class GithubTools(Toolkit):
         self,
         repo_name: str,
         issue_number: int,
-        title: Optional[str] = NotSet,
-        body: Optional[str] = NotSet,
+        title: Optional[str] = None,
+        body: Optional[str] = None,
     ) -> str:
         """Edit the title or body of an issue.
 
@@ -715,7 +637,7 @@ class GithubTools(Toolkit):
         try:
             repo = self.g.get_repo(repo_name)
             issue = repo.get_issue(number=issue_number)
-            issue.edit(title=title, body=body)
+            issue.edit(title=title, body=body)  # type: ignore
             return json.dumps({"message": f"Issue #{issue_number} updated."}, indent=2)
         except GithubException as e:
             logger.error(f"Error editing issue: {e}")
@@ -1324,7 +1246,7 @@ class GithubTools(Toolkit):
         path: str,
         content: str,
         message: str,
-        branch: Optional[str] = NotSet,
+        branch: Optional[str] = None,
     ) -> str:
         """Create a new file in a repository.
 
@@ -1350,7 +1272,7 @@ class GithubTools(Toolkit):
 
             # Extract relevant information
             file_info = {
-                "path": result["content"].path,
+                "path": result["content"].path,  # type: ignore
                 "sha": result["content"].sha,
                 "url": result["content"].html_url,
                 "commit": {