holmesgpt 0.13.2__py3-none-any.whl → 0.18.4__py3-none-any.whl

holmes/plugins/toolsets/elasticsearch/opensearch_query_assist.py

@@ -0,0 +1,78 @@
+import logging
+import os
+from typing import Any, Dict
+
+from holmes.core.tools import (
+    StructuredToolResult,
+    StructuredToolResultStatus,
+    Tool,
+    ToolInvokeContext,
+    ToolParameter,
+    Toolset,
+    ToolsetEnvironmentPrerequisite,
+    ToolsetTag,
+)
+
+
+class PplQueryAssistTool(Tool):
+    def __init__(self, toolset: "OpenSearchQueryAssistToolset"):
+        super().__init__(
+            name="opensearch_ppl_query_assist",
+            description="Generate valid OpenSearch Piped Processing Language (PPL) queries to suggest to users for execution",
+            parameters={
+                "query": ToolParameter(
+                    description="Valid OpenSearch Piped Processing Language (PPL) query to suggest to users for execution",
+                    type="string",
+                    required=True,
+                ),
+            },
+        )
+        self._toolset = toolset
+
+    def _invoke(self, params: dict, context: ToolInvokeContext) -> StructuredToolResult:
+        try:
+            query = params.get("query", "")
+            response_data = {"query": query}
+            return StructuredToolResult(
+                status=StructuredToolResultStatus.SUCCESS,
+                data=response_data,
+                params=params,
+            )
+
+        except Exception as e:
+            logging.exception(f"error using {self.name} tool")
+            return StructuredToolResult(
+                status=StructuredToolResultStatus.ERROR,
+                error=f"Failed to generate PPL query: {str(e)}",
+                params=params,
+            )
+
+    def get_parameterized_one_liner(self, params: Dict) -> str:
+        query = params.get("query", "")
+        return f"OpenSearchQueryToolset: Query ({query})"
+
+
+class OpenSearchQueryAssistToolset(Toolset):
+    """OpenSearch query assist with PPL queries"""
+
+    def __init__(self):
+        super().__init__(
+            name="opensearch/query_assist",
+            description="OpenSearch query assist with PPL queries.",
+            experimental=True,
+            icon_url="https://opensearch.org/assets/brand/PNG/Mark/opensearch_mark_default.png",
+            tools=[PplQueryAssistTool(self)],
+            tags=[ToolsetTag.CORE],
+            prerequisites=[ToolsetEnvironmentPrerequisite(env=["OPENSEARCH_URL"])],
+        )
+
+    def get_example_config(self) -> Dict[str, Any]:
+        return {"opensearch_url": "http://localhost:9200"}
+
+    def _reload_instructions(self):
+        template_file_path = os.path.abspath(
+            os.path.join(
+                os.path.dirname(__file__), "opensearch_query_assist_instructions.jinja2"
+            )
+        )
+        self._load_llm_instructions(jinja_template=f"file://{template_file_path}")

holmes/plugins/toolsets/elasticsearch/opensearch_query_assist_instructions.jinja2

