holmesgpt 0.12.6__py3-none-any.whl → 0.13.1__py3-none-any.whl

holmes/__init__.py

@@ -1,5 +1,5 @@
 # This is patched by github actions during release
-__version__ = "0.12.6"
+__version__ = "0.13.1"
 
 # Re-export version functions from version module for backward compatibility
 from .version import (

holmes/clients/robusta_client.py

@@ -1,4 +1,5 @@
-from typing import Optional
+import logging
+from typing import List, Optional
 import requests  # type: ignore
 from functools import cache
 from pydantic import BaseModel, ConfigDict
@@ -13,6 +14,23 @@ class HolmesInfo(BaseModel):
     latest_version: Optional[str] = None
 
 
+@cache
+def fetch_robusta_models(account_id, token) -> Optional[List[str]]:
+    try:
+        session_request = {"session_token": token, "account_id": account_id}
+        resp = requests.post(
+            f"{ROBUSTA_API_ENDPOINT}/api/llm/models",
+            json=session_request,
+            timeout=10,
+        )
+        resp.raise_for_status()
+        response_json = resp.json()
+        return response_json.get("models")
+    except Exception:
+        logging.exception("Failed to fetch robusta models")
+        return None
+
+
 @cache
 def fetch_holmes_info() -> Optional[HolmesInfo]:
     try:

holmes/common/env_vars.py

@@ -27,16 +27,19 @@ STORE_EMAIL = os.environ.get("STORE_EMAIL", "")
 STORE_PASSWORD = os.environ.get("STORE_PASSWORD", "")
 HOLMES_POST_PROCESSING_PROMPT = os.environ.get("HOLMES_POST_PROCESSING_PROMPT", "")
 ROBUSTA_AI = load_bool("ROBUSTA_AI", None)
+LOAD_ALL_ROBUSTA_MODELS = load_bool("LOAD_ALL_ROBUSTA_MODELS", True)
 ROBUSTA_API_ENDPOINT = os.environ.get("ROBUSTA_API_ENDPOINT", "https://api.robusta.dev")
 
 LOG_PERFORMANCE = os.environ.get("LOG_PERFORMANCE", None)
 
 
 ENABLE_TELEMETRY = load_bool("ENABLE_TELEMETRY", False)
+DEVELOPMENT_MODE = load_bool("DEVELOPMENT_MODE", False)
 SENTRY_DSN = os.environ.get("SENTRY_DSN", "")
 SENTRY_TRACES_SAMPLE_RATE = float(os.environ.get("SENTRY_TRACES_SAMPLE_RATE", "0.0"))
 
 THINKING = os.environ.get("THINKING", "")
+REASONING_EFFORT = os.environ.get("REASONING_EFFORT", "").strip().lower()
 TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.00000001"))
 
 STREAM_CHUNKS_PER_PARSE = int(
@@ -50,3 +53,17 @@ KUBERNETES_LOGS_TIMEOUT_SECONDS = int(
 
 TOOL_CALL_SAFEGUARDS_ENABLED = load_bool("TOOL_CALL_SAFEGUARDS_ENABLED", True)
 IS_OPENSHIFT = load_bool("IS_OPENSHIFT", False)
+
+LLMS_WITH_STRICT_TOOL_CALLS = os.environ.get(
+    "LLMS_WITH_STRICT_TOOL_CALLS", "azure/gpt-4o, openai/*"
+)
+TOOL_SCHEMA_NO_PARAM_OBJECT_IF_NO_PARAMS = load_bool(
+    "TOOL_SCHEMA_NO_PARAM_OBJECT_IF_NO_PARAMS", False
+)
+
+MAX_OUTPUT_TOKEN_RESERVATION = int(
+    os.environ.get("MAX_OUTPUT_TOKEN_RESERVATION", 16384)
+)  ## 16k
+
+# When using the bash tool, setting BASH_TOOL_UNSAFE_ALLOW_ALL will skip any command validation and run any command requested by the LLM
+BASH_TOOL_UNSAFE_ALLOW_ALL = load_bool("BASH_TOOL_UNSAFE_ALLOW_ALL", False)

holmes/config.py

@@ -9,7 +9,15 @@ from typing import TYPE_CHECKING, Any, List, Optional, Union
 import yaml  # type: ignore
 from pydantic import BaseModel, ConfigDict, FilePath, SecretStr
 
-from holmes.common.env_vars import ROBUSTA_AI, ROBUSTA_API_ENDPOINT, ROBUSTA_CONFIG_PATH
+
+from holmes.clients.robusta_client import fetch_robusta_models
+from holmes.core.llm import DefaultLLM
+from holmes.common.env_vars import (
+    ROBUSTA_AI,
+    LOAD_ALL_ROBUSTA_MODELS,
+    ROBUSTA_API_ENDPOINT,
+    ROBUSTA_CONFIG_PATH,
+)
 from holmes.core.tools_utils.tool_executor import ToolExecutor
 from holmes.core.toolset_manager import ToolsetManager
 from holmes.plugins.runbooks import (
@@ -22,7 +30,6 @@ from holmes.plugins.runbooks import (
 # Source plugin imports moved to their respective create methods to speed up startup
 if TYPE_CHECKING:
     from holmes.core.llm import LLM
-    from holmes.core.supabase_dal import SupabaseDal
     from holmes.core.tool_calling_llm import IssueInvestigator, ToolCallingLLM
     from holmes.plugins.destinations.slack import SlackDestination
     from holmes.plugins.sources.github import GitHubSource
@@ -31,6 +38,7 @@ if TYPE_CHECKING:
     from holmes.plugins.sources.pagerduty import PagerDutySource
     from holmes.plugins.sources.prometheus.plugin import AlertManagerSource
 
+from holmes.core.supabase_dal import SupabaseDal
 from holmes.core.config import config_path_dir
 from holmes.utils.definitions import RobustaConfig
 from holmes.utils.env import replace_env_vars_values
@@ -71,8 +79,11 @@ class Config(RobustaBaseConfig):
     api_key: Optional[SecretStr] = (
         None  # if None, read from OPENAI_API_KEY or AZURE_OPENAI_ENDPOINT env var
     )
+    account_id: Optional[str] = None
+    session_token: Optional[SecretStr] = None
+
     model: Optional[str] = "gpt-4o"
-    max_steps: int = 10
+    max_steps: int = 40
     cluster_name: Optional[str] = None
 
     alertmanager_url: Optional[str] = None
@@ -134,10 +145,51 @@ class Config(RobustaBaseConfig):
 
     def model_post_init(self, __context: Any) -> None:
         self._model_list = parse_models_file(MODEL_LIST_FILE_LOCATION)
-        if self._should_load_robusta_ai():
-            logging.info("Loading Robusta AI model")
+
+        if not self._should_load_robusta_ai():
+            return
+
+        self.configure_robusta_ai_model()
+
+    def configure_robusta_ai_model(self) -> None:
+        try:
+            if not self.cluster_name or not LOAD_ALL_ROBUSTA_MODELS:
+                self._load_default_robusta_config()
+                return
+
+            if not self.api_key:
+                dal = SupabaseDal(self.cluster_name)
+                self.load_robusta_api_key(dal)
+
+            if not self.account_id or not self.session_token:
+                self._load_default_robusta_config()
+                return
+
+            models = fetch_robusta_models(
+                self.account_id, self.session_token.get_secret_value()
+            )
+            if not models:
+                self._load_default_robusta_config()
+                return
+
+            for model in models:
+                logging.info(f"Loading Robusta AI model: {model}")
+                self._model_list[model] = {
+                    "base_url": f"{ROBUSTA_API_ENDPOINT}/llm/{model}",
+                    "is_robusta_model": True,
+                }
+
+        except Exception:
+            logging.exception("Failed to get all robusta models")
+            # fallback to default behavior
+            self._load_default_robusta_config()
+
+    def _load_default_robusta_config(self):
+        if self._should_load_robusta_ai() and self.api_key:
+            logging.info("Loading default Robusta AI model")
             self._model_list[ROBUSTA_AI_MODEL_NAME] = {
                 "base_url": ROBUSTA_API_ENDPOINT,
+                "is_robusta_model": True,
             }
 
     def _should_load_robusta_ai(self) -> bool:
@@ -465,7 +517,7 @@ class Config(RobustaBaseConfig):
         return SlackDestination(self.slack_token.get_secret_value(), self.slack_channel)
 
     def _get_llm(self, model_key: Optional[str] = None, tracer=None) -> "LLM":
-        api_key = self.api_key.get_secret_value() if self.api_key else None
+        api_key: Optional[str] = None
         model = self.model
         model_params = {}
         if self._model_list:
@@ -475,11 +527,12 @@ class Config(RobustaBaseConfig):
                 if model_key
                 else next(iter(self._model_list.values())).copy()
             )
-            api_key = model_params.pop("api_key", api_key)
+            if model_params.get("is_robusta_model") and self.api_key:
+                api_key = self.api_key.get_secret_value()
+            else:
+                api_key = model_params.pop("api_key", api_key)
             model = model_params.pop("model", model)
 
-        from holmes.core.llm import DefaultLLM
-
         return DefaultLLM(model, api_key, model_params, tracer)  # type: ignore
 
     def get_models_list(self) -> List[str]:
@@ -488,6 +541,13 @@ class Config(RobustaBaseConfig):
 
         return json.dumps([self.model])  # type: ignore
 
+    def load_robusta_api_key(self, dal: SupabaseDal):
+        if ROBUSTA_AI:
+            account_id, token = dal.get_ai_credentials()
+            self.api_key = SecretStr(f"{account_id} {token}")
+            self.account_id = account_id
+            self.session_token = SecretStr(token)
+
 
 class TicketSource(BaseModel):
     config: Config

holmes/core/conversations.py

@@ -133,6 +133,7 @@ def build_issue_chat_messages(
                     "issue": issue_chat_request.issue_type,
                     "toolsets": ai.tool_executor.toolsets,
                     "cluster_name": config.cluster_name,
+                    "investigation_id": ai.investigation_id,
                 },
             )
             messages = [
@@ -153,6 +154,7 @@ def build_issue_chat_messages(
             "issue": issue_chat_request.issue_type,
             "toolsets": ai.tool_executor.toolsets,
             "cluster_name": config.cluster_name,
+            "investigation_id": ai.investigation_id,
         }
         system_prompt_without_tools = load_and_render_prompt(
             template_path, template_context_without_tools
@@ -186,6 +188,7 @@ def build_issue_chat_messages(
             "issue": issue_chat_request.issue_type,
             "toolsets": ai.tool_executor.toolsets,
             "cluster_name": config.cluster_name,
+            "investigation_id": ai.investigation_id,
         }
         system_prompt_with_truncated_tools = load_and_render_prompt(
             template_path, truncated_template_context
@@ -227,6 +230,7 @@ def build_issue_chat_messages(
         "issue": issue_chat_request.issue_type,
         "toolsets": ai.tool_executor.toolsets,
         "cluster_name": config.cluster_name,
+        "investigation_id": ai.investigation_id,
     }
     system_prompt_without_tools = load_and_render_prompt(
         template_path, template_context_without_tools
@@ -250,6 +254,7 @@ def build_issue_chat_messages(
         "issue": issue_chat_request.issue_type,
         "toolsets": ai.tool_executor.toolsets,
         "cluster_name": config.cluster_name,
+        "investigation_id": ai.investigation_id,
     }
     system_prompt_with_truncated_tools = load_and_render_prompt(
         template_path, template_context
@@ -274,6 +279,7 @@ def add_or_update_system_prompt(
     context = {
         "toolsets": ai.tool_executor.toolsets,
         "cluster_name": config.cluster_name,
+        "investigation_id": ai.investigation_id,
     }
 
     system_prompt = load_and_render_prompt(template_path, context)
@@ -465,6 +471,7 @@ def build_workload_health_chat_messages(
                     "resource": resource,
                     "toolsets": ai.tool_executor.toolsets,
                     "cluster_name": config.cluster_name,
+                    "investigation_id": ai.investigation_id,
                 },
             )
             messages = [
@@ -485,6 +492,7 @@ def build_workload_health_chat_messages(
             "resource": resource,
             "toolsets": ai.tool_executor.toolsets,
             "cluster_name": config.cluster_name,
+            "investigation_id": ai.investigation_id,
         }
         system_prompt_without_tools = load_and_render_prompt(
             template_path, template_context_without_tools
@@ -518,6 +526,7 @@ def build_workload_health_chat_messages(
             "resource": resource,
             "toolsets": ai.tool_executor.toolsets,
             "cluster_name": config.cluster_name,
+            "investigation_id": ai.investigation_id,
         }
         system_prompt_with_truncated_tools = load_and_render_prompt(
             template_path, truncated_template_context
@@ -559,6 +568,7 @@ def build_workload_health_chat_messages(
         "resource": resource,
         "toolsets": ai.tool_executor.toolsets,
         "cluster_name": config.cluster_name,
+        "investigation_id": ai.investigation_id,
     }
     system_prompt_without_tools = load_and_render_prompt(
         template_path, template_context_without_tools
@@ -582,6 +592,7 @@ def build_workload_health_chat_messages(
         "resource": resource,
         "toolsets": ai.tool_executor.toolsets,
         "cluster_name": config.cluster_name,
+        "investigation_id": ai.investigation_id,
     }
     system_prompt_with_truncated_tools = load_and_render_prompt(
         template_path, template_context

holmes/core/investigation.py

@@ -7,8 +7,9 @@ from holmes.core.investigation_structured_output import process_response_into_se
 from holmes.core.issue import Issue
 from holmes.core.models import InvestigateRequest, InvestigationResult
 from holmes.core.supabase_dal import SupabaseDal
+from holmes.core.tracing import DummySpan, SpanType
 from holmes.utils.global_instructions import add_global_instructions_to_user_prompt
-from holmes.utils.robusta import load_robusta_api_key
+from holmes.core.todo_manager import get_todo_manager
 
 from holmes.core.investigation_structured_output import (
     DEFAULT_SECTIONS,
@@ -24,8 +25,9 @@ def investigate_issues(
     dal: SupabaseDal,
     config: Config,
     model: Optional[str] = None,
+    trace_span=DummySpan(),
 ) -> InvestigationResult:
-    load_robusta_api_key(dal=dal, config=config)
+    config.load_robusta_api_key(dal=dal)
     context = dal.get_issue_data(investigate_request.context.get("robusta_issue_id"))
 
     resource_instructions = dal.get_resource_instructions(
@@ -37,7 +39,12 @@ def investigate_issues(
     if context:
         raw_data["extra_context"] = context
 
+    # If config is not preinitilized
+    create_issue_investigator_span = trace_span.start_span(
+        "create_issue_investigator", SpanType.FUNCTION.value
+    )
     ai = config.create_issue_investigator(dal=dal, model=model)
+    create_issue_investigator_span.end()
 
     issue = Issue(
         id=context["id"] if context else "",
@@ -54,6 +61,7 @@ def investigate_issues(
         instructions=resource_instructions,
         global_instructions=global_instructions,
         sections=investigate_request.sections,
+        trace_span=trace_span,
     )
 
     (text_response, sections) = process_response_into_sections(investigation.result)
@@ -73,7 +81,7 @@ def get_investigation_context(
     config: Config,
     request_structured_output_from_llm: Optional[bool] = None,
 ):
-    load_robusta_api_key(dal=dal, config=config)
+    config.load_robusta_api_key(dal=dal)
     ai = config.create_issue_investigator(dal=dal, model=investigate_request.model)
 
     raw_data = investigate_request.model_dump()
@@ -125,6 +133,9 @@ def get_investigation_context(
     else:
         logging.info("Structured output is disabled for this request")
 
+    todo_manager = get_todo_manager()
+    todo_context = todo_manager.format_tasks_for_prompt(ai.investigation_id)
+
     system_prompt = load_and_render_prompt(
         investigate_request.prompt_template,
         {
@@ -133,6 +144,8 @@ def get_investigation_context(
             "structured_output": request_structured_output_from_llm,
             "toolsets": ai.tool_executor.toolsets,
             "cluster_name": config.cluster_name,
+            "todo_list": todo_context,
+            "investigation_id": ai.investigation_id,
         },
     )
 

holmes/core/investigation_structured_output.py

@@ -177,6 +177,18 @@ def pre_format_sections(response: Any) -> Any:
         # In that case it gets parsed once to get rid of the first level of marshalling
         with suppress(Exception):
             response = json.loads(response)
+
+    # Try to find any embedded code block with or without "json" label and parse it
+    # This has been seen a lot in newer bedrock models
+    # This is a more robust check for patterns like ```json\n{...}\n``` or ```\n{...}\n```
+    matches = re.findall(r"```(?:json)?\s*\n(.*?)\n```", response, re.DOTALL)
+    for block in matches:
+        with suppress(Exception):
+            parsed = json.loads(block)
+            if isinstance(parsed, dict):
+                logging.info("Extracted and parsed embedded JSON block successfully.")
+                return json.dumps(parsed)
+
     return response
 
 

holmes/core/llm.py

@@ -11,6 +11,7 @@ from pydantic import BaseModel
 import litellm
 import os
 from holmes.common.env_vars import (
+    REASONING_EFFORT,
     THINKING,
 )
 
@@ -118,7 +119,9 @@ class DefaultLLM(LLM):
                     "environment variable for proper functionality. For more information, refer to the documentation: "
                     "https://docs.litellm.ai/docs/providers/watsonx#usage---models-in-deployment-spaces"
                 )
-        elif provider == "bedrock" and os.environ.get("AWS_PROFILE"):
+        elif provider == "bedrock" and (
+            os.environ.get("AWS_PROFILE") or os.environ.get("AWS_BEARER_TOKEN_BEDROCK")
+        ):
             model_requirements = {"keys_in_environment": True, "missing_keys": []}
         else:
             #
@@ -207,6 +210,8 @@ class DefaultLLM(LLM):
         stream: Optional[bool] = None,
     ) -> Union[ModelResponse, CustomStreamWrapper]:
         tools_args = {}
+        allowed_openai_params = None
+
         if tools and len(tools) > 0 and tool_choice == "auto":
             tools_args["tools"] = tools
             tools_args["tool_choice"] = tool_choice  # type: ignore
@@ -217,6 +222,12 @@ class DefaultLLM(LLM):
         if self.args.get("thinking", None):
             litellm.modify_params = True
 
+        if REASONING_EFFORT:
+            self.args.setdefault("reasoning_effort", REASONING_EFFORT)
+            allowed_openai_params = [
+                "reasoning_effort"
+            ]  # can be removed after next litelm version
+
         self.args.setdefault("temperature", temperature)
         # Get the litellm module to use (wrapped or unwrapped)
         litellm_to_use = self.tracer.wrap_llm(litellm) if self.tracer else litellm
@@ -227,6 +238,7 @@ class DefaultLLM(LLM):
             messages=messages,
             response_format=response_format,
             drop_params=drop_params,
+            allowed_openai_params=allowed_openai_params,
             stream=stream,
             **tools_args,
             **self.args,

holmes/core/models.py

@@ -1,7 +1,7 @@
 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
+from pydantic import BaseModel, model_validator, Field
 from enum import Enum
 
 
@@ -89,6 +89,7 @@ class ConversationRequest(BaseModel):
 class ChatRequestBaseModel(BaseModel):
     conversation_history: Optional[list[dict]] = None
     model: Optional[str] = None
+    stream: bool = Field(default=False)
 
     # In our setup with litellm, the first message in conversation_history
     # should follow the structure [{"role": "system", "content": ...}],
@@ -150,6 +151,13 @@ class WorkloadHealthInvestigationResult(BaseModel):
     analysis: Optional[str] = None
     tools: Optional[List[ToolCallConversationResult]] = []
 
+    @model_validator(mode="before")
+    def check_analysis_and_result(cls, values):
+        if "result" in values and "analysis" not in values:
+            values["analysis"] = values["result"]
+            del values["result"]
+        return values
+
 
 class WorkloadHealthChatRequest(ChatRequestBaseModel):
     ask: str

holmes/core/openai_formatting.py

@@ -1,33 +1,87 @@
 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,
+)
+from holmes.utils.llms import model_matches_list
 
 # parses both simple types: "int", "array", "string"
 # but also arrays of those simpler types: "array[int]", "array[string]", etc.
 pattern = r"^(array\[(?P<inner_type>\w+)\])|(?P<simple_type>\w+)$"
 
+LLMS_WITH_STRICT_TOOL_CALLS_LIST = [
+    llm.strip() for llm in LLMS_WITH_STRICT_TOOL_CALLS.split(",")
+]
+
 
-def type_to_open_ai_schema(type_value):
-    match = re.match(pattern, type_value.strip())
+def type_to_open_ai_schema(param_attributes: Any, strict_mode: bool) -> dict[str, Any]:
+    param_type = param_attributes.type.strip()
+    type_obj: Optional[dict[str, Any]] = None
 
-    if not match:
-        raise ValueError(f"Invalid type format: {type_value}")
+    if param_type == "object":
+        type_obj = {"type": "object"}
+        if strict_mode:
+            type_obj["additionalProperties"] = False
 
-    if match.group("inner_type"):
-        return {"type": "array", "items": {"type": match.group("inner_type")}}
+        # Use explicit properties if provided
+        if hasattr(param_attributes, "properties") and param_attributes.properties:
+            type_obj["properties"] = {
+                name: type_to_open_ai_schema(prop, strict_mode)
+                for name, prop in param_attributes.properties.items()
+            }
+            if strict_mode:
+                type_obj["required"] = list(param_attributes.properties.keys())
 
+    elif param_type == "array":
+        # Handle arrays with explicit item schemas
+        if hasattr(param_attributes, "items") and param_attributes.items:
+            items_schema = type_to_open_ai_schema(param_attributes.items, strict_mode)
+            type_obj = {"type": "array", "items": items_schema}
+        else:
+            # Fallback for arrays without explicit item schema
+            type_obj = {"type": "array", "items": {"type": "object"}}
+            if strict_mode:
+                type_obj["items"]["additionalProperties"] = False
     else:
-        return {"type": match.group("simple_type")}
+        match = re.match(pattern, param_type)
+
+        if not match:
+            raise ValueError(f"Invalid type format: {param_type}")
+
+        if match.group("inner_type"):
+            inner_type = match.group("inner_type")
+            if inner_type == "object":
+                raise ValueError(
+                    "object inner type must have schema. Use ToolParameter.items"
+                )
+            else:
+                type_obj = {"type": "array", "items": {"type": inner_type}}
+        else:
+            type_obj = {"type": match.group("simple_type")}
+
+    if strict_mode and type_obj and not param_attributes.required:
+        type_obj["type"] = [type_obj["type"], "null"]
+
+    return type_obj
 
 
 def format_tool_to_open_ai_standard(
-    tool_name: str, tool_description: str, tool_parameters: dict
+    tool_name: str, tool_description: str, tool_parameters: dict, target_model: str
 ):
     tool_properties = {}
+
+    strict_mode = model_matches_list(target_model, LLMS_WITH_STRICT_TOOL_CALLS_LIST)
+
     for param_name, param_attributes in tool_parameters.items():
-        tool_properties[param_name] = type_to_open_ai_schema(param_attributes.type)
+        tool_properties[param_name] = type_to_open_ai_schema(
+            param_attributes=param_attributes, strict_mode=strict_mode
+        )
         if param_attributes.description is not None:
             tool_properties[param_name]["description"] = param_attributes.description
 
-    result = {
+    result: dict[str, Any] = {
         "type": "function",
         "function": {
             "name": tool_name,
@@ -37,15 +91,21 @@ def format_tool_to_open_ai_standard(
                 "required": [
                     param_name
                     for param_name, param_attributes in tool_parameters.items()
-                    if param_attributes.required
+                    if param_attributes.required or strict_mode
                 ],
                 "type": "object",
             },
         },
     }
 
+    if strict_mode and result["function"]:
+        result["function"]["strict"] = True
+        result["function"]["parameters"]["additionalProperties"] = False
+
     # gemini doesnt have parameters object if it is without params
-    if tool_properties is None or tool_properties == {}:
+    if TOOL_SCHEMA_NO_PARAM_OBJECT_IF_NO_PARAMS and (
+        tool_properties is None or tool_properties == {}
+    ):
         result["function"].pop("parameters")  # type: ignore
 
     return result

holmes/core/prompt.py

@@ -25,11 +25,22 @@ def append_all_files_to_user_prompt(
     return user_prompt
 
 
+def get_tasks_management_system_reminder() -> str:
+    return (
+        "\n\n<system-reminder>\nIMPORTANT: You have access to the TodoWrite tool. It creates a TodoList, in order to track progress. It's very important. You MUST use it:\n1. FIRST: Ask your self which sub problems you need to solve in order to answer the question."
+        "Do this, BEFORE any other tools\n2. "
+        "AFTER EVERY TOOL CALL: If required, update the TodoList\n3. "
+        "\n\nFAILURE TO UPDATE TodoList = INCOMPLETE INVESTIGATION\n\n"
+        "Example flow:\n- Think and divide to sub problems → create TodoList → Perform each task on the list → Update list → Verify your solution\n</system-reminder>"
+    )
+
+
 def build_initial_ask_messages(
     console: Console,
     initial_user_prompt: str,
     file_paths: Optional[List[Path]],
     tool_executor: Any,  # ToolExecutor type
+    investigation_id: str,
     runbooks: Union[RunbookCatalog, Dict, None] = None,
     system_prompt_additions: Optional[str] = None,
 ) -> List[Dict]:
@@ -49,6 +60,7 @@ def build_initial_ask_messages(
         "toolsets": tool_executor.toolsets,
         "runbooks": runbooks or {},
         "system_prompt_additions": system_prompt_additions or "",
+        "investigation_id": investigation_id,
     }
     system_prompt_rendered = load_and_render_prompt(
         system_prompt_template, template_context
@@ -59,6 +71,7 @@ def build_initial_ask_messages(
         console, initial_user_prompt, file_paths
     )
 
+    user_prompt_with_files += get_tasks_management_system_reminder()
     messages = [
         {"role": "system", "content": system_prompt_rendered},
         {"role": "user", "content": user_prompt_with_files},

holmes/core/supabase_dal.py

@@ -427,6 +427,9 @@ class SupabaseDal:
         return None
 
     def get_global_instructions_for_account(self) -> Optional[Instructions]:
+        if not self.enabled:
+            return None
+
         try:
             res = (
                 self.client.table(RUNBOOKS_TABLE)