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

holmes/core/models.py

@@ -1,15 +1,96 @@
-from holmes.core.investigation_structured_output import InputSectionsDataType
-from holmes.core.tool_calling_llm import ToolCallResult
-from typing import Optional, List, Dict, Any, Union
-from pydantic import BaseModel, model_validator, Field
+import json
 from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field, model_validator
+
+from holmes.core.investigation_structured_output import InputSectionsDataType
+from holmes.core.tools import StructuredToolResult, StructuredToolResultStatus
+
+
+class TruncationMetadata(BaseModel):
+    tool_call_id: str
+    start_index: int
+    end_index: int
+    tool_name: str
+    original_token_count: int
+
+
+class TruncationResult(BaseModel):
+    truncated_messages: list[dict]
+    truncations: list[TruncationMetadata]
+
+
+class ToolCallResult(BaseModel):
+    tool_call_id: str
+    tool_name: str
+    description: str
+    result: StructuredToolResult
+    size: Optional[int] = None
+
+    def as_tool_call_message(self):
+        return {
+            "tool_call_id": self.tool_call_id,
+            "role": "tool",
+            "name": self.tool_name,
+            "content": format_tool_result_data(
+                tool_result=self.result,
+                tool_call_id=self.tool_call_id,
+                tool_name=self.tool_name,
+            ),
+        }
+
+    def as_tool_result_response(self):
+        result_dump = self.result.model_dump()
+        result_dump["data"] = self.result.get_stringified_data()
+
+        return {
+            "tool_call_id": self.tool_call_id,
+            "tool_name": self.tool_name,
+            "description": self.description,
+            "role": "tool",
+            "result": result_dump,
+        }
+
+    def as_streaming_tool_result_response(self):
+        result_dump = self.result.model_dump()
+        result_dump["data"] = self.result.get_stringified_data()
+
+        return {
+            "tool_call_id": self.tool_call_id,
+            "role": "tool",
+            "description": self.description,
+            "name": self.tool_name,
+            "result": result_dump,
+        }
+
+
+def format_tool_result_data(
+    tool_result: StructuredToolResult, tool_call_id: str, tool_name: str
+) -> str:
+    tool_call_metadata = {"tool_name": tool_name, "tool_call_id": tool_call_id}
+    tool_response = f"tool_call_metadata={json.dumps(tool_call_metadata)}"
+
+    if tool_result.status == StructuredToolResultStatus.ERROR:
+        tool_response += f"{tool_result.error or 'Tool execution failed'}:\n\n"
+
+    tool_response += tool_result.get_stringified_data()
+
+    if tool_result.params:
+        tool_response = (
+            f"Params used for the tool call: {json.dumps(tool_result.params)}. The tool call output follows on the next line.\n"
+            + tool_response
+        )
+    return tool_response
 
 
 class InvestigationResult(BaseModel):
     analysis: Optional[str] = None
     sections: Optional[Dict[str, Union[str, None]]] = None
     tool_calls: List[ToolCallResult] = []
+    num_llm_calls: Optional[int] = None  # Number of LLM API calls (turns)
     instructions: List[str] = []
+    metadata: Optional[Dict[Any, Any]] = None
 
 
 class InvestigateRequest(BaseModel):
@@ -86,10 +167,31 @@ class ConversationRequest(BaseModel):
     include_tool_call_results: bool = False
 
 
+class PendingToolApproval(BaseModel):
+    """Represents a tool call that requires user approval."""
+
+    tool_call_id: str
+    tool_name: str
+    description: str
+    params: Dict[str, Any]
+
+
+class ToolApprovalDecision(BaseModel):
+    """Represents a user's decision on a tool approval."""
+
+    tool_call_id: str
+    approved: bool
+
+
 class ChatRequestBaseModel(BaseModel):
     conversation_history: Optional[list[dict]] = None
     model: Optional[str] = None
     stream: bool = Field(default=False)
+    enable_tool_approval: Optional[bool] = (
+        False  # Optional boolean for backwards compatibility
+    )
+    tool_decisions: Optional[List[ToolApprovalDecision]] = None
+    additional_system_prompt: Optional[str] = None
 
     # In our setup with litellm, the first message in conversation_history
     # should follow the structure [{"role": "system", "content": ...}],
@@ -145,6 +247,8 @@ class ChatResponse(BaseModel):
     conversation_history: list[dict]
     tool_calls: Optional[List[ToolCallResult]] = []
     follow_up_actions: Optional[List[FollowUpAction]] = []
+    pending_approvals: Optional[List[PendingToolApproval]] = None
+    metadata: Optional[Dict[Any, Any]] = None
 
 
 class WorkloadHealthInvestigationResult(BaseModel):

holmes/core/openai_formatting.py

@@ -2,8 +2,8 @@ import re
 from typing import Any, Optional
 
 from holmes.common.env_vars import (
-    TOOL_SCHEMA_NO_PARAM_OBJECT_IF_NO_PARAMS,
     LLMS_WITH_STRICT_TOOL_CALLS,
+    TOOL_SCHEMA_NO_PARAM_OBJECT_IF_NO_PARAMS,
 )
 from holmes.utils.llms import model_matches_list
 
@@ -80,6 +80,19 @@ def format_tool_to_open_ai_standard(
         )
         if param_attributes.description is not None:
             tool_properties[param_name]["description"] = param_attributes.description
