agno 1.8.1__py3-none-any.whl → 2.0.0rc1__py3-none-any.whl

agno/tools/jira.py

@@ -1,5 +1,5 @@
 import json
-import os
+from os import getenv
 from typing import Any, List, Optional, cast
 
 from agno.tools import Toolkit
@@ -18,12 +18,17 @@ class JiraTools(Toolkit):
         username: Optional[str] = None,
         password: Optional[str] = None,
         token: Optional[str] = None,
+        enable_get_issue: bool = True,
+        enable_create_issue: bool = True,
+        enable_search_issues: bool = True,
+        enable_add_comment: bool = True,
+        all: bool = False,
         **kwargs,
     ):
-        self.server_url = server_url or os.getenv("JIRA_SERVER_URL")
-        self.username = username or os.getenv("JIRA_USERNAME")
-        self.password = password or os.getenv("JIRA_PASSWORD")
-        self.token = token or os.getenv("JIRA_TOKEN")
+        self.server_url = server_url or getenv("JIRA_SERVER_URL")
+        self.username = username or getenv("JIRA_USERNAME")
+        self.password = password or getenv("JIRA_PASSWORD")
+        self.token = token or getenv("JIRA_TOKEN")
 
         if not self.server_url:
             raise ValueError("JIRA server URL not provided.")
@@ -42,10 +47,14 @@ class JiraTools(Toolkit):
             self.jira = JIRA(server=self.server_url)
 
         tools: List[Any] = []
-        tools.append(self.get_issue)
-        tools.append(self.create_issue)
-        tools.append(self.search_issues)
-        tools.append(self.add_comment)
+        if enable_get_issue or all:
+            tools.append(self.get_issue)
+        if enable_create_issue or all:
+            tools.append(self.create_issue)
+        if enable_search_issues or all:
+            tools.append(self.search_issues)
+        if enable_add_comment or all:
+            tools.append(self.add_comment)
 
         super().__init__(name="jira_tools", tools=tools, **kwargs)
 

agno/tools/knowledge.py

@@ -1,26 +1,25 @@
 import json
 from textwrap import dedent
-from typing import Any, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
-from agno.agent import Agent
-from agno.document import Document
-from agno.knowledge.agent import AgentKnowledge
-from agno.team.team import Team
+from agno.knowledge.document import Document
+from agno.knowledge.knowledge import Knowledge
 from agno.tools import Toolkit
-from agno.utils.log import log_debug, logger
+from agno.utils.log import log_debug, log_error
 
 
 class KnowledgeTools(Toolkit):
     def __init__(
         self,
-        knowledge: AgentKnowledge,
-        think: bool = True,
-        search: bool = True,
-        analyze: bool = True,
+        knowledge: Knowledge,
+        enable_think: bool = True,
+        enable_search: bool = True,
+        enable_analyze: bool = True,
         instructions: Optional[str] = None,
         add_instructions: bool = True,
         add_few_shot: bool = False,
         few_shot_examples: Optional[str] = None,
+        all: bool = False,
         **kwargs,
     ):
         if knowledge is None:
@@ -38,14 +37,14 @@ class KnowledgeTools(Toolkit):
             self.instructions = instructions
 
         # The knowledge to search
-        self.knowledge: AgentKnowledge = knowledge
+        self.knowledge: Knowledge = knowledge
 
         tools: List[Any] = []
-        if think:
+        if enable_think or all:
             tools.append(self.think)
-        if search:
+        if enable_search or all:
             tools.append(self.search)
-        if analyze:
+        if enable_analyze or all:
             tools.append(self.analyze)
 
         super().__init__(
@@ -56,7 +55,7 @@ class KnowledgeTools(Toolkit):
             **kwargs,
         )
 
