diff --git a/.github/workflows/mypy.yaml b/.github/workflows/mypy.yaml
index 9d93815..825fd4c 100644
--- a/.github/workflows/mypy.yaml
+++ b/.github/workflows/mypy.yaml
@@ -19,4 +19,4 @@ jobs:
       - name: Install dependencies
         run: uv sync
       - name: Python linter
-        run: uv run mypy --explicit-package-bases --disallow-untyped-calls --disallow-untyped-defs --disallow-incomplete-defs --ignore-missing-imports --disable-error-code attr-defined .
+        run: uv run mypy --config-file pyproject.toml .
diff --git a/.github/workflows/pydocstyle.yaml b/.github/workflows/pydocstyle.yaml
deleted file mode 100644
index 0b6e971..0000000
--- a/.github/workflows/pydocstyle.yaml
+++ /dev/null
@@ -1,20 +0,0 @@
-name: Pydocstyle
-
-on:
-  - push
-  - pull_request
-
-jobs:
-  pydocstyle:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: read
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          python-version: '3.13'
-      - name: Python linter
-        run: uv tool run pydocstyle -v .
diff --git a/Dockerfile b/Dockerfile
index 37a505d..5d436cd 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -14,6 +14,7 @@ RUN uv sync
 COPY server.py .
 COPY service_client ./service_client/
 COPY static_net ./static_net/
+COPY log_analyzer ./log_analyzer/
 COPY metrics ./metrics/
 
 RUN chown -R 1001:0 ${APP_HOME}
diff --git a/Makefile b/Makefile
index 00f324c..a05afb6 100644
--- a/Makefile
+++ b/Makefile
@@ -55,9 +55,9 @@ ruff:
 	uv run ruff check .
 
 check-types:
-	uv run mypy --explicit-package-bases --disallow-untyped-calls --disallow-untyped-defs --disallow-incomplete-defs --ignore-missing-imports --disable-error-code attr-defined .
+	uv run mypy --config-file pyproject.toml .
 
-verify: black pylint pyright docstyle ruff check-types test
+verify: black pylint pyright ruff check-types test
 
 format:
 	uv run black .
