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

holmes/__init__.py

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

holmes/clients/robusta_client.py

@@ -1,5 +1,5 @@
 import logging
-from typing import List, Optional
+from typing import Optional, Dict, Any
 import requests  # type: ignore
 from functools import cache
 from pydantic import BaseModel, ConfigDict
@@ -14,18 +14,31 @@ class HolmesInfo(BaseModel):
     latest_version: Optional[str] = None
 
 
+class RobustaModel(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    model: str
+    holmes_args: Optional[dict[str, Any]] = None
+    is_default: bool = False
+
+
+class RobustaModelsResponse(BaseModel):
+    models: Dict[str, RobustaModel]
+
+
 @cache
-def fetch_robusta_models(account_id, token) -> Optional[List[str]]:
+def fetch_robusta_models(
+    account_id: str, token: str
+) -> Optional[RobustaModelsResponse]:
     try:
         session_request = {"session_token": token, "account_id": account_id}
         resp = requests.post(
-            f"{ROBUSTA_API_ENDPOINT}/api/llm/models",
+            f"{ROBUSTA_API_ENDPOINT}/api/llm/models/v2",
             json=session_request,
             timeout=10,
         )
         resp.raise_for_status()
         response_json = resp.json()
-        return response_json.get("models")
+        return RobustaModelsResponse(**{"models": response_json})
     except Exception:
         logging.exception("Failed to fetch robusta models")
         return None

holmes/common/env_vars.py

@@ -2,6 +2,16 @@ import os
 import json
 from typing import Optional
 
+# Recommended models for different providers
+RECOMMENDED_OPENAI_MODEL = "gpt-4.1"
+RECOMMENDED_ANTHROPIC_MODEL = "anthropic/claude-opus-4-1-20250805"
+
+# Default model for HolmesGPT
+DEFAULT_MODEL = RECOMMENDED_OPENAI_MODEL
+FALLBACK_CONTEXT_WINDOW_SIZE = (
+    200000  # Fallback context window size if it can't be determined from the model
+)
+
 
 def load_bool(env_var, default: Optional[bool]) -> Optional[bool]:
     env_value = os.environ.get(env_var)
@@ -38,6 +48,7 @@ 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"))
 
+EXTRA_HEADERS = os.environ.get("EXTRA_HEADERS", "")
 THINKING = os.environ.get("THINKING", "")
 REASONING_EFFORT = os.environ.get("REASONING_EFFORT", "").strip().lower()
 TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.00000001"))
@@ -73,4 +84,32 @@ 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))
+MAX_GRAPH_POINTS = float(os.environ.get("MAX_GRAPH_POINTS", 100))
+
+# Limit each tool response to N% of the total context window.
+# Number between 0 and 100
+# Setting to either 0 or any number above 100 disables the logic that limits tool response size
+TOOL_MAX_ALLOCATED_CONTEXT_WINDOW_PCT = float(
+    os.environ.get("TOOL_MAX_ALLOCATED_CONTEXT_WINDOW_PCT", 15)
+)
+
+# Absolute max tokens to allocate for a single tool response
+TOOL_MAX_ALLOCATED_CONTEXT_WINDOW_TOKENS = int(
+    os.environ.get("TOOL_MAX_ALLOCATED_CONTEXT_WINDOW_TOKENS", 25000)
+)
+
+MAX_EVIDENCE_DATA_CHARACTERS_BEFORE_TRUNCATION = int(
+    os.environ.get("MAX_EVIDENCE_DATA_CHARACTERS_BEFORE_TRUNCATION", 3000)
+)
+
+ENABLE_CONVERSATION_HISTORY_COMPACTION = load_bool(
+    "ENABLE_CONVERSATION_HISTORY_COMPACTION", default=True
+)
+
+DISABLE_PROMETHEUS_TOOLSET = load_bool("DISABLE_PROMETHEUS_TOOLSET", False)
+
+RESET_REPEATED_TOOL_CALL_CHECK_AFTER_COMPACTION = load_bool(
+    "RESET_REPEATED_TOOL_CALL_CHECK_AFTER_COMPACTION", True
+)
+
+SSE_READ_TIMEOUT = float(os.environ.get("SSE_READ_TIMEOUT", "120"))

holmes/config.py

@@ -1,4 +1,3 @@
-import json
 import logging
 import os
 import os.path
@@ -6,18 +5,12 @@ from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, List, Optional, Union
 
+import sentry_sdk
 import yaml  # type: ignore
-from pydantic import BaseModel, ConfigDict, FilePath, SecretStr
+from pydantic import BaseModel, ConfigDict, FilePath, PrivateAttr, SecretStr
 
