holmesgpt 0.13.1__py3-none-any.whl → 0.13.3a0__py3-none-any.whl

holmes/__init__.py

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

holmes/common/env_vars.py

@@ -67,3 +67,10 @@ MAX_OUTPUT_TOKEN_RESERVATION = int(
 
 # 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)
+
+LOG_LLM_USAGE_RESPONSE = load_bool("LOG_LLM_USAGE_RESPONSE", False)
+
+# For CLI only, enable user approval for potentially sensitive commands that would otherwise be rejected
+ENABLE_CLI_TOOL_APPROVAL = load_bool("ENABLE_CLI_TOOL_APPROVAL", True)
+
+MAX_GRAPH_POINTS = float(os.environ.get("MAX_GRAPH_POINTS", 300))

holmes/config.py

@@ -527,7 +527,9 @@ class Config(RobustaBaseConfig):
                 if model_key
                 else next(iter(self._model_list.values())).copy()
             )
-            if model_params.get("is_robusta_model") and self.api_key:
+            is_robusta_model = model_params.pop("is_robusta_model", False)
+            if is_robusta_model and self.api_key:
+                # we set here the api_key since it is being refresh when exprided and not as part of the model loading.
                 api_key = self.api_key.get_secret_value()
             else:
                 api_key = model_params.pop("api_key", api_key)

holmes/core/conversations.py