diff --git a/log_analyzer/__init__.py b/log_analyzer/__init__.py
new file mode 100644
index 0000000..ef5f8b4
--- /dev/null
+++ b/log_analyzer/__init__.py
@@ -0,0 +1,15 @@
+"""
+OpenShift Assisted Installer Log Analyzer.
+
+A standalone tool for analyzing OpenShift Assisted Installer logs.
+"""
+
+from .log_analyzer import LogAnalyzer
+from .signatures import ALL_SIGNATURES, SignatureResult
+
+__version__ = "1.0.0"
+__all__ = [
+    "LogAnalyzer",
+    "ALL_SIGNATURES",
+    "SignatureResult",
+]
diff --git a/log_analyzer/log_analyzer.py b/log_analyzer/log_analyzer.py
new file mode 100644
index 0000000..e35b6a8
--- /dev/null
+++ b/log_analyzer/log_analyzer.py
@@ -0,0 +1,228 @@
+"""
+Core log analyzer for OpenShift Assisted Installer logs.
+"""
+
+import json
+import logging
+from collections import defaultdict
+from typing import Dict, List, Any, cast
+
+import dateutil.parser
+import nestedarchive
+
+logger = logging.getLogger(__name__)
+
+# Archive path constants for different log bundle formats
+NEW_LOG_BUNDLE_PATH = "*_bootstrap_*.tar/*_bootstrap_*.tar.gz/logs_host_*/log-bundle-*.tar.gz/log-bundle-*"
+OLD_LOG_BUNDLE_PATH = (
+    "*_bootstrap_*.tar.gz/logs_host_*/log-bundle-*.tar.gz/log-bundle-*"
+)
+
+
+class LogAnalyzer:
+    """Analyzer for OpenShift Assisted Installer logs."""
+
+    _metadata: dict[str, Any] | None
+
+    def __init__(self, logs_archive: nestedarchive.RemoteNestedArchive):
+        """
+        Initialize the log analyzer.
+
+        Args:
+            logs_archive: RemoteNestedArchive containing the cluster logs
+        """
+        self.logs_archive = logs_archive
+        self._metadata = None
+        self._cluster_events = None
+
+    @property
+    def metadata(self) -> Dict[str, Any] | None:
+        """Get cluster metadata."""
+        if self._metadata is None:
+            try:
+                metadata_content = self.logs_archive.get("cluster_metadata.json")
+                raw_metadata = json.loads(cast(str | bytes, metadata_content))
+
+                # The metadata file contains cluster information at the root level
+                # Wrap it in a "cluster" key to match the expected structure
+                wrapped_metadata = {"cluster": raw_metadata}
+                self._metadata = self._clean_metadata_json(wrapped_metadata)
+            except Exception as e:
+                logger.error("Failed to load metadata: %s", e)
+                raise
+        return self._metadata
+
+    @staticmethod
+    def _clean_metadata_json(md: Dict[str, Any]) -> Dict[str, Any]:
+        """Clean metadata JSON by separating deleted hosts."""
+        installation_start_time = dateutil.parser.isoparse(
+            md["cluster"]["install_started_at"]
+        )
+
+        def host_deleted_before_installation_started(host):
+            if deleted_at := host.get("deleted_at"):
+                return dateutil.parser.isoparse(deleted_at) < installation_start_time
+            return False
+
+        all_hosts = md["cluster"]["hosts"]
+        md["cluster"]["deleted_hosts"] = [
+            h for h in all_hosts if host_deleted_before_installation_started(h)
+        ]
+        md["cluster"]["hosts"] = [
+            h for h in all_hosts if not host_deleted_before_installation_started(h)
+        ]
+
+        return md
+
+    def get_last_install_cluster_events(self) -> List[Dict[str, Any]]:
+        """Get the cluster installation events for the most recent attempt."""
+        try:
+            all_events = self.get_all_cluster_events()
+
+            # Get the last partition (latest installation attempt)
+            events = self.partition_cluster_events(all_events)[-1]
+        except Exception as e:
+            logger.error("Failed to load cluster events: %s", e)
+            return []
+
+        return events
+
+    def get_all_cluster_events(self) -> List[Dict[str, Any]]:
+        """Get all the cluster installation events."""
+        if self._cluster_events is None:
+            try:
+                events_content = self.logs_archive.get("cluster_events.json")
+                all_events = json.loads(cast(str | bytes, events_content))
+
+                # Get the last partition (latest installation attempt)
+                self._cluster_events = self.partition_cluster_events(all_events)[-1]
+            except Exception as e:
+                logger.error("Failed to load cluster events: %s", e)
+                self._cluster_events = []
+
+        return self._cluster_events
+
+    @staticmethod
+    def partition_cluster_events(
+        events: List[Dict[str, Any]],
+    ) -> List[List[Dict[str, Any]]]:
+        """Partition events by reset events to separate installation attempts."""
+        partitions = []
+        current_partition = []
+
+        for event in events:
+            if event["name"] == "cluster_installation_reset":
+                if current_partition:
+                    partitions.append(current_partition)
+                    current_partition = []
+            else:
+                current_partition.append(event)
+
+        if current_partition:
+            partitions.append(current_partition)
+
+        return partitions or [[]]
+
+    def get_events_by_host(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Get events grouped by host ID."""
+        events_by_host = defaultdict(list)
+        for event in self.get_last_install_cluster_events():
+            if "host_id" in event:
+                events_by_host[event["host_id"]].append(event)
+        return events_by_host
+
+    def get_host_log_file(self, host_id: str, filename: str) -> str:
+        """
+        Get a specific log file for a host.
+
+        Args:
+            host_id: Host UUID
+            filename: Name of the log file (e.g., 'agent.logs', 'journal.logs')
+
+        Returns:
+            Content of the log file
+
+        Raises:
+            FileNotFoundError: If the log file cannot be found
+        """
+        hostname = "*"  # Use wildcard since hostname is not always known
+
+        # Try new log path format first
+        new_logs_path = (
+            f"{hostname}.tar/{hostname}.tar.gz/logs_host_{host_id}/{filename}"
+        )
+        try:
+            content = self.logs_archive.get(new_logs_path)
+            logger.debug("Found logs under new location: %s", new_logs_path)
+            return cast(str, content)
+        except FileNotFoundError:
+            pass
+
+        # Fall back to old log path format
+        old_logs_path = f"{hostname}.tar.gz/logs_host_{host_id}/{filename}"
+        content = self.logs_archive.get(old_logs_path)
+        logger.debug("Found logs under old location: %s", old_logs_path)
+        return cast(str, content)
+
+    def get_journal_log(self, host_ip: str, journal_file: str, **kwargs) -> str:
+        """
+        Get journal logs for a specific host.
+
+        Args:
+            host_ip: IP address of the host
+            journal_file: Name of the journal file
+            **kwargs: Additional arguments for the archive get method
+
+        Returns:
+            Content of the journal file
+
+        Raises:
+            FileNotFoundError: If the journal file cannot be found
+        """
+        new_logs_path = (
+            f"{NEW_LOG_BUNDLE_PATH}/control-plane/{host_ip}/journals/{journal_file}"
+        )
+        try:
+            content = self.logs_archive.get(new_logs_path, **kwargs)
+            logger.debug("Found journal under new location: %s", new_logs_path)
+            return cast(str, content)
+        except FileNotFoundError:
+            pass
+
+        old_logs_path = (
+            f"{OLD_LOG_BUNDLE_PATH}/control-plane/{host_ip}/journals/{journal_file}"
+        )
+        content = self.logs_archive.get(old_logs_path, **kwargs)
+        logger.debug("Found journal under old location: %s", old_logs_path)
+        return cast(str, content)
+
+    def get_controller_logs(self) -> str:
+        """Get assisted installer controller logs."""
+        return cast(
+            str,
+            self.logs_archive.get(
+                "controller_logs.tar.gz/assisted-installer-controller*.logs"
+            ),
+        )
+
+    def get_must_gather(self) -> bytes:
+        """Get must-gather logs."""
+        return cast(
+            bytes,
+            self.logs_archive.get(
+                "controller_logs.tar.gz/must-gather.tar.gz", mode="rb"
+            ),
+        )
+
+    @staticmethod
+    def get_hostname(host: Dict[str, Any]) -> str:
+        """Extract hostname from host metadata."""
+        hostname = host.get("requested_hostname")
+        if hostname:
+            return hostname
+
+        try:
+            inventory = json.loads(host["inventory"])
+            return inventory["hostname"]
+        except (KeyError, json.JSONDecodeError):
+            return host.get("id", "unknown")
diff --git a/log_analyzer/main.py b/log_analyzer/main.py
new file mode 100644
index 0000000..1947323
--- /dev/null
+++ b/log_analyzer/main.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+Main entry point for the OpenShift Assisted Installer Log Analyzer.
+"""
+import logging
+from typing import List, Optional
+
+from service_client.assisted_service_api import InventoryClient
+
+from .log_analyzer import LogAnalyzer
+from .signatures import ALL_SIGNATURES, SignatureResult
+
+
+async def analyze_cluster(
+    cluster_id: str,
+    api_client: InventoryClient,
+    specific_signatures: Optional[List[str]] = None,
+) -> List[SignatureResult]:
+    """
+    Analyze a cluster's logs.
+
+    Args:
+        cluster_id: UUID of the cluster to analyze
+        api_client: Client to fetch log files with
+        specific_signatures: List of specific signature names to run (None for all)
+
+    Returns:
+        List of SignatureResult objects
+    """
+    logger = logging.getLogger(__name__)
+
+    # Initialize API client
+    logger.info("Analyzing cluster: %s", cluster_id)
+
+    try:
+        # Download logs
+        logs_archive = await api_client.get_cluster_logs(cluster_id)
+
+        # Initialize log analyzer
+        log_analyzer = LogAnalyzer(logs_archive)
+
+        # Determine which signatures to run
+        signatures_to_run = ALL_SIGNATURES
+        if specific_signatures:
+            signature_classes = {sig.__name__: sig for sig in ALL_SIGNATURES}
+            signatures_to_run = []
+            for sig_name in specific_signatures:
+                if sig_name in signature_classes:
+                    signatures_to_run.append(signature_classes[sig_name])
+                else:
+                    logger.warning("Unknown signature: %s", sig_name)
+
+        # Run signatures
+        results = []
+        for signature_class in signatures_to_run:
+            logger.debug("Running signature: %s", signature_class.__name__)
+            try:
+                signature = signature_class()
+                result = signature.analyze(log_analyzer)
+                if result:
+                    results.append(result)
+            except Exception as e:
+                logger.error(
+                    "Error running signature %s: %s", signature_class.__name__, e
+                )
+
+        return results
+
+    except Exception as e:
+        logger.error("Error analyzing cluster %s: %s", cluster_id, e)
+        raise
+
+
+def print_results(results: List[SignatureResult]) -> None:
+    """Print analysis results to stdout."""
+    if not results:
+        print("No issues found in the cluster logs.")
+        return
+
+    print("OpenShift Assisted Installer Log Analysis")
+    print("=" * 50)
+    print()
+
+    for result in results:
+        print(result)
diff --git a/log_analyzer/signatures/__init__.py b/log_analyzer/signatures/__init__.py
new file mode 100644
index 0000000..a1b809d
--- /dev/null
+++ b/log_analyzer/signatures/__init__.py
@@ -0,0 +1,33 @@
+"""
+Signature analysis modules for OpenShift Assisted Installer logs.
+"""
+
+import sys
+import inspect
+
+from .base import Signature, ErrorSignature, SignatureResult
+from .basic_info import *  # noqa
+from .error_detection import *  # noqa
+from .performance import *  # noqa
+from .networking import *  # noqa
+from .advanced_analysis import *  # noqa
+from .platform_specific import *  # noqa
+
+# Collect all signatures from all modules
+ALL_SIGNATURES = []
+
+current_module = sys.modules[__name__]
+for name, obj in inspect.getmembers(current_module):
+    if (
+        inspect.isclass(obj)
+        and issubclass(obj, Signature)
+        and obj is not Signature
+        and obj is not ErrorSignature
+        and obj is not SignatureResult
+    ):
+        ALL_SIGNATURES.append(obj)
+
+# Sort by name for consistent ordering
+ALL_SIGNATURES.sort(key=lambda x: x.__name__)
+
+__all__ = ["Signature", "ErrorSignature", "SignatureResult", "ALL_SIGNATURES"]
diff --git a/log_analyzer/signatures/advanced_analysis.py b/log_analyzer/signatures/advanced_analysis.py
new file mode 100644
index 0000000..438a896
--- /dev/null
+++ b/log_analyzer/signatures/advanced_analysis.py
@@ -0,0 +1,474 @@
+"""
+Advanced analysis signatures for OpenShift Assisted Installer logs.
+These signatures perform complex analysis across multiple log sources.
+"""
+
+import json
+import logging
+import re
+from collections import Counter, OrderedDict
+from typing import Any, Generator, Optional, Callable, cast
+
+from log_analyzer.log_analyzer import NEW_LOG_BUNDLE_PATH, OLD_LOG_BUNDLE_PATH
+
+from .base import Signature, SignatureResult
+
+
+def operator_statuses_from_controller_logs(
+    controller_log: str, include_empty: bool = False
+):
+    operator_regex = re.compile(r"Operator ([a-z\-]+), statuses: \[(.*)\].*")
+    conditions_regex = re.compile(r"\{(.+?)\}")
+    condition_regex = re.compile(
+        r"([A-Za-z]+) (False|True) ([0-9a-zA-Z\-]+ [0-9a-zA-Z\:]+ [0-9a-zA-Z\-\+]+ [A-Z]+) (.*)"
+    )
+    operator_statuses = {}
+
+    for operator_name, operator_status in operator_regex.findall(controller_log):
+        if include_empty:
+            operator_statuses[operator_name] = {}
+        operator_conditions = operator_statuses.setdefault(operator_name, {})
+        for operator_conditions_raw in conditions_regex.findall(operator_status):
+            for (
+                condition_name,
+                condition_result,
+                condition_timestamp,
+                condition_reason,
+            ) in condition_regex.findall(operator_conditions_raw):
+                operator_conditions[condition_name] = {
+                    "result": condition_result == "True",
+                    "timestamp": condition_timestamp,
+                    "reason": condition_reason,
+                }
+
+    return operator_statuses
+
+
+def condition_has_result(
+    operator_conditions, expected_condition_name: str, expected_condition_result: bool
+) -> bool:
+    return any(
+        condition_values["result"] == expected_condition_result
+        for condition_name, condition_values in operator_conditions.items()
+        if condition_name == expected_condition_name
+    )
+
+
+def filter_operators(
+    operator_statuses,
+    required_conditions,
+    aggregation_function: Callable[[Generator[Any, None, None]], bool],
+):
+    return {
+        operator_name: operator_conditions
+        for operator_name, operator_conditions in operator_statuses.items()
+        if aggregation_function(
+            condition_has_result(
+                operator_conditions, required_condition_name, expected_condition_result
+            )
+            for required_condition_name, expected_condition_result in required_conditions
+        )
+    }
+
+
+logger = logging.getLogger(__name__)
+
+
+class EventsInstallationAttempts(Signature):
+    """Inspects events file to check for multiple installation attempts."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze multiple installation attempts."""
+        try:
+            # Get all cluster events and partition them by reset events
+            all_events = log_analyzer.get_all_cluster_events()
+            partitions = log_analyzer.partition_cluster_events(all_events)
+            installation_attempts = len(partitions)
+
+            if installation_attempts != 1:
+                current_events = log_analyzer.get_last_install_cluster_events()
+                if current_events:
+                    last_attempt_first_event = current_events[0]
+                    content = (
+                        f"The events file for this cluster contains events from {installation_attempts} installation attempts.\n"
+                        f"When reading the events for this ticket, make sure you look only at the events for the last installation attempt,\n"
+                        f"the first event in that attempt happened around {last_attempt_first_event['event_time']}."
+                    )
+
+                    return SignatureResult(
+                        signature_name=self.name,
+                        title="Multiple Installation Attempts in Events File",
+                        content=content,
+                        severity="warning",
+                    )
+
+        except Exception as e:
+            logger.error("Error in EventsInstallationAttempts: %s", e)
+
+        return None
+
+
+class MissingMustGatherLogs(Signature):
+    """Checks if must-gather logs are missing when they should be collected."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze for missing must-gather logs."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster_hosts = metadata["cluster"]["hosts"]
+            bootstrap_node = [
+                host for host in cluster_hosts if host.get("bootstrap", False)
+            ]
+
+            if not bootstrap_node:
+                return None
+
+            bootstrap_node = bootstrap_node[0]
+
+            eligible_bootstrap_stages = ["Rebooting", "Configuring", "Joined", "Done"]
+            if len(cluster_hosts) <= 1:
+                # In SNO when the bootstrap node goes to reboot the controller is still not running
+                eligible_bootstrap_stages.remove("Rebooting")
+
+            if (
+                bootstrap_node["progress"]["current_stage"]
+                not in eligible_bootstrap_stages
+            ):
+                return None
+
+            cluster = metadata["cluster"]
+            if cluster["logs_info"] in ("timeout", "completed"):
+                try:
+                    log_analyzer.get_must_gather()
+                    return None  # Must-gather exists, no issue
+                except FileNotFoundError:
+                    content = "This cluster's collected logs are missing must-gather logs although it should be collected, why is it missing?"
+
+                    return SignatureResult(
+                        signature_name=self.name,
+                        title="Missing Must-Gather Logs",
+                        content=content,
+                        severity="error",
+                    )
+
+        except Exception as e:
+            logger.error("Error in MissingMustGatherLogs: %s", e)
+
+        return None
+
+
+class FlappingValidations(Signature):
+    """Analyzes flapping validation states."""
+
+    validation_name_regexp = re.compile(r"Host .+: validation '(.+)'.+")
+    succeed_to_failing_regexp = re.compile(
+        r"Host .+: validation '.+' that used to succeed is now failing"
+    )
+    now_fixed_regexp = re.compile(r"Host .+: validation '.+' is now fixed")
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze flapping validations."""
+        try:
+            events_by_host = log_analyzer.get_events_by_host()
+
+            host_tables = {}
+            for host_id, events in events_by_host.items():
+                succeed_to_failing_counter = Counter(
+                    cast(
+                        re.Match[str],
+                        self.validation_name_regexp.match(event["message"]),
+                    ).groups()[0]
+                    for event in events
+                    if self.succeed_to_failing_regexp.match(event["message"])
+                )
+
+                now_fixed = Counter(
+                    cast(
+                        re.Match[str],
+                        self.validation_name_regexp.match(event["message"]),
+                    ).groups()[0]
+                    for event in events
+                    if self.now_fixed_regexp.match(event["message"])
+                )
+
+                table = [
+                    OrderedDict[str, Any](
+                        validation=validation_name,
+                        failed=f"This went from succeeding to failing {succeed_to_failing_occurrences} times",
+                        fixed=f"This validation was fixed {now_fixed.get(validation_name, 0)} times",
+                    )
+                    for validation_name, succeed_to_failing_occurrences in succeed_to_failing_counter.items()
+                ]
+
+                if table:
+                    host_tables[host_id] = self.generate_table(table)
+
+            if host_tables:
+                content = "\n".join(
+                    f"Host ID {host_id}:\n{table}"
+                    for host_id, table in host_tables.items()
+                )
+
+                return SignatureResult(
+                    signature_name=self.name,
+                    title="Flapping Validations",
+                    content=content,
+                    severity="warning",
+                )
+
+        except Exception as e:
+            logger.error("Error in FlappingValidations: %s", e)
+
+        return None
+
+
+class NodeStatus(Signature):
+    """Dump node statuses from installer gather nodes.json."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        for base in (NEW_LOG_BUNDLE_PATH, OLD_LOG_BUNDLE_PATH):
+            path = f"{base}/resources/nodes.json"
+            try:
+                nodes_json = log_analyzer.logs_archive.get(path)
+            except FileNotFoundError:
+                continue
+            try:
+                nodes = json.loads(nodes_json)
+            except json.JSONDecodeError:
+                continue
+            nodes_table = []
+            for node in nodes.get("items", []):
+
+                def get_by_type(t, node):
+                    conds = node.get("status", {}).get("conditions", [])
+
+                    c = next((c for c in conds if c.get("type") == t), None)
+                    if not c:
+                        return "(Condition not found)"
+                    return f"Status {c['status']} with reason {c['reason']}, message {c['message']}"
+
+                nodes_table.append(
+                    OrderedDict(
+                        name=node.get("metadata", {}).get("name"),
+                        MemoryPressure=get_by_type("MemoryPressure", node),
+                        DiskPressure=get_by_type("DiskPressure", node),
+                        PIDPressure=get_by_type("PIDPressure", node),
+                        Ready=get_by_type("Ready", node),
+                    )
+                )
+            if nodes_table:
+                return SignatureResult(
+                    signature_name=self.name,
+                    title="Collected nodes.json from installer gather",
+                    content=self.generate_table(nodes_table),
+                    severity="info",
+                )
+            return SignatureResult(
+                signature_name=self.name,
+                title="Collected nodes.json from installer gather",
+                content=(
+                    "The nodes.json file doesn't have any node resources in it. You should probably check the kubelet logs for the 2 non-bootstrap control-plane hosts"
+                ),
+                severity="warning",
+            )
+        return None
+
+
+class ControllerWarnings(Signature):
+    """Search for warnings in controller logs."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        try:
+            controller_logs = log_analyzer.get_controller_logs()
+        except FileNotFoundError:
+            return None
+        warnings = re.findall(r'time=".*" level=warning msg=".*', controller_logs)
+        if warnings:
+            shown = warnings[:10]
+            content = "\n".join(shown)
+            if len(warnings) > 10:
+                content += (
+                    f"\nThere are {len(warnings) - 10} additional warnings not shown"
+                )
+            return SignatureResult(
+                signature_name=self.name,
+                title="Controller warning logs",
+                content=content,
+                severity="warning",
+            )
+        return None
+
+
+class UserHasLoggedIntoCluster(Signature):
+    """Detect user login to cluster nodes during installation."""
+
+    USER_LOGIN_PATTERN = re.compile(
+        r"pam_unix\((sshd|login):session\): session opened for user .+ by"
+    )
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        cluster = log_analyzer.metadata.get("cluster", {})
+        msgs = []
+        for host in cluster.get("hosts", []):
+            host_id = host["id"]
+            try:
+                journal_logs = log_analyzer.get_host_log_file(host_id, "journal.logs")
+            except FileNotFoundError:
+                continue
+            if self.USER_LOGIN_PATTERN.findall(journal_logs):
+                msgs.append(
+                    f"Host {host_id}: found evidence of a user login during installation. This might indicate that some settings have been changed manually; if incorrect they could contribute to failure."
+                )
+        if msgs:
+            return SignatureResult(
+                signature_name=self.name,
+                title="User has logged into cluster nodes during installation",
+                content="\n".join(msgs),
+                severity="warning",
+            )
+        return None
+
+
+class FailedRequestTriggersHostTimeout(Signature):
+    """Look for failed requests that could have caused host timeout."""
+
+    LOG_PATTERN = re.compile(
+        r'time="(?P<time>.+)" level=(?P<severity>[a-z]+) msg="(?P<message>.*api\.openshift\.com/api/assisted-install.*Service Unavailable)" file=.+'
+    )
+    HOST_TIMED_OUT_STATUS_INFO = (
+        "Host failed to install due to timeout while connecting to host"
+    )
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        cluster = log_analyzer.metadata.get("cluster", {})
+        failed_requests_hosts = set()
+        timed_out_hosts = {
+            h["id"]
+            for h in cluster.get("hosts", [])
+            if h.get("status_info") == self.HOST_TIMED_OUT_STATUS_INFO
+        }
+        for host in cluster.get("hosts", []):
+            try:
+                agent_logs = log_analyzer.get_host_log_file(host["id"], "agent.logs")
+            except FileNotFoundError:
+                continue
+            if len(self.LOG_PATTERN.findall(agent_logs)) > 0:
+                failed_requests_hosts.add(host["id"])
+        intersect = failed_requests_hosts & timed_out_hosts
+        if intersect:
+            content = "\n".join(
+                f"Host {host_id} has request failures and timed out. Did the request cause the host to timeout?"
+                for host_id in sorted(intersect)
+            )
+            return SignatureResult(
+                signature_name=self.name,
+                title="Failed request triggering host timeout",
+                content=content,
+                severity="warning",
+            )
+        if failed_requests_hosts and timed_out_hosts:
+            return SignatureResult(
+                signature_name=self.name,
+                title="Failed request triggering host timeout",
+                content=(
+                    f"Cluster has at least one host that failed requests ({', '.join(sorted(failed_requests_hosts))}) and at least one host that timed out ({', '.join(sorted(timed_out_hosts))})"
+                ),
+                severity="warning",
+            )
+        return None
+
+
+class ControllerFailedToStart(Signature):
+    """Looks for controller readiness in pods.json when bootstrap is 'Waiting for controller'."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        cluster = log_analyzer.metadata.get("cluster", {})
+        bootstrap = [h for h in cluster.get("hosts", []) if h.get("bootstrap")] or []
+        if not bootstrap:
+            return None
+        if bootstrap[0]["progress"]["current_stage"] != "Waiting for controller":
+            return None
+        for base in (NEW_LOG_BUNDLE_PATH, OLD_LOG_BUNDLE_PATH):
+            path = f"{base}/resources/pods.json"
+            try:
+                pods_json = log_analyzer.logs_archive.get(path)
+            except FileNotFoundError:
+                continue
+            try:
+                pods = json.loads(pods_json)
+                controller_pod = [
+                    pod
+                    for pod in pods.get("items", [])
+                    if pod.get("metadata", {}).get("namespace") == "assisted-installer"
+                ][0]
+            except Exception:
+                continue
+            try:
+                ready = [
+                    condition.get("status") == "True"
+                    for condition in controller_pod.get("status", {}).get(
+                        "conditions", {}
+                    )
+                    if condition.get("type") == "Ready"
+                ][0]
+            except Exception:
+                ready = False
+            conditions_tbl = self.generate_table(
+                controller_pod.get("status", {}).get("conditions", [])
+            )
+            containers_tbl = self.generate_table(
+                controller_pod.get("status", {}).get("containerStatuses", [])
+            )
+            content = (
+                f"The controller pod {'is' if ready else 'is not'} ready.\n"
+                f"Conditions:\n{conditions_tbl}\n\nContainer Statuses:\n{containers_tbl}"
+            )
+            return SignatureResult(
+                signature_name=self.name,
+                title="Assisted Installer Controller failed to start",
+                content=content,
+                severity="warning",
+            )
+        return None
+
+
+class MachineConfigDaemonErrorExtracting(Signature):
+    """Looks for MCD firstboot extraction error (OCPBUGS-5352)."""
+
+    mco_error = re.compile(
+        r"must be empty, pass --confirm to overwrite contents of directory$",
+        re.MULTILINE,
+    )
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        for base in (NEW_LOG_BUNDLE_PATH, OLD_LOG_BUNDLE_PATH):
+            path = (
+                f"{base}/control-plane/*/journals/machine-config-daemon-firstboot.log"
+            )
+            try:
+                mcd_logs = log_analyzer.logs_archive.get(path)
+            except FileNotFoundError:
+                continue
+            if self.mco_error.search(mcd_logs):
+                return SignatureResult(
+                    signature_name=self.name,
+                    title="machine-config-daemon could not extract machine-os-content",
+                    content=(
+                        "machine-config-daemon-firstboot logs indicate a node may be hitting OCPBUGS-5352"
+                    ),
+                    severity="warning",
+                )
+        return None
+
+
+# Add more advanced analysis signatures here:
+# - AllInstallationAttemptsSignature (requires JIRA integration)
+# - MustGatherAnalysis
+# - NodeStatus
+# - UserManagedNetworkingLoadBalancer
+# - FailedRequestTriggersHostTimeout
+# - ControllerWarnings
+# - UserHasLoggedIntoCluster
+# - OSTreeCommitMismatch
+# - ControllerFailedToStart
+# - MachineConfigDaemonErrorExtracting
diff --git a/log_analyzer/signatures/base.py b/log_analyzer/signatures/base.py
new file mode 100644
index 0000000..e52c9a3
--- /dev/null
+++ b/log_analyzer/signatures/base.py
@@ -0,0 +1,120 @@
+"""
+Base signature classes for OpenShift Assisted Installer log analysis.
+"""
+
+import abc
+import logging
+from typing import Optional, Any, Sequence
+
+import dateutil.parser
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+
+class SignatureResult:
+    """Result of a signature analysis."""
+
+    def __init__(
+        self, signature_name: str, title: str, content: str = "", severity: str = "info"
+    ):
+        """
+        Initialize a signature result.
+
+        Args:
+            signature_name: Name of the signature class
+            title: Title of the analysis
+            content: Analysis content/report
+            severity: Severity level (info, warning, error)
+        """
+        self.signature_name = signature_name
+        self.title = title
+        self.content = content
+        self.severity = severity
+
+    def __str__(self) -> str:
+        """String representation of the result."""
+        if not self.content:
+            return ""
+
+        header = f"=== {self.title} ==="
+        if self.severity == "error":
+            header = f"ERROR: {header}"
+        elif self.severity == "warning":
+            header = f"WARNING: {header}"
+        else:
+            header = f"{header}"
+
+        return f"{header}\n{self.content}\n"
+
+
+class Signature(abc.ABC):
+    """Base class for signature analysis."""
+
+    def __init__(self):
+        """Initialize the signature."""
+        self.name = self.__class__.__name__
+
+    @abc.abstractmethod
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """
+        Analyze the logs and return a result if relevant.
+
+        Args:
+            log_analyzer: LogAnalyzer instance with access to logs
+
+        Returns:
+            SignatureResult if analysis finds something relevant, None otherwise
+        """
+
+    @staticmethod
+    def generate_table(data: Sequence[dict[str, Any]]) -> str:
+        """Generate a formatted table from data."""
+        if not data:
+            return "No data available"
+        return tabulate(data, headers="keys", tablefmt="grid")
+
+    @staticmethod
+    def format_time(time_str: str) -> str:
+        """Format time string for display."""
+        try:
+            return dateutil.parser.isoparse(time_str).strftime("%Y-%m-%d %H:%M:%S")
+        except Exception:
+            return time_str
+
+
+class ErrorSignature(Signature, abc.ABC):
+    """
+    ErrorSignature is a Signature that represents error conditions.
+    It optionally adds function impact and custom labels when issues are found.
+    """
+
+    def __init__(self, function_impact_label=None, label=None):
+        """
+        Initialize error signature.
+
+        Args:
+            function_impact_label: Optional function impact classification
+            label: Optional custom label for categorization
+        """
+        super().__init__()
+        self._function_impact_label = function_impact_label
+        self._label = label
+
+    def create_result(
+        self, title: str, content: str, severity: str = "error"
+    ) -> SignatureResult:
+        """
+        Create a SignatureResult with error severity by default.
+
+        Args:
+            title: Title of the error analysis
+            content: Description of the error found
+            severity: Severity level (defaults to "error")
+
+        Returns:
+            SignatureResult for this error signature
+        """
+        return SignatureResult(
+            signature_name=self.name, title=title, content=content, severity=severity
+        )
diff --git a/log_analyzer/signatures/basic_info.py b/log_analyzer/signatures/basic_info.py
new file mode 100644
index 0000000..f2ec7e7
--- /dev/null
+++ b/log_analyzer/signatures/basic_info.py
@@ -0,0 +1,367 @@
+"""
+Basic information and status signature analysis.
+These signatures provide fundamental information about the cluster and installation.
+"""
+
+import json
+import logging
+from collections import OrderedDict, defaultdict
+from datetime import datetime
+from typing import Optional
+
+from .base import Signature, SignatureResult
+
+logger = logging.getLogger(__name__)
+
+
+class HostsStatusSignature(Signature):
+    """Analyzes host status and progress."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze host status."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster = metadata["cluster"]
+
+            hosts = []
+            for host in cluster["hosts"]:
+                info = host["status_info"]
+                role = host["role"]
+                inventory = json.loads(host["inventory"])
+                if host.get("bootstrap", False):
+                    role = "bootstrap"
+
+                hosts.append(
+                    OrderedDict(
+                        id=host["id"],
+                        hostname=log_analyzer.get_hostname(host),
+                        progress=host["progress"]["current_stage"],
+                        status=host["status"],
+                        role=role,
+                        boot_mode=inventory.get("boot", {}).get(
+                            "current_boot_mode", "N/A"
+                        ),
+                        status_info=str(info),
+                        logs_info=host.get("logs_info", ""),
+                        last_checked_in_at=self.format_time(
+                            host.get("checked_in_at", str(datetime.min))
+                        ),
+                    )
+                )
+
+            # Generate host summary
+            summary_content = []
+
+            # Cluster status
+            summary_content.append("Cluster Status:")
+            summary_content.append(f"  Status: {cluster['status']}")
+            summary_content.append(f"  Status Info: {cluster['status_info']}")
+            summary_content.append("")
+
+            # Hosts table
+            summary_content.append("Hosts Status:")
+            summary_content.append(self.generate_table(hosts))
+
+            # Add host status summary if there are issues
+            host_summary = self._generate_hosts_summary(cluster["hosts"], log_analyzer)
+            if host_summary:
+                summary_content.append("")
+                summary_content.append("Host Status Summary:")
+                summary_content.append(host_summary)
+
+            return SignatureResult(
+                signature_name=self.name,
+                title="Installation Status",
+                content="\n".join(summary_content),
+                severity="info",
+            )
+
+        except Exception as e:
+            logger.error("Error in HostsStatusSignature: %s", e)
+            return None
+
+    def _generate_hosts_summary(self, hosts, log_analyzer):
+        """Generate a summary of host issues."""
+        host_summary = []
+        some_done = any(host["progress"]["current_stage"] == "Done" for host in hosts)
+
+        for host in hosts:
+            if host["role"] not in ["master", "bootstrap"]:
+                continue
+            if host["progress"]["current_stage"] == "Done" or host["status"] != "error":
+                continue
+
+            host_comment = {
+                "Waiting for bootkube": "bootkube.service never completed",
+                "Rebooting": "Node never pulled Ignition",
+                "Configuring": "Node pulled Ignition, but never started kubelet",
+                "Joined": (
+                    "The Node k8s resource associated with this host is not Ready"
+                    + (
+                        " or the Assisted Controller is not running on the cluster"
+                        if not some_done
+                        else ""
+                    )
+                ),
+                "Waiting for control plane": "Masters never formed 2-node cluster",
+                "Waiting for controller": "Assisted installer controller pod never started",
+                "Writing image to disk": "Image probably failed to be written on disk",
+            }.get(host["progress"]["current_stage"], "Unknown")
+
+            host_summary.append(
+                OrderedDict(
+                    hostname=log_analyzer.get_hostname(host),
+                    role=host["role"],
+                    description=host_comment,
+                )
+            )
+
+        return self.generate_table(host_summary) if host_summary else ""
+
+
+class ComponentsVersionSignature(Signature):
+    """Analyzes component versions."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze component versions."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster_md = metadata.get("cluster", {})
+
+            content_lines = []
+
+            release_tag = metadata.get("release_tag") or cluster_md.get("release_tag")
+            if release_tag:
+                content_lines.append(f"Release tag: {release_tag}")
+
+            versions = metadata.get("versions") or cluster_md.get("versions")
+            if versions:
+                if "assisted-installer" in versions:
+                    content_lines.append(
+                        f"assisted-installer: {versions['assisted-installer']}"
+                    )
+                if "assisted-installer-controller" in versions:
+                    content_lines.append(
+                        f"assisted-installer-controller: {versions['assisted-installer-controller']}"
+                    )
+                if "discovery-agent" in versions:
+                    content_lines.append(
+                        f"assisted-installer-agent: {versions['discovery-agent']}"
+                    )
+
+            if content_lines:
+                return SignatureResult(
+                    signature_name=self.name,
+                    title="Component Version Information",
+                    content="\n".join(content_lines),
+                    severity="info",
+                )
+
+        except Exception as e:
+            logger.error("Error in ComponentsVersionSignature: %s", e)
+
+        return None
+
+
+class FailureDescription(Signature):
+    """Generates failure description with cluster information."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze and format cluster failure description."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster = metadata["cluster"]
+
+            # Extract key information
+            cluster_info = {
+                "Cluster ID": cluster["id"],
+                "OpenShift Cluster ID": cluster.get("openshift_cluster_id", "N/A"),
+                "Username": cluster.get("user_name", "N/A"),
+                "Email Domain": cluster.get("email_domain", "N/A"),
+                "Created At": self.format_time(cluster["created_at"]),
+                "Installation Started At": self.format_time(
+                    cluster.get("install_started_at", "")
+                ),
+                "Failed On": self.format_time(cluster.get("status_updated_at", "")),
+                "Status": cluster["status"],
+                "Status Info": cluster["status_info"],
+                "OpenShift Version": cluster.get("openshift_version", "N/A"),
+                "Platform Type": cluster.get("platform", {}).get("type", "N/A"),
+            }
+
+            # Format as table
+            content = "Cluster Information:\n" + self.generate_table(
+                [{"Field": k, "Value": v} for k, v in cluster_info.items()]
+            )
+
+            return SignatureResult(
+                signature_name=self.name,
+                title="Cluster Failure Description",
+                content=content,
+                severity="info",
+            )
+
+        except Exception as e:
+            logger.error("Error in FailureDescription: %s", e)
+            return None
+
+
+class HostsExtraDetailSignature(Signature):
+    """Provides extra details about hosts."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze host extra details."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster = metadata["cluster"]
+
+            hosts = []
+            for host in cluster["hosts"]:
+                inventory = json.loads(host["inventory"])
+                hosts.append(
+                    OrderedDict(
+                        id=host["id"],
+                        hostname=inventory["hostname"],
+                        requested_hostname=host.get("requested_hostname", "N/A"),
+                        last_contacted=self.format_time(host["checked_in_at"]),
+                        installation_disk=host.get("installation_disk_path", "N/A"),
+                        product_name=inventory["system_vendor"].get(
+                            "product_name", "Unavailable"
+                        ),
+                        manufacturer=inventory["system_vendor"].get(
+                            "manufacturer", "Unavailable"
+                        ),
+                        virtual_host=inventory["system_vendor"].get("virtual", False),
+                        disks_count=len(inventory["disks"]),
+                    )
+                )
+
+            content = self.generate_table(hosts)
+
+            return SignatureResult(
+                signature_name=self.name,
+                title="Host Extra Details",
+                content=content,
+                severity="info",
+            )
+
+        except Exception as e:
+            logger.error("Error in HostsExtraDetailSignature: %s", e)
+            return None
+
+
+class HostsInterfacesSignature(Signature):
+    """Analyzes host network interfaces."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze host interfaces."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster = metadata["cluster"]
+
+            hosts = []
+            for host in cluster["hosts"]:
+                interfaces = self._get_interfaces(host)
+                hosts.append(
+                    OrderedDict(
+                        id=host["id"],
+                        hostname=log_analyzer.get_hostname(host),
+                        name="\n".join(interfaces["name"]),
+                        mac_address="\n".join(interfaces["mac_address"]),
+                        ipv4_addresses="\n".join(interfaces["ipv4_addresses"]),
+                        ipv6_addresses="\n".join(interfaces["ipv6_addresses"]),
+                    )
+                )
+
+            content = self.generate_table(hosts)
+
+            return SignatureResult(
+                signature_name=self.name,
+                title="Host Interfaces",
+                content=content,
+                severity="info",
+            )
+
+        except Exception as e:
+            logger.error("Error in HostsInterfacesSignature: %s", e)
+            return None
+
+    def _get_interfaces(self, host):
+        """Extract interface information from host."""
+        inventory = json.loads(host["inventory"])
+        interfaces_details = defaultdict(list)
+
+        for interface in inventory.get("interfaces", []):
+            name = interface.get("name")
+            if not name:
+                continue
+            interfaces_details["name"].append(name)
+            interfaces_details["mac_address"].append(
+                json.dumps(interface.get("mac_address"))
+            )
+            interfaces_details["ipv4_addresses"].append(
+                json.dumps(interface.get("ipv4_addresses", []))
+            )
+            interfaces_details["ipv6_addresses"].append(
+                json.dumps(interface.get("ipv6_addresses", []))
+            )
+
+        return interfaces_details
+
+
+class StorageDetailSignature(Signature):
+    """Analyzes host storage details."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze host storage details."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster = metadata["cluster"]
+
+            hosts = []
+            for host in cluster["hosts"]:
+                inventory = json.loads(host["inventory"])
+                disks = inventory["disks"]
+
+                disks_details = {
+                    "type": [],
+                    "bootable": [],
+                    "name": [],
+                    "path": [],
+                    "by-path": [],
+                }
+
+                for d in disks:
+                    disk_type = d.get("drive_type", "Not available")
+                    disks_details["type"].append(disk_type)
+                    disks_details["bootable"].append(str(d.get("bootable", False)))
+                    disks_details["name"].append(d.get("name", "Not available"))
+                    disks_details["path"].append(d.get("path", "Not available"))
+                    disks_details["by-path"].append(d.get("by_path", "Not available"))
+
+                hosts.append(
+                    OrderedDict(
+                        **{
+                            "Host ID": host["id"],
+                            "Hostname": log_analyzer.get_hostname(host),
+                            "Disk Name": "\n".join(disks_details["name"]),
+                            "Disk Type": "\n".join(disks_details["type"]),
+                            "Disk Path": "\n".join(disks_details["path"]),
+                            "Disk Bootable": "\n".join(disks_details["bootable"]),
+                            "Disk by-path": "\n".join(disks_details["by-path"]),
+                        }
+                    )
+                )
+
+            content = self.generate_table(hosts)
+
+            return SignatureResult(
+                signature_name=self.name,
+                title="Host Storage Details",
+                content=content,
+                severity="info",
+            )
+
+        except Exception as e:
+            logger.error("Error in StorageDetailSignature: %s", e)
+            return None
diff --git a/log_analyzer/signatures/error_detection.py b/log_analyzer/signatures/error_detection.py
new file mode 100644
index 0000000..3fc230f
--- /dev/null
+++ b/log_analyzer/signatures/error_detection.py
@@ -0,0 +1,314 @@
+"""
+Error detection signatures for OpenShift Assisted Installer logs.
+These signatures identify specific error conditions during installation.
+"""
+
+import json
+import logging
+import os
+import re
+from collections import OrderedDict
+from typing import Optional
+
+import yaml
+from log_analyzer.log_analyzer import NEW_LOG_BUNDLE_PATH, OLD_LOG_BUNDLE_PATH
+
+from .base import ErrorSignature, SignatureResult
+
+logger = logging.getLogger(__name__)
+
+# pylint: disable=duplicate-code
+
+
+def _search_patterns_in_string(string, patterns):
+    """Utility function to search for patterns in a string."""
+    if isinstance(patterns, str):
+        patterns = [patterns]
+
+    combined_regex = re.compile(
+        f'({"|".join(fr".*{pattern}.*" for pattern in patterns)})'
+    )
+    return combined_regex.findall(string)
+
+
+class MasterFailedToPullIgnitionSignature(ErrorSignature):
+    """Finds clusters where master nodes failed to pull ignition."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze master nodes ignition pull failures."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster_hosts = metadata["cluster"]["hosts"]
+
+            # Not relevant for SNO
+            if len(cluster_hosts) <= 1:
+                return None
+
+            hosts = []
+            for host in cluster_hosts:
+                if (
+                    host["role"] == "bootstrap"
+                    and host["progress"]["current_stage"] == "WaitingForControlPlane"
+                ):
+                    # Probably failed due to other issues
+                    return None
+
+                inventory = json.loads(host["inventory"])
+                boot_mode = inventory.get("boot", {}).get("current_boot_mode", "N/A")
+
+                if (
+                    host["role"] == "master"
+                    and host["progress"]["current_stage"] == "Rebooting"
+                    and host["status"] == "error"
+                    and boot_mode == "bios"
+                ):
+                    hosts.append(
+                        OrderedDict(
+                            HostID=host["id"],
+                            Hostname=inventory["hostname"],
+                            Progress=host["progress"]["current_stage"],
+                        )
+                    )
+
+            if len(hosts) == 2:
+                # Only sign if both masters didn't pull ignition
+                content = "When both master nodes didn't pull the ignition post reboot there is nothing we can do.\n\n"
+                content += self.generate_table(hosts)
+
+                return self.create_result(
+                    title="Master Nodes Failed to Pull Ignition",
+                    content=content,
+                    severity="error",
+                )
+
+        except Exception as e:
+            logger.error("Error in MasterFailedToPullIgnitionSignature: %s", e)
+
+        return None
+
+
+class SNOHostnameHasEtcd(ErrorSignature):
+    """Looks for etcd in SNO hostname (OCPBUGS-15852)."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze SNO hostname for etcd."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster = metadata["cluster"]
+
+            if cluster.get("high_availability_mode") != "None":
+                return None
+
+            if len(cluster["hosts"]) != 1:
+                return None
+
+            hostname = log_analyzer.get_hostname(cluster["hosts"][0])
+            if "etcd" in hostname:
+                content = "Hostname cannot contain etcd, see https://issues.redhat.com/browse/OCPBUGS-15852"
+
+                return self.create_result(
+                    title="No etcd in SNO hostname", content=content, severity="error"
+                )
+
+        except Exception as e:
+            logger.error("Error in SNOHostnameHasEtcd: %s", e)
+
+        return None
+
+
+class ApiInvalidCertificateSignature(ErrorSignature):
+    """Detect invalid SAN values on certificate for AI API from controller logs."""
+
+    LOG_PATTERN = re.compile(
+        'time=".*" level=error msg=".*x509: certificate is valid.* not .*'
+    )
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        try:
+            controller_logs = log_analyzer.get_controller_logs()
+        except FileNotFoundError:
+            return None
+
+        invalid_api_log_lines = self.LOG_PATTERN.findall(controller_logs)
+        if invalid_api_log_lines:
+            shown = invalid_api_log_lines[:5]
+            more = len(invalid_api_log_lines) - len(shown)
+            content = "\n".join(shown)
+            if more > 0:
+                content += f"\nadditional {more} similar error log lines found"
+            return self.create_result(
+                title="Invalid SAN values on certificate for AI API",
+                content=content,
+                severity="error",
+            )
+        return None
+
+
+class ApiExpiredCertificateSignature(ErrorSignature):
+    """Detect expired or not yet valid certificate in kube-apiserver logs."""
+
+    LOG_PATTERN = re.compile("x509: certificate has expired or is not yet valid.*")
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        new_logs_path = f"{NEW_LOG_BUNDLE_PATH}/bootstrap/containers/bootstrap-control-plane/kube-apiserver.log"
+        old_logs_path = f"{OLD_LOG_BUNDLE_PATH}/bootstrap/containers/bootstrap-control-plane/kube-apiserver.log"
+        for path in (new_logs_path, old_logs_path):
+            try:
+                logs = log_analyzer.logs_archive.get(path)
+            except FileNotFoundError:
+                continue
+            invalid_api_log_lines = self.LOG_PATTERN.findall(logs)
+            if invalid_api_log_lines:
+                content = invalid_api_log_lines[0]
+                if (num_lines := len(invalid_api_log_lines)) > 1:
+                    content += (
+                        f"\nadditional {num_lines - 1} similar error log lines found"
+                    )
+                return self.create_result(
+                    title="Expired Certificate",
+                    content=content,
+                    severity="error",
+                )
+        return None
+
+
+class ReleasePullErrorSignature(ErrorSignature):
+    """Finds clusters where release image cannot be pulled by bootstrap node."""
+
+    ERROR_PATTERN = re.compile(r"release-image-download\.sh\[.+\]: Pull failed")
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        try:
+            cluster = log_analyzer.metadata["cluster"]
+        except Exception:
+            return None
+
+        hosts_sections = []
+        for host in cluster.get("hosts", []):
+            host_id = host["id"]
+            try:
+                journal_logs = log_analyzer.get_host_log_file(host_id, "journal.logs")
+            except FileNotFoundError:
+                continue
+            if self.ERROR_PATTERN.findall(journal_logs):
+                hosts_sections.append(
+                    f"Release image cannot be pulled on {host_id} ({log_analyzer.get_hostname(host)})"
+                )
+
+        if hosts_sections:
+            return self.create_result(
+                title="Release image cannot be pulled",
+                content="\n".join(hosts_sections),
+                severity="error",
+            )
+        return None
+
+
+class ErrorOnCleanupInstallDevice(ErrorSignature):
+    """Detect non-fatal errors during cleanupInstallDevice in installer logs."""
+
+    LOG_PATTERN = re.compile(r'msg="(?P<message>failed to prepare install device.*)"')
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        cluster = log_analyzer.metadata.get("cluster", {})
+        hosts = []
+        for host in cluster.get("hosts", []):
+            host_id = host["id"]
+            try:
+                installer_logs = log_analyzer.get_host_log_file(
+                    host_id, "installer.logs"
+                )
+            except FileNotFoundError:
+                continue
+            match = self.LOG_PATTERN.search(installer_logs)
+            if match:
+                hosts.append(
+                    OrderedDict(
+                        host=log_analyzer.get_hostname(host),
+                        message=match.group("message"),
+                    )
+                )
+        if hosts:
+            content = "cleanupInstallDevice function has failed for the following hosts. However, its failure does not block installation. Check logs to see if it is related to the installation failure\n"
+            content += self.generate_table(hosts)
+            return self.create_result(
+                title="Non-fatal error on cleanupInstallDevice",
+                content=content,
+                severity="warning",
+            )
+        return None
+
+
+class MissingMC(ErrorSignature):
+    """Looks for missing MachineConfig error in SNO clusters."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        cluster = log_analyzer.metadata.get("cluster", {})
+        if cluster.get("high_availability_mode") != "None":
+            return None
+        path = (
+            "controller_logs.tar.gz/must-gather.tar.gz/must-gather.local.*/*/cluster-scoped-resources/"
+            "machineconfiguration.openshift.io/machineconfigpools/master.yaml"
+        )
+        try:
+            raw = log_analyzer.logs_archive.get(path, mode="rb")
+        except FileNotFoundError:
+            return None
+        try:
+            text = raw.decode("utf-8")
+        except Exception:
+            return None
+        if re.search(r"rendered-master-[0-9a-f]{32}.*not found", text) is not None:
+            return self.create_result(
+                title="Missing MachineConfig issue",
+                content="Missing rendered MachineConfig issue detected",
+                severity="error",
+            )
+        return None
+
+
+class ErrorCreatingReadWriteLayer(ErrorSignature):
+    """Detect pods failing with error creating read-write layer (BZ 1993243)."""
+
+    @staticmethod
+    def _is_bad_pod(pod):
+        return any(
+            containerStatus.get("state", {}).get("waiting", {}).get("reason")
+            == "CreateContainerError"
+            and "error creating read-write layer with ID"
+            in containerStatus.get("state", {}).get("waiting", {}).get("message", "")
+            for containerStatus in pod.get("status", {}).get("containerStatuses", [])
+        )
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        try:
+            namespaces_dir = log_analyzer.logs_archive.get(
+                "controller_logs.tar.gz/must-gather.tar.gz/must-gather.local.*/*/namespaces"
+            )
+        except FileNotFoundError:
+            return None
+
+        messages = []
+        for namespace_dir in getattr(namespaces_dir, "iterdir", lambda: [])():
+            try:
+                pods_yaml_path = os.path.join(namespace_dir, "core", "pods.yaml")
+                pods_yaml = log_analyzer.logs_archive.get(pods_yaml_path)
+            except FileNotFoundError:
+                continue
+            try:
+                pods_doc = yaml.safe_load(pods_yaml) or {}
+                for pod in pods_doc.get("items", []):
+                    if self._is_bad_pod(pod):
+                        messages.append(
+                            f"Pod {pod['metadata']['name']} in namespace {pod['metadata']['namespace']} has a container with an error creating the read-write layer, see BZ 1993243"
+                        )
+            except Exception:
+                continue
+
+        if messages:
+            return self.create_result(
+                title="Error creating read-write layer - Bugzilla 1993243",
+                content="\n\n".join(messages),
+                severity="error",
+            )
+        return None
diff --git a/log_analyzer/signatures/networking.py b/log_analyzer/signatures/networking.py
new file mode 100644
index 0000000..b1993cd
--- /dev/null
+++ b/log_analyzer/signatures/networking.py
@@ -0,0 +1,354 @@
+"""
+Networking analysis signatures for OpenShift Assisted Installer logs.
+These signatures analyze network configuration and connectivity issues.
+"""
+
+import json
+import logging
+import ipaddress
+import os
+import re
+from typing import Optional
+
+from log_analyzer.log_analyzer import NEW_LOG_BUNDLE_PATH, OLD_LOG_BUNDLE_PATH
+from log_analyzer.signatures.advanced_analysis import (
+    operator_statuses_from_controller_logs,
+    filter_operators,
+)
+
+from .base import Signature, ErrorSignature, SignatureResult
+
+logger = logging.getLogger(__name__)
+
+
+class SNOMachineCidrSignature(Signature):
+    """Validates machine CIDR configuration for SNO clusters."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze SNO machine CIDR configuration."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster = metadata["cluster"]
+
+            if cluster.get("high_availability_mode") != "None":
+                return None
+
+            if not cluster.get("hosts"):
+                return None
+            host = cluster["hosts"][0]
+            inventory = json.loads(host["inventory"])
+
+            # The first one is the machine_cidr that will be used for network configuration
+            machine_cidr = ipaddress.ip_network(cluster["machine_networks"][0]["cidr"])
+
+            for route in inventory.get("routes", []):
+                # currently only relevant for ipv4
+                if (
+                    route.get("destination") == "0.0.0.0"
+                    and route.get("gateway")
+                    and ipaddress.ip_address(route["gateway"]) in machine_cidr
+                ):
+                    return None
+
+            content = (
+                f"Machine cidr {machine_cidr} doesn't match any default route configured on the host.\n"
+                f"It will cause etcd certificate error (or some other) as kubelet and OVNKubernetes will not run with expected machine cidr.\n"
+                f"We hope it will be fixed after https://issues.redhat.com/browse/SDN-3053"
+            )
+
+            return SignatureResult(
+                signature_name=self.name,
+                title="Invalid Machine CIDR",
+                content=content,
+                severity="error",
+            )
+
+        except Exception as e:
+            logger.error("Error in SNOMachineCidrSignature: %s", e)
+            return None
+
+
+class DuplicateVIP(ErrorSignature):
+    """Looks for nodes holding the same VIP."""
+
+    # pylint: disable=too-many-nested-blocks,too-many-branches
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze for duplicate VIP issues."""
+        try:
+            cluster = log_analyzer.metadata["cluster"]
+
+            # SNO doesn't need balancing
+            if cluster.get("high_availability_mode") == "None":
+                return None
+
+            # VIPs are not relevant with load balancer
+            if cluster.get("user_managed_networking") is True:  # noqa: E712
+                return None
+
+            vips = [vip["ip"] for vip in cluster.get("api_vips", [])]
+            if not vips:
+                return None
+
+            collisions = []
+            # Check control-plane nodes
+            try:
+                control_plane_dir = log_analyzer.logs_archive.get(
+                    f"{NEW_LOG_BUNDLE_PATH}/control-plane/"
+                )
+                for node_dir in getattr(control_plane_dir, "iterdir", lambda: [])():
+                    node_ip = os.path.basename(node_dir)
+                    try:
+                        ip_addr = log_analyzer.logs_archive.get(
+                            f"{NEW_LOG_BUNDLE_PATH}/control-plane/{node_ip}/network/ip-addr.txt"
+                        )
+                    except FileNotFoundError:
+                        continue
+                    for vip in vips:
+                        if vip in ip_addr:
+                            collisions.append((vip, node_ip))
+            except FileNotFoundError:
+                pass
+
+            # Check bootstrap
+            try:
+                bootstrap_ip_addr = log_analyzer.logs_archive.get(
+                    f"{NEW_LOG_BUNDLE_PATH}/bootstrap/network/ip-addr.txt"
+                )
+                for vip in vips:
+                    if vip in bootstrap_ip_addr:
+                        collisions.append((vip, "bootstrap"))
+            except FileNotFoundError:
+                pass
+
+            # Fallback to OLD path
+            if not collisions:
+                try:
+                    control_plane_dir = log_analyzer.logs_archive.get(
+                        f"{OLD_LOG_BUNDLE_PATH}/control-plane/"
+                    )
+                    for node_dir in getattr(control_plane_dir, "iterdir", lambda: [])():
+                        node_ip = os.path.basename(node_dir)
+                        try:
+                            ip_addr = log_analyzer.logs_archive.get(
+                                f"{OLD_LOG_BUNDLE_PATH}/control-plane/{node_ip}/network/ip-addr.txt"
+                            )
+                        except FileNotFoundError:
+                            continue
+                        for vip in vips:
+                            if vip in ip_addr:
+                                collisions.append((vip, node_ip))
+                except FileNotFoundError:
+                    pass
+
+                try:
+                    bootstrap_ip_addr = log_analyzer.logs_archive.get(
+                        f"{OLD_LOG_BUNDLE_PATH}/bootstrap/network/ip-addr.txt"
+                    )
+                    for vip in vips:
+                        if vip in bootstrap_ip_addr:
+                            collisions.append((vip, "bootstrap"))
+                except FileNotFoundError:
+                    pass
+
+            # Aggregate per VIP
+            vip_to_nodes = {}
+            for vip, node in collisions:
+                vip_to_nodes.setdefault(vip, set()).add(node)
+
+            dup_msgs = [
+                f"Found duplicate VIP {vip} in control-plane hosts {' and '.join(sorted(nodes))}"
+                for vip, nodes in vip_to_nodes.items()
+                if len(nodes) > 1
+            ]
+
+            if dup_msgs:
+                return self.create_result(
+                    title="VIP found in multiple nodes",
+                    content="\n".join(dup_msgs),
+                    severity="error",
+                )
+            return None
+
+        except Exception as e:
+            logger.error("Error in DuplicateVIP: %s", e)
+
+        return None
+
+
+class NameserverInClusterNetwork(ErrorSignature):
+    """Detect nameservers that overlap with cluster networks."""
+
+    NAMESERVER_PATTERN = re.compile(r"^nameserver (.*)$")
+
+    def _get_nameservers(self, log_analyzer, base_path: str):
+        nameservers = set()
+        # control-plane
+        try:
+            control_plane_dir = log_analyzer.logs_archive.get(
+                f"{base_path}/control-plane/"
+            )
+            for node_dir in getattr(control_plane_dir, "iterdir", lambda: [])():
+                node_ip = os.path.basename(node_dir)
+                try:
+                    resolvconf = log_analyzer.logs_archive.get(
+                        f"{base_path}/control-plane/{node_ip}/network/resolv.conf"
+                    )
+                except FileNotFoundError:
+                    continue
+                for line in resolvconf.splitlines():
+                    m = self.NAMESERVER_PATTERN.search(line)
+                    if m:
+                        nameservers.add(m.group(1))
+        except FileNotFoundError:
+            pass
+        # bootstrap
+        try:
+            resolvconf = log_analyzer.logs_archive.get(
+                f"{base_path}/bootstrap/network/resolv.conf"
+            )
+            for line in resolvconf.splitlines():
+                m = self.NAMESERVER_PATTERN.search(line)
+                if m:
+                    nameservers.add(m.group(1))
+        except FileNotFoundError:
+            pass
+        return nameservers
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        md = log_analyzer.metadata
+        cidrs = [
+            network["cidr"] for network in md["cluster"].get("cluster_networks", [])
+        ]
+        if not cidrs:
+            return None
+
+        report_lines = []
+        for base in (NEW_LOG_BUNDLE_PATH, OLD_LOG_BUNDLE_PATH):
+            nameservers = self._get_nameservers(log_analyzer, base)
+            for ns in nameservers:
+                for cidr in cidrs:
+                    try:
+                        if ipaddress.ip_address(ns) in ipaddress.ip_network(
+                            cidr, strict=False
+                        ):
+                            report_lines.append(
+                                f"User defined nameserver {ns} overlaps with the cluster network {cidr}"
+                            )
+                    except ValueError:
+                        continue
+        if report_lines:
+            return self.create_result(
+                title="Nameserver in internal network",
+                content="\n".join(sorted(set(report_lines))),
+                severity="error",
+            )
+        return None
+
+
+class NetworksMtuMismatch(ErrorSignature):
+    """Detect MTU mismatch between interface and overlay network."""
+
+    LOG_PATTERN = re.compile(
+        r"Failed to start sdn: interface MTU [(]([0-9]+)[)] is too small for specified overlay MTU [(]([0-9]+)[)]"
+    )
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        path = "controller_logs.tar.gz/must-gather.tar.gz/must-gather.local.*/*/namespaces/openshift-sdn/pods/sdn-*/sdn/sdn/logs/*.log"
+        try:
+            sdn_logs = log_analyzer.logs_archive.get(path)
+        except FileNotFoundError:
+            return None
+        m = self.LOG_PATTERN.search(sdn_logs)
+        if m:
+            return self.create_result(
+                title="Networks MTU Mismatch",
+                content=f"SDN failed to start: Overlay (cluster) network MTU {m.group(2)} is bigger than the interface MTU {m.group(1)}",
+                severity="error",
+            )
+        return None
+
+
+class DualStackBadRoute(ErrorSignature):
+    """Looks for BZ 2088346 in ovnkube-node logs."""
+
+    fatal_error_regex = re.compile(
+        r"^F.*failed to get default gateway interface$", re.MULTILINE
+    )
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        for base in (NEW_LOG_BUNDLE_PATH, OLD_LOG_BUNDLE_PATH):
+            path = f"{base}/control-plane/*/containers/ovnkube-node-*.log"
+            try:
+                ovnkube_logs = log_analyzer.logs_archive.get(path)
+            except FileNotFoundError:
+                continue
+            if self.fatal_error_regex.search(ovnkube_logs):
+                return self.create_result(
+                    title="Bugzilla 2088346",
+                    content="ovnkube-node logs indicate the cluster may be hitting BZ 2088346",
+                    severity="error",
+                )
+        return None
+
+
+class DualstackrDNSBug(ErrorSignature):
+    """Detect kube-apiserver 'must match public address family' message (MGMT-11651)."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        for base in (NEW_LOG_BUNDLE_PATH, OLD_LOG_BUNDLE_PATH):
+            path = f"{base}/bootstrap/containers/kube-apiserver-*.log"
+            try:
+                kubeapiserver_logs = log_analyzer.logs_archive.get(path)
+            except FileNotFoundError:
+                continue
+            if "must match public address family" in kubeapiserver_logs:
+                return self.create_result(
+                    title="rDNS and DNS entries for IPv4/IPv6 interface - MGMT-11651",
+                    content=(
+                        "kube-apiserver logs contain the message 'must match public address family', this is probably due to MGMT-11651"
+                    ),
+                    severity="warning",
+                )
+        return None
+
+
+class UserManagedNetworkingLoadBalancer(ErrorSignature):
+    """Detects UMN clusters where load-balancer related operators are the only unhealthy ones."""
+
+    lb_operators = {"authentication", "console", "ingress"}
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        metadata = log_analyzer.metadata
+        cluster_md = metadata.get("cluster", {})
+
+        if not cluster_md.get("user_managed_networking", False):
+            return None
+
+        if cluster_md.get("high_availability_mode") == "None":
+            return None
+
+        try:
+            controller_logs = log_analyzer.get_controller_logs()
+        except FileNotFoundError:
+            return None
+
+        operator_statuses = operator_statuses_from_controller_logs(controller_logs)
+
+        unhealthy_operators = filter_operators(
+            operator_statuses,
+            (("Degraded", True), ("Available", False), ("Progressing", True)),
+            aggregation_function=any,
+        )
+
+        unhealthy_keys = set(unhealthy_operators.keys())
+        if unhealthy_keys and unhealthy_keys.issubset(self.lb_operators):
+            content = "Cluster has user-managed networking and only load-balancer related operators seem to be unhealthy."
+            if missing := self.lb_operators - unhealthy_keys:
+                content += f" Operators missing from unhealthy set: {', '.join(sorted(missing))}."
+            return self.create_result(
+                title="Probably user managed load-balancer issues",
+                content=content,
+                severity="warning",
+            )
+
+        return None
diff --git a/log_analyzer/signatures/performance.py b/log_analyzer/signatures/performance.py
new file mode 100644
index 0000000..da74c37
--- /dev/null
+++ b/log_analyzer/signatures/performance.py
@@ -0,0 +1,250 @@
+"""
+Performance analysis signatures for OpenShift Assisted Installer logs.
+These signatures analyze installation performance and identify bottlenecks.
+"""
+
+import logging
+import re
+from collections import OrderedDict
+from typing import Optional, List, Dict, Any
+
+import dateutil.parser
+
+from .base import Signature, ErrorSignature, SignatureResult
+
+logger = logging.getLogger(__name__)
+
+
+class SlowImageDownloadSignature(ErrorSignature):
+    """Analyzes slow image download rates."""
+
+    image_download_regex = re.compile(
+        r"Host (?P<hostname>.+?): New image status (?P<image>.+?). result:.+?; download rate: (?P<download_rate>.+?) MBps"
+    )
+    minimum_download_rate_mb = 10
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze image download speeds."""
+        try:
+            events = log_analyzer.get_last_install_cluster_events()
+            image_info_list = self._list_image_download_info(events)
+
+            abnormal_image_info = []
+            for image_info in image_info_list:
+                if float(image_info["download_rate"]) < self.minimum_download_rate_mb:
+                    abnormal_image_info.append(image_info)
+
+            if abnormal_image_info:
+                content = "Detected slow image download rate (MBps):\n"
+                content += self.generate_table(abnormal_image_info)
+
+                return self.create_result(
+                    title="Slow Image Download", content=content, severity="warning"
+                )
+
+        except Exception as e:
+            logger.error("Error in SlowImageDownloadSignature: %s", e)
+
+        return None
+
+    @classmethod
+    def _list_image_download_info(
+        cls, events: List[Dict[str, Any]]
+    ) -> List[Dict[str, str]]:
+        """Extract image download information from events."""
+
+        def get_image_download_info(event):
+            match = cls.image_download_regex.match(event["message"])
+            if match:
+                return match.groupdict()
+            return None
+
+        return [
+            info
+            for event in events
+            if (info := get_image_download_info(event)) is not None
+        ]
+
+
+class OSInstallationTimeSignature(Signature):
+    """Analyzes OS installation time duration."""
+
+    writing_image_start_event_regex = re.compile(
+        r".*reached installation stage Writing image to disk$"
+    )
+    writing_image_end_event_regex = re.compile(
+        r".*reached installation stage Writing image to disk: 100%$"
+    )
+    slow_threshold_seconds = 300
+
+    class NoEventFound(Exception):
+        pass
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze OS installation time."""
+        try:
+            metadata = log_analyzer.metadata
+            cluster = metadata["cluster"]
+            events_by_host = log_analyzer.get_events_by_host()
+
+            host_entries = []
+            for host in cluster["hosts"]:
+                host_id = host["id"]
+                host_events = events_by_host.get(host_id, [])
+                entry = self._create_host_entry(host, host_events, log_analyzer)
+                host_entries.append(entry)
+
+            # Only report if we have at least one slow host
+            if any("slow" in str(host.get("duration", "")) for host in host_entries):
+                content = "Some hosts had a slow OS installation. This is usually due to slow installation media (e.g. virtual media), but it could also be because of a slow disk\n\n"
+                content += self.generate_table(host_entries)
+
+                return SignatureResult(
+                    signature_name=self.name,
+                    title="OS Installation Time Analysis",
+                    content=content,
+                    severity="warning",
+                )
+
+        except Exception as e:
+            logger.error("Error in OSInstallationTimeSignature: %s", e)
+
+        return None
+
+    @classmethod
+    def _create_host_entry(
+        cls, host: Dict[str, Any], host_events: List[Dict[str, Any]], log_analyzer
+    ) -> Dict[str, Any]:
+        """Create host entry with duration analysis."""
+        entry = OrderedDict(
+            id=host["id"],
+            hostname=log_analyzer.get_hostname(host),
+            duration="OS installation time duration could not be determined for this host",
+            installation_disk=host.get("installation_disk_path", ""),
+        )
+
+        try:
+            start_time = cls._get_start_event_timestamp(host_events)
+            end_time = cls._get_end_event_timestamp(host_events)
+            total_duration_seconds = (end_time - start_time).total_seconds()
+        except cls.NoEventFound:
+            return entry
+
+        if total_duration_seconds <= 0:
+            return entry
+
+        if total_duration_seconds > cls.slow_threshold_seconds:
+            entry["duration"] = (
+                f"OS installation was rather slow, it took {total_duration_seconds} seconds"
+            )
+        else:
+            entry["duration"] = (
+                f"OS installation was relatively okay, it took {total_duration_seconds} seconds"
+            )
+
+        return entry
+
+    @classmethod
+    def _get_start_event_timestamp(cls, all_events: List[Dict[str, Any]]):
+        """Get start event timestamp."""
+        return cls._get_event_timestamp(
+            cls._get_last_event(all_events, cls.writing_image_start_event_regex)
+        )
+
+    @classmethod
+    def _get_end_event_timestamp(cls, all_events: List[Dict[str, Any]]):
+        """Get end event timestamp."""
+        return cls._get_event_timestamp(
+            cls._get_last_event(all_events, cls.writing_image_end_event_regex)
+        )
+
+    @classmethod
+    def _get_last_event(cls, all_events: List[Dict[str, Any]], regex):
+        """Get the last event matching a regex."""
+        try:
+            *_, last = (
+                event
+                for event in all_events
+                if regex.match(event["message"]) is not None
+            )
+        except ValueError as exc:
+            raise cls.NoEventFound from exc
+        return last
+
+    @staticmethod
+    def _get_event_timestamp(event: Dict[str, Any]):
+        """Get timestamp from event."""
+        return dateutil.parser.isoparse(event["event_time"])
+
+
+class InstallationDiskFIOSignature(Signature):
+    """Analyzes slow installation disks using FIO metrics."""
+
+    fio_regex = re.compile(r"\(fdatasync duration:\s(\d+)\sms\)")
+
+    # pylint: disable=too-many-locals
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        """Analyze disk FIO performance."""
+        try:
+            cluster = log_analyzer.metadata["cluster"]
+
+            events = log_analyzer.get_last_install_cluster_events()
+            fio_events = self._get_fio_events(events)
+
+            fio_events_by_host = {}
+            for event, fio_duration in fio_events:
+                host_id = event.get("host_id")
+                if host_id:
+                    if host_id not in fio_events_by_host:
+                        fio_events_by_host[host_id] = []
+                    fio_events_by_host[host_id].append((event, fio_duration))
+
+            hosts = []
+            for host in cluster["hosts"]:
+                host_fio_events = fio_events_by_host.get(host["id"], [])
+                if host_fio_events:
+                    _events, host_fio_events_durations = zip(*host_fio_events)
+                    fio_message = (
+                        "Installation disk is too slow, fio durations: "
+                        + ", ".join(
+                            f"{duration}ms" for duration in host_fio_events_durations
+                        )
+                    )
+
+                    hosts.append(
+                        OrderedDict(
+                            id=host["id"],
+                            hostname=log_analyzer.get_hostname(host),
+                            fio=fio_message,
+                            installation_disk=host.get("installation_disk_path", ""),
+                        )
+                    )
+
+            if hosts:
+                return SignatureResult(
+                    signature_name=self.name,
+                    title="Host Slow Installation Disks",
+                    content=self.generate_table(hosts),
+                    severity="warning",
+                )
+
+        except Exception as e:
+            logger.error("Error in InstallationDiskFIOSignature: %s", e)
+
+        return None
+
+    @classmethod
+    def _get_fio_events(cls, events):
+        """Extract FIO events from cluster events."""
+
+        def get_duration(event):
+            matches = cls.fio_regex.findall(event["message"])
+            if len(matches) == 0:
+                return None
+            return int(matches[0])
+
+        return (
+            (event, get_duration(event))
+            for event in events
+            if get_duration(event) is not None
+        )
diff --git a/log_analyzer/signatures/platform_specific.py b/log_analyzer/signatures/platform_specific.py
new file mode 100644
index 0000000..f4498cb
--- /dev/null
+++ b/log_analyzer/signatures/platform_specific.py
@@ -0,0 +1,122 @@
+"""
+Platform-specific signatures for OpenShift Assisted Installer logs.
+These signatures analyze issues specific to certain platforms or virtualization technologies.
+"""
+
+import gzip
+import ipaddress
+import json
+import logging
+import re
+from collections import OrderedDict
+from typing import Optional
+
+from .base import ErrorSignature, SignatureResult
+
+logger = logging.getLogger(__name__)
+
+
+class LibvirtRebootFlagSignature(ErrorSignature):
+    """Detect potential libvirt _on_reboot_ flag issue (MGMT-2840)."""
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        md = log_analyzer.metadata
+        cluster = md["cluster"]
+        # not relevant for SNO
+        if len(cluster.get("hosts", [])) <= 1:
+            return None
+
+        hosts = []
+        for host in cluster.get("hosts", []):
+            inventory = json.loads(host.get("inventory", "{}"))
+            if (
+                len(inventory.get("disks", [])) == 1
+                and "KVM" in inventory.get("system_vendor", {}).get("product_name", "")
+                and host.get("progress", {}).get("current_stage") == "Rebooting"
+                and host.get("status") == "error"
+            ):
+                if host.get("role") == "bootstrap":
+                    continue
+                hosts.append(
+                    OrderedDict(
+                        id=host["id"],
+                        hostname=log_analyzer.get_hostname(host),
+                        role=host.get("role"),
+                        progress=host.get("progress", {}).get("current_stage"),
+                        status=host.get("status"),
+                        num_disks=len(inventory.get("disks", [])),
+                    )
+                )
+        if hosts and len(hosts) + 1 == len(cluster.get("hosts", [])):
+            return self.create_result(
+                title="Potential hosts with libvirt _on_reboot_ flag issue (MGMT-2840)",
+                content=self.generate_table(hosts),
+                severity="warning",
+            )
+        return None
+
+
+class IpChangedAfterReboot(ErrorSignature):
+    """Detect if IP changed after reboot based on journals and inventory."""
+
+    agent_log_regex = re.compile(
+        r"Sending step <inventory-[0-9a-f]{8}> reply output <(.+)> error <.*> exit-code <0>"
+    )
+    journal_lease_regex = re.compile(r"state changed new lease, address=([^ \n]*)")
+
+    def _get_inventory(self, log_analyzer, host_id):
+        try:
+            agent_logs = log_analyzer.get_host_log_file(host_id, "agent.logs")
+        except FileNotFoundError:
+            return None
+        match = self.agent_log_regex.search(agent_logs)
+        return json.loads(match.group(1).replace('\\"', '"')) if match else None
+
+    def _get_address_map(self, inventory):
+        address_map = {}
+        interfaces = inventory.get("interfaces")
+        if interfaces:
+            for interface in interfaces:
+                for key in ["ipv4_addresses", "ipv6_addresses"]:
+                    addresses = interface.get(key)
+                    if addresses:
+                        for addr in addresses:
+                            intf = ipaddress.ip_interface(addr)
+                            address_map[str(intf.ip)] = str(intf.network)
+        return address_map
+
+    def analyze(self, log_analyzer) -> Optional[SignatureResult]:
+        md = log_analyzer.metadata
+        cluster = md["cluster"]
+
+        for host in cluster.get("hosts", []):
+            host_id = host["id"]
+            inventory = self._get_inventory(log_analyzer, host_id)
+            if not inventory:
+                continue
+            address_map = self._get_address_map(inventory)
+            if not address_map:
+                continue
+            for addr, n in address_map.items():
+                try:
+                    journal_gz = log_analyzer.get_journal_log(
+                        addr, "journal.log.gz", mode="rb"
+                    )
+                    journal = gzip.decompress(journal_gz).decode(
+                        "utf-8", errors="ignore"
+                    )
+                except FileNotFoundError:
+                    continue
+                for match in self.journal_lease_regex.finditer(journal):
+                    cidr = address_map.get(match.group(1))
+                    if not cidr:
+                        ipaddr = ipaddress.ip_address(match.group(1))
+                        if ipaddr in ipaddress.ip_network(n):
+                            return self.create_result(
+                                title="Ip changed after reboot",
+                                content=(
+                                    f"Discovered address {addr} changed by leased address {match.group(1)} after reboot for host {host_id}"
+                                ),
+                                severity="warning",
+                            )
+        return None
diff --git a/pyproject.toml b/pyproject.toml
index bde6d4d..3ed575e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -14,13 +14,15 @@ dependencies = [
     "prometheus_client>=0.22.1",
     "pyyaml>=6",
     "jinja2>=3.1",
-    "pydantic>=2",
+    "pydantic>=2.12.1",
+    "nestedarchive>=0.2.4",
+    "tabulate>=0.9.0",
 ]
 
 [dependency-groups]
 dev = [
     "black>=25.1.0",
-    "mypy>=1.16.1",
+    "mypy>=1.18.2",
     "pydocstyle>=6.3.0",
     "pylint>=3.3.7",
     "pyright>=1.1.402",
@@ -74,3 +76,13 @@ asyncio_mode = "auto"
 add-ignore=[
   "D400"  # Stop requiring periods after non-sentences.
 ]
+
+[tool.mypy]
+exclude = "log_analyzer/"
+follow_imports = "skip"
+explicit_package_bases = true
+disallow_untyped_calls = true
+disallow_untyped_defs = true 
+disallow_incomplete_defs = true
+ignore_missing_imports = true 
+disable_error_code = ["attr-defined"]
diff --git a/server.py b/server.py
index 60975d6..6fc4953 100644
--- a/server.py
+++ b/server.py
@@ -17,6 +17,7 @@
 from pydantic import Field
 from assisted_service_client import models
 from mcp.server.fastmcp import FastMCP
+from log_analyzer.main import analyze_cluster
 
 from metrics import metrics, track_tool_usage, initiate_metrics
 from service_client import InventoryClient
@@ -37,6 +38,11 @@
 mcp = FastMCP("AssistedService", host="0.0.0.0", stateless_http=use_stateless_http)
 
 
+TROUBLESHOOTING_ENABLED = (
+    os.environ.get("ENABLE_TROUBLESHOOTING_TOOLS", "0").lower() == "1"
+)
+
+
 def format_presigned_url(presigned_url: models.PresignedUrl) -> dict[str, Any]:
     r"""
     Format a presigned URL object into a readable string.
@@ -1009,6 +1015,18 @@ async def set_cluster_ssh_key(
     return result.to_str()
 
 
+@track_tool_usage()
+async def analyze_cluster_logs(
+    cluster_id: Annotated[str, Field(description="The ID of the cluster")],
+) -> str:
+    """
+    Analyze the cluster logs for the given cluster_id and return the results.
+    """
+    client = InventoryClient(get_access_token())
+    results = await analyze_cluster(cluster_id=cluster_id, api_client=client)
+    return "\n\n".join([str(r) for r in results])
+
+
 def list_tools() -> list[str]:
     """List all MCP tools."""
 
@@ -1026,6 +1044,9 @@ async def mcp_list_tools() -> list[str]:
         app = mcp.sse_app()
         log.info("Using SSE transport (stateful)")
 
+    if TROUBLESHOOTING_ENABLED:
+        mcp.add_tool(analyze_cluster_logs)
+
     initiate_metrics(list_tools())
     app.add_route("/metrics", metrics)
     uvicorn.run(app, host="0.0.0.0")
diff --git a/service_client/assisted_service_api.py b/service_client/assisted_service_api.py
index 4c1f503..3fbc071 100644
--- a/service_client/assisted_service_api.py
+++ b/service_client/assisted_service_api.py
@@ -11,9 +11,10 @@
 from typing import Any, Optional, cast, Callable, TypeVar
 from urllib.parse import urlparse
 
+import nestedarchive
 import requests
 from requests.exceptions import RequestException
-from assisted_service_client import ApiClient, Configuration, api, models
+from assisted_service_client import ApiClient, Configuration, PresignedUrl, api, models
 
 from service_client.logger import log
 from service_client.exceptions import sanitize_exceptions
@@ -156,6 +157,22 @@ async def list_clusters(self) -> list:
         log.info("Successfully listed clusters")
         return cast(list, result)
 
+    @sanitize_exceptions
+    async def get_cluster_logs(
+        self, cluster_id: str
+    ) -> nestedarchive.RemoteNestedArchive:
+        result = await self._api_call(
+            self._installer_api().v2_get_presigned_for_cluster_files,
+            cluster_id=cluster_id,
+            file_name="logs",
+        )
+
+        logs_url = cast(PresignedUrl, result).url
+        log.info("Downloading logs from %s", logs_url)
+        return nestedarchive.RemoteNestedArchive(
+            cast(str, logs_url), init_download=True
+        )
+
     @sanitize_exceptions
     async def get_events(
         self,
diff --git a/template.yaml b/template.yaml
index 5bca85f..d7b24b9 100644
--- a/template.yaml
+++ b/template.yaml
@@ -43,6 +43,9 @@ parameters:
 - name: TRANSPORT
   value: "streamable-http"
   description: "MCP Server transport type, can be sse or streamable-http"
+- name: ENABLE_TROUBLESHOOTING_TOOLS
+  value: "0"
+  description: "Whether the troubleshooting tool call(s) should be enabled"
 
 apiVersion: template.openshift.io/v1
 kind: Template
@@ -101,6 +104,8 @@ objects:
             value: ${LOGGING_LEVEL}
           - name: TRANSPORT
             value: ${TRANSPORT}
+          - name: ENABLE_TROUBLESHOOTING_TOOLS
+            value: ${ENABLE_TROUBLESHOOTING_TOOLS}
 - apiVersion: v1
   kind: Service
   metadata:
diff --git a/uv.lock b/uv.lock
index 0dc5980..2d22bac 100644
--- a/uv.lock
+++ b/uv.lock
@@ -115,7 +115,7 @@ wheels = [
 
 [[package]]
 name = "assisted-service-client"
-version = "2.46.0.post14"
+version = "2.46.0.post17"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -123,9 +123,9 @@ dependencies = [
     { name = "six" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/de/64/870e9cae96bb2fb042c1c52c3ddd0e44f4c4c8674bdd37f612f736238761/assisted_service_client-2.46.0.post14.tar.gz", hash = "sha256:756e92918def5881953241d615b0be837b148c7de27fbf8a32a5f1cc1311875f", size = 166222, upload-time = "2025-10-08T13:00:15.836Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/91/65/370e5b399890b26a5dc0c368a52ec416e1fcaadbece5cf0c260f35c1dd18/assisted_service_client-2.46.0.post17.tar.gz", hash = "sha256:9b2d7228d14a082e8514459041c364107e844e48be2103bec66de8b48a9ca8c1", size = 166151, upload-time = "2025-10-14T08:29:30.454Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/9f/954aa695c898f46f831f6796a62cd596968a13688bc0346d129e8838befc/assisted_service_client-2.46.0.post14-py3-none-any.whl", hash = "sha256:cb67f830bfda863eeb70d4bd6803df04f62775973ee117d09eef9c1a26136178", size = 459808, upload-time = "2025-10-08T13:00:09.671Z" },
+    { url = "https://files.pythonhosted.org/packages/81/94/cd99878d3f366d8000265e18eedb4e16ea614581f9899219f68cf5b9f098/assisted_service_client-2.46.0.post17-py3-none-any.whl", hash = "sha256:c4b6d88a17f923217deda6bbd38d9a864c968e741ff4946d6a74701a1cc311f9", size = 459807, upload-time = "2025-10-14T08:29:24.843Z" },
 ]
 
 [[package]]
@@ -136,12 +136,14 @@ dependencies = [
     { name = "assisted-service-client" },
     { name = "jinja2" },
     { name = "mcp" },
+    { name = "nestedarchive" },
     { name = "netaddr" },
     { name = "prometheus-client" },
     { name = "pydantic" },
     { name = "pyyaml" },
     { name = "requests" },
     { name = "retry" },
+    { name = "tabulate" },
     { name = "types-requests" },
 ]
 
@@ -170,19 +172,21 @@ requires-dist = [
     { name = "assisted-service-client", specifier = ">=2.41.0.post3" },
     { name = "jinja2", specifier = ">=3.1" },
     { name = "mcp", specifier = ">=1.15.0" },
+    { name = "nestedarchive", specifier = ">=0.2.4" },
     { name = "netaddr", specifier = ">=1.3.0" },
     { name = "prometheus-client", specifier = ">=0.22.1" },
-    { name = "pydantic", specifier = ">=2" },
+    { name = "pydantic", specifier = ">=2.12.1" },
     { name = "pyyaml", specifier = ">=6" },
     { name = "requests", specifier = ">=2.32.3" },
     { name = "retry", specifier = ">=0.9.2" },
+    { name = "tabulate", specifier = ">=0.9.0" },
     { name = "types-requests", specifier = ">=2.32.4.20250611" },
 ]
 
 [package.metadata.requires-dev]
 dev = [
     { name = "black", specifier = ">=25.1.0" },
-    { name = "mypy", specifier = ">=1.16.1" },
+    { name = "mypy", specifier = ">=1.18.2" },
     { name = "pydocstyle", specifier = ">=6.3.0" },
     { name = "pylint", specifier = ">=3.3.7" },
     { name = "pyright", specifier = ">=1.1.402" },
@@ -199,11 +203,11 @@ test = [
 
 [[package]]
 name = "astroid"
-version = "3.3.11"
+version = "4.0.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/18/74/dfb75f9ccd592bbedb175d4a32fc643cf569d7c218508bfbd6ea7ef9c091/astroid-3.3.11.tar.gz", hash = "sha256:1e5a5011af2920c7c67a53f65d536d65bfa7116feeaf2354d8b94f29573bb0ce", size = 400439, upload-time = "2025-07-13T18:04:23.177Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/d1/6eee8726a863f28ff50d26c5eacb1a590f96ccbb273ce0a8c047ffb10f5a/astroid-4.0.1.tar.gz", hash = "sha256:0d778ec0def05b935e198412e62f9bcca8b3b5c39fdbe50b0ba074005e477aab", size = 405414, upload-time = "2025-10-11T15:15:42.6Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/af/0f/3b8fdc946b4d9cc8cc1e8af42c4e409468c84441b933d037e101b3d72d86/astroid-3.3.11-py3-none-any.whl", hash = "sha256:54c760ae8322ece1abd213057c4b5bba7c49818853fc901ef09719a60dbf9dec", size = 275612, upload-time = "2025-07-13T18:04:21.07Z" },
+    { url = "https://files.pythonhosted.org/packages/47/f4/034361a9cbd9284ef40c8ad107955ede4efae29cbc17a059f63f6569c06a/astroid-4.0.1-py3-none-any.whl", hash = "sha256:37ab2f107d14dc173412327febf6c78d39590fdafcb44868f03b6c03452e3db0", size = 276268, upload-time = "2025-10-11T15:15:40.585Z" },
 ]
 
 [[package]]
@@ -247,33 +251,43 @@ wheels = [
 
 [[package]]
 name = "charset-normalizer"
-version = "3.4.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/83/2d/5fd176ceb9b2fc619e63405525573493ca23441330fcdaee6bef9460e924/charset_normalizer-3.4.3.tar.gz", hash = "sha256:6fce4b8500244f6fcb71465d4a4930d132ba9ab8e71a7859e6a5d59851068d14", size = 122371, upload-time = "2025-08-09T07:57:28.46Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/65/ca/2135ac97709b400c7654b4b764daf5c5567c2da45a30cdd20f9eefe2d658/charset_normalizer-3.4.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:14c2a87c65b351109f6abfc424cab3927b3bdece6f706e4d12faaf3d52ee5efe", size = 205326, upload-time = "2025-08-09T07:56:24.721Z" },
-    { url = "https://files.pythonhosted.org/packages/71/11/98a04c3c97dd34e49c7d247083af03645ca3730809a5509443f3c37f7c99/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41d1fc408ff5fdfb910200ec0e74abc40387bccb3252f3f27c0676731df2b2c8", size = 146008, upload-time = "2025-08-09T07:56:26.004Z" },
-    { url = "https://files.pythonhosted.org/packages/60/f5/4659a4cb3c4ec146bec80c32d8bb16033752574c20b1252ee842a95d1a1e/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1bb60174149316da1c35fa5233681f7c0f9f514509b8e399ab70fea5f17e45c9", size = 159196, upload-time = "2025-08-09T07:56:27.25Z" },
-    { url = "https://files.pythonhosted.org/packages/86/9e/f552f7a00611f168b9a5865a1414179b2c6de8235a4fa40189f6f79a1753/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:30d006f98569de3459c2fc1f2acde170b7b2bd265dc1943e87e1a4efe1b67c31", size = 156819, upload-time = "2025-08-09T07:56:28.515Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/95/42aa2156235cbc8fa61208aded06ef46111c4d3f0de233107b3f38631803/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:416175faf02e4b0810f1f38bcb54682878a4af94059a1cd63b8747244420801f", size = 151350, upload-time = "2025-08-09T07:56:29.716Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/a9/3865b02c56f300a6f94fc631ef54f0a8a29da74fb45a773dfd3dcd380af7/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6aab0f181c486f973bc7262a97f5aca3ee7e1437011ef0c2ec04b5a11d16c927", size = 148644, upload-time = "2025-08-09T07:56:30.984Z" },
-    { url = "https://files.pythonhosted.org/packages/77/d9/cbcf1a2a5c7d7856f11e7ac2d782aec12bdfea60d104e60e0aa1c97849dc/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:fdabf8315679312cfa71302f9bd509ded4f2f263fb5b765cf1433b39106c3cc9", size = 160468, upload-time = "2025-08-09T07:56:32.252Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/42/6f45efee8697b89fda4d50580f292b8f7f9306cb2971d4b53f8914e4d890/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:bd28b817ea8c70215401f657edef3a8aa83c29d447fb0b622c35403780ba11d5", size = 158187, upload-time = "2025-08-09T07:56:33.481Z" },
-    { url = "https://files.pythonhosted.org/packages/70/99/f1c3bdcfaa9c45b3ce96f70b14f070411366fa19549c1d4832c935d8e2c3/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:18343b2d246dc6761a249ba1fb13f9ee9a2bcd95decc767319506056ea4ad4dc", size = 152699, upload-time = "2025-08-09T07:56:34.739Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/ad/b0081f2f99a4b194bcbb1934ef3b12aa4d9702ced80a37026b7607c72e58/charset_normalizer-3.4.3-cp313-cp313-win32.whl", hash = "sha256:6fb70de56f1859a3f71261cbe41005f56a7842cc348d3aeb26237560bfa5e0ce", size = 99580, upload-time = "2025-08-09T07:56:35.981Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/8f/ae790790c7b64f925e5c953b924aaa42a243fb778fed9e41f147b2a5715a/charset_normalizer-3.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:cf1ebb7d78e1ad8ec2a8c4732c7be2e736f6e5123a4146c5b89c9d1f585f8cef", size = 107366, upload-time = "2025-08-09T07:56:37.339Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/91/b5a06ad970ddc7a0e513112d40113e834638f4ca1120eb727a249fb2715e/charset_normalizer-3.4.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3cd35b7e8aedeb9e34c41385fda4f73ba609e561faedfae0a9e75e44ac558a15", size = 204342, upload-time = "2025-08-09T07:56:38.687Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/ec/1edc30a377f0a02689342f214455c3f6c2fbedd896a1d2f856c002fc3062/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b89bc04de1d83006373429975f8ef9e7932534b8cc9ca582e4db7d20d91816db", size = 145995, upload-time = "2025-08-09T07:56:40.048Z" },
-    { url = "https://files.pythonhosted.org/packages/17/e5/5e67ab85e6d22b04641acb5399c8684f4d37caf7558a53859f0283a650e9/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2001a39612b241dae17b4687898843f254f8748b796a2e16f1051a17078d991d", size = 158640, upload-time = "2025-08-09T07:56:41.311Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/e5/38421987f6c697ee3722981289d554957c4be652f963d71c5e46a262e135/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8dcfc373f888e4fb39a7bc57e93e3b845e7f462dacc008d9749568b1c4ece096", size = 156636, upload-time = "2025-08-09T07:56:43.195Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/e4/5a075de8daa3ec0745a9a3b54467e0c2967daaaf2cec04c845f73493e9a1/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18b97b8404387b96cdbd30ad660f6407799126d26a39ca65729162fd810a99aa", size = 150939, upload-time = "2025-08-09T07:56:44.819Z" },
-    { url = "https://files.pythonhosted.org/packages/02/f7/3611b32318b30974131db62b4043f335861d4d9b49adc6d57c1149cc49d4/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ccf600859c183d70eb47e05a44cd80a4ce77394d1ac0f79dbd2dd90a69a3a049", size = 148580, upload-time = "2025-08-09T07:56:46.684Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/61/19b36f4bd67f2793ab6a99b979b4e4f3d8fc754cbdffb805335df4337126/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:53cd68b185d98dde4ad8990e56a58dea83a4162161b1ea9272e5c9182ce415e0", size = 159870, upload-time = "2025-08-09T07:56:47.941Z" },
-    { url = "https://files.pythonhosted.org/packages/06/57/84722eefdd338c04cf3030ada66889298eaedf3e7a30a624201e0cbe424a/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:30a96e1e1f865f78b030d65241c1ee850cdf422d869e9028e2fc1d5e4db73b92", size = 157797, upload-time = "2025-08-09T07:56:49.756Z" },
-    { url = "https://files.pythonhosted.org/packages/72/2a/aff5dd112b2f14bcc3462c312dce5445806bfc8ab3a7328555da95330e4b/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d716a916938e03231e86e43782ca7878fb602a125a91e7acb8b5112e2e96ac16", size = 152224, upload-time = "2025-08-09T07:56:51.369Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/8c/9839225320046ed279c6e839d51f028342eb77c91c89b8ef2549f951f3ec/charset_normalizer-3.4.3-cp314-cp314-win32.whl", hash = "sha256:c6dbd0ccdda3a2ba7c2ecd9d77b37f3b5831687d8dc1b6ca5f56a4880cc7b7ce", size = 100086, upload-time = "2025-08-09T07:56:52.722Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/7a/36fbcf646e41f710ce0a563c1c9a343c6edf9be80786edeb15b6f62e17db/charset_normalizer-3.4.3-cp314-cp314-win_amd64.whl", hash = "sha256:73dc19b562516fc9bcf6e5d6e596df0b4eb98d87e4f79f3ae71840e6ed21361c", size = 107400, upload-time = "2025-08-09T07:56:55.172Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1f/f041989e93b001bc4e44bb1669ccdcf54d3f00e628229a85b08d330615c5/charset_normalizer-3.4.3-py3-none-any.whl", hash = "sha256:ce571ab16d890d23b5c278547ba694193a45011ff86a9162a71307ed9f86759a", size = 53175, upload-time = "2025-08-09T07:57:26.864Z" },
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
 ]
 
 [[package]]
@@ -488,20 +502,20 @@ wheels = [
 
 [[package]]
 name = "httpx-sse"
-version = "0.4.2"
+version = "0.4.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/63/7a/280d644f906f077e4f4a6d327e9b6e5a936624395ad1bf6ee9165a9d9959/httpx_sse-0.4.2.tar.gz", hash = "sha256:5bb6a2771a51e6c7a5f5c645e40b8a5f57d8de708f46cb5f3868043c3c18124e", size = 16000, upload-time = "2025-10-07T08:10:05.219Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4f/e5/ec31165492ecc52426370b9005e0637d6da02f9579283298affcb1ab614d/httpx_sse-0.4.2-py3-none-any.whl", hash = "sha256:a9fa4afacb293fa50ef9bacb6cae8287ba5fd1f4b1c2d10a35bb981c41da31ab", size = 9018, upload-time = "2025-10-07T08:10:04.257Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
 ]
 
 [[package]]
 name = "idna"
-version = "3.10"
+version = "3.11"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
 ]
 
 [[package]]
@@ -515,11 +529,11 @@ wheels = [
 
 [[package]]
 name = "isort"
-version = "6.1.0"
+version = "7.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1e/82/fa43935523efdfcce6abbae9da7f372b627b27142c3419fcf13bf5b0c397/isort-6.1.0.tar.gz", hash = "sha256:9b8f96a14cfee0677e78e941ff62f03769a06d412aabb9e2a90487b3b7e8d481", size = 824325, upload-time = "2025-10-01T16:26:45.027Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/63/53/4f3c058e3bace40282876f9b553343376ee687f3c35a525dc79dbd450f88/isort-7.0.0.tar.gz", hash = "sha256:5513527951aadb3ac4292a41a16cbc50dd1642432f5e8c20057d414bdafb4187", size = 805049, upload-time = "2025-10-11T13:30:59.107Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7f/cc/9b681a170efab4868a032631dea1e8446d8ec718a7f657b94d49d1a12643/isort-6.1.0-py3-none-any.whl", hash = "sha256:58d8927ecce74e5087aef019f778d4081a3b6c98f15a80ba35782ca8a2097784", size = 94329, upload-time = "2025-10-01T16:26:43.291Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/ed/e3705d6d02b4f7aea715a353c8ce193efd0b5db13e204df895d38734c244/isort-7.0.0-py3-none-any.whl", hash = "sha256:1bcabac8bc3c36c7fb7b98a76c8abb18e0f841a3ba81decac7691008592499c1", size = 94672, upload-time = "2025-10-11T13:30:57.665Z" },
 ]
 
 [[package]]
@@ -624,7 +638,7 @@ wheels = [
 
 [[package]]
 name = "mcp"
-version = "1.16.0"
+version = "1.17.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -639,9 +653,9 @@ dependencies = [
     { name = "starlette" },
     { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3d/a1/b1f328da3b153683d2ec34f849b4b6eac2790fb240e3aef06ff2fab3df9d/mcp-1.16.0.tar.gz", hash = "sha256:39b8ca25460c578ee2cdad33feeea122694cfdf73eef58bee76c42f6ef0589df", size = 472918, upload-time = "2025-10-02T16:58:20.631Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/79/5724a540df19e192e8606c543cdcf162de8eb435077520cca150f7365ec0/mcp-1.17.0.tar.gz", hash = "sha256:1b57fabf3203240ccc48e39859faf3ae1ccb0b571ff798bbedae800c73c6df90", size = 477951, upload-time = "2025-10-10T12:16:44.519Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c9/0e/7cebc88e17daf94ebe28c95633af595ccb2864dc2ee7abd75542d98495cc/mcp-1.16.0-py3-none-any.whl", hash = "sha256:ec917be9a5d31b09ba331e1768aa576e0af45470d657a0319996a20a57d7d633", size = 167266, upload-time = "2025-10-02T16:58:19.039Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/72/3751feae343a5ad07959df713907b5c3fbaed269d697a14b0c449080cf2e/mcp-1.17.0-py3-none-any.whl", hash = "sha256:0660ef275cada7a545af154db3082f176cf1d2681d5e35ae63e014faf0a35d40", size = 167737, upload-time = "2025-10-10T12:16:42.863Z" },
 ]
 
 [[package]]
@@ -760,6 +774,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
 ]
 
+[[package]]
+name = "nestedarchive"
+version = "0.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9c/72/34ce0d8c2ff1a13c0f7eb8a6405b2b38821ea70cb1bec5e413b208839c07/nestedarchive-0.3.1.tar.gz", hash = "sha256:52ae12d234582ed718cf51f41daa2dbbda9d85203980efc7dd361de9f03e8be1", size = 5338, upload-time = "2025-09-30T13:32:33.618Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/ce/8b4937d41a64fd47a142ad774889dee01a15c41fad636517f9fd7c107a67/nestedarchive-0.3.1-py3-none-any.whl", hash = "sha256:ad6416838ee81a4a16ab02acfa527ff21658e012dd10c0ec7c79d1eafb7d1218", size = 5966, upload-time = "2025-09-30T13:32:32.465Z" },
+]
+
 [[package]]
 name = "netaddr"
 version = "1.3.0"
