holmesgpt 0.14.1a0__py3-none-any.whl → 0.14.3a0__py3-none-any.whl

holmes/plugins/toolsets/grafana/grafana_tempo_api.py

@@ -46,21 +46,18 @@ class TempoAPIError(Exception):
 class GrafanaTempoAPI:
     """Python wrapper for Grafana Tempo REST API.
 
-    This class provides a clean interface to all Tempo API endpoints,
-    supporting both GET and POST methods based on configuration.
+    This class provides a clean interface to all Tempo API endpoints.
     """
 
-    def __init__(self, config: GrafanaTempoConfig, use_post: bool = False):
+    def __init__(self, config: GrafanaTempoConfig):
         """Initialize the Tempo API wrapper.
 
         Args:
             config: GrafanaTempoConfig instance with connection details
-            use_post: If True, use POST method for API calls. Defaults to False (GET).
         """
         self.config = config
         self.base_url = get_base_url(config)
         self.headers = build_headers(config.api_key, config.headers)
-        self.use_post = use_post
 
     def _make_request(
         self,
@@ -74,7 +71,7 @@ class GrafanaTempoAPI:
 
         Args:
             endpoint: API endpoint path (e.g., "/api/echo")
-            params: Query parameters (GET) or body parameters (POST)
+            params: Query parameters
             path_params: Parameters to substitute in the endpoint path
             timeout: Request timeout in seconds
             retries: Number of retry attempts
@@ -101,22 +98,13 @@ class GrafanaTempoAPI:
             and e.response.status_code < 500,
         )
         def make_request():
-            if self.use_post:
-                # POST request with JSON body
-                response = requests.post(
-                    url,
-                    headers=self.headers,
-                    json=params or {},
-                    timeout=timeout,
-                )
-            else:
-                # GET request with query parameters
-                response = requests.get(
-                    url,
-                    headers=self.headers,
-                    params=params,
-                    timeout=timeout,
-                )
+            # GET request with query parameters
+            response = requests.get(
+                url,
+                headers=self.headers,
+                params=params,
+                timeout=timeout,
+            )
             response.raise_for_status()
             return response.json()
 
@@ -145,7 +133,7 @@ class GrafanaTempoAPI:
         """Query the echo endpoint to check Tempo status.
 
         API Endpoint: GET /api/echo
-        HTTP Method: GET (or POST if use_post=True)
+        HTTP Method: GET
 
         Returns:
             bool: True if endpoint returns 200 status code, False otherwise
@@ -153,18 +141,11 @@ class GrafanaTempoAPI:
         url = f"{self.base_url}/api/echo"
 
         try:
-            if self.use_post:
-                response = requests.post(
-                    url,
-                    headers=self.headers,
-                    timeout=30,
-                )
-            else:
-                response = requests.get(
-                    url,
-                    headers=self.headers,
-                    timeout=30,
-                )
+            response = requests.get(
+                url,
+                headers=self.headers,
+                timeout=30,
+            )
 
             # Just check status code, don't try to parse JSON
             return response.status_code == 200
@@ -182,7 +163,7 @@ class GrafanaTempoAPI:
         """Query a trace by its ID.
 
         API Endpoint: GET /api/v2/traces/{trace_id}
-        HTTP Method: GET (or POST if use_post=True)
+        HTTP Method: GET
 
         Args:
             trace_id: The trace ID to retrieve
@@ -250,7 +231,7 @@ class GrafanaTempoAPI:
         """Search for traces using tag-based search.
 
         API Endpoint: GET /api/search
-        HTTP Method: GET (or POST if use_post=True)
+        HTTP Method: GET
 
         Args:
             tags: logfmt-encoded span/process attributes (required)
@@ -291,7 +272,7 @@ class GrafanaTempoAPI:
         """Search for traces using TraceQL query.
 
         API Endpoint: GET /api/search
-        HTTP Method: GET (or POST if use_post=True)
+        HTTP Method: GET
 
         Note: minDuration and maxDuration are not supported with TraceQL queries.
         Use the TraceQL query syntax to filter by duration instead.
