Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

30.3 KB
Raw Blame
import logging
import threading
from dataclasses import asdict, dataclass, field
from typing import Any, Dict, List, Optional, Union
from pathlib import Path

from config import paths
from config.platform_registry import get_platform_descriptor
from config.v2_sessions import SessionsStore
from config.v2_settings import SettingsStore, ChannelSettings, GuildSettings, RoutingSettings, SCOPED_KEY_SEP
from config.v2_settings import normalize_routing_settings, routing_from_stored_payload, routing_to_dict
from config.v2_settings import split_thread_settings_key
from config.v2_settings import UserSettings as BoundUserSettings
from core.services import scope_settings
from modules.sessions_facade import SessionsFacade


logger = logging.getLogger(__name__)


DEFAULT_SHOW_MESSAGE_TYPES: List[str] = ["assistant"]


ChannelRouting = RoutingSettings


@dataclass
class UserSettings:
    show_message_types: List[str] = field(default_factory=lambda: DEFAULT_SHOW_MESSAGE_TYPES.copy())
    custom_cwd: Optional[str] = None
    channel_routing: Optional[ChannelRouting] = None
    enabled: bool = True

    def to_dict(self) -> dict:
        """Convert to dictionary for JSON serialization"""
        result = {
            "show_message_types": self.show_message_types,
            "custom_cwd": self.custom_cwd,
        }
        if self.channel_routing is not None:
            result["routing"] = routing_to_dict(self.channel_routing)
        return result

    @classmethod
    def from_dict(cls, data: dict) -> "UserSettings":
        """Create from dictionary"""
        if data is None:
            return cls()
        payload = dict(data)
        routing_data = payload.pop("routing", None)
        show_message_types = payload.get("show_message_types")
        settings = cls(
            show_message_types=(
                show_message_types if show_message_types is not None else DEFAULT_SHOW_MESSAGE_TYPES.copy()
            ),
            custom_cwd=payload.get("custom_cwd"),
        )
        if routing_data is not None:
            settings.channel_routing = routing_from_stored_payload(routing_data)
        return settings