@@ -903,7 +929,7 @@ wheels = [
 
 [[package]]
 name = "pydantic"
-version = "2.12.0"
+version = "2.12.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-types" },
@@ -911,54 +937,58 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c3/da/b8a7ee04378a53f6fefefc0c5e05570a3ebfdfa0523a878bcd3b475683ee/pydantic-2.12.0.tar.gz", hash = "sha256:c1a077e6270dbfb37bfd8b498b3981e2bb18f68103720e51fa6c306a5a9af563", size = 814760, upload-time = "2025-10-07T15:58:03.467Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3c/a7/d0d7b3c128948ece6676a6a21b9036e3ca53765d35052dbcc8c303886a44/pydantic-2.12.1.tar.gz", hash = "sha256:0af849d00e1879199babd468ec9db13b956f6608e9250500c1a9d69b6a62824e", size = 815997, upload-time = "2025-10-13T21:00:41.219Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f4/9d/d5c855424e2e5b6b626fbc6ec514d8e655a600377ce283008b115abb7445/pydantic-2.12.0-py3-none-any.whl", hash = "sha256:f6a1da352d42790537e95e83a8bdfb91c7efbae63ffd0b86fa823899e807116f", size = 459730, upload-time = "2025-10-07T15:58:01.576Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/69/ce4e60e5e67aa0c339a5dc3391a02b4036545efb6308c54dc4aa9425386f/pydantic-2.12.1-py3-none-any.whl", hash = "sha256:665931f5b4ab40c411439e66f99060d631d1acc58c3d481957b9123343d674d1", size = 460511, upload-time = "2025-10-13T21:00:38.935Z" },
 ]
 
 [[package]]
 name = "pydantic-core"
-version = "2.41.1"
+version = "2.41.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7d/14/12b4a0d2b0b10d8e1d9a24ad94e7bbb43335eaf29c0c4e57860e8a30734a/pydantic_core-2.41.1.tar.gz", hash = "sha256:1ad375859a6d8c356b7704ec0f547a58e82ee80bb41baa811ad710e124bc8f2f", size = 454870, upload-time = "2025-10-07T10:50:45.974Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/27/8a/6d54198536a90a37807d31a156642aae7a8e1263ed9fe6fc6245defe9332/pydantic_core-2.41.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:70e790fce5f05204ef4403159857bfcd587779da78627b0babb3654f75361ebf", size = 2105825, upload-time = "2025-10-06T21:10:51.719Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/2e/4784fd7b22ac9c8439db25bf98ffed6853d01e7e560a346e8af821776ccc/pydantic_core-2.41.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9cebf1ca35f10930612d60bd0f78adfacee824c30a880e3534ba02c207cceceb", size = 1910126, upload-time = "2025-10-06T21:10:53.145Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/92/31eb0748059ba5bd0aa708fb4bab9fcb211461ddcf9e90702a6542f22d0d/pydantic_core-2.41.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:170406a37a5bc82c22c3274616bf6f17cc7df9c4a0a0a50449e559cb755db669", size = 1961472, upload-time = "2025-10-06T21:10:55.754Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/91/946527792275b5c4c7dde4cfa3e81241bf6900e9fee74fb1ba43e0c0f1ab/pydantic_core-2.41.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:12d4257fc9187a0ccd41b8b327d6a4e57281ab75e11dda66a9148ef2e1fb712f", size = 2063230, upload-time = "2025-10-06T21:10:57.179Z" },
-    { url = "https://files.pythonhosted.org/packages/31/5d/a35c5d7b414e5c0749f1d9f0d159ee2ef4bab313f499692896b918014ee3/pydantic_core-2.41.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a75a33b4db105dd1c8d57839e17ee12db8d5ad18209e792fa325dbb4baeb00f4", size = 2229469, upload-time = "2025-10-06T21:10:59.409Z" },
-    { url = "https://files.pythonhosted.org/packages/21/4d/8713737c689afa57ecfefe38db78259d4484c97aa494979e6a9d19662584/pydantic_core-2.41.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08a589f850803a74e0fcb16a72081cafb0d72a3cdda500106942b07e76b7bf62", size = 2347986, upload-time = "2025-10-06T21:11:00.847Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ec/929f9a3a5ed5cda767081494bacd32f783e707a690ce6eeb5e0730ec4986/pydantic_core-2.41.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a97939d6ea44763c456bd8a617ceada2c9b96bb5b8ab3dfa0d0827df7619014", size = 2072216, upload-time = "2025-10-06T21:11:02.43Z" },
-    { url = "https://files.pythonhosted.org/packages/26/55/a33f459d4f9cc8786d9db42795dbecc84fa724b290d7d71ddc3d7155d46a/pydantic_core-2.41.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d2ae423c65c556f09569524b80ffd11babff61f33055ef9773d7c9fabc11ed8d", size = 2193047, upload-time = "2025-10-06T21:11:03.787Z" },
-    { url = "https://files.pythonhosted.org/packages/77/af/d5c6959f8b089f2185760a2779079e3c2c411bfc70ea6111f58367851629/pydantic_core-2.41.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:4dc703015fbf8764d6a8001c327a87f1823b7328d40b47ce6000c65918ad2b4f", size = 2140613, upload-time = "2025-10-06T21:11:05.607Z" },
-    { url = "https://files.pythonhosted.org/packages/58/e5/2c19bd2a14bffe7fabcf00efbfbd3ac430aaec5271b504a938ff019ac7be/pydantic_core-2.41.1-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:968e4ffdfd35698a5fe659e5e44c508b53664870a8e61c8f9d24d3d145d30257", size = 2327641, upload-time = "2025-10-06T21:11:07.143Z" },
-    { url = "https://files.pythonhosted.org/packages/93/ef/e0870ccda798c54e6b100aff3c4d49df5458fd64217e860cb9c3b0a403f4/pydantic_core-2.41.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:fff2b76c8e172d34771cd4d4f0ade08072385310f214f823b5a6ad4006890d32", size = 2318229, upload-time = "2025-10-06T21:11:08.73Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/4b/c3b991d95f5deb24d0bd52e47bcf716098fa1afe0ce2d4bd3125b38566ba/pydantic_core-2.41.1-cp313-cp313-win32.whl", hash = "sha256:a38a5263185407ceb599f2f035faf4589d57e73c7146d64f10577f6449e8171d", size = 1997911, upload-time = "2025-10-06T21:11:10.329Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/ce/5c316fd62e01f8d6be1b7ee6b54273214e871772997dc2c95e204997a055/pydantic_core-2.41.1-cp313-cp313-win_amd64.whl", hash = "sha256:b42ae7fd6760782c975897e1fdc810f483b021b32245b0105d40f6e7a3803e4b", size = 2034301, upload-time = "2025-10-06T21:11:12.113Z" },
-    { url = "https://files.pythonhosted.org/packages/29/41/902640cfd6a6523194123e2c3373c60f19006447f2fb06f76de4e8466c5b/pydantic_core-2.41.1-cp313-cp313-win_arm64.whl", hash = "sha256:ad4111acc63b7384e205c27a2f15e23ac0ee21a9d77ad6f2e9cb516ec90965fb", size = 1977238, upload-time = "2025-10-06T21:11:14.1Z" },
-    { url = "https://files.pythonhosted.org/packages/04/04/28b040e88c1b89d851278478842f0bdf39c7a05da9e850333c6c8cbe7dfa/pydantic_core-2.41.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:440d0df7415b50084a4ba9d870480c16c5f67c0d1d4d5119e3f70925533a0edc", size = 1875626, upload-time = "2025-10-06T21:11:15.69Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/58/b41dd3087505220bb58bc81be8c3e8cbc037f5710cd3c838f44f90bdd704/pydantic_core-2.41.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:71eaa38d342099405dae6484216dcf1e8e4b0bebd9b44a4e08c9b43db6a2ab67", size = 2045708, upload-time = "2025-10-06T21:11:17.258Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/b8/760f23754e40bf6c65b94a69b22c394c24058a0ef7e2aa471d2e39219c1a/pydantic_core-2.41.1-cp313-cp313t-win_amd64.whl", hash = "sha256:555ecf7e50f1161d3f693bc49f23c82cf6cdeafc71fa37a06120772a09a38795", size = 1997171, upload-time = "2025-10-06T21:11:18.822Z" },
-    { url = "https://files.pythonhosted.org/packages/41/12/cec246429ddfa2778d2d6301eca5362194dc8749ecb19e621f2f65b5090f/pydantic_core-2.41.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:05226894a26f6f27e1deb735d7308f74ef5fa3a6de3e0135bb66cdcaee88f64b", size = 2107836, upload-time = "2025-10-06T21:11:20.432Z" },
-    { url = "https://files.pythonhosted.org/packages/20/39/baba47f8d8b87081302498e610aefc37142ce6a1cc98b2ab6b931a162562/pydantic_core-2.41.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:85ff7911c6c3e2fd8d3779c50925f6406d770ea58ea6dde9c230d35b52b16b4a", size = 1904449, upload-time = "2025-10-06T21:11:22.185Z" },
-    { url = "https://files.pythonhosted.org/packages/50/32/9a3d87cae2c75a5178334b10358d631bd094b916a00a5993382222dbfd92/pydantic_core-2.41.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:47f1f642a205687d59b52dc1a9a607f45e588f5a2e9eeae05edd80c7a8c47674", size = 1961750, upload-time = "2025-10-06T21:11:24.348Z" },
-    { url = "https://files.pythonhosted.org/packages/27/42/a96c9d793a04cf2a9773bff98003bb154087b94f5530a2ce6063ecfec583/pydantic_core-2.41.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:df11c24e138876ace5ec6043e5cae925e34cf38af1a1b3d63589e8f7b5f5cdc4", size = 2063305, upload-time = "2025-10-06T21:11:26.556Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/8d/028c4b7d157a005b1f52c086e2d4b0067886b213c86220c1153398dbdf8f/pydantic_core-2.41.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7f0bf7f5c8f7bf345c527e8a0d72d6b26eda99c1227b0c34e7e59e181260de31", size = 2228959, upload-time = "2025-10-06T21:11:28.426Z" },
-    { url = "https://files.pythonhosted.org/packages/08/f7/ee64cda8fcc9ca3f4716e6357144f9ee71166775df582a1b6b738bf6da57/pydantic_core-2.41.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82b887a711d341c2c47352375d73b029418f55b20bd7815446d175a70effa706", size = 2345421, upload-time = "2025-10-06T21:11:30.226Z" },
-    { url = "https://files.pythonhosted.org/packages/13/c0/e8ec05f0f5ee7a3656973ad9cd3bc73204af99f6512c1a4562f6fb4b3f7d/pydantic_core-2.41.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b5f1d5d6bbba484bdf220c72d8ecd0be460f4bd4c5e534a541bb2cd57589fb8b", size = 2065288, upload-time = "2025-10-06T21:11:32.019Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/25/d77a73ff24e2e4fcea64472f5e39b0402d836da9b08b5361a734d0153023/pydantic_core-2.41.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2bf1917385ebe0f968dc5c6ab1375886d56992b93ddfe6bf52bff575d03662be", size = 2189759, upload-time = "2025-10-06T21:11:33.753Z" },
-    { url = "https://files.pythonhosted.org/packages/66/45/4a4ebaaae12a740552278d06fe71418c0f2869537a369a89c0e6723b341d/pydantic_core-2.41.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:4f94f3ab188f44b9a73f7295663f3ecb8f2e2dd03a69c8f2ead50d37785ecb04", size = 2140747, upload-time = "2025-10-06T21:11:35.781Z" },
-    { url = "https://files.pythonhosted.org/packages/da/6d/b727ce1022f143194a36593243ff244ed5a1eb3c9122296bf7e716aa37ba/pydantic_core-2.41.1-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:3925446673641d37c30bd84a9d597e49f72eacee8b43322c8999fa17d5ae5bc4", size = 2327416, upload-time = "2025-10-06T21:11:37.75Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/8c/02df9d8506c427787059f87c6c7253435c6895e12472a652d9616ee0fc95/pydantic_core-2.41.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:49bd51cc27adb980c7b97357ae036ce9b3c4d0bb406e84fbe16fb2d368b602a8", size = 2318138, upload-time = "2025-10-06T21:11:39.463Z" },
-    { url = "https://files.pythonhosted.org/packages/98/67/0cf429a7d6802536941f430e6e3243f6d4b68f41eeea4b242372f1901794/pydantic_core-2.41.1-cp314-cp314-win32.whl", hash = "sha256:a31ca0cd0e4d12ea0df0077df2d487fc3eb9d7f96bbb13c3c5b88dcc21d05159", size = 1998429, upload-time = "2025-10-06T21:11:41.989Z" },
-    { url = "https://files.pythonhosted.org/packages/38/60/742fef93de5d085022d2302a6317a2b34dbfe15258e9396a535c8a100ae7/pydantic_core-2.41.1-cp314-cp314-win_amd64.whl", hash = "sha256:1b5c4374a152e10a22175d7790e644fbd8ff58418890e07e2073ff9d4414efae", size = 2028870, upload-time = "2025-10-06T21:11:43.66Z" },
-    { url = "https://files.pythonhosted.org/packages/31/38/cdd8ccb8555ef7720bd7715899bd6cfbe3c29198332710e1b61b8f5dd8b8/pydantic_core-2.41.1-cp314-cp314-win_arm64.whl", hash = "sha256:4fee76d757639b493eb600fba668f1e17475af34c17dd61db7a47e824d464ca9", size = 1974275, upload-time = "2025-10-06T21:11:45.476Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/7e/8ac10ccb047dc0221aa2530ec3c7c05ab4656d4d4bd984ee85da7f3d5525/pydantic_core-2.41.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f9b9c968cfe5cd576fdd7361f47f27adeb120517e637d1b189eea1c3ece573f4", size = 1875124, upload-time = "2025-10-06T21:11:47.591Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/e4/7d9791efeb9c7d97e7268f8d20e0da24d03438a7fa7163ab58f1073ba968/pydantic_core-2.41.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f1ebc7ab67b856384aba09ed74e3e977dded40e693de18a4f197c67d0d4e6d8e", size = 2043075, upload-time = "2025-10-06T21:11:49.542Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/c3/3f6e6b2342ac11ac8cd5cb56e24c7b14afa27c010e82a765ffa5f771884a/pydantic_core-2.41.1-cp314-cp314t-win_amd64.whl", hash = "sha256:8ae0dc57b62a762985bc7fbf636be3412394acc0ddb4ade07fe104230f1b9762", size = 1995341, upload-time = "2025-10-06T21:11:51.497Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/00/e9/3916abb671bffb00845408c604ff03480dc8dc273310d8268547a37be0fb/pydantic_core-2.41.3.tar.gz", hash = "sha256:cdebb34b36ad05e8d77b4e797ad38a2a775c2a07a8fa386d4f6943b7778dcd39", size = 457489, upload-time = "2025-10-13T19:34:51.666Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/a6/7533cba20b8b66e209d8d2acbb9ccc0bc1b883b0654776d676e02696ef5d/pydantic_core-2.41.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:a8596700fdd3ee12b0d9c1f2395f4c32557e7ebfbfacdc08055b0bcbe7d2827e", size = 2105686, upload-time = "2025-10-13T19:31:57.675Z" },
+    { url = "https://files.pythonhosted.org/packages/84/d7/2d15cb9dfb9f94422fb4a8820cbfeb397e3823087c2361ef46df5c172000/pydantic_core-2.41.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:624503f918e472c0eed6935020c01b6a6b4bcdb7955a848da5c8805d40f15c0f", size = 1910554, upload-time = "2025-10-13T19:32:00.037Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/fc/cbd1caa19e88fd64df716a37b49e5864c1ac27dbb9eb870b8977a584fa42/pydantic_core-2.41.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:36388958d0c614df9f5de1a5f88f4b79359016b9ecdfc352037788a628616aa2", size = 1957559, upload-time = "2025-10-13T19:32:02.603Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/fe/da942ae51f602173556c627304dc24b9fa8bd04423bce189bf397ba0419e/pydantic_core-2.41.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3c50eba144add9104cf43ef9a3d81c37ebf48bfd0924b584b78ec2e03ec91daf", size = 2051084, upload-time = "2025-10-13T19:32:05.056Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/62/0abd59a7107d1ef502b9cfab68145c6bb87115c2d9e883afbf18b98fe6db/pydantic_core-2.41.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c6ea2102958eb5ad560d570c49996e215a6939d9bffd0e9fd3b9e808a55008cc", size = 2218098, upload-time = "2025-10-13T19:32:06.837Z" },
+    { url = "https://files.pythonhosted.org/packages/72/b1/93a36aa119b70126f3f0d06b6f9a81ca864115962669d8a85deb39c82ecc/pydantic_core-2.41.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd0d26f1e4335d5f84abfc880da0afa080c8222410482f9ee12043bb05f55ec8", size = 2341954, upload-time = "2025-10-13T19:32:08.583Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/be/7c2563b53b71ff3e41950b0ffa9eeba3d702091c6d59036fff8a39050528/pydantic_core-2.41.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41c38700094045b12c0cff35c8585954de66cf6dd63909fed1c2e6b8f38e1e1e", size = 2069474, upload-time = "2025-10-13T19:32:10.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/ac/2394004db9f6e03712c1e52f40f0979750fa87721f6baf5f76ad92b8be46/pydantic_core-2.41.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4061cc82d7177417fdb90e23e67b27425ecde2652cfd2053b5b4661a489ddc19", size = 2190633, upload-time = "2025-10-13T19:32:12.731Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/31/7b70c2d1fe41f450f8022f5523edaaea19c17a2d321fab03efd03aea1fe8/pydantic_core-2.41.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:b1d9699a4dae10a7719951cca1e30b591ef1dd9cdda9fec39282a283576c0241", size = 2137097, upload-time = "2025-10-13T19:32:14.634Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ae/f872198cffc8564f52c4ef83bcd3e324e5ac914e168c6b812f5ce3f80aab/pydantic_core-2.41.3-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:d5099f1b97e79f0e45cb6a236a5bd1a20078ed50b1b28f3d17f6c83ff3585baa", size = 2316771, upload-time = "2025-10-13T19:32:16.586Z" },
+    { url = "https://files.pythonhosted.org/packages/23/50/f0fce3a9a7554ced178d943e1eada58b15fca896e9eb75d50244fc12007c/pydantic_core-2.41.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:b5ff0467a8c1b6abb0ab9c9ea80e2e3a9788592e44c726c2db33fdaf1b5e7d0b", size = 2319449, upload-time = "2025-10-13T19:32:18.503Z" },
+    { url = "https://files.pythonhosted.org/packages/15/1f/86a6948408e8388604c02ffde651a2e39b711bd1ab6eeaff376094553a10/pydantic_core-2.41.3-cp313-cp313-win32.whl", hash = "sha256:edfe9b4cee4a91da7247c25732f24504071f3e101c050694d18194b7d2d320bf", size = 1995352, upload-time = "2025-10-13T19:32:20.5Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/4b/6dac37c3f62684dc459a31623d8ae97ee433fd68bb827e5c64dd831a5087/pydantic_core-2.41.3-cp313-cp313-win_amd64.whl", hash = "sha256:44af3276c0c2c14efde6590523e4d7e04bcd0e46e0134f0dbef1be0b64b2d3e3", size = 2031894, upload-time = "2025-10-13T19:32:23.11Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/75/3d9ba041a3fcb147279fbb37d2468efe62606809fec97b8de78174335ef4/pydantic_core-2.41.3-cp313-cp313-win_arm64.whl", hash = "sha256:59aeed341f92440d51fdcc82c8e930cfb234f1843ed1d4ae1074f5fb9789a64b", size = 1974036, upload-time = "2025-10-13T19:32:25.219Z" },
+    { url = "https://files.pythonhosted.org/packages/50/68/45842628ccdb384df029f884ef915306d195c4f08b66ca4d99867edc6338/pydantic_core-2.41.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ef37228238b3a280170ac43a010835c4a7005742bc8831c2c1a9560de4595dbe", size = 1876856, upload-time = "2025-10-13T19:32:27.504Z" },
+    { url = "https://files.pythonhosted.org/packages/99/73/336a82910c6a482a0ba9a255c08dcc456ebca9735df96d7a82dffe17626a/pydantic_core-2.41.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5cb19f36253152c509abe76c1d1b185436e0c75f392a82934fe37f4a1264449", size = 1884665, upload-time = "2025-10-13T19:32:29.567Z" },
+    { url = "https://files.pythonhosted.org/packages/34/87/ec610a7849561e0ef7c25b74ef934d154454c3aac8fb595b899557f3c6ab/pydantic_core-2.41.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:91be4756e05367ce19a70e1db3b77f01f9e40ca70d26fb4cdfa993e53a08964a", size = 2043067, upload-time = "2025-10-13T19:32:31.506Z" },
+    { url = "https://files.pythonhosted.org/packages/db/b4/5f2b0cf78752f9111177423bd5f2bc0815129e587c13401636b8900a417e/pydantic_core-2.41.3-cp313-cp313t-win_amd64.whl", hash = "sha256:ce7d8f4353f82259b55055bd162bbaf599f6c40cd0c098e989eeb95f9fdc022f", size = 1996799, upload-time = "2025-10-13T19:32:33.612Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7f/07e7f19a6a44a52abd48846e348e11fa1b3de5ed7c0231d53f055ffb365f/pydantic_core-2.41.3-cp313-cp313t-win_arm64.whl", hash = "sha256:f06a9e81da60e5a0ef584f6f4790f925c203880ae391bf363d97126fd1790b21", size = 1969574, upload-time = "2025-10-13T19:32:35.533Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/d8/db32fbced75853c1d8e7ada8cb2b837ade99b2f281de569908de3e29f0bf/pydantic_core-2.41.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:0c77e8e72344e34052ea26905fa7551ecb75fc12795ca1a8e44f816918f4c718", size = 2103383, upload-time = "2025-10-13T19:32:37.522Z" },
+    { url = "https://files.pythonhosted.org/packages/de/28/5bcb3327b3777994633f4cb459c5dc34a9cbe6cf0ac449d3e8f1e74bdaaa/pydantic_core-2.41.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32be442a017e82a6c496a52ef5db5f5ac9abf31c3064f5240ee15a1d27cc599e", size = 1904974, upload-time = "2025-10-13T19:32:39.513Z" },
+    { url = "https://files.pythonhosted.org/packages/71/8d/c9d8cad7c02d63869079fb6fb61b8ab27adbeeda0bf130c684fe43daa126/pydantic_core-2.41.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:af10c78f0e9086d2d883ddd5a6482a613ad435eb5739cf1467b1f86169e63d91", size = 1956879, upload-time = "2025-10-13T19:32:41.849Z" },
+    { url = "https://files.pythonhosted.org/packages/15/b1/8a84b55631a45375a467df288d8f905bec0abadb1e75bce3b32402b49733/pydantic_core-2.41.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6212874118704e27d177acee5b90b83556b14b2eb88aae01bae51cd9efe27019", size = 2051787, upload-time = "2025-10-13T19:32:43.86Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/97/a84ea9cb7ba4dbfd43865e5dd536b22c78ee763d82d501c6f6a553403c00/pydantic_core-2.41.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c6a24c82674a3a8e7f7306e57e98219e5c1cdfc0f57bc70986930dda136230b2", size = 2217830, upload-time = "2025-10-13T19:32:46.053Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/2c/64233c77410e314dbb7f2e8112be7f56de57cf64198a32d8ab3f7b74adf4/pydantic_core-2.41.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8e0c81dc047c18059410c959a437540abcefea6a882d6e43b9bf45c291eaacd9", size = 2341131, upload-time = "2025-10-13T19:32:48.402Z" },
+    { url = "https://files.pythonhosted.org/packages/23/3d/915b90eb0de93bd522b293fd1a986289f5d576c72e640f3bb426b496d095/pydantic_core-2.41.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0d7e1a9f80f00a8180b9194ecef66958eb03f3c3ae2d77195c9d665ac0a61e", size = 2063797, upload-time = "2025-10-13T19:32:50.458Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/25/a65665caa86e496e19feef48e6bd9263c1a46f222e8f9b0818f67bd98dc3/pydantic_core-2.41.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2868fabfc35ec0738539ce0d79aab37aeffdcb9682b9b91f0ac4b0ba31abb1eb", size = 2193041, upload-time = "2025-10-13T19:32:52.686Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/46/a7f7e17f99ee691a7d93a53aa41bf7d1b1d425945b6e9bc8020498a413e1/pydantic_core-2.41.3-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:cb4f40c93307e1c50996e4edcddf338e1f3f1fb86fb69b654111c6050ae3b081", size = 2136119, upload-time = "2025-10-13T19:32:54.737Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/92/c27c1f3edd06e04af71358aa8f4d244c8bc6726e3fb47e00157d3dffe66f/pydantic_core-2.41.3-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:287cbcd3407a875eaf0b1efa2e5288493d5b79bfd3629459cf0b329ad8a9071a", size = 2317223, upload-time = "2025-10-13T19:32:56.927Z" },
+    { url = "https://files.pythonhosted.org/packages/51/6c/20aabe3c32888fb13d4726e405716fed14b1d4d1d4292d585862c1458b7b/pydantic_core-2.41.3-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:5253835aa145049205a67056884555a936f9b3fea7c3ce860bff62be6a1ae4d1", size = 2320425, upload-time = "2025-10-13T19:32:59.454Z" },
+    { url = "https://files.pythonhosted.org/packages/67/d2/476d4bc6b3070e151ae920167f27f26415e12f8fcc6cf5a47a613aba7267/pydantic_core-2.41.3-cp314-cp314-win32.whl", hash = "sha256:69297795efe5349156d18eebea818b75d29a1d3d1d5f26a250f22ab4220aacd6", size = 1994216, upload-time = "2025-10-13T19:33:01.484Z" },
+    { url = "https://files.pythonhosted.org/packages/16/ca/2cd8515584b3d665ca3c4d946364c2a9932d0d5648694c2a10d273cde81c/pydantic_core-2.41.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1c133e3447c2f6d95e47ede58fff0053370758112a1d39117d0af8c93584049", size = 2026522, upload-time = "2025-10-13T19:33:03.546Z" },
+    { url = "https://files.pythonhosted.org/packages/77/61/c9f2791d7188594f0abdc1b7fe8ec3efc123ee2d9c553fd3b6da2d9fd53d/pydantic_core-2.41.3-cp314-cp314-win_arm64.whl", hash = "sha256:54534eecbb7a331521f832e15fc307296f491ee1918dacfd4d5b900da6ee3332", size = 1969070, upload-time = "2025-10-13T19:33:05.604Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/eb/45f9a91f8c09f4cfb62f78dce909b20b6047ce4fd8d89310fcac5ad62e54/pydantic_core-2.41.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6b4be10152098b43c093a4b5e9e9da1ac7a1c954c1934d4438d07ba7b7bcf293", size = 1876593, upload-time = "2025-10-13T19:33:07.814Z" },
+    { url = "https://files.pythonhosted.org/packages/99/f8/5c9d0959e0e1f260eea297a5ecc1dc29a14e03ee6a533e805407e8403c1a/pydantic_core-2.41.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe4ebd676c158a7994253161151b476dbbef2acbd2f547cfcfdf332cf67cc29", size = 1882977, upload-time = "2025-10-13T19:33:10.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f4/7ab918e35f55e7beee471ba8c67dfc4c9c19a8904e4867bfda7f9c76a72e/pydantic_core-2.41.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:984ca0113b39dda1d7c358d6db03dd6539ef244d0558351806c1327239e035bf", size = 2041033, upload-time = "2025-10-13T19:33:12.216Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/c8/5b12e5a36410ebcd0082ae5b0258150d72762e306f298cc3fe731b5574ec/pydantic_core-2.41.3-cp314-cp314t-win_amd64.whl", hash = "sha256:2a7dd8a6f5a9a2f8c7f36e4fc0982a985dbc4ac7176ee3df9f63179b7295b626", size = 1994462, upload-time = "2025-10-13T19:33:14.421Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f6/c6f3b7244a2a0524f4a04052e3d590d3be0ba82eb1a2f0fe5d068237701e/pydantic_core-2.41.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b387f08b378924fa82bd86e03c9d61d6daca1a73ffb3947bdcfe12ea14c41f68", size = 1973551, upload-time = "2025-10-13T19:33:16.87Z" },
 ]
 
 [[package]]