@@ -326,7 +307,7 @@ class GrafanaTempoAPI:
         """Search for available tag names.
 
         API Endpoint: GET /api/v2/search/tags
-        HTTP Method: GET (or POST if use_post=True)
+        HTTP Method: GET
 
         Args:
             scope: Optional scope filter ("resource", "span", or "intrinsic")
@@ -367,7 +348,7 @@ class GrafanaTempoAPI:
         """Search for values of a specific tag with optional TraceQL filtering.
 
         API Endpoint: GET /api/v2/search/tag/{tag}/values
-        HTTP Method: GET (or POST if use_post=True)
+        HTTP Method: GET
 
         Args:
             tag: The tag name to get values for (required)
@@ -410,7 +391,7 @@ class GrafanaTempoAPI:
         Computes a single value across the entire time range.
 
         API Endpoint: GET /api/metrics/query
-        HTTP Method: GET (or POST if use_post=True)
+        HTTP Method: GET
 
         Args:
             q: TraceQL metrics query (required)
@@ -445,7 +426,7 @@ class GrafanaTempoAPI:
         Returns metrics computed at regular intervals over the time range.
 
         API Endpoint: GET /api/metrics/query_range
-        HTTP Method: GET (or POST if use_post=True)
+        HTTP Method: GET
 
         Args:
             q: TraceQL metrics query (required)

holmes/plugins/toolsets/grafana/toolset_grafana.py

@@ -3,6 +3,7 @@ from urllib.parse import urlencode, urljoin
 from holmes.core.tools import (
     StructuredToolResult,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     StructuredToolResultStatus,
 )
