holmesgpt 0.12.0a0__py3-none-any.whl → 0.12.2a0__py3-none-any.whl

holmes/__init__.py

@@ -1,76 +1,8 @@
-import json
-import os
-import subprocess
-import sys
-from cachetools import cached  # type: ignore
-
-# For relative imports to work in Python 3.6 - see https://stackoverflow.com/a/49375740
-this_path = os.path.dirname(os.path.realpath(__file__))
-sys.path.append(this_path)
-
 # This is patched by github actions during release
-__version__ = "0.12.0-alpha"
-
-
-def is_official_release() -> bool:
-    return not __version__.startswith("0.0.0")
-
-
-@cached(cache=dict())
-def get_version() -> str:
-    # the version string was patched by a release - return __version__ which will be correct
-    if is_official_release():
-        return __version__
-
-    # we are running from an unreleased dev version
-    try:
-        # Get the latest git tag
-        tag = (
-            subprocess.check_output(
-                ["git", "describe", "--tags"], stderr=subprocess.STDOUT, cwd=this_path
-            )
-            .decode()
-            .strip()
-        )
-
-        # Get the current branch name
-        branch = (
-            subprocess.check_output(
-                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-                stderr=subprocess.STDOUT,
-                cwd=this_path,
-            )
-            .decode()
-            .strip()
-        )
-
-        # Check if there are uncommitted changes
-        status = (
-            subprocess.check_output(
-                ["git", "status", "--porcelain"],
-                stderr=subprocess.STDOUT,
-                cwd=this_path,
-            )
-            .decode()
-            .strip()
-        )
-        dirty = "-dirty" if status else ""
-
-        return f"{tag}-{branch}{dirty}"
-
-    except Exception:
-        pass
-
-    # we are running without git history, but we still might have git archival data (e.g. if we were pip installed)
-    archival_file_path = os.path.join(this_path, ".git_archival.json")
-    if os.path.exists(archival_file_path):
-        try:
-            with open(archival_file_path, "r") as f:
-                archival_data = json.load(f)
-                return f"dev-{archival_data['refs']}-{archival_data['hash-short']}"
-        except Exception:
-            pass
-
-        return "dev-version"
+__version__ = "0.12.2-alpha"
 