+        # Add enum constraint if specified
+        if hasattr(param_attributes, "enum") and param_attributes.enum:
+            enum_values = list(
+                param_attributes.enum
+            )  # Create a copy to avoid modifying original
+            # In strict mode, optional parameters need None in their enum to match the type allowing null
+            if (
+                strict_mode
+                and not param_attributes.required
+                and None not in enum_values
+            ):
+                enum_values.append(None)
+            tool_properties[param_name]["enum"] = enum_values
 
     result: dict[str, Any] = {
         "type": "function",

holmes/core/prompt.py

@@ -1,8 +1,11 @@
-from rich.console import Console
-from typing import Optional, List, Dict, Any, Union
 from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from rich.console import Console
+
 from holmes.plugins.prompts import load_and_render_prompt
 from holmes.plugins.runbooks import RunbookCatalog
+from holmes.utils.global_instructions import generate_runbooks_args
 
 
 def append_file_to_user_prompt(user_prompt: str, file_path: Path) -> str:
@@ -35,6 +38,39 @@ def get_tasks_management_system_reminder() -> str:
     )
 
 
+def _has_content(value: Optional[str]) -> bool:
+    """
+    Check if the value is a non-empty string and not None.
+    """
+    return bool(value and isinstance(value, str) and value.strip())
+
+
+def _should_enable_runbooks(context: Dict[str, str]) -> bool:
+    return any(
+        (
+            _has_content(context.get("runbook_catalog")),
+            _has_content(context.get("custom_instructions")),
+            _has_content(context.get("global_instructions")),
+        )
+    )
+
+
+def generate_user_prompt(
+    user_prompt: str,
+    context: Dict[str, str],
+) -> str:
+    runbooks_enabled = _should_enable_runbooks(context)
+
+    return load_and_render_prompt(
+        "builtin://base_user_prompt.jinja2",
+        context={
+            "user_prompt": user_prompt,
+            "runbooks_enabled": runbooks_enabled,
+            **context,
+        },
+    )
+
+
 def build_initial_ask_messages(
     console: Console,
     initial_user_prompt: str,
@@ -57,7 +93,7 @@ def build_initial_ask_messages(
     system_prompt_template = "builtin://generic_ask.jinja2"
     template_context = {
         "toolsets": tool_executor.toolsets,
-        "runbooks": runbooks or {},
+        "runbooks_enabled": True if runbooks else False,
         "system_prompt_additions": system_prompt_additions or "",
     }
     system_prompt_rendered = load_and_render_prompt(
@@ -70,6 +106,15 @@ def build_initial_ask_messages(
     )
 
     user_prompt_with_files += get_tasks_management_system_reminder()
+
+    runbooks_ctx = generate_runbooks_args(
+        runbook_catalog=runbooks,  # type: ignore
+    )
+    user_prompt_with_files = generate_user_prompt(
+        user_prompt_with_files,
+        runbooks_ctx,
+    )
+
     messages = [
         {"role": "system", "content": system_prompt_rendered},
         {"role": "user", "content": user_prompt_with_files},

holmes/core/runbooks.py

@@ -1,4 +1,5 @@
 from typing import List
+
 from holmes.core.issue import Issue
 from holmes.plugins.runbooks import Runbook
 

holmes/core/safeguards.py

@@ -4,9 +4,11 @@ from typing import Optional
 from pydantic import ValidationError
 
 from holmes.common.env_vars import TOOL_CALL_SAFEGUARDS_ENABLED
-from holmes.plugins.toolsets.logging_utils.logging_api import POD_LOGGING_TOOL_NAME
-from holmes.core.tools import StructuredToolResult, ToolResultStatus
-from holmes.plugins.toolsets.logging_utils.logging_api import FetchPodLogsParams
+from holmes.core.tools import StructuredToolResult, StructuredToolResultStatus
+from holmes.plugins.toolsets.logging_utils.logging_api import (
+    POD_LOGGING_TOOL_NAME,
+    FetchPodLogsParams,
+)
 
 
 def _is_redundant_fetch_pod_logs(
@@ -39,7 +41,7 @@ def _has_previous_unfiltered_pod_logs_call(
             result = tool_call.get("result", {})
             if (
                 tool_call.get("tool_name") == POD_LOGGING_TOOL_NAME
-                and result.get("status") == ToolResultStatus.NO_DATA
+                and result.get("status") == StructuredToolResultStatus.NO_DATA
                 and result.get("params")
             ):
                 params = FetchPodLogsParams(**result.get("params"))
@@ -94,7 +96,7 @@ def prevent_overly_repeated_tool_call(
                 For example if Holmes checks if a resource is deployed, runs a command to deploy it and then checks again if it has deployed properly.
             """
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=(
                     "Refusing to run this tool call because it has already been called during this session with the exact same parameters.\n"
                     "Move on with your investigation to a different tool or change the parameter values."
@@ -106,7 +108,7 @@ def prevent_overly_repeated_tool_call(
             tool_name=tool_name, tool_params=tool_params, tool_calls=tool_calls
         ):
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=(
                     f"Refusing to run this tool call because the exact same {POD_LOGGING_TOOL_NAME} tool call without filter has already run and returned no data.\n"
                     "This tool call would also have returned no data.\n"