class SettingsManager:
    """Manages user personalization settings with JSON persistence"""

    MESSAGE_TYPE_ALIASES = {
        "tool_call": "toolcall",
        "tool": "toolcall",
    }

    def __init__(
        self,
        settings_file: Optional[str] = None,
        platform: str = "slack",
        sessions_store: Optional[SessionsStore] = None,
        sessions_facade: Optional[SessionsFacade] = None,
    ):
        paths.ensure_data_dirs()
        self.settings_file = Path(settings_file) if settings_file else paths.get_settings_path()
        self.platform = platform
        # The controller replaces this with the live platform config during
        # dependency injection. Keep standalone managers aligned with the
        # built-in defaults before that happens.
        self.require_mention_default = lambda: platform == "telegram"
        self.channel_settings: Dict[str, UserSettings] = {}
        self.dm_user_settings: Dict[str, UserSettings] = {}
        self.store = SettingsStore.get_instance(self.settings_file)
        self.sessions_store = sessions_store or SessionsStore()
        if sessions_store is None:
            self.sessions_store.load()
        self.sessions = sessions_facade or SessionsFacade(self.sessions_store)
        self._runtime_settings_lock = threading.RLock()
        self._last_seen_store_generation: Optional[int] = None
        self._runtime_rebuild_count = 0
        self._last_changed_channel_count = 0
        self._last_changed_dm_user_count = 0
        self._load_settings()

    # ---------------------------------------------
    # Internal helpers
    # ---------------------------------------------
    def _normalize_user_id(self, user_id: Union[int, str]) -> str:
        """Normalize user_id consistently to string.

        Rationale: JSON object keys are strings; Slack IDs are strings; unifying to
        string avoids mixed-type keys (e.g., 123 vs "123").
        """
        return str(user_id)

    def get_store(self) -> SettingsStore:
        """Explicit access to underlying SettingsStore.

        Intended for shared auth pipeline and API integrations that require
        store-level operations.
        """
        return self.store

    def iter_bound_users(self):
        """Iterate over bound users from persisted settings."""
        self._reload_if_changed()
        return self.store.get_users_for_platform(self.platform).items()

    def is_bound_user(self, user_id: Union[int, str]) -> bool:
        """Check whether a user is already bound."""
        return self.store.is_bound_user(str(user_id), platform=self.platform)

    def is_enabled_user(self, user_id: Union[int, str]) -> bool:
        """Check whether a bound user is enabled for access."""
        return self.store.is_enabled_user(str(user_id), platform=self.platform)

    def bind_user_with_code(
        self,
        user_id: Union[int, str],
        display_name: str,
        code: str,
        dm_chat_id: str = "",
    ) -> tuple[bool, bool]:
        """Atomically validate bind code and create user binding."""
        return self.store.bind_user_with_code(
            str(user_id),
            display_name,
            code,
            dm_chat_id=dm_chat_id,
            platform=self.platform,
        )

    def _from_channel_settings(self, channel_settings: ChannelSettings) -> UserSettings:
        return UserSettings(
            show_message_types=self._normalize_show_message_types(channel_settings.show_message_types),
            custom_cwd=channel_settings.custom_cwd,
            channel_routing=normalize_routing_settings(channel_settings.routing),
            enabled=channel_settings.enabled,
        )

    def _from_bound_user_settings(self, bound_user: BoundUserSettings) -> UserSettings:
        """Convert a bound user's settings (from v2_settings.UserSettings) to runtime UserSettings."""
        return UserSettings(
            show_message_types=self._normalize_show_message_types(bound_user.show_message_types),
            custom_cwd=bound_user.custom_cwd,
            channel_routing=normalize_routing_settings(bound_user.routing),
            enabled=bound_user.enabled,
        )

    def _load_settings(self):
        """Load runtime settings from the shared settings store."""
        self.store = SettingsStore.get_instance(self.settings_file)
        self._rebuild_runtime_settings(reason="initial_load")
        self._last_seen_store_generation = self.store.generation

    def _reload_if_changed(self) -> None:
        """Reload runtime settings after a committed settings-domain change.

        Uses a locally tracked generation so that same-process writes (e.g. from
        the UI API hitting the singleton store) are detected correctly.
        """
        with self._runtime_settings_lock:
            self.store.maybe_reload()
            if self.store.generation != self._last_seen_store_generation:
                self._rebuild_runtime_settings(reason="settings_revision_changed")
                self._last_seen_store_generation = self.store.generation

    def _rebuild_runtime_settings(self, *, reason: str = "manual") -> None:
        """Synchronize only runtime entries whose persisted settings changed."""
        channels = {
            str(cid): self._from_channel_settings(settings)
            for cid, settings in self.store.get_channels_for_platform(self.platform).items()
        }
        dm_users = {
            str(uid): self._from_bound_user_settings(settings)
            for uid, settings in self.store.get_users_for_platform(self.platform).items()
        }
        changed_channels = set(self.channel_settings) ^ set(channels)
        changed_channels.update(
            key
            for key in self.channel_settings.keys() & channels.keys()
            if self.channel_settings[key] != channels[key]
        )
        changed_dm_users = set(self.dm_user_settings) ^ set(dm_users)
        changed_dm_users.update(
            key
            for key in self.dm_user_settings.keys() & dm_users.keys()
            if self.dm_user_settings[key] != dm_users[key]
        )
        for key in changed_channels:
            if key in channels:
                self.channel_settings[key] = channels[key]
            else:
                self.channel_settings.pop(key, None)
        for key in changed_dm_users:
            if key in dm_users:
                self.dm_user_settings[key] = dm_users[key]
            else:
                self.dm_user_settings.pop(key, None)
        self._runtime_rebuild_count += 1
        self._last_changed_channel_count = len(changed_channels)
        self._last_changed_dm_user_count = len(changed_dm_users)
        logger.info(
            "Runtime settings synchronized reason=%s sync_count=%d "
            "changed_channels=%d changed_dm_users=%d total_channels=%d total_dm_users=%d",
            reason,
            self._runtime_rebuild_count,
            self._last_changed_channel_count,
            self._last_changed_dm_user_count,
            len(self.channel_settings),
            len(self.dm_user_settings),
        )

    def runtime_settings_diagnostics(self) -> dict[str, int]:
        """Return bounded counters for reload-frequency diagnostics."""
        with self._runtime_settings_lock:
            return {
                "store_reload_count": self.store.reload_count,
                "rebuild_count": self._runtime_rebuild_count,
                "changed_channels": self._last_changed_channel_count,
                "changed_dm_users": self._last_changed_dm_user_count,
                "channels": len(self.channel_settings),
                "dm_users": len(self.dm_user_settings),
            }

    def get_user_settings(self, user_id: Union[int, str]) -> UserSettings:
        """Get settings for a specific user/channel context.

        Checks dm_user_settings first, then channel_settings, then falls back
        to the store. A key with no settings gets the defaults, unsaved.
        """
        normalized_id = self._normalize_user_id(user_id)

        self._reload_if_changed()

        thread_ref = split_thread_settings_key(normalized_id)
        if thread_ref is not None:
            channel_id, thread_id = thread_ref
            thread = self.store.find_thread(channel_id, thread_id, platform=self.platform)
            if thread is not None:
                return self._from_channel_settings(thread)
            parent = self.store.find_channel(channel_id, platform=self.platform)
            return self._from_channel_settings(parent or ChannelSettings())

        if normalized_id in self.dm_user_settings:
            return self.dm_user_settings[normalized_id]
        if normalized_id in self.channel_settings:
            return self.channel_settings[normalized_id]

        # New key — check store
        platform_users = self.store.get_users_for_platform(self.platform)
        platform_channels = self.store.get_channels_for_platform(self.platform)
        if normalized_id in platform_users:
            settings = self._from_bound_user_settings(platform_users[normalized_id])
            self.dm_user_settings[normalized_id] = settings
            return settings
        if normalized_id in platform_channels:
            settings = self._from_channel_settings(platform_channels[normalized_id])
            self.channel_settings[normalized_id] = settings
            return settings

        # Truly new: the defaults, persisted only when updated. A read never
        # saves. It is on every emit, so a save here ran on the controller loop
        # (#2706), and the row it saved was enabled, which authorized an IM
        # channel nobody enabled (core/auth.py). A channel is authorized only
        # when someone enables it explicitly.
        return UserSettings()

    def _scope_of(self, settings_key: str) -> tuple[str, str, str]:
        """The stored scope a runtime settings key names: (kind, id, thread id)."""
        thread_ref = split_thread_settings_key(settings_key)
        if thread_ref is not None:
            return "thread", thread_ref[0], thread_ref[1]
        if settings_key in self.store.get_users_for_platform(self.platform):
            return "user", settings_key, ""
        return "channel", settings_key, ""

    def change_scope_settings(
        self,
        user_id: Union[int, str],
        changes: dict,
        *,
        expected_agent_name: Any = scope_settings.MISSING,
    ):
        """Write only ``changes`` to the scope this key names; return its stored row.

        The one IM write path, shared with the Web settings pages. A refused
        save raises, and the runtime view then holds the committed rows.
        """
        normalized_id = self._normalize_user_id(user_id)
        self._reload_if_changed()
        kind, native_id, thread_id = self._scope_of(normalized_id)
        # A DM has no mention or binding gate; those settings belong to channels.
        changes = {name: value for name, value in changes.items() if name in scope_settings.SCOPE_FIELDS[kind]}
        try:
            return scope_settings.apply_scope_change(
                self.store,
                platform=self.platform,
                kind=kind,
                native_id=native_id,
                thread_id=thread_id,
                changes=changes,
                expected_agent_name=expected_agent_name,
                new_topic_require_mention=bool(self.require_mention_default()) if kind == "thread" else None,
            )
        except Exception as e:
            logger.error(f"Error saving settings: {e}")
            raise
        finally:
            self._reload_if_changed()

    def set_show_message_types(self, user_id: Union[int, str], show_message_types: List[str]) -> None:
        self.change_scope_settings(
            user_id, {"show_message_types": self._normalize_show_message_types(show_message_types)}
        )

    def toggle_show_message_type(self, user_id: Union[int, str], message_type: str) -> bool:
        """Toggle a message type in show list, returns new state (True if now shown)"""
        message_type = self._canonicalize_message_type(message_type)
        shown = list(self.get_user_settings(user_id).show_message_types)
        is_shown = message_type not in shown
        if is_shown:
            shown.append(message_type)
        else:
            shown.remove(message_type)
        self.set_show_message_types(user_id, shown)
        return is_shown

    def set_custom_cwd(self, user_id: Union[int, str], cwd: str):
        """Set custom working directory for user"""
        self.change_scope_settings(user_id, {"custom_cwd": cwd})

    def get_custom_cwd(self, user_id: Union[int, str]) -> Optional[str]:
        """Get custom working directory for user"""
        settings = self.get_user_settings(user_id)
        return settings.custom_cwd

    def get_channel_settings(self, channel_id: Union[int, str]) -> Optional[ChannelSettings]:
        """Get raw ChannelSettings for a channel without creating defaults."""
        self._reload_if_changed()
        key = str(channel_id)
        thread_ref = split_thread_settings_key(key)
        if thread_ref is not None:
            parent_id, thread_id = thread_ref
            return self.store.find_effective_channel(
                parent_id,
                thread_id=thread_id,
                platform=self.platform,
            )
        return self.store.get_channels_for_platform(self.platform).get(key)

    def has_guild_scope(self) -> bool:
        """Return whether this platform has an explicit server access policy."""
        self._reload_if_changed()
        return self.store.has_guild_scope_for_platform(self.platform)

    def get_enabled_guild_ids(self) -> list[str]:
        """Return enabled Discord server IDs for this platform."""
        self._reload_if_changed()
        return [
            guild_id
            for guild_id, settings in self.store.get_guilds_for_platform(self.platform).items()
            if settings.enabled
        ]

    def set_enabled_guild_ids(self, guild_ids: list[str]) -> None:
        """Replace enabled Discord server IDs for this platform."""
        self.store.set_guilds_for_platform(
            self.platform,
            {str(guild_id): GuildSettings(enabled=True) for guild_id in guild_ids},
        )
        self.store.save()

    def is_guild_enabled(self, guild_id: Union[int, str]) -> bool:
        """Return whether a Discord server is enabled in settings."""
        self._reload_if_changed()
        return self.store.is_guild_enabled(self.platform, str(guild_id))

    def is_message_type_hidden(self, user_id: Union[int, str], message_type: str) -> bool:
        """Check if a message type is hidden for user (not in show_message_types)"""
        self._reload_if_changed()
        message_type = self._canonicalize_message_type(message_type)
        settings = self.get_user_settings(user_id)
        return message_type not in settings.show_message_types

    def get_available_message_types(self) -> List[str]:
        """Get list of available message types that can be hidden.

        ``system`` is intentionally excluded: system/init messages are never
        pushed to users, so there is nothing for the toggle to control.
        """
        message_types = ["assistant"]
        if get_platform_descriptor(self.platform).capabilities.supports_toolcall_delivery:
            message_types.append("toolcall")
        return message_types

    def get_message_type_display_names(self) -> Dict[str, str]:
        """Get display names for message types"""
        return {
            "assistant": "Muttering",
            "toolcall": "Toolcall",
        }

    def _canonicalize_message_type(self, message_type: str) -> str:
        """Normalize message type to canonical form to support aliases."""
        return self.MESSAGE_TYPE_ALIASES.get(message_type, message_type)

    def _normalize_show_message_types(self, show_message_types: Optional[List[str]]) -> List[str]:
        """Normalize and migrate show message types to current canonical schema.

        "system" is deprecated and dropped here: system/init messages are never
        pushed to users, so a legacy stored "system" value is filtered out on
        load/save instead of leaking into settings UIs.
        """
        allowed = {"assistant", "toolcall"}
        if show_message_types is None:
            return DEFAULT_SHOW_MESSAGE_TYPES.copy()
        normalized: List[str] = []
        seen = set()

        for msg_type in show_message_types or []:
            canonical = self._canonicalize_message_type(msg_type)
            if canonical not in allowed:
                continue
            if canonical in seen:
                continue
            seen.add(canonical)
            normalized.append(canonical)

        return normalized

    # ---------------------------------------------
    # Channel routing management
    # ---------------------------------------------
    def get_channel_routing(self, settings_key: Union[int, str]) -> Optional[ChannelRouting]:
        """Get channel routing override for the given settings key."""
        self._reload_if_changed()
        settings = self.get_user_settings(settings_key)
        return settings.channel_routing

    def set_channel_routing(self, settings_key: Union[int, str], routing: ChannelRouting) -> ChannelRouting:
        """Store a complete route for this scope and return the stored route.

        The route is the caller's whole choice, so it is based on the Agent the
        scope runs now.
        """
        current = self.get_channel_routing(settings_key)
        saved = self.change_scope_settings(
            settings_key,
            {"routing": routing_to_dict(routing)},
            expected_agent_name=current.agent_name if current else None,
        )
        logger.info(
            "Updated channel routing for %s: agent=%s, model=%s, reasoning_effort=%s",
            settings_key,
            saved.routing.agent_name,
            saved.routing.model,
            saved.routing.reasoning_effort,
        )
        return normalize_routing_settings(saved.routing)

    # ---------------------------------------------
    # Per-channel require_mention management
    # ---------------------------------------------
    def get_require_mention(self, channel_id: Union[int, str], global_default: bool = False) -> bool:
        """Get effective require_mention value for a channel.

        Args:
            channel_id: The channel to check
            global_default: The global require_mention setting from config

        Returns:
            True if mention is required, False otherwise.
            Uses per-channel setting if set, otherwise falls back to global_default.
        """
        self._reload_if_changed()
        key = str(channel_id)
        thread_ref = split_thread_settings_key(key)
        if thread_ref is not None:
            parent_id, thread_id = thread_ref
            channel_settings = self.store.find_effective_channel(
                parent_id,
                thread_id=thread_id,
                platform=self.platform,
            )
        else:
            channel_settings = self.store.get_channels_for_platform(self.platform).get(key)

        if channel_settings is not None and channel_settings.require_mention is not None:
            return channel_settings.require_mention

        return global_default

    def set_require_mention(self, channel_id: Union[int, str], value: Optional[bool]):
        """Set per-channel require_mention override.

        Args:
            channel_id: The channel to configure
            value: True=require mention, False=don't require, None=use global default.
                A topic's first override keeps the gate it inherited.
        """
        self.change_scope_settings(channel_id, {"require_mention": value})
        logger.info("Updated require_mention for %s: %s", channel_id, value)

    def get_require_mention_override(self, channel_id: Union[int, str]) -> Optional[bool]:
        """Get the raw per-channel require_mention override (may be None)."""
        self._reload_if_changed()
        key = str(channel_id)
        thread_ref = split_thread_settings_key(key)
        if thread_ref is not None:
            parent_id, thread_id = thread_ref
            channel_settings = self.store.find_thread(parent_id, thread_id, platform=self.platform)
            if channel_settings is None:
                channel_settings = self.store.find_channel(parent_id, platform=self.platform)
        else:
            channel_settings = self.store.get_channels_for_platform(self.platform).get(key)
        if channel_settings is not None:
            return channel_settings.require_mention
        return None