@@ -0,0 +1,223 @@
+# Query Generation
+You have access to the opensearch_ppl_query_assist tool to help you generate your valid, accurate OpenSearch Piped Processing Language (PPL) queries.
+DO NOT PROVIDE INVALID QUERIES. ALWAYS CHECK YOUR QUERY WITH VALID QUERIES FIRST.
+
+Once a valid query is generated, you MUST provide a concise, but informative breakdown of each part of the query structure
+
+## CRITICAL: Query Intent Detection
+
+ALWAYS check if the user's question is about:
+
+* Log Analysis: Errors, warnings, messages, patterns, tool usage
+* Metrics Analysis: Performance, latency, throughput, resource usage
+* Time-based Analysis: "Last X hours/days", "recent", "today", "since"
+* Aggregation Requests: Count, sum, average, top, frequency
+* Troubleshooting: Issues, problems, failures, debugging
+
+If ANY of the above apply → Generate PPL query IMMEDIATELY and use the OpenSearch Dashboards Page State
+
+### Example GOOD response:
+I've retrieved your current query from the query bar `source=logs-otel-v1* | STAT count() BY severityText` and it
+appears there is a typo in "STAT", it should be "STATS". Below is the fixed query:
+```
+source=logs-otel-v1* | STATS count() BY severityText
+```
+
+
+## CRITICAL: OpenSearch Dashboards Page State
+User may be using this agent from OpenSearch Dashboards (OSD) for which provides the current page state.
+It may be included in the conversation history as a system message.
+
+IMPORTANT: YOU CAN USE THE CURRENT USE QUERY TO HELP ENHANCE/MODIFY/FIX/SUGGEST VALID QUERY USING THE SAME INDEX PATTERN
+REFER TO "Core PPL Commands" FOR SYNTAX
+
+```
+## OpenSearch PPL Query Language
+
+### PPL (Piped Processing Language) Overview
+PPL is OpenSearch's query language for analyzing logs, metrics, and traces. It uses a pipe-based syntax similar to Unix commands, processing data through sequential transformations.
+
+### Core PPL Commands
+
+**Data Source & Search:**
+- `source=<index>` or `search source=<index>` - Specify data source
+- `source=<cluster>:<index>` - Cross-cluster search
+- `| where <condition>` - Filter results
+- `| fields <field-list>` - Project specific fields
+- `| fields - <field-list>` - Exclude specific fields
+
+**Data Transformation:**
+- `| stats <aggregation> by <field>` - Aggregate data (count(), sum(), avg(), min(), max())
+- `| eval <field>=<expression>` - Create calculated fields
+- `| sort [+|-] <field>` - Sort results (+ ascending, - descending)
+- `| head <n>` - Return first n results
+- `| tail <n>` - Return last n results
+- `| dedup <field-list>` - Remove duplicates
+
+**Advanced Analysis:**
+- `| top [N] <field>` - Find most common values
+- `| rare [N] <field>` - Find least common values
+- `| parse <field> <regex>` - Extract fields using regex patterns
+- `| grok <field> <pattern>` - Parse using grok patterns
+- `| patterns <field> [SIMPLE_PATTERN|BRAIN]` - Extract log patterns
+
+**Time Series:**
+- `| trendline SMA(<period>, <field>)` - Calculate moving averages
+- `| fillnull with <value> in <fields>` - Replace null values
+
+**Joins & Lookups:**
+- `| join <table>` - Join with another dataset
+- `| lookup <table> <field>` - Enrich with lookup data (requires Calcite)
+
+**Pattern Extraction:**
+- `| patterns message BRAIN` - Semantic log pattern extraction
+- `| patterns new_field='extracted' pattern='[0-9]' message` - Custom regex patterns
+
+### PPL Query Examples for Observability
+
+**Error Analysis:**
+```ppl
+source=ai-agent-logs-*
+| where level="ERROR"
+| stats count() by message
+| sort - count
+```
+
+**Service Latency Analysis:**
+```ppl
+source=traces
+| where service="checkout"
+| stats avg(duration) as avg_latency, max(duration) as max_latency by endpoint
+| where avg_latency > 100
+```
+
+**Log Pattern Detection:**
+```ppl
+source=ai-agent-audit-logs-*
+| patterns message BRAIN
+| stats count() by patterns_field
+| top 10 patterns_field
+```
+
+**Time-based Aggregation:**
+```ppl
+source=metrics
+| eval hour=date_format(timestamp, 'HH')
+| stats avg(cpu_usage) by hour, host
+| sort hour
+```
+
+**Multi-field Correlation:**
+```ppl
+source=ai-agent-logs-*
+| parse message '.*thread_id=(?<tid>[^,]+).*run_id=(?<rid>[^,]+)'
+| stats count() by tid, rid, level
+| where count > 100
+```
+
+**Advanced PPL Query Patterns:**
+
+**Top N Analysis with Filtering:**
+```ppl
+source=ai-agent-logs-*
+| where timestamp >= now() - 1h
+| top 20 message by level
+| where level in ["ERROR", "WARN"]
+```
+
+**Deduplication and Unique Values:**
+```ppl
+source=ai-agent-audit-logs-*
+| dedup thread_id
+| fields thread_id, run_id, timestamp
+| sort - timestamp
+```
+
+**Fillnull for Missing Data Handling:**
+```ppl
+source=ai-agent-metrics-*
+| fillnull with 0 in cpu_usage, memory_usage
+| stats avg(cpu_usage) as avg_cpu, avg(memory_usage) as avg_mem by host
+```
+
+**Rare Events Detection:**
+```ppl
+source=ai-agent-logs-*
+| rare 10 error_code
+| where count < 5
+```
+
+**Field Extraction with Grok:**
+```ppl
+source=ai-agent-logs-*
+| grok message '%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} %{GREEDYDATA:msg}'
+| stats count() by level
+```
+
+**Time Span Aggregations:**
+```ppl
+source=ai-agent-metrics-*
+| stats count() by span(timestamp, 5m) as time_bucket, status
+| where status != 200
+```
+
+**Eval with Conditional Logic:**
+```ppl
+source=ai-agent-logs-*
+| eval severity = case(
+    level = "ERROR", 1,
+    level = "WARN", 2,
+    level = "INFO", 3,
+    else = 4
+  )
+| stats count() by severity
+```
+
+**Join Operations (with Calcite enabled):**
+```ppl
+source=ai-agent-logs-*
+| join left=l right=r on l.thread_id = r.thread_id
+  [ source=ai-agent-audit-logs-* ]
+| fields l.timestamp, l.message, r.tool_name
+```
+
+**Subquery for Complex Filtering:**
+```ppl
+source=ai-agent-logs-*
+| where thread_id in [
+    source=ai-agent-audit-logs-*
+    | where tool_name = "opensearch__search"
+    | fields thread_id
+  ]
+```
+
+**Trendline for Moving Averages:**
+```ppl
+source=ai-agent-metrics-*
+| trendline SMA(5, cpu_usage) as cpu_trend
+| fields timestamp, cpu_usage, cpu_trend
+```
+
+### PPL Best Practices
+
+1. **Index Patterns**: Use wildcards for daily indices: `source=ai-agent-logs-*`
+2. **Field Extraction**: Use `parse` for structured logs, `patterns` for unstructured
+3. **Performance**: Apply `where` filters early in the pipeline
+4. **Aggregations**: Use `stats` before `sort` for better performance
+5. **Null Handling**: Use `fillnull` to handle missing data in calculations
+
+### OpenSearch Index Patterns (Current Environment)
+- `ai-agent-logs-YYYY.MM.DD` - Application logs
+- `ai-agent-audit-logs-YYYY.MM.DD` - Audit logs
+- `ai-agent-metrics-YYYY.MM.DD` - Prometheus metrics
+
+## Query Response Formatting
+You MUST respond with queries in the following format. `ppl` contains the valid ppl query
+```typescript
+query: {
+ ppl: string,
+}
+```
+
+## More PPL Queries
+{% include "opensearch_ppl_query_docs.jinja2" %}

holmes/plugins/toolsets/git.py

@@ -1,17 +1,20 @@
 import base64
 import logging
-import requests  # type: ignore
 import os
-from typing import Any, Optional, Dict, List, Tuple
+from typing import Any, Dict, List, Optional, Tuple
+
+import requests  # type: ignore
 from pydantic import BaseModel
-from holmes.core.tools import StructuredToolResult, ToolResultStatus
 
 from holmes.core.tools import (
-    Toolset,
+    CallablePrerequisite,
+    StructuredToolResult,
+    StructuredToolResultStatus,
     Tool,
+    ToolInvokeContext,
     ToolParameter,
+    Toolset,
     ToolsetTag,
-    CallablePrerequisite,
 )
 from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 
@@ -20,10 +23,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 +38,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 +80,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 +88,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 +104,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 +113,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 +126,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 +142,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 +156,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 +174,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 +194,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 +221,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 +256,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 +276,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 +304,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 +322,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 +348,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 +361,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 +416,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 +634,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 +647,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 +718,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 +726,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 +735,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 +749,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)}"
                 ),