-
-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.common.env_vars import ROBUSTA_CONFIG_PATH
+from holmes.core.llm import DefaultLLM, LLMModelRegistry
 from holmes.core.tools_utils.tool_executor import ToolExecutor
 from holmes.core.toolset_manager import ToolsetManager
 from holmes.plugins.runbooks import (
@@ -29,7 +22,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.tool_calling_llm import IssueInvestigator, ToolCallingLLM
     from holmes.plugins.destinations.slack import SlackDestination
     from holmes.plugins.sources.github import GitHubSource
@@ -38,18 +30,12 @@ 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.core.supabase_dal import SupabaseDal
 from holmes.utils.definitions import RobustaConfig
-from holmes.utils.env import replace_env_vars_values
-from holmes.utils.file_utils import load_yaml_file
 from holmes.utils.pydantic_utils import RobustaBaseConfig, load_model_from_file
 
 DEFAULT_CONFIG_LOCATION = os.path.join(config_path_dir, "config.yaml")
-MODEL_LIST_FILE_LOCATION = os.environ.get(
-    "MODEL_LIST_FILE_LOCATION", "/etc/holmes/config/model_list.yaml"
-)
-ROBUSTA_AI_MODEL_NAME = "Robusta"
 
 
 class SupportedTicketSources(str, Enum):
@@ -57,32 +43,14 @@ class SupportedTicketSources(str, Enum):
     PAGERDUTY = "pagerduty"
 
 
-def is_old_toolset_config(
-    toolsets: Union[dict[str, dict[str, Any]], List[dict[str, Any]]],
-) -> bool:
-    # old config is a list of toolsets
-    if isinstance(toolsets, list):
-        return True
-    return False
-
-
-def parse_models_file(path: str):
-    models = load_yaml_file(path, raise_error=False, warn_not_found=False)
-
-    for _, params in models.items():
-        params = replace_env_vars_values(params)
-
-    return models
-
-
 class Config(RobustaBaseConfig):
+    model: Optional[str] = None
     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"
+    api_base: Optional[str] = None
+    api_version: Optional[str] = None
+    fast_model: Optional[str] = None
     max_steps: int = 40
     cluster_name: Optional[str] = None
 
@@ -123,14 +91,19 @@ class Config(RobustaBaseConfig):
     # custom_toolsets_from_cli is passed from CLI option `--custom-toolsets` as 'experimental' custom toolsets.
     # The status of toolset here won't be cached, so the toolset from cli will always be loaded when specified in the CLI.
     custom_toolsets_from_cli: Optional[List[FilePath]] = None
-    should_try_robusta_ai: bool = False  # if True, we will try to load the Robusta AI model, in cli we aren't trying to load it.
+    # if True, we will try to load the Robusta AI model, in cli we aren't trying to load it.
+    should_try_robusta_ai: bool = False
 
     toolsets: Optional[dict[str, dict[str, Any]]] = None
     mcp_servers: Optional[dict[str, dict[str, Any]]] = None
 
     _server_tool_executor: Optional[ToolExecutor] = None
+    _agui_tool_executor: Optional[ToolExecutor] = None
 
-    _toolset_manager: Optional[ToolsetManager] = None
+    # TODO: Separate those fields to facade class, this shouldn't be part of the config.
+    _toolset_manager: Optional[ToolsetManager] = PrivateAttr(None)
+    _llm_model_registry: Optional[LLMModelRegistry] = PrivateAttr(None)
+    _dal: Optional[SupabaseDal] = PrivateAttr(None)
 
     @property
     def toolset_manager(self) -> ToolsetManager:
@@ -140,80 +113,29 @@ class Config(RobustaBaseConfig):
                 mcp_servers=self.mcp_servers,
                 custom_toolsets=self.custom_toolsets,
                 custom_toolsets_from_cli=self.custom_toolsets_from_cli,
+                global_fast_model=self.fast_model,
             )
         return self._toolset_manager
 
-    def model_post_init(self, __context: Any) -> None:
-        self._model_list = parse_models_file(MODEL_LIST_FILE_LOCATION)
-
-        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
+    @property
+    def dal(self) -> SupabaseDal:
+        if not self._dal:
+            self._dal = SupabaseDal(self.cluster_name)  # type: ignore
+        return self._dal
 
-            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:
-        if not self.should_try_robusta_ai:
-            return False
-
-        # ROBUSTA_AI were set in the env vars, so we can use it directly
-        if ROBUSTA_AI is not None:
-            return ROBUSTA_AI
-
-        # MODEL is set in the env vars, e.g. the user is using a custom model
-        # so we don't need to load the robusta AI model and keep the behavior backward compatible
-        if "MODEL" in os.environ:
-            return False
-
-        # if the user has provided a model list, we don't need to load the robusta AI model
-        if self._model_list:
-            return False
-
-        return True
+    @property
+    def llm_model_registry(self) -> LLMModelRegistry:
+        if not self._llm_model_registry:
+            self._llm_model_registry = LLMModelRegistry(self, dal=self.dal)
+        return self._llm_model_registry
 
     def log_useful_info(self):
-        if self._model_list:
-            logging.info(f"loaded models: {list(self._model_list.keys())}")
+        if self.llm_model_registry.models:
+            logging.info(
+                f"Loaded models: {list(self.llm_model_registry.models.keys())}"
+            )
+        else:
+            logging.warning("No llm models were loaded")
 
     @classmethod
     def load_from_file(cls, config_file: Optional[Path], **kwargs) -> "Config":
@@ -227,6 +149,7 @@ class Config(RobustaBaseConfig):
         Returns:
             Config instance with merged settings
         """
+
         config_from_file: Optional[Config] = None
         if config_file is not None and config_file.exists():
             logging.debug(f"Loading config from {config_file}")
@@ -250,7 +173,10 @@ class Config(RobustaBaseConfig):
         kwargs = {}
         for field_name in [
             "model",
+            "fast_model",
             "api_key",
+            "api_base",
+            "api_version",
             "max_steps",
             "alertmanager_url",
             "alertmanager_username",
@@ -297,10 +223,9 @@ class Config(RobustaBaseConfig):
 
         return None
 
-    @staticmethod
-    def get_runbook_catalog() -> Optional[RunbookCatalog]:
+    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()
+        runbook_catalog = load_runbook_catalog(dal=self.dal)
         return runbook_catalog
 
     def create_console_tool_executor(
@@ -320,6 +245,23 @@ class Config(RobustaBaseConfig):
         )
         return ToolExecutor(cli_toolsets)
 
+    def create_agui_tool_executor(self, dal: Optional["SupabaseDal"]) -> ToolExecutor:
+        """
+        Creates ToolExecutor for the AG-UI server endpoints
+        """
+
+        if self._agui_tool_executor:
+            return self._agui_tool_executor
+
+        # Use same toolset as CLI for AG-UI front-end.
+        agui_toolsets = self.toolset_manager.list_console_toolsets(
+            dal=dal, refresh_status=True
+        )
+
+        self._agui_tool_executor = ToolExecutor(agui_toolsets)
+
+        return self._agui_tool_executor
+
     def create_tool_executor(self, dal: Optional["SupabaseDal"]) -> ToolExecutor:
         """
         Creates ToolExecutor for the server endpoints
@@ -351,6 +293,19 @@ class Config(RobustaBaseConfig):
             tool_executor, self.max_steps, self._get_llm(tracer=tracer)
         )
 
+    def create_agui_toolcalling_llm(
+        self,
+        dal: Optional["SupabaseDal"] = None,
+        model: Optional[str] = None,
+        tracer=None,
+    ) -> "ToolCallingLLM":
+        tool_executor = self.create_agui_tool_executor(dal)
+        from holmes.core.tool_calling_llm import ToolCallingLLM
+
+        return ToolCallingLLM(
+            tool_executor, self.max_steps, self._get_llm(model, tracer)
+        )
+
     def create_toolcalling_llm(
         self,
         dal: Optional["SupabaseDal"] = None,
@@ -516,39 +471,54 @@ class Config(RobustaBaseConfig):
             raise ValueError("--slack-channel must be specified")
         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: Optional[str] = None
-        model = self.model
-        model_params = {}
-        if self._model_list:
-            # get requested model or the first credentials if no model requested.
-            model_params = (
-                self._model_list.get(model_key, {}).copy()
-                if model_key
-                else next(iter(self._model_list.values())).copy()
-            )
-            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)
-            model = model_params.pop("model", model)
-
-        return DefaultLLM(model, api_key, model_params, tracer)  # type: ignore
+    # TODO: move this to the llm model registry
+    def _get_llm(self, model_key: Optional[str] = None, tracer=None) -> "DefaultLLM":
+        sentry_sdk.set_tag("requested_model", model_key)
+        model_entry = self.llm_model_registry.get_model_params(model_key)
+        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:
+            # we set here the api_key since it is being refresh when exprided and not as part of the model loading.
+            account_id, token = self.dal.get_ai_credentials()
+            api_key = f"{account_id} {token}"
+        else:
+            api_key = model_params.pop("api_key", None)
+            if api_key is not None:
+                api_key = api_key.get_secret_value()
+
+        model = model_params.pop("model")
+        # It's ok if the model does not have api base and api version, which are defaults to None.
+        # Handle both api_base and base_url - api_base takes precedence
+        model_api_base = model_params.pop("api_base", None)
+        model_base_url = model_params.pop("base_url", None)
+        api_base = model_api_base or model_base_url or api_base
+        api_version = model_params.pop("api_version", api_version)
+        model_name = model_params.pop("name", None) or model_key or model
+        sentry_sdk.set_tag("model_name", model_name)
+        llm = DefaultLLM(
+            model=model,
+            api_key=api_key,
+            api_base=api_base,
+            api_version=api_version,
+            args=model_params,
+            tracer=tracer,
+            name=model_name,
+            is_robusta_model=is_robusta_model,
+        )  # type: ignore
+        logging.info(
+            f"Using model: {model_name} ({llm.get_context_window_size():,} total tokens, {llm.get_maximum_output_token():,} output tokens)"
+        )
+        return llm
 
     def get_models_list(self) -> List[str]:
-        if self._model_list:
-            return json.dumps(list(self._model_list.keys()))  # type: ignore
-
-        return json.dumps([self.model])  # type: ignore
+        if self.llm_model_registry and self.llm_model_registry.models:
+            return list(self.llm_model_registry.models.keys())
 
-    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)
+        return []
 
 
 class TicketSource(BaseModel):