@@ -43,9 +44,7 @@ class ListAndBuildGrafanaDashboardURLs(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         url = urljoin(
             self._toolset._grafana_config.url, "/api/search?query=&type=dash-db"
         )

holmes/plugins/toolsets/grafana/toolset_grafana_loki.py

@@ -14,6 +14,7 @@ from holmes.plugins.toolsets.logging_utils.logging_api import (
     LoggingCapability,
     PodLoggingTool,
     DEFAULT_TIME_SPAN_SECONDS,
+    DEFAULT_LOG_LIMIT,
 )
 from holmes.plugins.toolsets.utils import (
     process_timestamps_to_rfc3339,
@@ -94,7 +95,7 @@ class GrafanaLokiToolset(BasePodLoggingToolset):
             label_value=params.pod_name,
             start=start,
             end=end,
-            limit=params.limit or 2000,
+            limit=params.limit or DEFAULT_LOG_LIMIT,
         )
         if logs:
             logs.sort(key=lambda x: x["timestamp"])

holmes/plugins/toolsets/grafana/toolset_grafana_tempo.py

@@ -7,6 +7,7 @@ from holmes.common.env_vars import load_bool, MAX_GRAPH_POINTS
 from holmes.core.tools import (
     StructuredToolResult,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     StructuredToolResultStatus,
 )
@@ -29,7 +30,6 @@ from holmes.plugins.toolsets.utils import (
 )
 
 TEMPO_LABELS_ADD_PREFIX = load_bool("TEMPO_LABELS_ADD_PREFIX", True)
-TEMPO_API_USE_POST = False  # Use GET method for direct API mapping
 
 
 class BaseGrafanaTempoToolset(BaseGrafanaToolset):
@@ -56,7 +56,7 @@ class BaseGrafanaTempoToolset(BaseGrafanaToolset):
 
         # Then check Tempo-specific echo endpoint
         try:
-            api = GrafanaTempoAPI(self.grafana_config, use_post=TEMPO_API_USE_POST)
+            api = GrafanaTempoAPI(self.grafana_config)
             if api.query_echo_endpoint():
                 return True, "Successfully connected to Tempo"
             else:
@@ -195,9 +195,7 @@ Examples:
 
         return f"At least one of the following argument is expected but none were set: {expected_params}"
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         try:
             # Build query
             if params.get("base_query"):
@@ -231,9 +229,7 @@ Examples:
             start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
 
             # Create API instance
-            api = GrafanaTempoAPI(
-                self._toolset.grafana_config, use_post=TEMPO_API_USE_POST
-            )
+            api = GrafanaTempoAPI(self._toolset.grafana_config)
 
             # Step 1: Get all trace summaries
             stats_query = f"{{{base_query}}}"
@@ -242,9 +238,9 @@ Examples:
             import logging
 
             logger = logging.getLogger(__name__)
-            logger.info(f"Tempo query: {stats_query}")
+            logger.debug(f"Tempo query: {stats_query}")
 
-            logger.info(f"start: {start}, end: {end}")
+            logger.debug(f"start: {start}, end: {end}")
 
             all_traces_response = api.search_traces_by_query(
                 q=stats_query,
@@ -253,7 +249,7 @@ Examples:
                 limit=1000,
             )
 
-            logger.info(f"Response: {all_traces_response}")
+            logger.debug(f"Response: {all_traces_response}")
 
             traces = all_traces_response.get("traces", [])
             if not traces:
@@ -413,10 +409,8 @@ class SearchTracesByQuery(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(
-        self, params: Dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
+    def _invoke(self, params: Dict, context: ToolInvokeContext) -> StructuredToolResult:
+        api = GrafanaTempoAPI(self._toolset.grafana_config)
 
         start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
 
@@ -495,10 +489,8 @@ class SearchTracesByTags(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(
-        self, params: Dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
+    def _invoke(self, params: Dict, context: ToolInvokeContext) -> StructuredToolResult:
+        api = GrafanaTempoAPI(self._toolset.grafana_config)
 
         start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
 
@@ -559,10 +551,8 @@ class QueryTraceById(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(
-        self, params: Dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
+    def _invoke(self, params: Dict, context: ToolInvokeContext) -> StructuredToolResult:
+        api = GrafanaTempoAPI(self._toolset.grafana_config)
 
         start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
 
@@ -636,10 +626,8 @@ class SearchTagNames(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(
-        self, params: Dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
+    def _invoke(self, params: Dict, context: ToolInvokeContext) -> StructuredToolResult:
+        api = GrafanaTempoAPI(self._toolset.grafana_config)
 
         start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
 
@@ -714,10 +702,8 @@ class SearchTagValues(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(
-        self, params: Dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
+    def _invoke(self, params: Dict, context: ToolInvokeContext) -> StructuredToolResult:
+        api = GrafanaTempoAPI(self._toolset.grafana_config)
 
         start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
 
@@ -794,10 +780,8 @@ class QueryMetricsInstant(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(
-        self, params: Dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
+    def _invoke(self, params: Dict, context: ToolInvokeContext) -> StructuredToolResult:
+        api = GrafanaTempoAPI(self._toolset.grafana_config)
 
         start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
 
@@ -880,10 +864,8 @@ class QueryMetricsRange(Tool):
         )
         self._toolset = toolset
 
-    def _invoke(
-        self, params: Dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
+    def _invoke(self, params: Dict, context: ToolInvokeContext) -> StructuredToolResult:
+        api = GrafanaTempoAPI(self._toolset.grafana_config)
 
         start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
 

holmes/plugins/toolsets/internet/internet.py

@@ -6,6 +6,7 @@ from typing import Any, Optional, Tuple, Dict, List
 from requests import RequestException, Timeout  # type: ignore
 from holmes.core.tools import (
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     Toolset,
     ToolsetTag,
@@ -186,9 +187,7 @@ class FetchWebpage(Tool):
             toolset=toolset,  # type: ignore
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         url: str = params["url"]
 
         additional_headers = (

holmes/plugins/toolsets/internet/notion.py

@@ -4,6 +4,7 @@ import json
 from typing import Any, Dict, Tuple
 from holmes.core.tools import (
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     ToolsetTag,
 )
@@ -44,9 +45,7 @@ class FetchNotion(Tool):
             return f"https://api.notion.com/v1/blocks/{notion_id}/children"
         return url  # Return original URL if no match is found
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         url: str = params["url"]
 
         # Get headers from the toolset configuration

holmes/plugins/toolsets/investigator/core_investigation.py

@@ -1,16 +1,17 @@
 import logging
 import os
 from typing import Any, Dict
-
 from uuid import uuid4
+
 from holmes.core.todo_tasks_formatter import format_tasks
 from holmes.core.tools import (
-    Toolset,
-    ToolsetTag,
-    ToolParameter,
-    Tool,
     StructuredToolResult,
     StructuredToolResultStatus,
+    Tool,
+    ToolInvokeContext,
+    ToolParameter,
+    Toolset,
+    ToolsetTag,
 )
 from holmes.plugins.toolsets.investigator.model import Task, TaskStatus
 
@@ -74,9 +75,7 @@ class TodoWriteTool(Tool):
 
         logging.info(separator)
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         try:
             todos_data = params.get("todos", [])
 
@@ -133,7 +132,6 @@ class CoreInvestigationToolset(Toolset):
             tags=[ToolsetTag.CORE],
             is_default=True,
         )
-        logging.info("Core investigation toolset loaded")
 
     def get_example_config(self) -> Dict[str, Any]:
         return {}

holmes/plugins/toolsets/kafka.py

@@ -27,6 +27,7 @@ from holmes.core.tools import (
     CallablePrerequisite,
     StructuredToolResult,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     StructuredToolResultStatus,
     Toolset,
@@ -153,9 +154,7 @@ class ListKafkaConsumers(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         try:
             kafka_cluster_name = get_param_or_raise(params, "kafka_cluster_name")
             client = self.get_kafka_client(kafka_cluster_name)
@@ -228,9 +227,7 @@ class DescribeConsumerGroup(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         group_id = params["group_id"]
         try:
             kafka_cluster_name = get_param_or_raise(params, "kafka_cluster_name")
@@ -286,9 +283,7 @@ class ListTopics(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         try:
             kafka_cluster_name = get_param_or_raise(params, "kafka_cluster_name")
             client = self.get_kafka_client(kafka_cluster_name)
@@ -344,9 +339,7 @@ class DescribeTopic(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         topic_name = params["topic_name"]
         try:
             kafka_cluster_name = get_param_or_raise(params, "kafka_cluster_name")
@@ -469,9 +462,7 @@ class FindConsumerGroupsByTopic(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         topic_name = params["topic_name"]
         try:
             kafka_cluster_name = get_param_or_raise(params, "kafka_cluster_name")
@@ -559,9 +550,7 @@ class ListKafkaClusters(BaseKafkaTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         cluster_names = list(self.toolset.clients.keys())
         return StructuredToolResult(
             status=StructuredToolResultStatus.SUCCESS,

holmes/plugins/toolsets/logging_utils/logging_api.py

@@ -1,27 +1,36 @@
 from abc import ABC, abstractmethod
 from datetime import datetime, timedelta
 import logging
+from math import ceil
 from typing import Optional, Set
 from enum import Enum
 
 from pydantic import BaseModel, field_validator
 from datetime import timezone
+from holmes.core.llm import LLM
 from holmes.core.tools import (
     StructuredToolResult,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     Toolset,
 )
+from holmes.core.tools_utils.token_counting import count_tool_response_tokens
 from holmes.plugins.toolsets.utils import get_param_or_raise
 
 # Default values for log fetching
 DEFAULT_LOG_LIMIT = 100
 SECONDS_PER_DAY = 24 * 60 * 60
 DEFAULT_TIME_SPAN_SECONDS = 7 * SECONDS_PER_DAY  # 1 week in seconds
-DEFAULT_GRAPH_TIME_SPAN_SECONDS = 1 * SECONDS_PER_DAY  # 1 day in seconds
+DEFAULT_GRAPH_TIME_SPAN_SECONDS = 1 * 60 * 60  # 1 hour in seconds
 
 POD_LOGGING_TOOL_NAME = "fetch_pod_logs"
 
+TRUNCATION_PROMPT_PREFIX = "[... PREVIOUS LOGS ABOVE THIS LINE HAVE BEEN TRUNCATED]"
+MIN_NUMBER_OF_CHARACTERS_TO_TRUNCATE: int = (
+    50 + len(TRUNCATION_PROMPT_PREFIX)
+)  # prevents the truncation algorithm from going too slow once the actual token count gets close to the expected limit
+
 
 class LoggingCapability(str, Enum):
     """Optional advanced logging capabilities"""
@@ -74,6 +83,68 @@ class BasePodLoggingToolset(Toolset, ABC):
         return ""
 
 
+def truncate_logs(
+    logging_structured_tool_result: StructuredToolResult,
+    llm: LLM,
+    token_limit: int,
+    structured_params: FetchPodLogsParams,
+):
+    original_token_count = count_tool_response_tokens(
+        llm=llm, structured_tool_result=logging_structured_tool_result
+    )
+    token_count = original_token_count
+    text = None
+    while token_count > token_limit:
+        # Loop because we are counting tokens but trimming characters. This means we try to trim a number of
+        # characters proportional to the number of tokens but we may still have too many tokens
+        if not text:
+            text = logging_structured_tool_result.get_stringified_data()
+        if not text:
+            # Weird scenario where the result exceeds the token allowance but there is not data.
+            # Exit and do nothing because I don't know how to handle such scenario.
+            logging.warning(
+                f"The calculated token count for logs is {token_count} but the limit is {token_limit}. However the data field is empty so there are no logs to truncate."
+            )
+            return
+        ratio = token_count / token_limit
+        character_count = len(text)
+        number_of_characters_to_truncate = character_count - ceil(
+            character_count / ratio
+        )
+        number_of_characters_to_truncate = max(
+            MIN_NUMBER_OF_CHARACTERS_TO_TRUNCATE, number_of_characters_to_truncate
+        )
+
+        if len(text) <= number_of_characters_to_truncate:
+            logging.warning(
+                f"The calculated token count for logs is {token_count} (max allowed tokens={token_limit}) but the logs are only {len(text)} characters which is below the intended truncation of {number_of_characters_to_truncate} characters. Logs will no longer be truncated"
+            )
+            return
+        else:
+            linefeed_truncation_offset = max(
+                text[number_of_characters_to_truncate:].find("\n"), 0
+            )  # keep log lines atomic
+
+            # Tentatively add the truncation prefix.
+            # When counting tokens, we want to include the TRUNCATION_PROMPT_PREFIX because it will be part of the tool response.
+            # Because we're truncating based on character counts but ultimately checking tokens count,
+            # it is possible that the character truncation is incorrect and more need to be truncated.
+            # This will be caught in the next iteration and the truncation prefix will be truncated
+            # because MIN_NUMBER_OF_CHARACTERS_TO_TRUNCATE cannot be smaller than TRUNCATION_PROMPT_PREFIX
+            text = (
+                TRUNCATION_PROMPT_PREFIX
+                + text[number_of_characters_to_truncate + linefeed_truncation_offset :]
+            )
+            logging_structured_tool_result.data = text
+            token_count = count_tool_response_tokens(
+                llm=llm, structured_tool_result=logging_structured_tool_result
+            )
+    if token_count < original_token_count:
+        logging.info(
+            f"Logs for pod {structured_params.pod_name}/{structured_params.namespace} have been truncated from {original_token_count} tokens down to {token_count} tokens."
+        )
+
+
 class PodLoggingTool(Tool):
     """Common tool for fetching pod logs across different logging backends"""
 
@@ -175,9 +246,7 @@ If you hit the log limit and see lots of repetitive INFO logs, use exclude_filte
 
         return params
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         structured_params = FetchPodLogsParams(
             namespace=get_param_or_raise(params, "namespace"),
             pod_name=get_param_or_raise(params, "pod_name"),
@@ -192,6 +261,13 @@ If you hit the log limit and see lots of repetitive INFO logs, use exclude_filte
             params=structured_params,
         )
 
+        truncate_logs(
+            logging_structured_tool_result=result,
+            llm=context.llm,
+            token_limit=context.max_token_count,
+            structured_params=structured_params,
+        )
+
         return result
 
     def get_parameterized_one_liner(self, params: dict) -> str:

holmes/plugins/toolsets/mcp/toolset_mcp.py

@@ -1,4 +1,5 @@
 from holmes.core.tools import (
+    ToolInvokeContext,
     Toolset,
     Tool,
     ToolParameter,
@@ -24,9 +25,7 @@ class RemoteMCPTool(Tool):
     url: str
     headers: Optional[Dict[str, str]] = None
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         try:
             return asyncio.run(self._invoke_async(params))
         except Exception as e: