holmesgpt 0.12.0__tar.gz → 0.12.1__tar.gz

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holmesgpt
-Version: 0.12.0
+Version: 0.12.1
 Summary: 
 Author: Natan Yellin
 Author-email: natan@robusta.dev
@@ -28,7 +28,7 @@ Requires-Dist: google-api-python-client (>=2.156.0,<3.0.0)
 Requires-Dist: humanize (>=4.9.0,<5.0.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
 Requires-Dist: kubernetes (>=32.0.1,<33.0.0)
-Requires-Dist: litellm (==1.66.0)
+Requires-Dist: litellm (==1.74.7)
 Requires-Dist: markdown (>=3.6,<4.0)
 Requires-Dist: markdownify (>=1.1.0,<2.0.0)
 Requires-Dist: mcp (==v1.9.0)
@@ -40,6 +40,7 @@ Requires-Dist: pydantic (>=2.7,<3.0)
 Requires-Dist: pydantic-settings (>=2.1.0,<3.0.0)
 Requires-Dist: pydash (>=8.0.1,<9.0.0)
 Requires-Dist: pyodbc (>=5.0.1,<6.0.0)
+Requires-Dist: pytest-shared-session-scope (>=0.4.0,<0.5.0)
 Requires-Dist: python-benedict (>=0.33.1,<0.34.0)
 Requires-Dist: python_multipart (>=0.0.18,<0.0.19)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)

holmesgpt-0.12.1/holmes/__init__.py

@@ -0,0 +1,8 @@
+# This is patched by github actions during release
+__version__ = "0.12.1"
+
+# 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,
+)

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/clients/robusta_client.py

@@ -5,7 +5,7 @@ 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"
-TIMEOUT = 0.3
+TIMEOUT = 0.5
 
 
 class HolmesInfo(BaseModel):

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/common/env_vars.py

@@ -49,3 +49,4 @@ KUBERNETES_LOGS_TIMEOUT_SECONDS = int(
 )
 
 TOOL_CALL_SAFEGUARDS_ENABLED = load_bool("TOOL_CALL_SAFEGUARDS_ENABLED", True)
+IS_OPENSHIFT = load_bool("IS_OPENSHIFT", False)

holmesgpt-0.12.1/holmes/common/openshift.py

@@ -0,0 +1,15 @@
+from typing import Optional
+import os
+
+# NOTE: This one will be mounted if openshift is enabled in values.yaml
+TOKEN_LOCATION = os.environ.get(
+    "TOKEN_LOCATION", "/var/run/secrets/kubernetes.io/serviceaccount/token"
+)
+
+
+def load_openshift_token() -> Optional[str]:
+    try:
+        with open(TOKEN_LOCATION, "r") as file:
+            return file.read()
+    except FileNotFoundError:
+        return None

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/config.py

@@ -9,8 +9,6 @@ from typing import Any, List, Optional, Union
 import yaml  # type: ignore
 from pydantic import BaseModel, ConfigDict, FilePath, SecretStr
 
-from holmes import get_version  # type: ignore
-from holmes.clients.robusta_client import HolmesInfo, fetch_holmes_info
 from holmes.common.env_vars import ROBUSTA_AI, ROBUSTA_API_ENDPOINT, ROBUSTA_CONFIG_PATH
 from holmes.core.llm import LLM, DefaultLLM
 from holmes.core.runbooks import RunbookManager
@@ -39,6 +37,7 @@ DEFAULT_CONFIG_LOCATION = os.path.expanduser("~/.holmes/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):
@@ -115,26 +114,8 @@ class Config(RobustaBaseConfig):
 
     _server_tool_executor: Optional[ToolExecutor] = None
 
-    _version: Optional[str] = None
-    _holmes_info: Optional[HolmesInfo] = None
-
     _toolset_manager: Optional[ToolsetManager] = None
 
-    @property
-    def is_latest_version(self) -> bool:
-        if (
-            not self._holmes_info
-            or not self._holmes_info.latest_version
-            or not self._version
-        ):
-            # We couldn't resolve version, assume we are running the latest version
-            return True
-        if self._version.startswith("dev-"):
-            # dev versions are considered to be the latest version
-            return True
-
-        return self._version.startswith(self._holmes_info.latest_version)
-
     @property
     def toolset_manager(self) -> ToolsetManager:
         if not self._toolset_manager:
@@ -146,12 +127,10 @@ class Config(RobustaBaseConfig):
         return self._toolset_manager
 
     def model_post_init(self, __context: Any) -> None:
-        self._version = get_version()
-        self._holmes_info = fetch_holmes_info()
         self._model_list = parse_models_file(MODEL_LIST_FILE_LOCATION)
         if self._should_load_robusta_ai():
             logging.info("Loading Robusta AI model")
-            self._model_list["Robusta"] = {
+            self._model_list[ROBUSTA_AI_MODEL_NAME] = {
                 "base_url": ROBUSTA_API_ENDPOINT,
             }
 
@@ -178,11 +157,6 @@ class Config(RobustaBaseConfig):
         if self._model_list:
             logging.info(f"loaded models: {list(self._model_list.keys())}")
 
-        if not self.is_latest_version and self._holmes_info:
-            logging.warning(
-                f"You are running version {self._version} of holmes, but the latest version is {self._holmes_info.latest_version}. Please update.",
-            )
-
     @classmethod
     def load_from_file(cls, config_file: Optional[Path], **kwargs) -> "Config":
         """

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/core/llm.py

@@ -140,14 +140,11 @@ class DefaultLLM(LLM):
         https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json
         """
         model_name = self.model
-        if model_name.startswith("openai/"):
-            model_name = model_name[len("openai/") :]  # Strip the 'openai/' prefix
-        elif model_name.startswith("bedrock/"):
-            model_name = model_name[len("bedrock/") :]  # Strip the 'bedrock/' prefix
-        elif model_name.startswith("vertex_ai/"):
-            model_name = model_name[
-                len("vertex_ai/") :
-            ]  # Strip the 'vertex_ai/' prefix
+        prefixes = ["openai/", "bedrock/", "vertex_ai/", "anthropic/"]
+
+        for prefix in prefixes:
+            if model_name.startswith(prefix):
+                return model_name[len(prefix) :]
 
         return model_name
 

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/core/supabase_dal.py

@@ -182,6 +182,10 @@ class SupabaseDal:
         res = self.client.auth.sign_in_with_password(
             {"email": self.email, "password": self.password}
         )
+        if not res.session:
+            raise ValueError("Authentication failed: no session returned")
+        if not res.user:
+            raise ValueError("Authentication failed: no user returned")
         self.client.auth.set_session(
             res.session.access_token, res.session.refresh_token
         )

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/core/tool_calling_llm.py

@@ -39,7 +39,7 @@ from holmes.utils.global_instructions import (
 )
 from holmes.utils.tags import format_tags_in_string, parse_messages_tags
 from holmes.core.tools_utils.tool_executor import ToolExecutor
-from holmes.core.tracing import DummySpan, SpanType
+from holmes.core.tracing import DummySpan
 
 
 def format_tool_result_data(tool_result: StructuredToolResult) -> str:
@@ -249,6 +249,7 @@ class ToolCallingLLM:
         user_prompt: Optional[str] = None,
         sections: Optional[InputSectionsDataType] = None,
         trace_span=DummySpan(),
+        tool_number_offset: int = 0,
     ) -> LLMResult:
         perf_timing = PerformanceTiming("tool_calling_llm.call")
         tool_calls = []  # type: ignore
@@ -367,7 +368,7 @@ class ToolCallingLLM:
                             tool_to_call=t,
                             previous_tool_calls=tool_calls,
                             trace_span=trace_span,
-                            tool_number=tool_index,
+                            tool_number=tool_number_offset + tool_index,
                         )
                     )
 
@@ -383,6 +384,8 @@ class ToolCallingLLM:
                 if tools_to_call:
                     logging.info("")
 
+        raise Exception(f"Too many LLM calls - exceeded max_steps: {i}/{max_steps}")
+
     def _invoke_tool(
         self,
         tool_to_call: ChatCompletionMessageToolCall,
@@ -419,7 +422,7 @@ class ToolCallingLLM:
         tool_response = None
 
         # Create tool span if tracing is enabled
-        tool_span = trace_span.start_span(name=tool_name, type=SpanType.TOOL)
+        tool_span = trace_span.start_span(name=tool_name, type="tool")
 
         try:
             tool_response = prevent_overly_repeated_tool_call(
@@ -448,6 +451,8 @@ class ToolCallingLLM:
                 metadata={
                     "status": tool_response.status.value,
                     "error": tool_response.error,
+                    "description": tool.get_parameterized_one_liner(tool_params),
+                    "structured_tool_result": tool_response,
                 },
             )
 
@@ -720,6 +725,10 @@ class ToolCallingLLM:
                         "tool_calling_result", streaming_result_dict
                     )
 
+        raise Exception(
+            f"Too many LLM calls - exceeded max_steps: {i}/{self.max_steps}"
+        )
+
 
 # TODO: consider getting rid of this entirely and moving templating into the cmds in holmes_cli.py
 class IssueInvestigator(ToolCallingLLM):

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/core/tools.py

@@ -154,8 +154,9 @@ class Tool(ABC, BaseModel):
             if hasattr(result, "get_stringified_data")
             else str(result)
         )
+        show_hint = f"/show {tool_number}" if tool_number else "/show"
         logging.info(
-            f"  [dim]Finished {tool_number_str}in {elapsed:.2f}s, output length: {len(output_str):,} characters - /show to view contents[/dim]"
+            f"  [dim]Finished {tool_number_str}in {elapsed:.2f}s, output length: {len(output_str):,} characters - {show_hint} to view contents[/dim]"
         )
         return result
 

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/core/toolset_manager.py

@@ -290,7 +290,7 @@ class ToolsetManager:
                 [toolset for toolset in all_toolsets_with_status if toolset.enabled]
             )
             logging.info(
-                f"Using {num_available_toolsets} datasources (toolsets). To refresh: `holmes toolset refresh`"
+                f"Using {num_available_toolsets} datasources (toolsets). To refresh: use flag `--refresh-toolsets`"
             )
         return all_toolsets_with_status
 

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/core/tracing.py

@@ -32,12 +32,13 @@ class SpanType(Enum):
     TOOL = "tool"
     TASK = "task"
     SCORE = "score"
+    EVAL = "eval"
 
 
 class DummySpan:
     """A no-op span implementation for when tracing is disabled."""
 
-    def start_span(self, name: str, span_type: Optional[SpanType] = None, **kwargs):
+    def start_span(self, name: str, span_type=None, **kwargs):
         return DummySpan()
 
     def log(self, *args, **kwargs):
@@ -121,17 +122,17 @@ class BraintrustTracer:
         # Add span type to kwargs if provided
         kwargs = {}
         if span_type:
-            kwargs["type"] = getattr(SpanTypeAttribute, span_type.name)
+            kwargs["type"] = span_type.value
 
         # Use current Braintrust context (experiment or parent span)
         current_span = braintrust.current_span()
         if not _is_noop_span(current_span):
-            return current_span.start_span(name=name, **kwargs)
+            return current_span.start_span(name=name, **kwargs)  # type: ignore
 
         # Fallback to current experiment
         current_experiment = braintrust.current_experiment()
         if current_experiment:
-            return current_experiment.start_span(name=name, **kwargs)
+            return current_experiment.start_span(name=name, **kwargs)  # type: ignore
 
         return DummySpan()
 

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/interactive.py

@@ -6,15 +6,15 @@ import threading
 from collections import defaultdict
 from enum import Enum
 from pathlib import Path
-from typing import Optional, List, DefaultDict
+from typing import DefaultDict, List, Optional
 
 import typer
 from prompt_toolkit import PromptSession
 from prompt_toolkit.application import Application
 from prompt_toolkit.completion import Completer, Completion, merge_completers
 from prompt_toolkit.completion.filesystem import ExecutableCompleter, PathCompleter
-from prompt_toolkit.history import InMemoryHistory, FileHistory
 from prompt_toolkit.document import Document
+from prompt_toolkit.history import FileHistory, InMemoryHistory
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.layout import Layout
 from prompt_toolkit.layout.containers import HSplit, Window
@@ -22,27 +22,26 @@ from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.shortcuts.prompt import CompleteStyle
 from prompt_toolkit.styles import Style
 from prompt_toolkit.widgets import TextArea
-
 from rich.console import Console
 from rich.markdown import Markdown, Panel
 
 from holmes.core.prompt import build_initial_ask_messages
 from holmes.core.tool_calling_llm import ToolCallingLLM, ToolCallResult
 from holmes.core.tools import pretty_print_toolset_status
-from holmes.core.tracing import DummySpan
+from holmes.version import check_version_async
+from holmes.core.tracing import DummyTracer
 
 
 class SlashCommands(Enum):
     EXIT = ("/exit", "Exit interactive mode")
     HELP = ("/help", "Show help message with all commands")
-    RESET = ("/reset", "Reset the conversation context")
+    CLEAR = ("/clear", "Clear screen and reset conversation context")
     TOOLS_CONFIG = ("/tools", "Show available toolsets and their status")
     TOGGLE_TOOL_OUTPUT = (
         "/auto",
         "Toggle auto-display of tool outputs after responses",
     )
     LAST_OUTPUT = ("/last", "Show all tool outputs from last response")
-    CLEAR = ("/clear", "Clear the terminal screen")
     RUN = ("/run", "Run a bash command and optionally share with LLM")
     SHELL = (
         "/shell",
@@ -722,9 +721,9 @@ def run_interactive_loop(
     show_tool_output: bool,
     tracer=None,
 ) -> None:
-    # Initialize tracer - use DummySpan if no tracer provided
+    # Initialize tracer - use DummyTracer if no tracer provided
     if tracer is None:
-        tracer = DummySpan()
+        tracer = DummyTracer()
 
     style = Style.from_dict(
         {
@@ -753,6 +752,23 @@ def run_interactive_loop(
     # Create custom key bindings for Ctrl+C behavior
     bindings = KeyBindings()
     status_message = ""
+    version_message = ""
+
+    def clear_version_message():
+        nonlocal version_message
+        version_message = ""
+        session.app.invalidate()
+
+    def on_version_check_complete(result):
+        """Callback when background version check completes"""
+        nonlocal version_message
+        if not result.is_latest and result.update_message:
+            version_message = result.update_message
+            session.app.invalidate()
+
+            # Auto-clear after 10 seconds
+            timer = threading.Timer(10, clear_version_message)
+            timer.start()
 
     @bindings.add("c-c")
     def _(event):
@@ -776,9 +792,19 @@ def run_interactive_loop(
             raise KeyboardInterrupt()
 
     def get_bottom_toolbar():
+        messages = []
+
+        # Ctrl-c status message (red background)
         if status_message:
-            return [("bg:#ff0000 fg:#000000", status_message)]
-        return None
+            messages.append(("bg:#ff0000 fg:#000000", status_message))
+
+        # Version message (yellow background)
+        if version_message:
+            if messages:
+                messages.append(("", " | "))
+            messages.append(("bg:#ffff00 fg:#000000", version_message))
+
+        return messages if messages else None
 
     session = PromptSession(
         completer=command_completer,
@@ -789,6 +815,9 @@ def run_interactive_loop(
         bottom_toolbar=get_bottom_toolbar,
     )  # type: ignore
 
+    # Start background version check
+    check_version_async(on_version_check_complete)
+
     input_prompt = [("class:prompt", "User: ")]
 
     console.print(WELCOME_BANNER)
@@ -833,9 +862,10 @@ def run_interactive_loop(
                     for cmd, description in SLASH_COMMANDS_REFERENCE.items():
                         console.print(f"  [bold]{cmd}[/bold] - {description}")
                     continue
-                elif command == SlashCommands.RESET.value:
+                elif command == SlashCommands.CLEAR.command:
+                    console.clear()
                     console.print(
-                        f"[bold {STATUS_COLOR}]Context reset. You can now ask a new question.[/bold {STATUS_COLOR}]"
+                        f"[bold {STATUS_COLOR}]Screen cleared and context reset. You can now ask a new question.[/bold {STATUS_COLOR}]"
                     )
                     messages = None
                     last_response = None
@@ -854,9 +884,6 @@ def run_interactive_loop(
                 elif command == SlashCommands.LAST_OUTPUT.command:
                     handle_last_command(last_response, console, all_tool_calls_history)
                     continue
-                elif command == SlashCommands.CLEAR.command:
-                    console.clear()
-                    continue
                 elif command == SlashCommands.CONTEXT.command:
                     handle_context_command(messages, ai, console)
                     continue
@@ -902,7 +929,10 @@ def run_interactive_loop(
                     metadata={"type": "user_question"},
                 )
                 response = ai.call(
-                    messages, post_processing_prompt, trace_span=trace_span
+                    messages,
+                    post_processing_prompt,
+                    trace_span=trace_span,
+                    tool_number_offset=len(all_tool_calls_history),
                 )
                 trace_span.log(
                     output=response.result,

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/main.py

@@ -219,16 +219,20 @@ def ask(
     Ask any question and answer using available tools
     """
     console = init_logging(verbose)  # type: ignore
-
     # Detect and read piped input
     piped_data = None
-    if not sys.stdin.isatty():
+
+    # when attaching a pycharm debugger sys.stdin.isatty() returns false and sys.stdin.read() is stuck
+    running_from_pycharm = os.environ.get("PYCHARM_HOSTED", False)
+
+    if not sys.stdin.isatty() and not running_from_pycharm:
         piped_data = sys.stdin.read().strip()
         if interactive:
             console.print(
                 "[bold yellow]Interactive mode disabled when reading piped input[/bold yellow]"
             )
             interactive = False
+
     config = Config.load_from_file(
         config_file,
         api_key=api_key,

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/plugins/toolsets/prometheus/prometheus.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 from urllib.parse import urljoin
 
 import requests  # type: ignore
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, field_validator, Field, model_validator
 from requests import RequestException
 
 from holmes.core.tools import (
@@ -29,6 +29,8 @@ from holmes.plugins.toolsets.utils import (
     standard_start_datetime_tool_param_description,
 )
 from holmes.utils.cache import TTLCache
+from holmes.common.env_vars import IS_OPENSHIFT
+from holmes.common.openshift import load_openshift_token
 
 PROMETHEUS_RULES_CACHE_KEY = "cached_prometheus_rules"
 DEFAULT_TIME_SPAN_SECONDS = 3600
@@ -45,7 +47,7 @@ class PrometheusConfig(BaseModel):
     fetch_labels_with_labels_api: bool = False
     fetch_metadata_with_series_api: bool = False
     tool_calls_return_data: bool = True
-    headers: Dict = {}
+    headers: Dict = Field(default_factory=dict)
     rules_cache_duration_seconds: Union[int, None] = 1800  # 30 minutes
     additional_labels: Optional[Dict[str, str]] = None
 
@@ -55,6 +57,23 @@ class PrometheusConfig(BaseModel):
             return v + "/"
         return v
 
+    @model_validator(mode="after")
+    def validate_prom_config(self):
+        # If openshift is enabled, and the user didn't configure auth headers, we will try to load the token from the service account.
+        if IS_OPENSHIFT:
+            if self.healthcheck == "-/healthy":
+                self.healthcheck = "api/v1/query?query=up"
+
+            if self.headers.get("Authorization"):
+                return self
+
+            openshift_token = load_openshift_token()
+            if openshift_token:
+                logging.info("Using openshift token for prometheus toolset auth")
+                self.headers["Authorization"] = f"Bearer {openshift_token}"
+
+        return self
+
 
 class BasePrometheusTool(Tool):
     toolset: "PrometheusToolset"

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/utils/console/logging.py

@@ -46,6 +46,7 @@ def init_logging(verbose_flags: Optional[List[bool]] = None):
 
     if verbosity == Verbosity.VERY_VERBOSE:
         logging.basicConfig(
+            force=True,
             level=logging.DEBUG,
             format="%(message)s",
             handlers=[
@@ -60,6 +61,7 @@ def init_logging(verbose_flags: Optional[List[bool]] = None):
         )
     elif verbosity == Verbosity.VERBOSE:
         logging.basicConfig(
+            force=True,
             level=logging.INFO,
             format="%(message)s",
             handlers=[
@@ -76,6 +78,7 @@ def init_logging(verbose_flags: Optional[List[bool]] = None):
         suppress_noisy_logs()
     else:
         logging.basicConfig(
+            force=True,
             level=logging.INFO,
             format="%(message)s",
             handlers=[

{holmesgpt-0.12.0 → holmesgpt-0.12.1}/holmes/utils/robusta.py

@@ -1,10 +1,9 @@
-from holmes.config import Config
+from holmes.config import Config, ROBUSTA_AI_MODEL_NAME
 from holmes.core.supabase_dal import SupabaseDal
 from pydantic import SecretStr
-from holmes.common.env_vars import load_bool
 
 
 def load_robusta_api_key(dal: SupabaseDal, config: Config):
-    if load_bool("ROBUSTA_AI", False):
+    if ROBUSTA_AI_MODEL_NAME in config._model_list:
         account_id, token = dal.get_ai_credentials()
         config.api_key = SecretStr(f"{account_id} {token}")