holmesgpt 0.13.2__py3-none-any.whl → 0.16.2a0__py3-none-any.whl

holmes/plugins/toolsets/datadog/toolset_datadog_rds.py

@@ -9,8 +9,9 @@ from holmes.core.tools import (
     CallablePrerequisite,
     StructuredToolResult,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
-    ToolResultStatus,
+    StructuredToolResultStatus,
     Toolset,
     ToolsetTag,
 )
@@ -69,7 +70,7 @@ class GenerateRDSPerformanceReport(BaseDatadogRDSTool):
     def __init__(self, toolset: "DatadogRDSToolset"):
         super().__init__(
             name="datadog_rds_performance_report",
-            description="Generate a comprehensive performance report for a specific RDS instance including latency, resource utilization, and storage metrics with analysis",
+            description="[datadog/rds toolset] Generate a comprehensive performance report for a specific RDS instance including latency, resource utilization, and storage metrics with analysis",
             parameters={
                 "db_instance_identifier": ToolParameter(
                     description="The RDS database instance identifier",
@@ -92,12 +93,10 @@ class GenerateRDSPerformanceReport(BaseDatadogRDSTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.dd_config:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=TOOLSET_CONFIG_MISSING_ERROR,
                 params=params,
             )
@@ -150,7 +149,7 @@ class GenerateRDSPerformanceReport(BaseDatadogRDSTool):
             formatted_report = self._format_report(report)
 
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=formatted_report,
                 params=params,
             )
@@ -158,7 +157,7 @@ class GenerateRDSPerformanceReport(BaseDatadogRDSTool):
         except Exception as e:
             logging.error(f"Error generating RDS performance report: {str(e)}")
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Failed to generate RDS performance report: {str(e)}",
                 params=params,
             )
@@ -364,7 +363,7 @@ class GetTopWorstPerformingRDSInstances(BaseDatadogRDSTool):
     def __init__(self, toolset: "DatadogRDSToolset"):
         super().__init__(
             name="datadog_rds_top_worst_performing",
-            description="Get a summarized report of the top worst performing RDS instances based on latency, CPU utilization, and error rates",
+            description="[datadog/rds toolset] Get a summarized report of the top worst performing RDS instances based on latency, CPU utilization, and error rates",
             parameters={
                 "top_n": ToolParameter(
                     description=f"Number of worst performing instances to return (default: {DEFAULT_TOP_INSTANCES})",
@@ -392,12 +391,10 @@ class GetTopWorstPerformingRDSInstances(BaseDatadogRDSTool):
             toolset=toolset,
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         if not self.toolset.dd_config:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=TOOLSET_CONFIG_MISSING_ERROR,
                 params=params,
             )
@@ -416,7 +413,7 @@ class GetTopWorstPerformingRDSInstances(BaseDatadogRDSTool):
 
             if not instances:
                 return StructuredToolResult(
-                    status=ToolResultStatus.NO_DATA,
+                    status=StructuredToolResultStatus.NO_DATA,
                     data="No RDS instances found with metrics in the specified time range",
                     params=params,
                 )
@@ -443,7 +440,7 @@ class GetTopWorstPerformingRDSInstances(BaseDatadogRDSTool):
             report += f"\n\nInstances:\n{json.dumps(worst_performers, indent=2)}"
 
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=report,
                 params=params,
             )
@@ -451,7 +448,7 @@ class GetTopWorstPerformingRDSInstances(BaseDatadogRDSTool):
         except Exception as e:
             logging.error(f"Error getting top worst performing RDS instances: {str(e)}")
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Failed to get top worst performing RDS instances: {str(e)}",
                 params=params,
             )

holmes/plugins/toolsets/datadog/toolset_datadog_traces.py

@@ -9,10 +9,11 @@ from typing import Any, Dict, Optional, Tuple
 from holmes.core.tools import (
     CallablePrerequisite,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
     Toolset,
     StructuredToolResult,
-    ToolResultStatus,
+    StructuredToolResultStatus,
     ToolsetTag,
 )
 from holmes.plugins.toolsets.datadog.datadog_api import (
@@ -49,7 +50,7 @@ class DatadogTracesToolset(Toolset):
         super().__init__(
             name="datadog/traces",
             description="Toolset for interacting with Datadog APM to fetch and analyze traces",
-            docs_url="https://docs.datadoghq.com/api/latest/spans/",
+            docs_url="https://holmesgpt.dev/data-sources/builtin-toolsets/datadog/",
             icon_url="https://imgix.datadoghq.com//img/about/presskit/DDlogo.jpg",
             prerequisites=[CallablePrerequisite(callable=self.prerequisites_callable)],
             tools=[
@@ -57,7 +58,6 @@ class DatadogTracesToolset(Toolset):
                 FetchDatadogTraceById(toolset=self),
                 FetchDatadogSpansByFilter(toolset=self),
             ],
-            experimental=True,
             tags=[ToolsetTag.CORE],
         )
         self._reload_instructions()
@@ -157,7 +157,7 @@ class FetchDatadogTracesList(BaseDatadogTracesTool):
     def __init__(self, toolset: "DatadogTracesToolset"):
         super().__init__(
             name="fetch_datadog_traces",
-            description="Fetch a list of traces from Datadog with optional filters",
+            description="[datadog/traces toolset] Fetch a list of traces from Datadog with optional filters",
             parameters={
                 "service": ToolParameter(
                     description="Filter by service name",
@@ -211,13 +211,11 @@ class FetchDatadogTracesList(BaseDatadogTracesTool):
         filter_str = ", ".join(filters) if filters else "all"
         return f"{toolset_name_for_one_liner(self.toolset.name)}: Fetch Traces ({filter_str})"
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         """Execute the tool to fetch traces."""
         if not self.toolset.dd_config:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error="Datadog configuration not initialized",
                 params=params,
             )
@@ -306,13 +304,13 @@ class FetchDatadogTracesList(BaseDatadogTracesTool):
             formatted_output = format_traces_list(spans, limit=params.get("limit", 50))
             if not formatted_output:
                 return StructuredToolResult(
-                    status=ToolResultStatus.NO_DATA,
+                    status=StructuredToolResultStatus.NO_DATA,
                     params=params,
                     data="No matching traces found.",
                 )
 
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=formatted_output,
                 params=params,
             )
@@ -331,7 +329,7 @@ class FetchDatadogTracesList(BaseDatadogTracesTool):
                 error_msg = f"Exception while querying Datadog: {str(e)}"
 
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=error_msg,
                 params=params,
                 invocation=(
@@ -344,7 +342,7 @@ class FetchDatadogTracesList(BaseDatadogTracesTool):
         except Exception as e:
             logging.exception(e, exc_info=True)
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Unexpected error: {str(e)}",
                 params=params,
                 invocation=(
@@ -361,7 +359,7 @@ class FetchDatadogTraceById(BaseDatadogTracesTool):
     def __init__(self, toolset: "DatadogTracesToolset"):
         super().__init__(
             name="fetch_datadog_trace_by_id",
-            description="Fetch detailed information about a specific trace by its ID",
+            description="[datadog/traces toolset] Fetch detailed information about a specific trace by its ID",
             parameters={
                 "trace_id": ToolParameter(
                     description="The trace ID to fetch details for",
@@ -377,13 +375,11 @@ class FetchDatadogTraceById(BaseDatadogTracesTool):
         trace_id = params.get("trace_id", "unknown")
         return f"{toolset_name_for_one_liner(self.toolset.name)}: Fetch Trace Details ({trace_id})"
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         """Execute the tool to fetch trace details."""
         if not self.toolset.dd_config:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error="Datadog configuration not initialized",
                 params=params,
             )
@@ -391,7 +387,7 @@ class FetchDatadogTraceById(BaseDatadogTracesTool):
         trace_id = params.get("trace_id")
         if not trace_id:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error="trace_id parameter is required",
                 params=params,
             )
@@ -445,13 +441,13 @@ class FetchDatadogTraceById(BaseDatadogTracesTool):
             formatted_output = format_trace_hierarchy(trace_id, spans)
             if not formatted_output:
                 return StructuredToolResult(
-                    status=ToolResultStatus.NO_DATA,
+                    status=StructuredToolResultStatus.NO_DATA,
                     params=params,
                     data=f"No trace found for trace_id: {trace_id}",
                 )
 
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=formatted_output,
                 params=params,
             )
@@ -470,7 +466,7 @@ class FetchDatadogTraceById(BaseDatadogTracesTool):
                 error_msg = f"Exception while querying Datadog: {str(e)}"
 
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=error_msg,
                 params=params,
                 invocation=(
@@ -483,7 +479,7 @@ class FetchDatadogTraceById(BaseDatadogTracesTool):
         except Exception as e:
             logging.exception(e, exc_info=True)
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Unexpected error: {str(e)}",
                 params=params,
                 invocation=(
@@ -500,7 +496,7 @@ class FetchDatadogSpansByFilter(BaseDatadogTracesTool):
     def __init__(self, toolset: "DatadogTracesToolset"):
         super().__init__(
             name="fetch_datadog_spans",
-            description="Search for spans in Datadog with detailed filters",
+            description="[datadog/traces toolset] Search for spans in Datadog with detailed filters",
             parameters={
                 "query": ToolParameter(
                     description="Datadog search query (e.g., 'service:web-app @http.status_code:500')",
@@ -560,13 +556,11 @@ class FetchDatadogSpansByFilter(BaseDatadogTracesTool):
         filter_str = ", ".join(filters) if filters else "all"
         return f"{toolset_name_for_one_liner(self.toolset.name)}: Search Spans ({filter_str})"
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         """Execute the tool to search spans."""
         if not self.toolset.dd_config:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error="Datadog configuration not initialized",
                 params=params,
             )
@@ -654,13 +648,13 @@ class FetchDatadogSpansByFilter(BaseDatadogTracesTool):
             formatted_output = format_spans_search(spans)
             if not formatted_output:
                 return StructuredToolResult(
-                    status=ToolResultStatus.NO_DATA,
+                    status=StructuredToolResultStatus.NO_DATA,
                     params=params,
                     data="No matching spans found.",
                 )
 
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=formatted_output,
                 params=params,
             )
@@ -678,7 +672,7 @@ class FetchDatadogSpansByFilter(BaseDatadogTracesTool):
                 error_msg = f"Exception while querying Datadog: {str(e)}"
 
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=error_msg,
                 params=params,
                 invocation=(
@@ -691,7 +685,7 @@ class FetchDatadogSpansByFilter(BaseDatadogTracesTool):
         except Exception as e:
             logging.exception(e, exc_info=True)
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Unexpected error: {str(e)}",
                 params=params,
                 invocation=(

holmes/plugins/toolsets/git.py

@@ -4,7 +4,11 @@ import requests  # type: ignore
 import os
 from typing import Any, Optional, Dict, List, Tuple
 from pydantic import BaseModel
-from holmes.core.tools import StructuredToolResult, ToolResultStatus
+from holmes.core.tools import (
+    StructuredToolResult,
+    StructuredToolResultStatus,
+    ToolInvokeContext,
+)
 
 from holmes.core.tools import (
     Toolset,
@@ -20,10 +24,12 @@ class GitHubConfig(BaseModel):
     git_repo: str
     git_credentials: str
     git_branch: str = "main"
+    git_url: str = "https://api.github.com"
 
 
 class GitToolset(Toolset):
     git_repo: Optional[str] = None
+    git_url: Optional[str] = None
     git_credentials: Optional[str] = None
     git_branch: Optional[str] = None
     _created_branches: set[str] = set()  # Track branches created by the tool
@@ -33,7 +39,7 @@ class GitToolset(Toolset):
         super().__init__(
             name="git",
             description="Runs git commands to read repos and create PRs",
-            docs_url="https://docs.github.com/en/rest",
+            docs_url="https://holmesgpt.dev/data-sources/builtin-toolsets/github/",
             icon_url="https://upload.wikimedia.org/wikipedia/commons/9/91/Octicons-mark-github.svg",
             prerequisites=[CallablePrerequisite(callable=self.prerequisites_callable)],
             tools=[
@@ -75,6 +81,7 @@ class GitToolset(Toolset):
 
         try:
             self.git_repo = os.getenv("GIT_REPO") or config.get("git_repo")
+            self.git_url = os.getenv("GIT_URL") or config.get("git_url")
             self.git_credentials = os.getenv("GIT_CREDENTIALS") or config.get(
                 "git_credentials"
             )
@@ -82,7 +89,9 @@ class GitToolset(Toolset):
                 "git_branch", "main"
             )
 
-            if not all([self.git_repo, self.git_credentials, self.git_branch]):
+            if not all(
+                [self.git_repo, self.git_url, self.git_credentials, self.git_branch]
+            ):
                 logging.error("Missing one or more required Git configuration values.")
                 return False, "Missing one or more required Git configuration values."
             return True, ""
@@ -96,7 +105,7 @@ class GitToolset(Toolset):
     def list_open_prs(self) -> List[Dict[str, Any]]:
         """Helper method to list all open PRs in the repository."""
         headers = {"Authorization": f"token {self.git_credentials}"}
-        url = f"https://api.github.com/repos/{self.git_repo}/pulls?state=open"
+        url = f"{self.git_url}/repos/{self.git_repo}/pulls?state=open"
         resp = requests.get(url, headers=headers)
         if resp.status_code != 200:
             raise Exception(self._sanitize_error(f"Error listing PRs: {resp.text}"))
@@ -105,9 +114,7 @@ class GitToolset(Toolset):
     def get_branch_ref(self, branch_name: str) -> Optional[str]:
         """Get the SHA of a branch reference."""
         headers = {"Authorization": f"token {self.git_credentials}"}
-        url = (
-            f"https://api.github.com/repos/{self.git_repo}/git/refs/heads/{branch_name}"
-        )
+        url = f"{self.git_url}/repos/{self.git_repo}/git/refs/heads/{branch_name}"
         resp = requests.get(url, headers=headers)
         if resp.status_code == 404:
             return None
@@ -120,7 +127,7 @@ class GitToolset(Toolset):
     def create_branch(self, branch_name: str, base_sha: str) -> None:
         """Create a new branch from a base SHA."""
         headers = {"Authorization": f"token {self.git_credentials}"}
-        url = f"https://api.github.com/repos/{self.git_repo}/git/refs"
+        url = f"{self.git_url}/repos/{self.git_repo}/git/refs"
         resp = requests.post(
             url,
             headers=headers,
@@ -136,7 +143,7 @@ class GitToolset(Toolset):
     def get_file_content(self, filepath: str, branch: str) -> tuple[str, str]:
         """Get file content and SHA from a specific branch."""
         headers = {"Authorization": f"token {self.git_credentials}"}
-        url = f"https://api.github.com/repos/{self.git_repo}/contents/{filepath}?ref={branch}"
+        url = f"{self.git_url}/repos/{self.git_repo}/contents/{filepath}?ref={branch}"
         resp = requests.get(url, headers=headers)
         if resp.status_code == 404:
             raise Exception(f"File not found: {filepath}")
@@ -150,7 +157,7 @@ class GitToolset(Toolset):
     ) -> None:
         """Update a file in a specific branch."""
         headers = {"Authorization": f"token {self.git_credentials}"}
-        url = f"https://api.github.com/repos/{self.git_repo}/contents/{filepath}"
+        url = f"{self.git_url}/repos/{self.git_repo}/contents/{filepath}"
         encoded_content = base64.b64encode(content.encode()).decode()
         resp = requests.put(
             url,
@@ -168,7 +175,7 @@ class GitToolset(Toolset):
     def create_pr(self, title: str, head: str, base: str, body: str) -> str:
         """Create a new pull request."""
         headers = {"Authorization": f"token {self.git_credentials}"}
-        url = f"https://api.github.com/repos/{self.git_repo}/pulls"
+        url = f"{self.git_url}/repos/{self.git_repo}/pulls"
         resp = requests.post(
             url,
             headers=headers,
@@ -188,7 +195,7 @@ class GitToolset(Toolset):
     def get_pr_details(self, pr_number: int) -> Dict[str, Any]:
         """Get details of a specific PR."""
         headers = {"Authorization": f"token {self.git_credentials}"}
-        url = f"https://api.github.com/repos/{self.git_repo}/pulls/{pr_number}"
+        url = f"{self.git_url}/repos/{self.git_repo}/pulls/{pr_number}"
         resp = requests.get(url, headers=headers)
         if resp.status_code != 200:
             raise Exception(
@@ -215,7 +222,7 @@ class GitToolset(Toolset):
 
         # Update file
         headers = {"Authorization": f"token {self.git_credentials}"}
-        url = f"https://api.github.com/repos/{self.git_repo}/contents/{filepath}"
+        url = f"{self.git_url}/repos/{self.git_repo}/contents/{filepath}"
         encoded_content = base64.b64encode(content.encode()).decode()
         data = {
             "message": message,
@@ -250,16 +257,18 @@ class GitReadFileWithLineNumbers(Tool):
         )
 
     def _invoke(
-        self, params: dict, user_approved: bool = False
+        self,
+        params: dict,
+        context: ToolInvokeContext,
     ) -> StructuredToolResult:
         filepath = params["filepath"]
         try:
             headers = {"Authorization": f"token {self.toolset.git_credentials}"}
-            url = f"https://api.github.com/repos/{self.toolset.git_repo}/contents/{filepath}"
+            url = f"{self.toolset.git_url}/repos/{self.toolset.git_repo}/contents/{filepath}"
             resp = requests.get(url, headers=headers)
             if resp.status_code != 200:
                 return StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
+                    status=StructuredToolResultStatus.ERROR,
                     data=self.toolset._sanitize_error(
                         f"Error fetching file: {resp.text}"
                     ),
@@ -268,13 +277,13 @@ class GitReadFileWithLineNumbers(Tool):
             content = base64.b64decode(resp.json()["content"]).decode().splitlines()
             numbered = "\n".join(f"{i+1}: {line}" for i, line in enumerate(content))
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=numbered,
                 params=params,
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 data=self.toolset._sanitize_error(str(e)),
                 params=params,
             )
@@ -296,15 +305,17 @@ class GitListFiles(Tool):
         )
 
     def _invoke(
-        self, params: dict, user_approved: bool = False
+        self,
+        params: dict,
+        context: ToolInvokeContext,
     ) -> StructuredToolResult:
         try:
             headers = {"Authorization": f"token {self.toolset.git_credentials}"}
-            url = f"https://api.github.com/repos/{self.toolset.git_repo}/git/trees/{self.toolset.git_branch}?recursive=1"
+            url = f"{self.toolset.git_url}/repos/{self.toolset.git_repo}/git/trees/{self.toolset.git_branch}?recursive=1"
             resp = requests.get(url, headers=headers)
             if resp.status_code != 200:
                 return StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
+                    status=StructuredToolResultStatus.ERROR,
                     data=self.toolset._sanitize_error(
                         f"Error listing files: {resp.text}"
                     ),
@@ -312,13 +323,13 @@ class GitListFiles(Tool):
                 )
             paths = [entry["path"] for entry in resp.json()["tree"]]
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=paths,
                 params=params,
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 data=self.toolset._sanitize_error(str(e)),
                 params=params,
             )
@@ -338,9 +349,7 @@ class GitListOpenPRs(Tool):
             toolset=toolset,  # type: ignore
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         try:
             prs = self.toolset.list_open_prs()
             formatted = [
@@ -353,13 +362,13 @@ class GitListOpenPRs(Tool):
                 for pr in prs
             ]
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=formatted,
                 params=params,
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 data=self.toolset._sanitize_error(str(e)),
                 params=params,
             )
@@ -408,19 +417,17 @@ class GitExecuteChanges(Tool):
             toolset=toolset,  # type: ignore
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         def error(msg: str) -> StructuredToolResult:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 data=self.toolset._sanitize_error(msg),
                 params=params,
             )
 
         def success(msg: Any) -> StructuredToolResult:
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS, data=msg, params=params
+                status=StructuredToolResultStatus.SUCCESS, data=msg, params=params
             )
 
         def modify_lines(lines: List[str]) -> List[str]:
@@ -628,9 +635,7 @@ class GitUpdatePR(Tool):
             toolset=toolset,  # type: ignore
         )
 
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
         try:
             line = params["line"]
             filename = params["filename"]
@@ -643,24 +648,24 @@ class GitUpdatePR(Tool):
             # Validate inputs
             if not commit_message.strip():
                 return StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
+                    status=StructuredToolResultStatus.ERROR,
                     error="Tool call failed to run: Commit message cannot be empty",
                 )
             if not filename.strip():
                 return StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
+                    status=StructuredToolResultStatus.ERROR,
                     error="Tool call failed to run: Filename cannot be empty",
                 )
             if line < 1:
                 return StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
+                    status=StructuredToolResultStatus.ERROR,
                     error="Tool call failed to run: Line number must be positive",
                 )
 
             # Verify this is a PR created by our tool
             if not self.toolset.is_created_pr(pr_number):
                 return StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
+                    status=StructuredToolResultStatus.ERROR,
                     error=f"Tool call failed to run: PR #{pr_number} was not created by this tool. Only PRs created using git_execute_changes can be updated.",
                 )
 
@@ -714,7 +719,7 @@ class GitUpdatePR(Tool):
                     del content_lines[line - 1]
                 else:
                     return StructuredToolResult(
-                        status=ToolResultStatus.ERROR,
+                        status=StructuredToolResultStatus.ERROR,
                         error=f"Tool call failed to run: Invalid command: {command}",
                     )
 
@@ -722,7 +727,7 @@ class GitUpdatePR(Tool):
 
                 if dry_run:
                     return StructuredToolResult(
-                        status=ToolResultStatus.SUCCESS,
+                        status=StructuredToolResultStatus.SUCCESS,
                         data=f"DRY RUN: Updated content for PR #{pr_number}:\n\n{updated_content}",
                     )
 
@@ -731,13 +736,13 @@ class GitUpdatePR(Tool):
                     pr_number, filename, updated_content, commit_message
                 )
                 return StructuredToolResult(
-                    status=ToolResultStatus.SUCCESS,
+                    status=StructuredToolResultStatus.SUCCESS,
                     data=f"Added commit to PR #{pr_number} successfully",
                 )
 
             except Exception as e:
                 return StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
+                    status=StructuredToolResultStatus.ERROR,
                     error=self.toolset._sanitize_error(
                         f"Tool call failed to run: Error updating PR: {str(e)}"
                     ),
@@ -745,14 +750,14 @@ class GitUpdatePR(Tool):
 
         except requests.exceptions.RequestException as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=self.toolset._sanitize_error(
                     f"Tool call failed to run: Network error: {str(e)}"
                 ),
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=self.toolset._sanitize_error(
                     f"Tool call failed to run: Unexpected error: {str(e)}"
                 ),