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.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
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)