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

agno/tools/gmail.py

@@ -101,17 +101,6 @@ class GmailTools(Toolkit):
 
     def __init__(
         self,
-        get_latest_emails: bool = True,
-        get_emails_from_user: bool = True,
-        get_unread_emails: bool = True,
-        get_starred_emails: bool = True,
-        get_emails_by_context: bool = True,
-        get_emails_by_date: bool = True,
-        get_emails_by_thread: bool = True,
-        create_draft_email: bool = True,
-        send_email: bool = True,
-        send_email_reply: bool = True,
-        search_emails: bool = True,
         creds: Optional[Credentials] = None,
         credentials_path: Optional[str] = None,
         token_path: Optional[str] = None,
@@ -122,17 +111,6 @@ class GmailTools(Toolkit):
         """Initialize GmailTools and authenticate with Gmail API
 
         Args:
-            get_latest_emails (bool): Enable getting latest emails. Defaults to True.
-            get_emails_from_user (bool): Enable getting emails from specific user. Defaults to True.
-            get_unread_emails (bool): Enable getting unread emails. Defaults to True.
-            get_starred_emails (bool): Enable getting starred emails. Defaults to True.
-            get_emails_by_context (bool): Enable getting emails by context. Defaults to True.
-            get_emails_by_date (bool): Enable getting emails by date. Defaults to True.
-            get_emails_by_thread (bool): Enable getting emails by thread. Defaults to True.
-            create_draft_email (bool): Enable creating draft emails. Defaults to True.
-            send_email (bool): Enable sending emails. Defaults to True.
-            search_emails (bool): Enable searching emails. Defaults to True.
-            send_email_reply (bool): Enable sending email replies. Defaults to True.
             creds (Optional[Credentials]): Pre-fetched OAuth credentials. Use this to skip a new auth flow. Defaults to None.
             credentials_path (Optional[str]): Path to credentials file. Defaults to None.
             token_path (Optional[str]): Path to token file. Defaults to None.
@@ -146,55 +124,61 @@ class GmailTools(Toolkit):
         self.scopes = scopes or self.DEFAULT_SCOPES
         self.port = port
 
-        # Validate that required scopes are present for requested operations
-        if (create_draft_email or send_email) and "https://www.googleapis.com/auth/gmail.compose" not in self.scopes:
+        """ tools functions:
+         enable_get_latest_emails (bool): Enable getting latest emails.
+         enable_get_emails_from_user (bool): Enable getting emails from specific user.
+         enable_get_unread_emails (bool): Enable getting unread emails.
+         enable_get_starred_emails (bool): Enable getting starred emails.
+         enable_get_emails_by_context (bool): Enable getting emails by context.
+         enable_get_emails_by_date (bool): Enable getting emails by date.
+         enable_get_emails_by_thread (bool): Enable getting emails by thread.
+         enable_create_draft_email (bool): Enable creating draft emails.
+         enable_send_email (bool): Enable sending emails.
+         enable_send_email_reply (bool): Enable sending email replies.
+         all (bool): Enable all tools.
+        """
+
+        tools: List[Any] = [
+            # Reading emails
+            self.get_latest_emails,
+            self.get_emails_from_user,
+            self.get_unread_emails,
+            self.get_starred_emails,
+            self.get_emails_by_context,
+            self.get_emails_by_date,
+            self.get_emails_by_thread,
+            self.search_emails,
+            # Composing emails
+            self.create_draft_email,
+            self.send_email,
+            self.send_email_reply,
+        ]
+
+        super().__init__(name="gmail_tools", tools=tools, **kwargs)
+
+        # Validate that required scopes are present for requested operations (only check registered functions)
+        if (
+            "create_draft_email" in self.functions or "send_email" in self.functions
+        ) and "https://www.googleapis.com/auth/gmail.compose" not in self.scopes:
             raise ValueError(
                 "The scope https://www.googleapis.com/auth/gmail.compose is required for email composition operations"
             )
-
         read_operations = [
-            get_latest_emails,
-            get_emails_from_user,
-            get_unread_emails,
-            get_starred_emails,
-            get_emails_by_context,
-            get_emails_by_date,
-            get_emails_by_thread,
-            search_emails,
+            "get_latest_emails",
+            "get_emails_from_user",
+            "get_unread_emails",
+            "get_starred_emails",
+            "get_emails_by_context",
+            "get_emails_by_date",
+            "get_emails_by_thread",
+            "search_emails",
         ]
-
-        if any(read_operations):
+        if any(read_operation in self.functions for read_operation in read_operations):
             read_scope = "https://www.googleapis.com/auth/gmail.readonly"
             write_scope = "https://www.googleapis.com/auth/gmail.modify"
             if read_scope not in self.scopes and write_scope not in self.scopes:
                 raise ValueError(f"The scope {read_scope} is required for email reading operations")
 
-        tools: List[Any] = []
-        if get_latest_emails:
-            tools.append(self.get_latest_emails)
-        if get_emails_from_user:
-            tools.append(self.get_emails_from_user)
-        if get_unread_emails:
-            tools.append(self.get_unread_emails)
-        if get_starred_emails:
-            tools.append(self.get_starred_emails)
-        if get_emails_by_context:
-            tools.append(self.get_emails_by_context)
-        if get_emails_by_date:
-            tools.append(self.get_emails_by_date)
-        if get_emails_by_thread:
-            tools.append(self.get_emails_by_thread)
-        if create_draft_email:
-            tools.append(self.create_draft_email)
-        if send_email:
-            tools.append(self.send_email)
-        if send_email_reply:
-            tools.append(self.send_email_reply)
-        if search_emails:
-            tools.append(self.search_emails)
-
-        super().__init__(name="gmail_tools", tools=tools, **kwargs)
-
     def _auth(self) -> None:
         """Authenticate with Gmail API"""
         token_file = Path(self.token_path or "token.json")

agno/tools/google_bigquery.py

@@ -17,10 +17,11 @@ class GoogleBigQueryTools(Toolkit):
         dataset: str,
         project: Optional[str] = None,
         location: Optional[str] = None,
-        list_tables: Optional[bool] = True,
-        describe_table: Optional[bool] = True,
-        run_sql_query: Optional[bool] = True,
         credentials: Optional[Any] = None,
+        enable_list_tables: bool = True,
+        enable_describe_table: bool = True,
+        enable_run_sql_query: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.project = project or getenv("GOOGLE_CLOUD_PROJECT")
@@ -37,11 +38,11 @@ class GoogleBigQueryTools(Toolkit):
         self.client = bigquery.Client(project=self.project, credentials=credentials)
 
         tools: List[Any] = []
-        if list_tables:
+        if all or enable_list_tables:
             tools.append(self.list_tables)
-        if describe_table:
+        if all or enable_describe_table:
             tools.append(self.describe_table)
-        if run_sql_query:
+        if all or enable_run_sql_query:
             tools.append(self.run_sql_query)
 
         super().__init__(name="google_bigquery_tools", tools=tools, **kwargs)

agno/tools/google_maps.py

@@ -6,7 +6,7 @@ Prerequisites:
   You can obtain the API key from the Google Cloud Console:
   https://console.cloud.google.com/projectselector2/google/maps-apis/credentials
 
-- You also need to activate the Address Validation API for your .
+- You also need to activate the Address Validation API for your project.
   https://console.developers.google.com/apis/api/addressvalidation.googleapis.com
 
 """
@@ -29,14 +29,6 @@ class GoogleMapTools(Toolkit):
     def __init__(
         self,
         key: Optional[str] = None,
-        search_places: bool = True,
-        get_directions: bool = True,
-        validate_address: bool = True,
-        geocode_address: bool = True,
-        reverse_geocode: bool = True,
-        get_distance_matrix: bool = True,
-        get_elevation: bool = True,
-        get_timezone: bool = True,
         **kwargs,
     ):
         self.api_key = key or getenv("GOOGLE_MAPS_API_KEY")
@@ -46,23 +38,16 @@ class GoogleMapTools(Toolkit):
 
         self.places_client = places_v1.PlacesClient()
 
-        tools: List[Any] = []
-        if search_places:
-            tools.append(self.search_places)
-        if get_directions:
-            tools.append(self.get_directions)
-        if validate_address:
-            tools.append(self.validate_address)
-        if geocode_address:
-            tools.append(self.geocode_address)
-        if reverse_geocode:
-            tools.append(self.reverse_geocode)
-        if get_distance_matrix:
-            tools.append(self.get_distance_matrix)
-        if get_elevation:
-            tools.append(self.get_elevation)
-        if get_timezone:
-            tools.append(self.get_timezone)
+        tools: List[Any] = [
+            self.search_places,
+            self.get_directions,
+            self.validate_address,
+            self.geocode_address,
+            self.reverse_geocode,
+            self.get_distance_matrix,
+            self.get_elevation,
+            self.get_timezone,
+        ]
 
         super().__init__(name="google_maps", tools=tools, **kwargs)
 

agno/tools/googlesearch.py

@@ -29,6 +29,8 @@ class GoogleSearchTools(Toolkit):
         cache_results (bool): Enable caching of search results.
         cache_ttl (int): Time-to-live for cached results in seconds.
         cache_dir (Optional[str]): Directory to store cache files.
+        enable_google_search (bool): Enable Google search.
+        all (bool): Enable all tools.
     """
 
     def __init__(
@@ -38,6 +40,8 @@ class GoogleSearchTools(Toolkit):
         headers: Optional[Any] = None,
         proxy: Optional[str] = None,
         timeout: Optional[int] = 10,
+        enable_google_search: bool = True,
+        all: bool = False,
         **kwargs,
     ):
         self.fixed_max_results: Optional[int] = fixed_max_results
@@ -47,7 +51,8 @@ class GoogleSearchTools(Toolkit):
         self.timeout: Optional[int] = timeout
 
         tools = []
-        tools.append(self.google_search)
+        if all or enable_google_search:
+            tools.append(self.google_search)
 
         super().__init__(name="google_search_tools", tools=tools, **kwargs)
 
@@ -77,7 +82,7 @@ class GoogleSearchTools(Toolkit):
         log_debug(f"Searching Google [{language}] for: {query}")
 
         # Perform Google search using the googlesearch-python package
-        results = list(search(query, num_results=max_results, lang=language, proxy=self.proxy, advanced=True))
+        results = list(search(query, num=max_results, lang=language))
 
         # Collect the search results
         res: List[Dict[str, str]] = []

agno/tools/googlesheets.py

@@ -94,27 +94,29 @@ class GoogleSheetsTools(Toolkit):
         creds: Optional[Credentials] = None,
         creds_path: Optional[str] = None,
         token_path: Optional[str] = None,
-        read: bool = True,
-        create: bool = False,
-        update: bool = False,
-        duplicate: bool = False,
         oauth_port: int = 0,
+        enable_read_sheet: bool = True,
+        enable_create_sheet: bool = False,
+        enable_update_sheet: bool = False,
+        enable_create_duplicate_sheet: bool = False,
+        all: bool = False,
         **kwargs,
     ):
         """Initialize GoogleSheetsTools with the specified configuration.
 
         Args:
-            scopes (Optional[List[str]]): Custom OAuth scopes. If None, determined by operations.
+            scopes (Optional[List[str]]): Custom OAuth scopes. If None, uses write scope by default.
             spreadsheet_id (Optional[str]): ID of the target spreadsheet.
             spreadsheet_range (Optional[str]): Range within the spreadsheet.
             creds (Optional[Credentials]): Pre-existing credentials.
             creds_path (Optional[str]): Path to credentials file.
             token_path (Optional[str]): Path to token file.
-            read (bool): Enable read operations. Defaults to True.
-            create (bool): Enable create operations. Defaults to False.
-            update (bool): Enable update operations. Defaults to False.
-            duplicate (bool): Enable duplicate operations. Defaults to False.
             oauth_port (int): Port to use for OAuth authentication. Defaults to 0.
+            enable_read_sheet (bool): Enable reading from a sheet.
+            enable_create_sheet (bool): Enable creating a sheet.
+            enable_update_sheet (bool): Enable updating a sheet.
+            enable_create_duplicate_sheet (bool): Enable creating a duplicate sheet.
+            all (bool): Enable all tools.
         """
 
         self.spreadsheet_id = spreadsheet_id
@@ -128,19 +130,21 @@ class GoogleSheetsTools(Toolkit):
         # Determine required scopes based on operations if no custom scopes provided
         if scopes is None:
             self.scopes = []
-            if read:
+            if enable_read_sheet:
                 self.scopes.append(self.DEFAULT_SCOPES["read"])
-            if create or update or duplicate:
+            if enable_create_sheet or enable_update_sheet or enable_create_duplicate_sheet:
                 self.scopes.append(self.DEFAULT_SCOPES["write"])
             # Remove duplicates while preserving order
             self.scopes = list(dict.fromkeys(self.scopes))
         else:
             self.scopes = scopes
             # Validate that required scopes are present for requested operations
-            if (create or update or duplicate) and self.DEFAULT_SCOPES["write"] not in self.scopes:
+            if (enable_create_sheet or enable_update_sheet or enable_create_duplicate_sheet) and self.DEFAULT_SCOPES[
+                "write"
+            ] not in self.scopes:
                 raise ValueError(f"The scope {self.DEFAULT_SCOPES['write']} is required for write operations")
             if (
-                read
+                enable_read_sheet
                 and self.DEFAULT_SCOPES["read"] not in self.scopes
                 and self.DEFAULT_SCOPES["write"] not in self.scopes
             ):
@@ -149,13 +153,13 @@ class GoogleSheetsTools(Toolkit):
                 )
 
         tools: List[Any] = []
-        if read:
+        if all or enable_read_sheet:
             tools.append(self.read_sheet)
-        if create:
+        if all or enable_create_sheet:
             tools.append(self.create_sheet)
-        if update:
+        if all or enable_update_sheet:
             tools.append(self.update_sheet)
-        if duplicate:
+        if all or enable_create_duplicate_sheet:
             tools.append(self.create_duplicate_sheet)
 
         super().__init__(name="google_sheets_tools", tools=tools, **kwargs)

agno/tools/hackernews.py

@@ -10,16 +10,20 @@ from agno.utils.log import log_debug, logger
 class HackerNewsTools(Toolkit):
     """
     HackerNews is a tool for getting top stories from Hacker News.
+
     Args:
-        get_top_stories (bool): Whether to get top stories from Hacker News.
-        get_user_details (bool): Whether to get user details from Hacker News.
+        enable_get_top_stories (bool): Enable getting top stories from Hacker News. Default is True.
+        enable_get_user_details (bool): Enable getting user details from Hacker News. Default is True.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
     """
 
-    def __init__(self, get_top_stories: bool = True, get_user_details: bool = True, **kwargs):
+    def __init__(
+        self, enable_get_top_stories: bool = True, enable_get_user_details: bool = True, all: bool = False, **kwargs
+    ):
         tools: List[Any] = []
-        if get_top_stories:
+        if all or enable_get_top_stories:
             tools.append(self.get_top_hackernews_stories)
-        if get_user_details:
+        if all or enable_get_user_details:
             tools.append(self.get_user_details)
 
         super().__init__(name="hackers_news", tools=tools, **kwargs)

agno/tools/jina.py

@@ -25,9 +25,10 @@ class JinaReaderTools(Toolkit):
         search_url: str = "https://s.jina.ai/",
         max_content_length: int = 10000,
         timeout: Optional[int] = None,
-        read_url: bool = True,
-        search_query: bool = False,
         search_query_content: bool = True,
+        enable_read_url: bool = True,
+        enable_search_query: bool = False,
+        all: bool = False,
         **kwargs,
     ):
         self.api_key = api_key or getenv("JINA_API_KEY")
@@ -41,9 +42,9 @@ class JinaReaderTools(Toolkit):
         )
 
         tools: List[Any] = []
-        if read_url:
+        if all or enable_read_url:
             tools.append(self.read_url)
-        if search_query:
+        if all or enable_search_query:
             tools.append(self.search_query)
 
         super().__init__(name="jina_reader_tools", tools=tools, **kwargs)

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}
           ) {