@@ -133,7 +133,6 @@ 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 = [
@@ -154,7 +153,6 @@ 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
@@ -188,7 +186,6 @@ 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
@@ -230,7 +227,6 @@ 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
@@ -254,7 +250,6 @@ 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
@@ -279,7 +274,6 @@ 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)
@@ -471,7 +465,6 @@ def build_workload_health_chat_messages(
                     "resource": resource,
                     "toolsets": ai.tool_executor.toolsets,
                     "cluster_name": config.cluster_name,
-                    "investigation_id": ai.investigation_id,
                 },
             )
             messages = [
@@ -492,7 +485,6 @@ 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
@@ -526,7 +518,6 @@ 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
@@ -568,7 +559,6 @@ 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
@@ -592,7 +582,6 @@ 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

@@ -9,7 +9,6 @@ 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.core.todo_manager import get_todo_manager
 
 from holmes.core.investigation_structured_output import (
     DEFAULT_SECTIONS,
@@ -133,9 +132,6 @@ 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,
         {
@@ -144,8 +140,6 @@ 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/llm.py

@@ -229,9 +229,11 @@ class DefaultLLM(LLM):
             ]  # can be removed after next litelm version
 
         self.args.setdefault("temperature", temperature)
+
+        self._add_cache_control_to_last_message(messages)
+
         # Get the litellm module to use (wrapped or unwrapped)
         litellm_to_use = self.tracer.wrap_llm(litellm) if self.tracer else litellm
-
         result = litellm_to_use.completion(
             model=self.model,
             api_key=self.api_key,
@@ -266,3 +268,60 @@ class DefaultLLM(LLM):
                 f"Couldn't find model's name {model_name} in litellm's model list, fallback to 4096 tokens for max_output_tokens"
             )
             return 4096
+
+    def _add_cache_control_to_last_message(
+        self, messages: List[Dict[str, Any]]
+    ) -> None:
+        """
+        Add cache_control to the last non-user message for Anthropic prompt caching.
+        Removes any existing cache_control from previous messages to avoid accumulation.
+        """
+        # First, remove any existing cache_control from all messages
+        for msg in messages:
+            content = msg.get("content")
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and "cache_control" in block:
+                        del block["cache_control"]
+                        logging.debug(
+                            f"Removed existing cache_control from {msg.get('role')} message"
+                        )
+
+        # Find the last non-user message to add cache_control to.
+        # Adding cache_control to user message requires changing its structure, so we avoid it
+        # This avoids breaking parse_messages_tags which only processes user messages
+        target_msg = None
+        for msg in reversed(messages):
+            if msg.get("role") != "user":
+                target_msg = msg
+                break
+
+        if not target_msg:
+            logging.debug("No non-user message found for cache_control")
+            return
+
+        content = target_msg.get("content")
+
+        if content is None:
+            return
+
+        if isinstance(content, str):
+            # Convert string to structured format with cache_control
+            target_msg["content"] = [
+                {
+                    "type": "text",
+                    "text": content,
+                    "cache_control": {"type": "ephemeral"},
+                }
+            ]
+            logging.debug(
+                f"Added cache_control to {target_msg.get('role')} message (converted from string)"
+            )
+        elif isinstance(content, list) and content:
+            # Add cache_control to the last content block
+            last_block = content[-1]
+            if isinstance(last_block, dict) and "type" in last_block:
+                last_block["cache_control"] = {"type": "ephemeral"}
+                logging.debug(
+                    f"Added cache_control to {target_msg.get('role')} message (structured content)"
+                )

holmes/core/prompt.py

@@ -40,7 +40,6 @@ def build_initial_ask_messages(
     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]:
@@ -60,7 +59,6 @@ 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

holmes/core/supabase_dal.py

@@ -131,7 +131,7 @@ class SupabaseDal:
                         raise Exception(
                             "No robusta token provided to Holmes.\n"
                             "Please set a valid Robusta UI token.\n "
-                            "See https://docs.robusta.dev/master/configuration/ai-analysis.html#choosing-and-configuring-an-ai-provider for instructions."
+                            "See https://holmesgpt.dev/ai-providers/ for instructions."
                         )
                     env_replacement_token = get_env_replacement(token)
                     if env_replacement_token:
@@ -143,7 +143,7 @@ class SupabaseDal:
                             "Ensure your Helm chart or environment variables are set correctly.\n "
                             "If you store the token in a secret, you must also pass "
                             "the environment variable ROBUSTA_UI_TOKEN to Holmes.\n "
-                            "See https://docs.robusta.dev/master/configuration/ai-analysis.html#configuring-holmesgpt-access-to-saas-data for instructions."
+                            "See https://holmesgpt.dev/data-sources/builtin-toolsets/robusta/ for instructions."
                         )
                     try:
                         decoded = base64.b64decode(token)

holmes/core/todo_tasks_formatter.py

@@ -0,0 +1,51 @@
+from typing import List
+
+from holmes.plugins.toolsets.investigator.model import Task, TaskStatus
+
+
+def format_tasks(tasks: List[Task]) -> str:
+    """
+    Format tasks for tool response
+    Returns empty string if no tasks exist.
+    """
+    if not tasks:
+        return ""
+
+    status_order = {
+        TaskStatus.PENDING: 0,
+        TaskStatus.IN_PROGRESS: 1,
+        TaskStatus.COMPLETED: 2,
+    }
+
+    sorted_tasks = sorted(
+        tasks,
+        key=lambda t: (status_order.get(t.status, 3),),
+    )
+
+    lines = ["# CURRENT INVESTIGATION TASKS"]
+    lines.append("")
+
+    pending_count = sum(1 for t in tasks if t.status == TaskStatus.PENDING)
+    progress_count = sum(1 for t in tasks if t.status == TaskStatus.IN_PROGRESS)
+    completed_count = sum(1 for t in tasks if t.status == TaskStatus.COMPLETED)
+
+    lines.append(
+        f"**Task Status**: {completed_count} completed, {progress_count} in progress, {pending_count} pending"
+    )
+    lines.append("")
+
+    for task in sorted_tasks:
+        status_indicator = {
+            TaskStatus.PENDING: "[ ]",
+            TaskStatus.IN_PROGRESS: "[~]",
+            TaskStatus.COMPLETED: "[✓]",
+        }.get(task.status, "[?]")
+
+        lines.append(f"{status_indicator} [{task.id}] {task.content}")
+
+    lines.append("")
+    lines.append(
+        "**Instructions**: Use TodoWrite tool to update task status as you work. Mark tasks as 'in_progress' when starting, 'completed' when finished."
+    )
+
+    return "\n".join(lines)

holmes/core/tool_calling_llm.py

@@ -2,8 +2,8 @@ import concurrent.futures
 import json
 import logging
 import textwrap
-import uuid
-from typing import Dict, List, Optional, Type, Union
+from typing import Dict, List, Optional, Type, Union, Callable
+
 
 import sentry_sdk
 from openai import BadRequestError
@@ -13,7 +13,11 @@ from openai.types.chat.chat_completion_message_tool_call import (
 from pydantic import BaseModel, Field
 from rich.console import Console
 
-from holmes.common.env_vars import TEMPERATURE, MAX_OUTPUT_TOKEN_RESERVATION
+from holmes.common.env_vars import (
+    TEMPERATURE,
+    MAX_OUTPUT_TOKEN_RESERVATION,
+    LOG_LLM_USAGE_RESPONSE,
+)
 
 from holmes.core.investigation_structured_output import (
     DEFAULT_SECTIONS,
@@ -39,9 +43,6 @@ from holmes.core.tools_utils.tool_executor import ToolExecutor
 from holmes.core.tracing import DummySpan
 from holmes.utils.colors import AI_COLOR
 from holmes.utils.stream import StreamEvents, StreamMessage
-from holmes.core.todo_manager import (
-    get_todo_manager,
-)
 
 # Create a named logger for cost tracking
 cost_logger = logging.getLogger("holmes.costs")
@@ -94,6 +95,8 @@ def _process_cost_info(
         usage = getattr(full_response, "usage", {})
 
         if usage:
+            if LOG_LLM_USAGE_RESPONSE:  # shows stats on token cache usage
+                logging.info(f"LLM usage response:\n{usage}\n")
             prompt_toks = usage.get("prompt_tokens", 0)
             completion_toks = usage.get("completion_tokens", 0)
             total_toks = usage.get("total_tokens", 0)
@@ -283,7 +286,9 @@ class ToolCallingLLM:
         self.max_steps = max_steps
         self.tracer = tracer
         self.llm = llm
-        self.investigation_id = str(uuid.uuid4())
+        self.approval_callback: Optional[
+            Callable[[StructuredToolResult], tuple[bool, Optional[str]]]
+        ] = None
 
     def prompt_call(
         self,
@@ -465,21 +470,35 @@ class ToolCallingLLM:
             perf_timing.measure("pre-tool-calls")
             with concurrent.futures.ThreadPoolExecutor(max_workers=16) as executor:
                 futures = []
+                futures_tool_numbers: dict[
+                    concurrent.futures.Future, Optional[int]
+                ] = {}
+                tool_number: Optional[int]
                 for tool_index, t in enumerate(tools_to_call, 1):
                     logging.debug(f"Tool to call: {t}")
-                    futures.append(
-                        executor.submit(
-                            self._invoke_tool,
-                            tool_to_call=t,
-                            previous_tool_calls=tool_calls,
-                            trace_span=trace_span,
-                            tool_number=tool_number_offset + tool_index,
-                        )
+                    tool_number = tool_number_offset + tool_index
+                    future = executor.submit(
+                        self._invoke_llm_tool_call,
+                        tool_to_call=t,
+                        previous_tool_calls=tool_calls,
+                        trace_span=trace_span,
+                        tool_number=tool_number,
                     )
+                    futures_tool_numbers[future] = tool_number
+                    futures.append(future)
 
                 for future in concurrent.futures.as_completed(futures):
                     tool_call_result: ToolCallResult = future.result()
 
+                    tool_number = (
+                        futures_tool_numbers[future]
+                        if future in futures_tool_numbers
+                        else None
+                    )
+                    tool_call_result = self.handle_tool_call_approval(
+                        tool_call_result=tool_call_result, tool_number=tool_number
+                    )
+
                     tool_calls.append(tool_call_result.as_tool_result_response())
                     messages.append(tool_call_result.as_tool_call_message())
 
@@ -494,7 +513,63 @@ class ToolCallingLLM:
 
         raise Exception(f"Too many LLM calls - exceeded max_steps: {i}/{max_steps}")
 
-    def _invoke_tool(
+    def _directly_invoke_tool(
+        self,
+        tool_name: str,
+        tool_params: dict,
+        user_approved: bool,
+        trace_span=DummySpan(),
+        tool_number: Optional[int] = None,
+    ) -> StructuredToolResult:
+        tool_span = trace_span.start_span(name=tool_name, type="tool")
+        tool = self.tool_executor.get_tool_by_name(tool_name)
+        tool_response = None
+        try:
+            if (not tool) or (tool_params is None):
+                logging.warning(
+                    f"Skipping tool execution for {tool_name}: args: {tool_params}"
+                )
+                tool_response = StructuredToolResult(
+                    status=ToolResultStatus.ERROR,
+                    error=f"Failed to find tool {tool_name}",
+                    params=tool_params,
+                )
+            else:
+                tool_response = tool.invoke(
+                    tool_params, tool_number=tool_number, user_approved=user_approved
+                )
+        except Exception as e:
+            logging.error(
+                f"Tool call to {tool_name} failed with an Exception", exc_info=True
+            )
+            tool_response = StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                error=f"Tool call failed: {e}",
+                params=tool_params,
+            )
+
+            # Log error to trace span
+            tool_span.log(
+                input=tool_params, output=str(e), metadata={"status": "ERROR"}
+            )
+
+        tool_span.log(
+            input=tool_params,
+            output=tool_response.data,
+            metadata={
+                "status": tool_response.status.value,
+                "error": tool_response.error,
+                "description": tool.get_parameterized_one_liner(tool_params)
+                if tool
+                else "",
+                "structured_tool_result": tool_response,
+            },
+        )
+        tool_span.end()
+
+        return tool_response
+
+    def _invoke_llm_tool_call(
         self,
         tool_to_call: ChatCompletionMessageToolCall,
         previous_tool_calls: list[dict],
@@ -523,92 +598,97 @@ class ToolCallingLLM:
                 ),
             )
 
-        tool_params = None
+        tool_params = {}
         try:
             tool_params = json.loads(tool_arguments)
         except Exception:
             logging.warning(
                 f"Failed to parse arguments for tool: {tool_name}. args: {tool_arguments}"
             )
-        tool_call_id = tool_to_call.id
-        tool = self.tool_executor.get_tool_by_name(tool_name)
 
-        if (not tool) or (tool_params is None):
-            logging.warning(
-                f"Skipping tool execution for {tool_name}: args: {tool_arguments}"
-            )
-            return ToolCallResult(
-                tool_call_id=tool_call_id,
-                tool_name=tool_name,
-                description="NA",
-                result=StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
-                    error=f"Failed to find tool {tool_name}",
-                    params=tool_params,
-                ),
-            )
-
-        tool_response = None
+        tool_call_id = tool_to_call.id
 
-        # Create tool span if tracing is enabled
-        tool_span = trace_span.start_span(name=tool_name, type="tool")
+        tool_response = prevent_overly_repeated_tool_call(
+            tool_name=tool_name,
+            tool_params=tool_params,
+            tool_calls=previous_tool_calls,
+        )
 
-        try:
-            tool_response = prevent_overly_repeated_tool_call(
-                tool_name=tool.name,
+        if not tool_response:
+            tool_response = self._directly_invoke_tool(
+                tool_name=tool_name,
                 tool_params=tool_params,
-                tool_calls=previous_tool_calls,
+                user_approved=False,
+                trace_span=trace_span,
+                tool_number=tool_number,
             )
-            if not tool_response:
-                tool_response = tool.invoke(tool_params, tool_number=tool_number)
 
-            if not isinstance(tool_response, StructuredToolResult):
-                # Should never be needed but ensure Holmes does not crash if one of the tools does not return the right type
-                logging.error(
-                    f"Tool {tool.name} return type is not StructuredToolResult. Nesting the tool result into StructuredToolResult..."
-                )
-                tool_response = StructuredToolResult(
-                    status=ToolResultStatus.SUCCESS,
-                    data=tool_response,
-                    params=tool_params,
-                )
-
-            # Log tool execution to trace span
-            tool_span.log(
-                input=tool_params,
-                output=tool_response.data,
-                metadata={
-                    "status": tool_response.status.value,
-                    "error": tool_response.error,
-                    "description": tool.get_parameterized_one_liner(tool_params),
-                    "structured_tool_result": tool_response,
-                },
-            )
-
-        except Exception as e:
+        if not isinstance(tool_response, StructuredToolResult):
+            # Should never be needed but ensure Holmes does not crash if one of the tools does not return the right type
             logging.error(
-                f"Tool call to {tool_name} failed with an Exception", exc_info=True
+                f"Tool {tool_name} return type is not StructuredToolResult. Nesting the tool result into StructuredToolResult..."
             )
             tool_response = StructuredToolResult(
-                status=ToolResultStatus.ERROR,
-                error=f"Tool call failed: {e}",
+                status=ToolResultStatus.SUCCESS,
+                data=tool_response,
                 params=tool_params,
             )
 
-            # Log error to trace span
-            tool_span.log(
-                input=tool_params, output=str(e), metadata={"status": "ERROR"}
-            )
-        finally:
-            # End tool span
-            tool_span.end()
+        tool = self.tool_executor.get_tool_by_name(tool_name)
         return ToolCallResult(
             tool_call_id=tool_call_id,
             tool_name=tool_name,
-            description=tool.get_parameterized_one_liner(tool_params),
+            description=tool.get_parameterized_one_liner(tool_params) if tool else "",
             result=tool_response,
         )
 
+    def handle_tool_call_approval(
+        self, tool_call_result: ToolCallResult, tool_number: Optional[int]
+    ) -> ToolCallResult:
+        """
+        Handle approval for a single tool call if required.
+
+        Args:
+            tool_call_result: A single tool call result that may require approval
+
+        Returns:
+            Updated tool call result with approved/denied status
+        """
+
+        if tool_call_result.result.status != ToolResultStatus.APPROVAL_REQUIRED:
+            return tool_call_result
+
+        # If no approval callback, convert to ERROR because it is assumed the client may not be able to handle approvals
+        if not self.approval_callback:
+            tool_call_result.result.status = ToolResultStatus.ERROR
+            return tool_call_result
+
+        # Get approval from user
+        approved, feedback = self.approval_callback(tool_call_result.result)
+
+        if approved:
+            logging.debug(
+                f"User approved command: {tool_call_result.result.invocation}"
+            )
+
+            new_response = self._directly_invoke_tool(
+                tool_name=tool_call_result.tool_name,
+                tool_params=tool_call_result.result.params or {},
+                user_approved=True,
+                trace_span=DummySpan(),
+                tool_number=tool_number,
+            )
+            tool_call_result.result = new_response
+        else:
+            # User denied - update to error
+            feedback_text = f" User feedback: {feedback}" if feedback else ""
+            tool_call_result.result.status = ToolResultStatus.ERROR
+            tool_call_result.result.error = (
+                f"User denied command execution.{feedback_text}"
+            )
+
+        return tool_call_result
+
     @staticmethod
     def __load_post_processing_user_prompt(
         input_prompt, investigation, user_prompt: Optional[str] = None
@@ -787,15 +867,15 @@ class ToolCallingLLM:
             with concurrent.futures.ThreadPoolExecutor(max_workers=16) as executor:
                 futures = []
                 for tool_index, t in enumerate(tools_to_call, 1):  # type: ignore
-                    futures.append(
-                        executor.submit(
-                            self._invoke_tool,
-                            tool_to_call=t,  # type: ignore
-                            previous_tool_calls=tool_calls,
-                            trace_span=DummySpan(),  # Streaming mode doesn't support tracing yet
-                            tool_number=tool_number_offset + tool_index,
-                        )
+                    tool_number = tool_number_offset + tool_index
+                    future = executor.submit(
+                        self._invoke_llm_tool_call,
+                        tool_to_call=t,  # type: ignore
+                        previous_tool_calls=tool_calls,
+                        trace_span=DummySpan(),  # Streaming mode doesn't support tracing yet
+                        tool_number=tool_number,
                     )
+                    futures.append(future)
                     yield StreamMessage(
                         event=StreamEvents.START_TOOL,
                         data={"tool_name": t.function.name, "id": t.id},
@@ -894,9 +974,6 @@ class IssueInvestigator(ToolCallingLLM):
                 "[bold]No runbooks found for this issue. Using default behaviour. (Add runbooks to guide the investigation.)[/bold]"
             )
 
-        todo_manager = get_todo_manager()
-        todo_context = todo_manager.format_tasks_for_prompt(self.investigation_id)
-
         system_prompt = load_and_render_prompt(
             prompt,
             {
@@ -905,8 +982,6 @@ class IssueInvestigator(ToolCallingLLM):
                 "structured_output": request_structured_output_from_llm,
                 "toolsets": self.tool_executor.toolsets,
                 "cluster_name": self.cluster_name,
-                "todo_list": todo_context,
-                "investigation_id": self.investigation_id,
             },
         )