@@ -998,7 +1028,7 @@ wheels = [
 
 [[package]]
 name = "pylint"
-version = "3.3.9"
+version = "4.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "astroid" },
@@ -1009,9 +1039,9 @@ dependencies = [
     { name = "platformdirs" },
     { name = "tomlkit" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/04/9d/81c84a312d1fa8133b0db0c76148542a98349298a01747ab122f9314b04e/pylint-3.3.9.tar.gz", hash = "sha256:d312737d7b25ccf6b01cc4ac629b5dcd14a0fcf3ec392735ac70f137a9d5f83a", size = 1525946, upload-time = "2025-10-05T18:41:43.786Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b6/2f/e80cc4301c81c41a8836d726377daeebf5901a33c06ba8c2d5afb94f7612/pylint-4.0.0.tar.gz", hash = "sha256:62da212808c0681e49ffb125f0a994c685d912cf19ae373075649ebb5870ec28", size = 1567676, upload-time = "2025-10-12T15:21:15.165Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1a/a7/69460c4a6af7575449e615144aa2205b89408dc2969b87bc3df2f262ad0b/pylint-3.3.9-py3-none-any.whl", hash = "sha256:01f9b0462c7730f94786c283f3e52a1fbdf0494bbe0971a78d7277ef46a751e7", size = 523465, upload-time = "2025-10-05T18:41:41.766Z" },
+    { url = "https://files.pythonhosted.org/packages/42/af/068a0b92c49927ada0e177561244157dc9d122eeea5987e34c423172a296/pylint-4.0.0-py3-none-any.whl", hash = "sha256:196b92a85204bb0c0a416a6bb324f6185e59ff1d687ee1d614bf0abf34a348e8", size = 535836, upload-time = "2025-10-12T15:21:13.041Z" },
 ]
 
 [[package]]
@@ -1171,15 +1201,15 @@ wheels = [
 
 [[package]]
 name = "referencing"
-version = "0.36.2"
+version = "0.37.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "attrs" },
     { name = "rpds-py" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744, upload-time = "2025-01-25T08:48:16.138Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775, upload-time = "2025-01-25T08:48:14.241Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
 ]
 
 [[package]]
@@ -1353,6 +1383,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/be/72/2db2f49247d0a18b4f1bb9a5a39a0162869acf235f3a96418363947b3d46/starlette-0.48.0-py3-none-any.whl", hash = "sha256:0764ca97b097582558ecb498132ed0c7d942f233f365b86ba37770e026510659", size = 73736, upload-time = "2025-09-13T08:41:03.869Z" },
 ]
 
+[[package]]
+name = "tabulate"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090, upload-time = "2022-10-06T17:21:48.54Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252, upload-time = "2022-10-06T17:21:44.262Z" },
+]
+
 [[package]]
 name = "tomlkit"
 version = "0.13.3"