-    return "unknown-version"
+# 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,
+)

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):

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)

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

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
@@ -116,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:
@@ -147,8 +127,6 @@ 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")
@@ -179,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":
         """

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
 

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
         )

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):

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
 

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
 

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()
 

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,

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,

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"

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=[

holmes/version.py

@@ -0,0 +1,178 @@
+"""
+Centralized version management for Holmes.
+Handles current version detection, latest version fetching, and comparison logic.
+"""
+
+import json
+import os
+import subprocess
+import sys
+import threading
+from typing import Optional, NamedTuple
+from functools import cache
+import requests  # type: ignore
+from pydantic import BaseModel, ConfigDict
+from holmes.common.env_vars import ROBUSTA_API_ENDPOINT
+
+# For relative imports to work in Python 3.6 - see https://stackoverflow.com/a/49375740
+this_path = os.path.dirname(os.path.realpath(__file__))
+sys.path.append(this_path)
+
+# Version checking API constants
+HOLMES_GET_INFO_URL = f"{ROBUSTA_API_ENDPOINT}/api/holmes/get_info"
+TIMEOUT = 0.5
+
+
+class HolmesInfo(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    latest_version: Optional[str] = None
+
+
+class VersionCheckResult(NamedTuple):
+    """Result of version check with all relevant info"""
+
+    is_latest: bool
+    current_version: str
+    latest_version: Optional[str] = None
+    update_message: Optional[str] = None
+
+
+def is_official_release() -> bool:
+    """Check if this is an official release (version was patched by CI/CD)"""
+    from holmes import __version__
+
+    return not __version__.startswith("0.0.0")
+
+
+@cache
+def get_version() -> str:
+    """
+    Get the current version of Holmes.
+    Returns the official version if patched by CI/CD, otherwise builds from git.
+    """
+    from holmes import __version__
+
+    # the version string was patched by a release - return __version__ which will be correct
+    if is_official_release():
+        return __version__
+
+    # we are running from an unreleased dev version
+    try:
+        # Get the latest git tag
+        tag = (
+            subprocess.check_output(
+                ["git", "describe", "--tags"], stderr=subprocess.STDOUT, cwd=this_path
+            )
+            .decode()
+            .strip()
+        )
+
+        # Get the current branch name
+        branch = (
+            subprocess.check_output(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                stderr=subprocess.STDOUT,
+                cwd=this_path,
+            )
+            .decode()
+            .strip()
+        )
+
+        # Check if there are uncommitted changes
+        status = (
+            subprocess.check_output(
+                ["git", "status", "--porcelain"],
+                stderr=subprocess.STDOUT,
+                cwd=this_path,
+            )
+            .decode()
+            .strip()
+        )
+        dirty = "-dirty" if status else ""
+
+        return f"{tag}-{branch}{dirty}"
+
+    except Exception:
+        pass
+
+    # we are running without git history, but we still might have git archival data (e.g. if we were pip installed)
+    archival_file_path = os.path.join(this_path, ".git_archival.json")
+    if os.path.exists(archival_file_path):
+        try:
+            with open(archival_file_path, "r") as f:
+                archival_data = json.load(f)
+                return f"dev-{archival_data['refs']}-{archival_data['hash-short']}"
+        except Exception:
+            pass
+
+        return "dev-version"
+
+    return "unknown-version"
+
+
+@cache
+def fetch_holmes_info() -> Optional[HolmesInfo]:
+    """Fetch latest version information from Robusta API"""
+    try:
+        response = requests.get(HOLMES_GET_INFO_URL, timeout=TIMEOUT)
+        response.raise_for_status()
+        result = response.json()
+        return HolmesInfo(**result)
+    except Exception:
+        return None
+
+
+def check_version() -> VersionCheckResult:
+    """
+    Centralized version checking logic.
+    Returns complete version check result with message.
+    """
+    current_version = get_version()
+    holmes_info = fetch_holmes_info()
+
+    # Default to latest if we can't determine
+    if not holmes_info or not holmes_info.latest_version or not current_version:
+        return VersionCheckResult(
+            is_latest=True, current_version=current_version or "unknown"
+        )
+
+    # Dev versions are considered latest
+    if current_version.startswith("dev-"):
+        return VersionCheckResult(
+            is_latest=True,
+            current_version=current_version,
+            latest_version=holmes_info.latest_version,
+        )
+
+    # Check if current version starts with latest version
+    is_latest = current_version.startswith(holmes_info.latest_version)
+
+    update_message = None
+    if not is_latest:
+        update_message = f"Update available: v{holmes_info.latest_version} (current: {current_version})"
+
+    return VersionCheckResult(
+        is_latest=is_latest,
+        current_version=current_version,
+        latest_version=holmes_info.latest_version,
+        update_message=update_message,
+    )
+
+
+def check_version_async(callback):
+    """
+    Async version check for background use.
+    Calls callback with VersionCheckResult when complete.
+    """
+
+    def _check():
+        try:
+            result = check_version()
+            callback(result)
+        except Exception:
+            # Silent failure - call callback with "latest" result
+            callback(VersionCheckResult(is_latest=True, current_version="unknown"))
+
+    thread = threading.Thread(target=_check, daemon=True)
+    thread.start()
+    return thread

{holmesgpt-0.12.0a0.dist-info → holmesgpt-0.12.2a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holmesgpt
-Version: 0.12.0a0
+Version: 0.12.2a0
 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.0a0.dist-info → holmesgpt-0.12.2a0.dist-info}/RECORD

@@ -1,14 +1,15 @@
 holmes/.git_archival.json,sha256=PbwdO7rNhEJ4ALiO12DPPb81xNAIsVxCA0m8OrVoqsk,182
-holmes/__init__.py,sha256=YOPbAEB6arNwdwPT4mge8qNkAdjgv1yQdSZK3qwUefY,2178
-holmes/clients/robusta_client.py,sha256=b6zje8VF8aOpjXnluBcBDdf3Xb88yFXvKDcy2gV1DeM,672
-holmes/common/env_vars.py,sha256=ayfuw30HnfWmEoghgWlF3vOwiarl7uQns_yxVfs7N_w,1915
-holmes/config.py,sha256=0wRpKpBNCFAXqxrcAmfyPMQ5WYOCypjhoLeL4m4ZZic,21324
+holmes/__init__.py,sha256=kzD9kWiOhuk8juWhaleYlfxpu82K3UT37Ik6P09Em-M,263
+holmes/clients/robusta_client.py,sha256=u1ZvPBE7VaNVrPdtiTLDjI3Xrx6TWTnOWeIlky_aCHg,672
+holmes/common/env_vars.py,sha256=6Pi3v9cumKKCnEoeJT5fGgmzzerM5oV0izHnM-nPsBA,1963
+holmes/common/openshift.py,sha256=akbQ0GpnmuzXOqTcotpTDQSDKIROypS9mgPOprUgkCw,407
+holmes/config.py,sha256=WblVSBedeDeG_xl-SkPGkxTUgdw4vXz2mOJg08oQQpU,20266
 holmes/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 holmes/core/conversations.py,sha256=LXT3T-5hwl4xHXBhO4XyOKm6k9w58anQ3dw4F2aptqs,20769
 holmes/core/investigation.py,sha256=nSVkCfeliZjQT2PrgNPD3o1EwKe9je0Pq3F2bDNQiCU,5646
 holmes/core/investigation_structured_output.py,sha256=f9MDfhaI5OfaZ4J_UKqMFhWncoODuo6CBNMNWbdIkvE,9991
 holmes/core/issue.py,sha256=dbctGv8KHAXC1SeOMkEP-BudJ50u7kA8jLN5FN_d808,2426
-holmes/core/llm.py,sha256=cC0B8p-mB3iiL2u1FgtcbwBgDv_Xg94DmYSXdIlGNdg,10995
+holmes/core/llm.py,sha256=P81ZlwDSzK4B1uIMAtJuchQdHUfh088KDz0Yvr-jHk4,10761
 holmes/core/models.py,sha256=Bfo-HxC4SjW1Y60fjwn8AAq2zyrTfM61x6OsWartmU8,5693
 holmes/core/openai_formatting.py,sha256=T5GguKhYiJbHx7mFTyJZZReV-s9LBX443BD_nJQZR2s,1677
 holmes/core/performance_timing.py,sha256=MTbTiiX2jjPmW7PuNA2eYON40eWsHPryR1ap_KlwZ_E,2217
@@ -16,16 +17,16 @@ holmes/core/prompt.py,sha256=pc2qoCw0xeJDjGwG0DHOtEUvKsnUAtR6API10ThdlkU,1244
 holmes/core/resource_instruction.py,sha256=rduue_t8iQi1jbWc3-k3jX867W1Fvc6Tah5uOJk35Mc,483
 holmes/core/runbooks.py,sha256=Oj5ICmiGgaq57t4erPzQDvHQ0rMGj1nhiiYhl8peH3Q,939
 holmes/core/safeguards.py,sha256=SAw-J9y3uAehJVZJYsFs4C62jzLV4p_C07F2jUuJHug,4895
-holmes/core/supabase_dal.py,sha256=spnBESlw5XK3BFjAFXUtKH069NHF0J-WCD_v--83ZdY,20031
-holmes/core/tool_calling_llm.py,sha256=8HwqWCa6H6WaWr49UHBQS-VGSrgQ9SnzcWBzwohLnPo,34547
-holmes/core/tools.py,sha256=gfs60sQ_4QQEKX785ejIoxgmrgBrSRolt6xLl2Px3GY,20203
+holmes/core/supabase_dal.py,sha256=76QjQcQKlZb8Mr9RCfXq5OJOfkVgm1m6dn-Gtux_J24,20231
+holmes/core/tool_calling_llm.py,sha256=SakvJ2nGgZquFMFkT66Iv0Kg3FnvsLxYTc3JnEGc6LA,34930
+holmes/core/tools.py,sha256=RU9d1onms_1M3-knZQN9HTOrJCB15xhfn5_kRG22Fr4,20280
 holmes/core/tools_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 holmes/core/tools_utils/tool_executor.py,sha256=ZGrzn8c8RelQa_t6ZR9siWBBzOCQ1fgKhug4JDqqgUM,2100
 holmes/core/tools_utils/toolset_utils.py,sha256=1r7nlET4e7CjzMl9MUc_pYOTtRU7YSL8AKp6fQF3_3o,2217
-holmes/core/toolset_manager.py,sha256=4oZGr8WinEIiFSVHkNSQ4Drj2k4h2ICMcC-i1aACddE,18166
-holmes/core/tracing.py,sha256=Ei0x4Kp9D7LG9FVX-CjicLwEAindIxMbioe2sDdgJXo,7087
-holmes/interactive.py,sha256=cK-9bg_wAxlMNvqrqVnLVQag2n8BLjerHvLc2W7Oh40,35315
-holmes/main.py,sha256=Wsue8fVfaccnJ8cFfgW25yPSGk1yoa-OjG44jVc2s4k,34687
+holmes/core/toolset_manager.py,sha256=xc9-tv5jt5f-8qgDCGD4tn_mYcDHvX65UxIcnZfUGME,18171
+holmes/core/tracing.py,sha256=PTWjonUIfZLINeLzZgPmKRYdwYwINZopLXnco-cwpgU,7088
+holmes/interactive.py,sha256=g4CLH8lr2e5n_VSRfU5v-wzy0g0Vn7uIRXuQJ9GvG_8,36355
+holmes/main.py,sha256=DbDMrI3BDtcMT7E1n3tll3-U8xW4ZuAllBjbHhyR0Uw,34888
 holmes/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 holmes/plugins/destinations/__init__.py,sha256=vMYwTfA5nQ05us5Rzbaoe0R5C8Navo6ENVZhojtACTk,98
 holmes/plugins/destinations/slack/__init__.py,sha256=HVoDdTbdJJ1amXt12ZSMVcn3E04rcOrqk6BgNwvMbWY,56
@@ -151,7 +152,7 @@ holmes/plugins/toolsets/opensearch/opensearch_logs.py,sha256=TbBzLv7we91pTGqmsM1
 holmes/plugins/toolsets/opensearch/opensearch_traces.py,sha256=gXV2yXrAn0Tu3r5GMiSdsLAKx9myUrHWD0U-OYBXN0g,8497
 holmes/plugins/toolsets/opensearch/opensearch_traces_instructions.jinja2,sha256=Xn8AW4XCMYV1VkBbF8nNB9fUpKQ1Vbm88iFczj-LQXo,1035
 holmes/plugins/toolsets/opensearch/opensearch_utils.py,sha256=mh9Wp22tOdJYmA9IaFS7tD3aEENljyeuPOsF-lEe5C0,5097
-holmes/plugins/toolsets/prometheus/prometheus.py,sha256=dOi0rSh_oJtZrlxJ5bOT2r0wqXmBA0zBA6--njXuSyE,30958
+holmes/plugins/toolsets/prometheus/prometheus.py,sha256=H8YWHj1Q2C8SqabNYQdyoTGe0kZlEarELDQcSVmSkE0,31795
 holmes/plugins/toolsets/prometheus/prometheus_instructions.jinja2,sha256=hIR8Uo9QNVgsUdY94NVNKwpQvJiuGpkECGw8Eu-oVuY,2856
 holmes/plugins/toolsets/rabbitmq/api.py,sha256=-BtqF7hQWtl_OamnQ521vYHhR8E2n2wcPNYxfI9r4kQ,14307
 holmes/plugins/toolsets/rabbitmq/rabbitmq_instructions.jinja2,sha256=qetmtJUMkx9LIihr2fSJ2EV9h2J-b-ZdUAvMtopXZYY,3105
@@ -172,7 +173,7 @@ holmes/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 holmes/utils/cache.py,sha256=aPc7zTdpBQ3JQR7ET4wvIwzXhx2PpPKiBBSTgbVNXlY,2219
 holmes/utils/cert_utils.py,sha256=5YAUOY3LjFqqFpYHnHLvSc70LCxEWf0spw1vZwLLvOw,1193
 holmes/utils/console/consts.py,sha256=klHl0_iXcw_mqtv-YUWBzx3oxi0maaHok_Eq_7ZZdb8,257
-holmes/utils/console/logging.py,sha256=nKB3NN0lq45Ux1hMMGetk3TMb9WosTZVliVivkQv0sE,3000
+holmes/utils/console/logging.py,sha256=jnNWqHIJRb6mCOXN24YSi1w_oMxUcOkkXsZb42daFU0,3072
 holmes/utils/console/result.py,sha256=-n9QtaJtgagIYXu9XYF6foQ6poiCUcYZbK0CWbK9cJw,1334
 holmes/utils/default_toolset_installation_guide.jinja2,sha256=HEf7tX75HE3H4-YeLbJfa0WbiLEsI71usKrXHCO_sHo,992
 holmes/utils/definitions.py,sha256=WKVDFh1wfuo0UCV_1jXFjgP0gjGM3-U-UdxdVxmXaKM,287
@@ -185,8 +186,9 @@ holmes/utils/markdown_utils.py,sha256=_yDc_IRB5zkj9THUlZ6nzir44VfirTjPccC_DrFrBk
 holmes/utils/pydantic_utils.py,sha256=g0e0jLTa8Je8JKrhEP4N5sMxj0_hhPOqFZr0Vpd67sg,1649
 holmes/utils/robusta.py,sha256=4FZKv5DhDnvINuMlbyFRWCYdR4p7Pj4tyYIUkq1vHUU,363
 holmes/utils/tags.py,sha256=SU4EZMBtLlIb7OlHsSpguFaypczRzOcuHYxDSanV3sQ,3364
-holmesgpt-0.12.0a0.dist-info/LICENSE.txt,sha256=RdZMj8VXRQdVslr6PMYMbAEu5pOjOdjDqt3yAmWb9Ds,1072
-holmesgpt-0.12.0a0.dist-info/METADATA,sha256=V2xw8ymq8gN2kOfuHbOnzgR4K_ziLf77XaTYiSsBxt4,21643
-holmesgpt-0.12.0a0.dist-info/WHEEL,sha256=kLuE8m1WYU0Ig0_YEGrXyTtiJvKPpLpDEiChiNyei5Y,88
-holmesgpt-0.12.0a0.dist-info/entry_points.txt,sha256=JdzEyZhpaYr7Boo4uy4UZgzY1VsAEbzMgGmHZtx9KFY,42
-holmesgpt-0.12.0a0.dist-info/RECORD,,
+holmes/version.py,sha256=g_ytiKxYSKlQqYwYDMYBjDWprAc9ZyS2sLrfPb3XDkg,5217
+holmesgpt-0.12.2a0.dist-info/LICENSE.txt,sha256=RdZMj8VXRQdVslr6PMYMbAEu5pOjOdjDqt3yAmWb9Ds,1072
+holmesgpt-0.12.2a0.dist-info/METADATA,sha256=yelkj0mNpwggsMASSTatSoLYutgfbWI47ORy2J_8xlQ,21703
+holmesgpt-0.12.2a0.dist-info/WHEEL,sha256=kLuE8m1WYU0Ig0_YEGrXyTtiJvKPpLpDEiChiNyei5Y,88
+holmesgpt-0.12.2a0.dist-info/entry_points.txt,sha256=JdzEyZhpaYr7Boo4uy4UZgzY1VsAEbzMgGmHZtx9KFY,42
+holmesgpt-0.12.2a0.dist-info/RECORD,,