class MultiSettingsManager:
    """Route settings operations to per-platform managers using scoped keys."""

    def __init__(self, platforms: list[str], settings_file: Optional[str] = None, primary_platform: str = "slack"):
        self.settings_file = settings_file
        self.platform = primary_platform
        self.primary_platform = primary_platform
        self.sessions_store = SessionsStore()
        self.sessions_store.load()
        self.sessions_store.migrate_active_polls(primary_platform)
        self.sessions_store.migrate_session_mappings(primary_platform)
        self.sessions = SessionsFacade(self.sessions_store)
        self.managers = {
            platform: SettingsManager(
                settings_file=settings_file,
                platform=platform,
                sessions_store=self.sessions_store,
                sessions_facade=self.sessions,
            )
            for platform in platforms
        }
        if primary_platform not in self.managers:
            self.managers[primary_platform] = self._create_platform_manager(primary_platform)

    def _create_platform_manager(self, platform: str) -> SettingsManager:
        return SettingsManager(
            settings_file=self.settings_file,
            platform=platform,
            sessions_store=self.sessions_store,
            sessions_facade=self.sessions,
        )

    def add_platform(self, platform: str) -> SettingsManager:
        manager = self.managers.get(platform)
        if manager is None:
            manager = self._create_platform_manager(platform)
            self.managers[platform] = manager
        return manager

    def remove_platform(self, platform: str) -> None:
        if platform == self.primary_platform:
            return
        self.managers.pop(platform, None)

    def set_primary_platform(self, platform: str) -> None:
        if platform not in self.managers:
            self.add_platform(platform)
        self.platform = platform
        self.primary_platform = platform

    def get_store(self) -> SettingsStore:
        return self.managers[self.primary_platform].get_store()

    def get_platform_manager(self, platform: str) -> SettingsManager:
        return self.managers[platform]

    def _resolve(self, settings_key: Union[int, str], platform: Optional[str] = None) -> tuple[SettingsManager, str]:
        key = str(settings_key)
        if platform and platform in self.managers:
            return self.managers[platform], key
        # Backward compat: still try to split if :: present (for any legacy callers)
        if SCOPED_KEY_SEP in key:
            plat, raw = key.split(SCOPED_KEY_SEP, 1)
            if plat in self.managers:
                return self.managers[plat], raw
        return self.managers[self.primary_platform], key

    def iter_bound_users(self, platform: Optional[str] = None):
        if platform:
            return self.managers[platform].iter_bound_users()
        merged = []
        for plat, manager in self.managers.items():
            merged.extend(((f"{plat}{SCOPED_KEY_SEP}{uid}", user) for uid, user in manager.iter_bound_users()))
        return merged

    def is_bound_user(self, user_id: Union[int, str], platform: Optional[str] = None) -> bool:
        if platform:
            return self.managers[platform].is_bound_user(user_id)
        manager, raw = self._resolve(user_id)
        return manager.is_bound_user(raw)

    def is_enabled_user(self, user_id: Union[int, str], platform: Optional[str] = None) -> bool:
        if platform:
            return self.managers[platform].is_enabled_user(user_id)
        manager, raw = self._resolve(user_id)
        return manager.is_enabled_user(raw)

    def bind_user_with_code(
        self,
        user_id: Union[int, str],
        display_name: str,
        code: str,
        dm_chat_id: str = "",
        platform: Optional[str] = None,
    ):
        if platform:
            return self.managers[platform].bind_user_with_code(user_id, display_name, code, dm_chat_id=dm_chat_id)
        manager, raw = self._resolve(user_id)
        return manager.bind_user_with_code(raw, display_name, code, dm_chat_id=dm_chat_id)

    def get_user_settings(self, settings_key: Union[int, str]) -> UserSettings:
        manager, raw = self._resolve(settings_key)
        return manager.get_user_settings(raw)

    def change_scope_settings(self, settings_key: Union[int, str], changes: dict, **kwargs):
        manager, raw = self._resolve(settings_key)
        return manager.change_scope_settings(raw, changes, **kwargs)

    def set_show_message_types(self, settings_key: Union[int, str], show_message_types: List[str]) -> None:
        manager, raw = self._resolve(settings_key)
        return manager.set_show_message_types(raw, show_message_types)

    def toggle_show_message_type(self, settings_key: Union[int, str], message_type: str) -> bool:
        manager, raw = self._resolve(settings_key)
        return manager.toggle_show_message_type(raw, message_type)

    def set_custom_cwd(self, settings_key: Union[int, str], cwd: str):
        manager, raw = self._resolve(settings_key)
        return manager.set_custom_cwd(raw, cwd)

    def get_custom_cwd(self, settings_key: Union[int, str]) -> Optional[str]:
        manager, raw = self._resolve(settings_key)
        return manager.get_custom_cwd(raw)

    def get_channel_settings(self, settings_key: Union[int, str]) -> Optional[ChannelSettings]:
        manager, raw = self._resolve(settings_key)
        return manager.get_channel_settings(raw)

    def has_guild_scope(self, platform: Optional[str] = None) -> bool:
        manager = self.managers[platform or self.primary_platform]
        return manager.has_guild_scope()

    def get_enabled_guild_ids(self, platform: Optional[str] = None) -> list[str]:
        manager = self.managers[platform or self.primary_platform]
        return manager.get_enabled_guild_ids()

    def set_enabled_guild_ids(self, guild_ids: list[str], platform: Optional[str] = None) -> None:
        manager = self.managers[platform or self.primary_platform]
        return manager.set_enabled_guild_ids(guild_ids)

    def is_guild_enabled(self, guild_id: Union[int, str], platform: Optional[str] = None) -> bool:
        manager = self.managers[platform or self.primary_platform]
        return manager.is_guild_enabled(guild_id)

    def is_message_type_hidden(self, settings_key: Union[int, str], message_type: str) -> bool:
        manager, raw = self._resolve(settings_key)
        return manager.is_message_type_hidden(raw, message_type)

    def get_available_message_types(self) -> List[str]:
        return self.managers[self.primary_platform].get_available_message_types()

    def get_message_type_display_names(self) -> Dict[str, str]:
        return self.managers[self.primary_platform].get_message_type_display_names()

    def _canonicalize_message_type(self, message_type: str) -> str:
        return self.managers[self.primary_platform]._canonicalize_message_type(message_type)

    def get_channel_routing(self, settings_key: Union[int, str]) -> Optional[ChannelRouting]:
        manager, raw = self._resolve(settings_key)
        return manager.get_channel_routing(raw)

    def set_channel_routing(self, settings_key: Union[int, str], routing: ChannelRouting):
        manager, raw = self._resolve(settings_key)
        return manager.set_channel_routing(raw, routing)

    def get_require_mention(self, settings_key: Union[int, str], global_default: bool = False) -> bool:
        manager, raw = self._resolve(settings_key)
        return manager.get_require_mention(raw, global_default=global_default)

    def set_require_mention(self, settings_key: Union[int, str], value: Optional[bool]):
        manager, raw = self._resolve(settings_key)
        return manager.set_require_mention(raw, value)

    def get_require_mention_override(self, settings_key: Union[int, str]) -> Optional[bool]:
        manager, raw = self._resolve(settings_key)
        return manager.get_require_mention_override(raw)