holmesgpt 0.14.2__py3-none-any.whl → 0.14.3a0__py3-none-any.whl

holmes/plugins/toolsets/prometheus/prometheus.py

@@ -15,11 +15,14 @@ from holmes.core.tools import (
     CallablePrerequisite,
     StructuredToolResult,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     StructuredToolResultStatus,
     Toolset,
     ToolsetTag,
 )
+from holmes.core.tools_utils.token_counting import count_tool_response_tokens
+from holmes.core.tools_utils.tool_context_window_limiter import get_pct_token_count
 from holmes.plugins.toolsets.consts import STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION
 from holmes.plugins.toolsets.prometheus.utils import parse_duration_to_seconds
 from holmes.plugins.toolsets.service_discovery import PrometheusDiscovery
@@ -42,8 +45,6 @@ PROMETHEUS_METADATA_API_LIMIT = 100  # Default limit for Prometheus metadata API
 # Default timeout values for PromQL queries
 DEFAULT_QUERY_TIMEOUT_SECONDS = 20
 MAX_QUERY_TIMEOUT_SECONDS = 180
-# Default character limit for query responses to prevent token limit issues
-DEFAULT_QUERY_RESPONSE_SIZE_LIMIT = 30000
 # Default timeout for metadata API calls (discovery endpoints)
 DEFAULT_METADATA_TIMEOUT_SECONDS = 20
 MAX_METADATA_TIMEOUT_SECONDS = 60
@@ -91,8 +92,8 @@ class PrometheusConfig(BaseModel):
     rules_cache_duration_seconds: Optional[int] = 1800  # 30 minutes
     additional_labels: Optional[Dict[str, str]] = None
     prometheus_ssl_enabled: bool = True
-    query_response_size_limit: Optional[int] = (
-        DEFAULT_QUERY_RESPONSE_SIZE_LIMIT  # Limit the max number of characters in a query result to proactively prevent token limit issues (roughly 5-6k tokens)
+    query_response_size_limit_pct: Optional[int] = (
+        2  # Limit the max number of tokens that a query result can take to proactively prevent token limit issues. Expressed in % of the model's context window
     )
 
     @field_validator("prometheus_url")
@@ -318,7 +319,7 @@ def add_prometheus_auth(prometheus_auth_header: Optional[str]) -> Dict[str, Any]
 
 
 def create_data_summary_for_large_result(
-    result_data: Dict, query: str, data_size_chars: int, is_range_query: bool = False
+    result_data: Dict, query: str, data_size_tokens: int, is_range_query: bool = False
 ) -> Dict[str, Any]:
     """
     Create a summary for large Prometheus results instead of returning full data.
@@ -326,7 +327,7 @@ def create_data_summary_for_large_result(
     Args:
         result_data: The Prometheus data result
         query: The original PromQL query
-        data_size_chars: Size of the data in characters
+        data_size_tokens: Size of the data in tokens
         is_range_query: Whether this is a range query (vs instant query)
 
     Returns:
@@ -361,10 +362,10 @@ def create_data_summary_for_large_result(
         )
 
         return {
-            "message": f"Data too large to return ({data_size_chars:,} characters). Query returned {num_items} time series with {total_points:,} total data points.",
+            "message": f"Data too large to return ({data_size_tokens:,} tokens). Query returned {num_items} time series with {total_points:,} total data points.",
             "series_count": num_items,
             "total_data_points": total_points,
-            "data_size_characters": data_size_chars,
+            "data_size_tokens": data_size_tokens,
             "label_cardinality": label_summary,
             "suggestion": f'Consider using topk({min(5, num_items)}, {query}) to limit results to the top {min(5, num_items)} series. To also capture remaining data as \'other\': topk({min(5, num_items)}, {query}) or label_replace((sum({query}) - sum(topk({min(5, num_items)}, {query}))), "pod", "other", "", "")',
         }
@@ -394,15 +395,46 @@ def create_data_summary_for_large_result(
         )
 
         return {
-            "message": f"Data too large to return ({data_size_chars:,} characters). Query returned {num_items} results.",
+            "message": f"Data too large to return ({data_size_tokens:,} tokens). Query returned {num_items} results.",
             "result_count": num_items,
             "result_type": result_type,
-            "data_size_characters": data_size_chars,
+            "data_size_tokens": data_size_tokens,
             "label_cardinality": label_summary,
             "suggestion": f'Consider using topk({min(5, num_items)}, {query}) to limit results. To also capture remaining data as \'other\': topk({min(5, num_items)}, {query}) or label_replace((sum({query}) - sum(topk({min(5, num_items)}, {query}))), "instance", "other", "", "")',
         }
 
 
+class MetricsBasedResponse(BaseModel):
+    status: str
+    error_message: Optional[str] = None
+    data: Optional[str] = None
+    random_key: str
+    tool_name: str
+    description: str
+    query: str
+    start: Optional[str] = None
+    end: Optional[str] = None
+    step: Optional[float] = None
+    output_type: Optional[str] = None
+    data_summary: Optional[dict[str, Any]] = None
+
+
+def create_structured_tool_result(
+    params: dict, response: MetricsBasedResponse
+) -> StructuredToolResult:
+    status = StructuredToolResultStatus.SUCCESS
+    if response.error_message or response.status.lower() in ("failed", "error"):
+        status = StructuredToolResultStatus.ERROR
+    elif not response.data:
+        status = StructuredToolResultStatus.NO_DATA
+
+    return StructuredToolResult(
+        status=status,
+        data=response.model_dump_json(indent=2),
+        params=params,
+    )
+
+
 class ListPrometheusRules(BasePrometheusTool):
     def __init__(self, toolset: "PrometheusToolset"):
         super().__init__(
@@ -413,9 +445,7 @@ class ListPrometheusRules(BasePrometheusTool):
         )
         self._cache = None
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.config or not self.toolset.config.prometheus_url:
             return StructuredToolResult(
                 status=StructuredToolResultStatus.ERROR,
@@ -533,9 +563,7 @@ class GetMetricNames(BasePrometheusTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.config or not self.toolset.config.prometheus_url:
             return StructuredToolResult(
                 status=StructuredToolResultStatus.ERROR,
@@ -654,9 +682,7 @@ class GetLabelValues(BasePrometheusTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.config or not self.toolset.config.prometheus_url:
             return StructuredToolResult(
                 status=StructuredToolResultStatus.ERROR,
@@ -770,9 +796,7 @@ class GetAllLabels(BasePrometheusTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.config or not self.toolset.config.prometheus_url:
             return StructuredToolResult(
                 status=StructuredToolResultStatus.ERROR,
@@ -877,9 +901,7 @@ class GetSeries(BasePrometheusTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.config or not self.toolset.config.prometheus_url:
             return StructuredToolResult(
                 status=StructuredToolResultStatus.ERROR,
@@ -981,9 +1003,7 @@ class GetMetricMetadata(BasePrometheusTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.config or not self.toolset.config.prometheus_url:
             return StructuredToolResult(
                 status=StructuredToolResultStatus.ERROR,
@@ -1072,9 +1092,7 @@ class ExecuteInstantQuery(BasePrometheusTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.config or not self.toolset.config.prometheus_url:
             return StructuredToolResult(
                 status=StructuredToolResultStatus.ERROR,
@@ -1120,56 +1138,64 @@ class ExecuteInstantQuery(BasePrometheusTool):
                     error_message = (
                         "The prometheus query returned no result. Is the query correct?"
                     )
-                response_data = {
-                    "status": status,
-                    "error_message": error_message,
-                    "random_key": generate_random_key(),
-                    "tool_name": self.name,
-                    "description": description,
-                    "query": query,
-                }
-
+                response_data = MetricsBasedResponse(
+                    status=status,
+                    error_message=error_message,
+                    random_key=generate_random_key(),
+                    tool_name=self.name,
+                    description=description,
+                    query=query,
+                )
+                structured_tool_result: StructuredToolResult
                 # Check if data should be included based on size
                 if self.toolset.config.tool_calls_return_data:
                     result_data = data.get("data", {})
+                    response_data.data = result_data
 
-                    # Estimate the size of the data
-                    data_str_preview = json.dumps(result_data)
-                    data_size_chars = len(data_str_preview)
+                    structured_tool_result = create_structured_tool_result(
+                        params=params, response=response_data
+                    )
+                    token_count = count_tool_response_tokens(
+                        llm=context.llm, structured_tool_result=structured_tool_result
+                    )
+
+                    token_limit = context.max_token_count
+                    if self.toolset.config.query_response_size_limit_pct:
+                        custom_token_limit = get_pct_token_count(
+                            percent_of_total_context_window=self.toolset.config.query_response_size_limit_pct,
+                            llm=context.llm,
+                        )
+                        if custom_token_limit < token_limit:
+                            token_limit = custom_token_limit
 
                     # Provide summary if data is too large
-                    if (
-                        self.toolset.config.query_response_size_limit
-                        and data_size_chars
-                        > self.toolset.config.query_response_size_limit
-                    ):
-                        response_data["data_summary"] = (
+                    if token_count > token_limit:
+                        response_data.data = None
+                        response_data.data_summary = (
                             create_data_summary_for_large_result(
                                 result_data,
                                 query,
-                                data_size_chars,
+                                token_count,
                                 is_range_query=False,
                             )
                         )
                         logging.info(
                             f"Prometheus instant query returned large dataset: "
-                            f"{response_data['data_summary'].get('result_count', 0)} results, "
-                            f"{data_size_chars:,} characters (limit: {self.toolset.config.query_response_size_limit:,}). "
+                            f"{response_data.data_summary.get('result_count', 0)} results, "
+                            f"{token_count:,} tokens (limit: {token_limit:,}). "
                             f"Returning summary instead of full data."
                         )
-                        # Also add character info to the summary for debugging
-                        response_data["data_summary"]["_debug_info"] = (
-                            f"Data size: {data_size_chars:,} chars exceeded limit of {self.toolset.config.query_response_size_limit:,} chars"
+                        # Also add token info to the summary for debugging
+                        response_data.data_summary["_debug_info"] = (
+                            f"Data size: {token_count:,} tokens exceeded limit of {token_limit:,} tokens"
                         )
                     else:
-                        response_data["data"] = result_data
+                        response_data.data = result_data
 
-                data_str = json.dumps(response_data, indent=2)
-                return StructuredToolResult(
-                    status=StructuredToolResultStatus.SUCCESS,
-                    data=data_str,
-                    params=params,
+                structured_tool_result = create_structured_tool_result(
+                    params=params, response=response_data
                 )
+                return structured_tool_result
 
             # Handle known Prometheus error status codes
             error_msg = "Unknown error occurred"
@@ -1280,9 +1306,7 @@ class ExecuteRangeQuery(BasePrometheusTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.config or not self.toolset.config.prometheus_url:
             return StructuredToolResult(
                 status=StructuredToolResultStatus.ERROR,
@@ -1352,59 +1376,69 @@ class ExecuteRangeQuery(BasePrometheusTool):
                     error_message = (
                         "The prometheus query returned no result. Is the query correct?"
                     )
-                response_data = {
-                    "status": status,
-                    "error_message": error_message,
-                    "random_key": generate_random_key(),
-                    "tool_name": self.name,
-                    "description": description,
-                    "query": query,
-                    "start": start,
-                    "end": end,
-                    "step": step,
-                    "output_type": output_type,
-                }
+                response_data = MetricsBasedResponse(
+                    status=status,
+                    error_message=error_message,
+                    random_key=generate_random_key(),
+                    tool_name=self.name,
+                    description=description,
+                    query=query,
+                    start=start,
+                    end=end,
+                    step=step,
+                    output_type=output_type,
+                )
+
+                structured_tool_result: StructuredToolResult
 
                 # Check if data should be included based on size
                 if self.toolset.config.tool_calls_return_data:
                     result_data = data.get("data", {})
+                    response_data.data = result_data
+                    structured_tool_result = create_structured_tool_result(
+                        params=params, response=response_data
+                    )
 
-                    # Estimate the size of the data
-                    data_str_preview = json.dumps(result_data)
-                    data_size_chars = len(data_str_preview)
+                    token_count = count_tool_response_tokens(
+                        llm=context.llm, structured_tool_result=structured_tool_result
+                    )
+
+                    token_limit = context.max_token_count
+                    if self.toolset.config.query_response_size_limit_pct:
+                        custom_token_limit = get_pct_token_count(
+                            percent_of_total_context_window=self.toolset.config.query_response_size_limit_pct,
+                            llm=context.llm,
+                        )
+                        if custom_token_limit < token_limit:
+                            token_limit = custom_token_limit
 
                     # Provide summary if data is too large
-                    if (
-                        self.toolset.config.query_response_size_limit
-                        and data_size_chars
-                        > self.toolset.config.query_response_size_limit
-                    ):
-                        response_data["data_summary"] = (
+                    if token_count > token_limit:
+                        response_data.data = None
+                        response_data.data_summary = (
                             create_data_summary_for_large_result(
-                                result_data, query, data_size_chars, is_range_query=True
+                                result_data, query, token_count, is_range_query=True
                             )
                         )
                         logging.info(
                             f"Prometheus range query returned large dataset: "
-                            f"{response_data['data_summary'].get('series_count', 0)} series, "
-                            f"{data_size_chars:,} characters (limit: {self.toolset.config.query_response_size_limit:,}). "
+                            f"{response_data.data_summary.get('series_count', 0)} series, "
+                            f"{token_count:,} tokens (limit: {token_limit:,}). "
                             f"Returning summary instead of full data."
                         )
                         # Also add character info to the summary for debugging
-                        response_data["data_summary"]["_debug_info"] = (
-                            f"Data size: {data_size_chars:,} chars exceeded limit of {self.toolset.config.query_response_size_limit:,} chars"
+                        response_data.data_summary["_debug_info"] = (
+                            f"Data size: {token_count:,} tokens exceeded limit of {token_limit:,} tokens"
                         )
                     else:
-                        response_data["data"] = result_data
-
-                data_str = json.dumps(response_data, indent=2)
+                        response_data.data = result_data
 
-                return StructuredToolResult(
-                    status=StructuredToolResultStatus.SUCCESS,
-                    data=data_str,
-                    params=params,
+                structured_tool_result = create_structured_tool_result(
+                    params=params, response=response_data
                 )
 
+                return structured_tool_result
+
             error_msg = "Unknown error occurred"
             if response.status_code in [400, 429]:
                 try:

holmes/plugins/toolsets/rabbitmq/toolset_rabbitmq.py

@@ -7,6 +7,7 @@ from holmes.core.tools import (
     CallablePrerequisite,
     StructuredToolResult,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     StructuredToolResultStatus,
     Toolset,
@@ -63,9 +64,7 @@ class ListConfiguredClusters(BaseRabbitMQTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.config:
             raise ValueError("RabbitMQ is not configured.")
 
@@ -103,9 +102,7 @@ class GetRabbitMQClusterStatus(BaseRabbitMQTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         try:
             # Fetch node details which include partition info
             cluster_config = self._get_cluster_config(

holmes/plugins/toolsets/robusta/robusta.py

@@ -7,6 +7,7 @@ from holmes.core.supabase_dal import SupabaseDal
 from holmes.core.tools import (
     StaticPrerequisite,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     Toolset,
     ToolsetTag,
@@ -45,9 +46,7 @@ class FetchRobustaFinding(Tool):
             logging.error(error)
             return {"error": error}
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         finding_id = params[PARAM_FINDING_ID]
         try:
             finding = self._fetch_finding(finding_id)
@@ -115,9 +114,7 @@ class FetchResourceRecommendation(Tool):
             )
         return None
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         try:
             recommendations = self._resource_recommendation(params)
             if recommendations:
@@ -175,9 +172,7 @@ class FetchConfigurationChanges(Tool):
             )
         return None
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         try:
             changes = self._fetch_change_history(params)
             if changes:

holmes/plugins/toolsets/runbook/runbook_fetcher.py

@@ -1,17 +1,23 @@
 import logging
+import os
 import textwrap
 from typing import Any, Dict, List, Optional
 
 from holmes.core.tools import (
     StructuredToolResult,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     StructuredToolResultStatus,
     Toolset,
     ToolsetTag,
 )
 
-from holmes.plugins.runbooks import get_runbook_by_path, DEFAULT_RUNBOOK_SEARCH_PATH
+from holmes.plugins.runbooks import (
+    get_runbook_by_path,
+    load_runbook_catalog,
+    DEFAULT_RUNBOOK_SEARCH_PATH,
+)
 from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 
 
@@ -19,30 +25,104 @@ from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 # runbooks from external sources as well.
 class RunbookFetcher(Tool):
     toolset: "RunbookToolset"
+    available_runbooks: List[str] = []
+    additional_search_paths: Optional[List[str]] = None
+
+    def __init__(
+        self,
+        toolset: "RunbookToolset",
+        additional_search_paths: Optional[List[str]] = None,
+    ):
+        catalog = load_runbook_catalog()
+        available_runbooks = []
+        if catalog:
+            available_runbooks = [entry.link for entry in catalog.catalog]
+
+        # If additional search paths are configured (e.g., for testing), also scan those for .md files
+        if additional_search_paths:
+            for search_path in additional_search_paths:
+                if not os.path.isdir(search_path):
+                    continue
+
+                for file in os.listdir(search_path):
+                    if file.endswith(".md") and file not in available_runbooks:
+                        available_runbooks.append(file)
+
+        # Build description with available runbooks
+        runbook_list = ", ".join([f'"{rb}"' for rb in available_runbooks])
 
-    def __init__(self, toolset: "RunbookToolset"):
         super().__init__(
             name="fetch_runbook",
             description="Get runbook content by runbook link. Use this to get troubleshooting steps for incidents",
             parameters={
-                # use link as a more generic term for runbook path, considering we may have external links in the future
                 "link": ToolParameter(
-                    description="The link to the runbook",
+                    description=f"The link to the runbook (non-empty string required). Must be one of: {runbook_list}",
                     type="string",
                     required=True,
                 ),
             },
-            toolset=toolset,  # type: ignore
+            toolset=toolset,  # type: ignore[call-arg]
+            available_runbooks=available_runbooks,  # type: ignore[call-arg]
+            additional_search_paths=additional_search_paths,  # type: ignore[call-arg]
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        link: str = params["link"]
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
+        link: str = params.get("link", "")
+        # Validate link is not empty
+        if not link or not link.strip():
+            err_msg = (
+                "Runbook link cannot be empty. Please provide a valid runbook path."
+            )
+            logging.error(err_msg)
+            return StructuredToolResult(
+                status=StructuredToolResultStatus.ERROR,
+                error=err_msg,
+                params=params,
+            )
 
+        # Build list of allowed search paths
         search_paths = [DEFAULT_RUNBOOK_SEARCH_PATH]
-        if self.toolset.config and "additional_search_paths" in self.toolset.config:
-            search_paths.extend(self.toolset.config["additional_search_paths"])
+        if self.additional_search_paths:
+            search_paths.extend(self.additional_search_paths)
+
+        # Validate link is in the available runbooks list OR is a valid path within allowed directories
+        if link not in self.available_runbooks:
+            # For links not in the catalog, perform strict path validation
+            if not link.endswith(".md"):
+                err_msg = f"Invalid runbook link '{link}'. Must end with .md extension."
+                logging.error(err_msg)
+                return StructuredToolResult(
+                    status=StructuredToolResultStatus.ERROR,
+                    error=err_msg,
+                    params=params,
+                )
+
+            # Check if the link would resolve to a valid path within allowed directories
+            # This prevents path traversal attacks like ../../secret.md
+            is_valid_path = False
+            for search_path in search_paths:
+                candidate_path = os.path.join(search_path, link)
+                # Canonicalize both paths to resolve any .. or . components
+                real_search_path = os.path.realpath(search_path)
+                real_candidate_path = os.path.realpath(candidate_path)
+
+                # Check if the resolved path is within the allowed directory
+                if (
+                    real_candidate_path.startswith(real_search_path + os.sep)
+                    or real_candidate_path == real_search_path
+                ):
+                    if os.path.isfile(real_candidate_path):
+                        is_valid_path = True
+                        break
+
+            if not is_valid_path:
+                err_msg = f"Invalid runbook link '{link}'. Must be one of: {', '.join(self.available_runbooks) if self.available_runbooks else 'No runbooks available'}"
+                logging.error(err_msg)
+                return StructuredToolResult(
+                    status=StructuredToolResultStatus.ERROR,
+                    error=err_msg,
+                    params=params,
+                )
 
         runbook_path = get_runbook_by_path(link, search_paths)
 
@@ -116,7 +196,7 @@ class RunbookFetcher(Tool):
 
 class RunbookToolset(Toolset):
     def __init__(self, additional_search_paths: Optional[List[str]] = None):
-        # Store additional search paths in config
+        # Store additional search paths in config for RunbookFetcher to access
         config = {}
         if additional_search_paths:
             config["additional_search_paths"] = additional_search_paths
@@ -126,7 +206,7 @@ class RunbookToolset(Toolset):
             description="Fetch runbooks",
             icon_url="https://platform.robusta.dev/demos/runbook.svg",
             tools=[
-                RunbookFetcher(self),
+                RunbookFetcher(self, additional_search_paths),
             ],
             docs_url="https://holmesgpt.dev/data-sources/",
             tags=[