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

holmes/__init__.py

@@ -1,8 +1,6 @@
 # This is patched by github actions during release
-__version__ = "0.16.2-alpha"
+__version__ = "0.18.4"
 
 # Re-export version functions from version module for backward compatibility
-from .version import (
-    get_version as get_version,
-    is_official_release as is_official_release,
-)
+from .version import get_version as get_version
+from .version import is_official_release as is_official_release

holmes/clients/robusta_client.py

@@ -1,8 +1,10 @@
 import logging
-from typing import Optional, Dict, Any
-import requests  # type: ignore
 from functools import cache
+from typing import Any, Dict, Optional
+
+import requests  # type: ignore
 from pydantic import BaseModel, ConfigDict
+
 from holmes.common.env_vars import ROBUSTA_API_ENDPOINT
 
 HOLMES_GET_INFO_URL = f"{ROBUSTA_API_ENDPOINT}/api/holmes/get_info"
@@ -25,7 +27,6 @@ class RobustaModelsResponse(BaseModel):
     models: Dict[str, RobustaModel]
 
 
-@cache
 def fetch_robusta_models(
     account_id: str, token: str
 ) -> Optional[RobustaModelsResponse]:

holmes/common/env_vars.py

@@ -1,5 +1,6 @@
-import os
 import json
+import os
+import platform
 from typing import Optional
 
 # Recommended models for different providers
@@ -35,7 +36,6 @@ STORE_URL = os.environ.get("STORE_URL", "")
 STORE_API_KEY = os.environ.get("STORE_API_KEY", "")
 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")
@@ -53,6 +53,15 @@ THINKING = os.environ.get("THINKING", "")
 REASONING_EFFORT = os.environ.get("REASONING_EFFORT", "").strip().lower()
 TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.00000001"))
 
+# Set default memory limit based on CPU architecture
+# ARM architectures typically need more memory
+_default_memory_limit = (
+    1500 if platform.machine().lower() in ("arm64", "aarch64", "arm") else 800
+)
+TOOL_MEMORY_LIMIT_MB = int(
+    os.environ.get("TOOL_MEMORY_LIMIT_MB", _default_memory_limit)
+)
+
 STREAM_CHUNKS_PER_PARSE = int(
     os.environ.get("STREAM_CHUNKS_PER_PARSE", 80)
 )  # Empirical value with 6~ parsing calls. Consider using larger value if LLM response is long as to reduce markdown to section calls.
@@ -113,3 +122,10 @@ RESET_REPEATED_TOOL_CALL_CHECK_AFTER_COMPACTION = load_bool(
 )
 
 SSE_READ_TIMEOUT = float(os.environ.get("SSE_READ_TIMEOUT", "120"))
+
+LLM_REQUEST_TIMEOUT = float(os.environ.get("LLM_REQUEST_TIMEOUT", "600"))
+
+ENABLE_CONNECTION_KEEPALIVE = load_bool("ENABLE_CONNECTION_KEEPALIVE", False)
+KEEPALIVE_IDLE = int(os.environ.get("KEEPALIVE_IDLE", 2))
+KEEPALIVE_INTVL = int(os.environ.get("KEEPALIVE_INTVL", 2))
+KEEPALIVE_CNT = int(os.environ.get("KEEPALIVE_CNT", 5))

holmes/common/openshift.py

@@ -1,5 +1,5 @@
-from typing import Optional
 import os
+from typing import Optional
 
 # NOTE: This one will be mounted if openshift is enabled in values.yaml
 TOKEN_LOCATION = os.environ.get(

holmes/config.py

@@ -84,6 +84,7 @@ class Config(RobustaBaseConfig):
     opsgenie_query: Optional[str] = None
 
     custom_runbooks: List[FilePath] = []
+    custom_runbook_catalogs: List[Union[str, FilePath]] = []
 
     # custom_toolsets is passed from config file, and be used to override built-in toolsets, provides 'stable' customized toolset.
     # The status of custom toolsets can be cached.
@@ -114,6 +115,7 @@ class Config(RobustaBaseConfig):
                 custom_toolsets=self.custom_toolsets,
                 custom_toolsets_from_cli=self.custom_toolsets_from_cli,
                 global_fast_model=self.fast_model,
+                custom_runbook_catalogs=self.custom_runbook_catalogs,
             )
         return self._toolset_manager
 
@@ -224,8 +226,9 @@ class Config(RobustaBaseConfig):
         return None
 
     def get_runbook_catalog(self) -> Optional[RunbookCatalog]:
-        # TODO(mainred): besides the built-in runbooks, we need to allow the user to bring their own runbooks
-        runbook_catalog = load_runbook_catalog(dal=self.dal)
+        runbook_catalog = load_runbook_catalog(
+            dal=self.dal, custom_catalog_paths=self.custom_runbook_catalogs
+        )
         return runbook_catalog
 
     def create_console_tool_executor(
@@ -285,12 +288,15 @@ class Config(RobustaBaseConfig):
         dal: Optional["SupabaseDal"] = None,
         refresh_toolsets: bool = False,
         tracer=None,
+        model_name: Optional[str] = None,
     ) -> "ToolCallingLLM":
         tool_executor = self.create_console_tool_executor(dal, refresh_toolsets)
         from holmes.core.tool_calling_llm import ToolCallingLLM
 
         return ToolCallingLLM(
-            tool_executor, self.max_steps, self._get_llm(tracer=tracer)
+            tool_executor,
+            self.max_steps,
+            self._get_llm(tracer=tracer, model_key=model_name),
         )
 
     def create_agui_toolcalling_llm(
@@ -344,7 +350,7 @@ class Config(RobustaBaseConfig):
         )
 
     def create_console_issue_investigator(
-        self, dal: Optional["SupabaseDal"] = None
+        self, dal: Optional["SupabaseDal"] = None, model_name: Optional[str] = None
     ) -> "IssueInvestigator":
         all_runbooks = load_builtin_runbooks()
         for runbook_path in self.custom_runbooks:
@@ -360,7 +366,7 @@ class Config(RobustaBaseConfig):
             tool_executor=tool_executor,
             runbook_manager=runbook_manager,
             max_steps=self.max_steps,
-            llm=self._get_llm(),
+            llm=self._get_llm(model_key=model_name),
             cluster_name=self.cluster_name,
         )
 
@@ -478,7 +484,6 @@ class Config(RobustaBaseConfig):
         model_params = model_entry.model_dump(exclude_none=True)
         api_base = self.api_base
         api_version = self.api_version
-
         is_robusta_model = model_params.pop("is_robusta_model", False)
         sentry_sdk.set_tag("is_robusta_model", is_robusta_model)
         if is_robusta_model:

holmes/core/conversations.py

@@ -1,18 +1,20 @@
 from typing import Dict, List, Optional
 
 import sentry_sdk
+
 from holmes.config import Config
 from holmes.core.models import (
-    ToolCallConversationResult,
     IssueChatRequest,
+    ToolCallConversationResult,
     WorkloadHealthChatRequest,
 )
-from holmes.plugins.prompts import load_and_render_prompt
+from holmes.core.prompt import generate_user_prompt
 from holmes.core.tool_calling_llm import ToolCallingLLM
+from holmes.plugins.prompts import load_and_render_prompt
 from holmes.plugins.runbooks import RunbookCatalog
 from holmes.utils.global_instructions import (
     Instructions,
-    add_runbooks_to_user_prompt,
+    generate_runbooks_args,
 )
 
 DEFAULT_TOOL_SIZE = 10000
@@ -121,11 +123,14 @@ def build_issue_chat_messages(
     tools_for_investigation = issue_chat_request.investigation_result.tools
 
     if not conversation_history or len(conversation_history) == 0:
-        user_prompt = add_runbooks_to_user_prompt(
-            user_prompt=user_prompt,
+        runbooks_ctx = generate_runbooks_args(
             runbook_catalog=runbooks,
             global_instructions=global_instructions,
         )
+        user_prompt = generate_user_prompt(
+            user_prompt,
+            runbooks_ctx,
+        )
 
         number_of_tools_for_investigation = len(tools_for_investigation)  # type: ignore
         if number_of_tools_for_investigation == 0:
@@ -208,11 +213,14 @@ def build_issue_chat_messages(
             },
         ]
 
-    user_prompt = add_runbooks_to_user_prompt(
-        user_prompt=user_prompt,
+    runbooks_ctx = generate_runbooks_args(
         runbook_catalog=runbooks,
         global_instructions=global_instructions,
     )
+    user_prompt = generate_user_prompt(
+        user_prompt,
+        runbooks_ctx,
+    )
 
     conversation_history.append(
         {
@@ -385,11 +393,14 @@ def build_chat_messages(
         runbooks=runbooks,
     )
 
-    ask = add_runbooks_to_user_prompt(
-        user_prompt=ask,
+    runbooks_ctx = generate_runbooks_args(
         runbook_catalog=runbooks,
         global_instructions=global_instructions,
     )
+    ask = generate_user_prompt(
+        ask,
+        runbooks_ctx,
+    )
 
     conversation_history.append(  # type: ignore
         {
@@ -481,11 +492,14 @@ def build_workload_health_chat_messages(
     resource = workload_health_chat_request.resource
 
     if not conversation_history or len(conversation_history) == 0:
-        user_prompt = add_runbooks_to_user_prompt(
-            user_prompt=user_prompt,
+        runbooks_ctx = generate_runbooks_args(
             runbook_catalog=runbooks,
             global_instructions=global_instructions,
         )
+        user_prompt = generate_user_prompt(
+            user_prompt,
+            runbooks_ctx,
+        )
 
         number_of_tools_for_workload = len(tools_for_workload)  # type: ignore
         if number_of_tools_for_workload == 0:
@@ -568,11 +582,14 @@ def build_workload_health_chat_messages(
             },
         ]
 
-    user_prompt = add_runbooks_to_user_prompt(
-        user_prompt=user_prompt,
+    runbooks_ctx = generate_runbooks_args(
         runbook_catalog=runbooks,
         global_instructions=global_instructions,
     )
+    user_prompt = generate_user_prompt(
+        user_prompt,
+        runbooks_ctx,
+    )
 
     conversation_history.append(
         {

holmes/core/investigation.py

@@ -1,24 +1,22 @@
 import logging
 from typing import Optional
 
-
-from holmes.common.env_vars import HOLMES_POST_PROCESSING_PROMPT
 from holmes.config import Config
-from holmes.core.investigation_structured_output import process_response_into_sections
-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.plugins.runbooks import RunbookCatalog
-from holmes.utils.global_instructions import add_runbooks_to_user_prompt
-
 from holmes.core.investigation_structured_output import (
     DEFAULT_SECTIONS,
     REQUEST_STRUCTURED_OUTPUT_FROM_LLM,
     get_output_format_for_investigation,
+    process_response_into_sections,
 )
-
+from holmes.core.issue import Issue
+from holmes.core.models import InvestigateRequest, InvestigationResult
+from holmes.core.prompt import generate_user_prompt
+from holmes.core.supabase_dal import SupabaseDal
+from holmes.core.tracing import DummySpan, SpanType
 from holmes.plugins.prompts import load_and_render_prompt
+from holmes.plugins.runbooks import RunbookCatalog
+from holmes.utils import sentry_helper
+from holmes.utils.global_instructions import generate_runbooks_args
 
 
 def investigate_issues(
@@ -31,9 +29,6 @@ def investigate_issues(
 ) -> InvestigationResult:
     context = dal.get_issue_data(investigate_request.context.get("robusta_issue_id"))
 
-    resource_instructions = dal.get_resource_instructions(
-        "alert", investigate_request.context.get("issue_type")
-    )
     global_instructions = dal.get_global_instructions_for_account()
 
     raw_data = investigate_request.model_dump()
@@ -58,8 +53,6 @@ def investigate_issues(
     investigation = ai.investigate(
         issue,
         prompt=investigate_request.prompt_template,
-        post_processing_prompt=HOLMES_POST_PROCESSING_PROMPT,
-        instructions=resource_instructions,
         global_instructions=global_instructions,
         sections=investigate_request.sections,
         trace_span=trace_span,
@@ -68,11 +61,15 @@ def investigate_issues(
 
     (text_response, sections) = process_response_into_sections(investigation.result)
 
+    if sections is None:
+        sentry_helper.capture_sections_none(content=investigation.result)
+
     logging.debug(f"text response: {text_response}")
     return InvestigationResult(
         analysis=text_response,
         sections=sections,
         tool_calls=investigation.tool_calls or [],
+        num_llm_calls=investigation.num_llm_calls,
         instructions=investigation.instructions,
         metadata=investigation.metadata,
     )
@@ -101,10 +98,6 @@ def get_investigation_context(
 
     issue_instructions = ai.runbook_manager.get_instructions_for_issue(issue)
 
-    resource_instructions = dal.get_resource_instructions(
-        "alert", investigate_request.context.get("issue_type")
-    )
-
     # This section is about setting vars to request the LLM to return structured output.
     # It does not mean that Holmes will not return structured sections for investigation as it is
     # capable of splitting the markdown into sections
@@ -140,17 +133,20 @@ def get_investigation_context(
             "runbooks_enabled": True if runbook_catalog else False,
         },
     )
-    user_prompt = ""
+    base_user = ""
 
     global_instructions = dal.get_global_instructions_for_account()
-    user_prompt = add_runbooks_to_user_prompt(
-        user_prompt=user_prompt,
+    runbooks_ctx = generate_runbooks_args(
         runbook_catalog=runbook_catalog,
         global_instructions=global_instructions,
         issue_instructions=issue_instructions,
-        resource_instructions=resource_instructions,
     )
 
-    user_prompt = f"{user_prompt}\n #This is context from the issue:\n{issue.raw}"
+    base_user = f"{base_user}\n #This is context from the issue:\n{issue.raw}"
+
+    user_prompt = generate_user_prompt(
+        base_user,
+        runbooks_ctx,
+    )
 
     return ai, system_prompt, user_prompt, response_format, sections, issue_instructions

holmes/core/investigation_structured_output.py

@@ -1,10 +1,10 @@
-import logging
-from typing import Any, Dict, Optional, Tuple
 import json
+import logging
 import re
 from contextlib import suppress
-from holmes.common.env_vars import load_bool
+from typing import Any, Dict, Optional, Tuple
 
+from holmes.common.env_vars import load_bool
 
 REQUEST_STRUCTURED_OUTPUT_FROM_LLM = load_bool(
     "REQUEST_STRUCTURED_OUTPUT_FROM_LLM", True

holmes/core/issue.py

@@ -1,7 +1,7 @@
-from strenum import StrEnum
 from typing import Optional
 
 from pydantic import BaseModel, ConfigDict
+from strenum import StrEnum
 
 
 class IssueStatus(StrEnum):

holmes/core/llm.py

@@ -1,14 +1,15 @@
 import json
 import logging
 import os
+import threading
 from abc import abstractmethod
 from math import floor
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 
 import litellm
+import sentry_sdk
 from litellm.litellm_core_utils.streaming_handler import CustomStreamWrapper
 from litellm.types.utils import ModelResponse, TextCompletionResponse
-import sentry_sdk
 from pydantic import BaseModel, ConfigDict, SecretStr
 from typing_extensions import Self
 
@@ -17,15 +18,15 @@ from holmes.clients.robusta_client import (
     RobustaModelsResponse,
     fetch_robusta_models,
 )
-
 from holmes.common.env_vars import (
+    EXTRA_HEADERS,
     FALLBACK_CONTEXT_WINDOW_SIZE,
+    LLM_REQUEST_TIMEOUT,
     LOAD_ALL_ROBUSTA_MODELS,
     REASONING_EFFORT,
     ROBUSTA_AI,
     ROBUSTA_API_ENDPOINT,
     THINKING,
-    EXTRA_HEADERS,
     TOOL_MAX_ALLOCATED_CONTEXT_WINDOW_PCT,
     TOOL_MAX_ALLOCATED_CONTEXT_WINDOW_TOKENS,
 )
@@ -396,6 +397,12 @@ class DefaultLLM(LLM):
                 "reasoning_effort"
             ]  # can be removed after next litelm version
 
+        existing_allowed = self.args.pop("allowed_openai_params", None)
+        if existing_allowed:
+            if allowed_openai_params is None:
+                allowed_openai_params = []
+            allowed_openai_params.extend(existing_allowed)
+
         self.args.setdefault("temperature", temperature)
 
         self._add_cache_control_to_last_message(messages)
@@ -414,6 +421,7 @@ class DefaultLLM(LLM):
             drop_params=drop_params,
             allowed_openai_params=allowed_openai_params,
             stream=stream,
+            timeout=LLM_REQUEST_TIMEOUT,
             **tools_args,
             **self.args,
         )
@@ -524,6 +532,7 @@ class LLMModelRegistry:
         self._llms: dict[str, ModelEntry] = {}
         self._default_robusta_model = None
         self.dal = dal
+        self._lock = threading.RLock()
 
         self._init_models()
 
@@ -549,6 +558,9 @@ class LLMModelRegistry:
 
     def _should_load_config_model(self) -> bool:
         if self.config.model is not None:
+            if self._llms and self.config.model in self._llms:
+                # model already loaded from file
+                return False
             return True
 
         # backward compatibility - in the past config.model was set by default to gpt-4o.
@@ -628,39 +640,46 @@ class LLMModelRegistry:
         return True
 
     def get_model_params(self, model_key: Optional[str] = None) -> ModelEntry:
-        if not self._llms:
-            raise Exception("No llm models were loaded")
-
-        if model_key:
-            model_params = self._llms.get(model_key)
-            if model_params is not None:
-                logging.info(f"Using selected model: {model_key}")
-                return model_params.copy()
-
-            logging.error(f"Couldn't find model: {model_key} in model list")
-
-        if self._default_robusta_model:
-            model_params = self._llms.get(self._default_robusta_model)
-            if model_params is not None:
-                logging.info(
-                    f"Using default Robusta AI model: {self._default_robusta_model}"
+        with self._lock:
+            if not self._llms:
+                raise Exception("No llm models were loaded")
+
+            if model_key:
+                model_params = self._llms.get(model_key)
+                if model_params:
+                    logging.info(f"Using selected model: {model_key}")
+                    return model_params.model_copy()
+
+                if model_key.startswith("Robusta/"):
+                    logging.warning("Resyncing Registry and Robusta models.")
+                    self._init_models()
+                    model_params = self._llms.get(model_key)
+                    if model_params:
+                        logging.info(f"Using selected model: {model_key}")
+                        return model_params.model_copy()
+
+                logging.error(f"Couldn't find model: {model_key} in model list")
+
+            if self._default_robusta_model:
+                model_params = self._llms.get(self._default_robusta_model)
+                if model_params is not None:
+                    logging.info(
+                        f"Using default Robusta AI model: {self._default_robusta_model}"
+                    )
+                    return model_params.model_copy()
+
+                logging.error(
+                    f"Couldn't find default Robusta AI model: {self._default_robusta_model} in model list"
                 )
-                return model_params.copy()
-
-            logging.error(
-                f"Couldn't find default Robusta AI model: {self._default_robusta_model} in model list"
-            )
-
-        model_key, first_model_params = next(iter(self._llms.items()))
-        logging.debug(f"Using first available model: {model_key}")
-        return first_model_params.copy()
 
-    def get_llm(self, name: str) -> LLM:  # TODO: fix logic
-        return self._llms[name]  # type: ignore
+            model_key, first_model_params = next(iter(self._llms.items()))
+            logging.debug(f"Using first available model: {model_key}")
+            return first_model_params.model_copy()
 
     @property
     def models(self) -> dict[str, ModelEntry]:
-        return self._llms
+        with self._lock:
+            return self._llms
 
     def _parse_models_file(self, path: str) -> dict[str, ModelEntry]:
         models = load_yaml_file(path, raise_error=False, warn_not_found=False)

holmes/core/models.py

@@ -1,9 +1,10 @@
 import json
-from holmes.core.investigation_structured_output import InputSectionsDataType
-from typing import Optional, List, Dict, Any, Union
-from pydantic import BaseModel, model_validator, Field
 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
 
 
@@ -32,7 +33,11 @@ class ToolCallResult(BaseModel):
             "tool_call_id": self.tool_call_id,
             "role": "tool",
             "name": self.tool_name,
-            "content": format_tool_result_data(self.result),
+            "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):
@@ -60,20 +65,16 @@ class ToolCallResult(BaseModel):
         }
 
 
-def format_tool_result_data(tool_result: StructuredToolResult) -> str:
-    tool_response = tool_result.data
-    if isinstance(tool_result.data, str):
-        tool_response = tool_result.data
-    else:
-        try:
-            if isinstance(tool_result.data, BaseModel):
-                tool_response = tool_result.data.model_dump_json(indent=2)
-            else:
-                tool_response = json.dumps(tool_result.data, indent=2)
-        except Exception:
-            tool_response = str(tool_result.data)
+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_result.data or ''}".strip()
+        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 = (
@@ -87,6 +88,7 @@ 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
 

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
 

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,
@@ -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},