-    def think(self, agent: Union[Agent, Team], thought: str) -> str:
+    def think(self, session_state: Dict[str, Any], 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.
@@ -72,14 +71,14 @@ class KnowledgeTools(Toolkit):
             log_debug(f"Thought: {thought}")
 
             # Add the thought to the Agent state
-            if agent.session_state is None:
-                agent.session_state = {}
-            if "thoughts" not in agent.session_state:
-                agent.session_state["thoughts"] = []
-            agent.session_state["thoughts"].append(thought)
+            if session_state is None:
+                session_state = {}
+            if "thoughts" not in session_state:
+                session_state["thoughts"] = []
+            session_state["thoughts"].append(thought)
 
             # Return the full log of thoughts and the new thought
-            thoughts = "\n".join([f"- {t}" for t in agent.session_state["thoughts"]])
+            thoughts = "\n".join([f"- {t}" for t in session_state["thoughts"]])
             formatted_thoughts = dedent(
                 f"""Thoughts:
                 {thoughts}
@@ -87,10 +86,10 @@ class KnowledgeTools(Toolkit):
             ).strip()
             return formatted_thoughts
         except Exception as e:
-            logger.error(f"Error recording thought: {e}")
+            log_error(f"Error recording thought: {e}")
             return f"Error recording thought: {e}"
 
-    def search(self, agent: Union[Agent, Team], query: str) -> str:
+    def search(self, session_state: Dict[str, Any], query: str) -> str:
         """Use this tool to search the knowledge base for relevant information.
         After thinking through the question, use this tool as many times as needed to search for relevant information.
 
@@ -109,10 +108,10 @@ class KnowledgeTools(Toolkit):
                 return "No documents found"
             return json.dumps([doc.to_dict() for doc in relevant_docs])
         except Exception as e:
-            logger.error(f"Error searching knowledge base: {e}")
+            log_error(f"Error searching knowledge base: {e}")
             return f"Error searching knowledge base: {e}"
 
-    def analyze(self, agent: Union[Agent, Team], analysis: str) -> str:
+    def analyze(self, session_state: Dict[str, Any], 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.
 
@@ -126,14 +125,14 @@ class KnowledgeTools(Toolkit):
             log_debug(f"Analysis: {analysis}")
 
             # Add the thought to the Agent state
-            if agent.session_state is None:
-                agent.session_state = {}
-            if "analysis" not in agent.session_state:
-                agent.session_state["analysis"] = []
-            agent.session_state["analysis"].append(analysis)
+            if session_state is None:
+                session_state = {}
+            if "analysis" not in session_state:
+                session_state["analysis"] = []
+            session_state["analysis"].append(analysis)
 
             # Return the full log of thoughts and the new thought
-            analysis = "\n".join([f"- {a}" for a in agent.session_state["analysis"]])
+            analysis = "\n".join([f"- {a}" for a in session_state["analysis"]])
             formatted_analysis = dedent(
                 f"""Analysis:
                 {analysis}
@@ -141,7 +140,7 @@ class KnowledgeTools(Toolkit):
             ).strip()
             return formatted_analysis
         except Exception as e:
-            logger.error(f"Error recording analysis: {e}")
+            log_error(f"Error recording analysis: {e}")
             return f"Error recording analysis: {e}"
 
     DEFAULT_INSTRUCTIONS = dedent("""\

agno/tools/linear.py

@@ -10,44 +10,29 @@ from agno.utils.log import log_info, logger
 class LinearTools(Toolkit):
     def __init__(
         self,
-        get_user_details: bool = True,
-        get_teams_details: bool = True,
-        get_issue_details: bool = True,
-        create_issue: bool = True,
-        update_issue: bool = True,
-        get_user_assigned_issues: bool = True,
-        get_workflow_issues: bool = True,
-        get_high_priority_issues: bool = True,
+        api_key: Optional[str] = None,
         **kwargs,
     ):
-        self.api_token = getenv("LINEAR_API_KEY")
+        self.api_key = api_key or getenv("LINEAR_API_KEY")
 
-        if not self.api_token:
-            api_error_message = "API token 'LINEAR_API_KEY' is missing. Please set it as an environment variable."
-            logger.error(api_error_message)
+        if not self.api_key:
+            raise ValueError("Linear API key is required")
 
         self.endpoint = "https://api.linear.app/graphql"
-        self.headers = {"Authorization": f"{self.api_token}"}
-
-        tools: List[Any] = []
-        if get_user_details:
-            tools.append(self.get_user_details)
-        if get_teams_details:
-            tools.append(self.get_teams_details)
-        if get_issue_details:
-            tools.append(self.get_issue_details)
-        if create_issue:
-            tools.append(self.create_issue)
-        if update_issue:
-            tools.append(self.update_issue)
-        if get_user_assigned_issues:
-            tools.append(self.get_user_assigned_issues)
-        if get_workflow_issues:
-            tools.append(self.get_workflow_issues)
-        if get_high_priority_issues:
-            tools.append(self.get_high_priority_issues)
-
-        super().__init__(name="linear tools", tools=tools, **kwargs)
+        self.headers = {"Authorization": f"{self.api_key}"}
+
+        tools: List[Any] = [
+            self.get_user_details,
+            self.get_teams_details,
+            self.get_issue_details,
+            self.create_issue,
+            self.update_issue,
+            self.get_user_assigned_issues,
+            self.get_workflow_issues,
+            self.get_high_priority_issues,
+        ]
+
+        super().__init__(name="linear_tools", tools=tools, **kwargs)
 
     def _execute_query(self, query, variables=None):
         """Helper method to execute GraphQL queries with optional variables."""
@@ -217,7 +202,7 @@ class LinearTools(Toolkit):
         """
 
         query = """
-        mutation IssueCreate ($title: String!, $description: String!, $teamId: String!, $projectId: String!, $assigneeId: String!){
+        mutation IssueCreate ($title: String!, $description: String!, $teamId: String!, $projectId: String, $assigneeId: String){
           issueCreate(
             input: { title: $title, description: $description, teamId: $teamId, projectId: $projectId, assigneeId: $assigneeId}
           ) {

agno/tools/linkup.py

@@ -16,6 +16,8 @@ class LinkupTools(Toolkit):
         api_key: Optional[str] = None,
         depth: Literal["standard", "deep"] = "standard",
         output_type: Literal["sourcedAnswer", "searchResults"] = "searchResults",
+        enable_web_search_with_linkup: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.api_key = api_key or getenv("LINKUP_API_KEY")
@@ -26,7 +28,9 @@ class LinkupTools(Toolkit):
         self.depth = depth
         self.output_type = output_type
 
-        tools: List[Any] = [self.web_search_with_linkup]
+        tools: List[Any] = []
+        if all or enable_web_search_with_linkup:
+            tools.append(self.web_search_with_linkup)
 
         super().__init__(name="linkup_tools", tools=tools, **kwargs)
 

agno/tools/local_file_system.py

@@ -1,4 +1,3 @@
-import os
 from pathlib import Path
 from typing import Optional
 from uuid import uuid4
@@ -12,6 +11,8 @@ class LocalFileSystemTools(Toolkit):
         self,
         target_directory: Optional[str] = None,
         default_extension: str = "txt",
+        enable_write_file: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """
@@ -21,14 +22,15 @@ class LocalFileSystemTools(Toolkit):
             default_extension (str): Default file extension to use if none specified.
         """
 
-        self.target_directory = target_directory or os.getcwd()
+        self.target_directory = target_directory or str(Path.cwd())
         self.default_extension = default_extension.lstrip(".")
 
         target_path = Path(self.target_directory)
         target_path.mkdir(parents=True, exist_ok=True)
 
         tools = []
-        tools.append(self.write_file)
+        if all or enable_write_file:
+            tools.append(self.write_file)
 
         super().__init__(name="write_to_local", tools=tools, **kwargs)
 
@@ -53,8 +55,9 @@ class LocalFileSystemTools(Toolkit):
             filename = filename or str(uuid4())
             directory = directory or self.target_directory
             if filename and "." in filename:
-                filename, file_ext = os.path.splitext(filename)
-                extension = extension or file_ext.lstrip(".")
+                path_obj = Path(filename)
+                filename = path_obj.stem
+                extension = extension or path_obj.suffix.lstrip(".")
 
             log_debug(f"Writing file to local system: {filename}")
 

agno/tools/lumalab.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Literal, Optional, TypedDict
 from agno.agent import Agent
 from agno.media import VideoArtifact
 from agno.tools import Toolkit
+from agno.tools.function import ToolResult
 from agno.utils.log import log_info, logger
 
 try:
@@ -30,6 +31,9 @@ class LumaLabTools(Toolkit):
         wait_for_completion: bool = True,
         poll_interval: int = 3,
         max_wait_time: int = 300,  # 5 minutes
+        enable_generate_video: bool = True,
+        enable_image_to_video: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.wait_for_completion = wait_for_completion
@@ -43,8 +47,10 @@ class LumaLabTools(Toolkit):
         self.client = LumaAI(auth_token=self.api_key)
 
         tools: List[Any] = []
-        tools.append(self.generate_video)
-        tools.append(self.image_to_video)
+        if all or enable_generate_video:
+            tools.append(self.generate_video)
+        if all or enable_image_to_video:
+            tools.append(self.image_to_video)
 
         super().__init__(name="luma_lab", tools=tools, **kwargs)
 
@@ -56,7 +62,7 @@ class LumaLabTools(Toolkit):
         end_image_url: Optional[str] = None,
         loop: bool = False,
         aspect_ratio: Literal["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21"] = "16:9",
-    ) -> str:
+    ) -> ToolResult:
         """Generate a video from one or two images with a prompt.
 
         Args:
@@ -68,7 +74,7 @@ class LumaLabTools(Toolkit):
             aspect_ratio: Aspect ratio of the output video
 
         Returns:
-            str: Status message or error
+            ToolResult: A ToolResult containing the generated video or error message.
         """
 
         try:
@@ -90,33 +96,36 @@ class LumaLabTools(Toolkit):
             video_id = str(uuid.uuid4())
 
             if not self.wait_for_completion:
-                return "Async generation unsupported"
+                return ToolResult(content="Async generation unsupported")
 
             # Poll for completion
             seconds_waited = 0
             while seconds_waited < self.max_wait_time:
                 if not generation or not generation.id:
-                    return "Failed to get generation ID"
+                    return ToolResult(content="Failed to get generation ID")
 
                 generation = self.client.generations.get(generation.id)
 
                 if generation.state == "completed" and generation.assets:
                     video_url = generation.assets.video
                     if video_url:
-                        agent.add_video(VideoArtifact(id=video_id, url=video_url, eta="completed"))
-                        return f"Video generated successfully: {video_url}"
+                        video_artifact = VideoArtifact(id=video_id, url=video_url, eta="completed")
+                        return ToolResult(
+                            content=f"Video generated successfully: {video_url}",
+                            videos=[video_artifact],
+                        )
                 elif generation.state == "failed":
-                    return f"Generation failed: {generation.failure_reason}"
+                    return ToolResult(content=f"Generation failed: {generation.failure_reason}")
 
                 log_info(f"Generation in progress... State: {generation.state}")
                 time.sleep(self.poll_interval)
                 seconds_waited += self.poll_interval
 
-            return f"Video generation timed out after {self.max_wait_time} seconds"
+            return ToolResult(content=f"Video generation timed out after {self.max_wait_time} seconds")
 
         except Exception as e:
             logger.error(f"Failed to generate video: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")
 
     def generate_video(
         self,
@@ -125,7 +134,7 @@ class LumaLabTools(Toolkit):
         loop: bool = False,
         aspect_ratio: Literal["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21"] = "16:9",
         keyframes: Optional[Dict[str, Dict[str, str]]] = None,
-    ) -> str:
+    ) -> ToolResult:
         """Use this function to generate a video given a prompt."""
 
         try:
@@ -142,30 +151,33 @@ class LumaLabTools(Toolkit):
 
             video_id = str(uuid.uuid4())
             if not self.wait_for_completion:
-                return "Async generation unsupported"
+                return ToolResult(content="Async generation unsupported")
 
             # Poll for completion
             seconds_waited = 0
             while seconds_waited < self.max_wait_time:
                 if not generation or not generation.id:
-                    return "Failed to get generation ID"
+                    return ToolResult(content="Failed to get generation ID")
 
                 generation = self.client.generations.get(generation.id)
 
                 if generation.state == "completed" and generation.assets:
                     video_url = generation.assets.video
                     if video_url:
-                        agent.add_video(VideoArtifact(id=video_id, url=video_url, state="completed"))
-                        return f"Video generated successfully: {video_url}"
+                        video_artifact = VideoArtifact(id=video_id, url=video_url, state="completed")
+                        return ToolResult(
+                            content=f"Video generated successfully: {video_url}",
+                            videos=[video_artifact],
+                        )
                 elif generation.state == "failed":
-                    return f"Generation failed: {generation.failure_reason}"
+                    return ToolResult(content=f"Generation failed: {generation.failure_reason}")
 
                 log_info(f"Generation in progress... State: {generation.state}")
                 time.sleep(self.poll_interval)
                 seconds_waited += self.poll_interval
 
-            return f"Video generation timed out after {self.max_wait_time} seconds"
+            return ToolResult(content=f"Video generation timed out after {self.max_wait_time} seconds")
 
         except Exception as e:
             logger.error(f"Failed to generate video: {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")

agno/tools/mem0.py

@@ -1,9 +1,9 @@
 import json
 from os import getenv
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from agno.agent import Agent
-from agno.tools.toolkit import Toolkit
+from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error, log_warning
 
 try:
@@ -22,18 +22,24 @@ class Mem0Tools(Toolkit):
         org_id: Optional[str] = None,
         project_id: Optional[str] = None,
         infer: bool = True,
+        enable_add_memory: bool = True,
+        enable_search_memory: bool = True,
+        enable_get_all_memories: bool = True,
+        enable_delete_all_memories: bool = True,
+        all: bool = False,
         **kwargs,
     ):
-        super().__init__(
-            name="mem0_tools",
-            tools=[
-                self.add_memory,
-                self.search_memory,
-                self.get_all_memories,
-                self.delete_all_memories,
-            ],
-            **kwargs,
-        )
+        tools: List[Any] = []
+        if enable_add_memory or all:
+            tools.append(self.add_memory)
+        if enable_search_memory or all:
+            tools.append(self.search_memory)
+        if enable_get_all_memories or all:
+            tools.append(self.get_all_memories)
+        if enable_delete_all_memories or all:
+            tools.append(self.delete_all_memories)
+
+        super().__init__(name="mem0_tools", tools=tools, **kwargs)
         self.api_key = api_key or getenv("MEM0_API_KEY")
         self.user_id = user_id
         self.org_id = org_id or getenv("MEM0_ORG_ID")

agno/tools/memori.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from agno.agent import Agent
 from agno.tools.toolkit import Toolkit
@@ -54,6 +54,10 @@ class MemoriTools(Toolkit):
         verbose: bool = False,
         config: Optional[Dict[str, Any]] = None,
         auto_enable: bool = True,
+        enable_search_memory: bool = True,
+        enable_record_conversation: bool = True,
+        enable_get_memory_stats: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         """
@@ -69,15 +73,15 @@ class MemoriTools(Toolkit):
             auto_enable: Automatically enable the memory system on initialization
             **kwargs: Additional arguments passed to Toolkit base class
         """
-        super().__init__(
-            name="memori_tools",
-            tools=[
-                self.search_memory,
-                self.record_conversation,
-                self.get_memory_stats,
-            ],
-            **kwargs,
-        )
+        tools: List[Any] = []
+        if all or enable_search_memory:
+            tools.append(self.search_memory)
+        if all or enable_record_conversation:
+            tools.append(self.record_conversation)
+        if all or enable_get_memory_stats:
+            tools.append(self.get_memory_stats)
+
+        super().__init__(name="memori_tools", tools=tools, **kwargs)
 
         # Set default database connection if not provided
         if not database_connect:

agno/tools/mlx_transcribe.py

@@ -32,7 +32,7 @@ class MLXTranscribeTools(Toolkit):
     def __init__(
         self,
         base_dir: Optional[Path] = None,
-        read_files_in_base_dir: bool = True,
+        enable_read_files_in_base_dir: bool = True,
         path_or_hf_repo: str = "mlx-community/whisper-large-v3-turbo",
         verbose: Optional[bool] = None,
         temperature: Optional[Union[float, Tuple[float, ...]]] = None,
@@ -47,6 +47,7 @@ class MLXTranscribeTools(Toolkit):
         clip_timestamps: Optional[Union[str, List[float]]] = None,
         hallucination_silence_threshold: Optional[float] = None,
         decode_options: Optional[dict] = None,
+        all: bool = False,
         **kwargs,
     ):
         self.base_dir: Path = base_dir or Path.cwd()
@@ -66,7 +67,7 @@ class MLXTranscribeTools(Toolkit):
         self.decode_options: Optional[dict] = decode_options
 
         tools: List[Any] = [self.transcribe]
-        if read_files_in_base_dir:
+        if enable_read_files_in_base_dir or all:
             tools.append(self.read_files)
 
         super().__init__(name="mlx_transcribe", tools=tools, **kwargs)