Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
"""Settings domain WebSocket handlers.
Extracted from ``routers/websocket.py`` (Wave 13.3). 8 handlers covering:
- User settings I/O (``get_user_settings`` / ``save_user_settings``).
- Provider defaults (per-LLM-provider tuning) (``get_provider_defaults``
/ ``save_provider_defaults``).
- Validated AI providers + global default model
(``get_validated_ai_providers`` / ``save_global_model``).
- Memory compaction settings (``get_compaction_stats`` /
``configure_compaction``).
Wire shape preserved across the move; frontend handlers continue
working unchanged.
"""
from __future__ import annotations
from typing import Any, Dict
from fastapi import WebSocket
from core.logging import get_logger
from services.ws_handler_registry import ws_handler
logger = get_logger(__name__)
@ws_handler()
async def handle_get_user_settings(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
"""Get user settings from database."""
from core.container import container
database = container.database()
user_id = data.get("user_id", "default")
settings = await database.get_user_settings(user_id)
if settings is None:
settings = {
"user_id": user_id,
"auto_save": True,
"auto_save_interval": 30,
"sidebar_default_open": True,
"component_palette_default_open": True,
}
return {"settings": settings}
@ws_handler()
async def handle_save_user_settings(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
"""Save user settings to database."""
from core.container import container
from services.settings.profile import normalize_profile_patch
database = container.database()
user_id = data.get("user_id", "default")
# Profile text reaches every hired employee's instructions: clean it here.
raw = data.get("settings")
settings_data = normalize_profile_patch(raw if isinstance(raw, dict) else {})
# The chat's model picker keeps to what it offers (services/chat/choice.py).
from services.chat.choice import ChoiceRefused, check_settings
try:
check_settings(settings_data)
except ChoiceRefused as exc:
return {"success": False, "error": "chat_choice_refused", "detail": exc.detail}
success = await database.save_user_settings(settings_data, user_id)
if success:
if "max_processes" in settings_data:
from services.process_service import get_process_service
get_process_service().max_processes = int(settings_data["max_processes"])
settings = await database.get_user_settings(user_id)
return {"settings": settings}
return {"success": False, "error": "Failed to save settings"}
@ws_handler()
async def handle_get_provider_defaults(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
"""Get default parameters for a provider."""
from core.container import container
from services.llm.config import get_default_model
from services.model_registry import get_model_registry
database = container.database()
provider = data.get("provider", "").lower()
defaults = await database.get_provider_defaults(provider)
config_default_model = get_default_model(provider)
if defaults:
if not defaults.get("default_model"):
defaults["default_model"] = config_default_model
return {"provider": provider, "defaults": defaults}
registry = get_model_registry()
model_max_tokens = registry.get_max_output_tokens(config_default_model, provider)
return {
"provider": provider,
"defaults": {
"default_model": config_default_model,
"temperature": 0.7,
"max_tokens": model_max_tokens,
"thinking_enabled": False,
"thinking_budget": 2048,
"reasoning_effort": "medium",
"reasoning_format": "parsed",
},
}
@ws_handler()
async def handle_save_provider_defaults(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
"""Save default parameters for a provider."""
from core.container import container
database = container.database()
provider = data.get("provider", "").lower()
defaults = data.get("defaults", {})
success = await database.save_provider_defaults(provider, defaults)
return {"success": success, "provider": provider}
@ws_handler()
async def handle_get_validated_ai_providers(
data: Dict[str, Any],
websocket: WebSocket,
) -> Dict[str, Any]:
"""Get all AI providers with stored API keys and their popular models.
Returns providers that have validated keys, their stored models,
and the current global default provider/model from UserSettings.
"""
import json
from pathlib import Path
from core.container import container
auth_service = container.auth_service()
database = container.database()
from services.authz.ws_surface import execution_principal
principal = execution_principal({}, websocket)
from services.llm.config import PROVIDER_CONFIGS
AI_PROVIDERS = list(PROVIDER_CONFIGS.keys())
defaults_path = Path(__file__).parent.parent.parent / "config" / "llm_defaults.json"
try:
with open(defaults_path) as f:
llm_defaults = json.load(f)
except Exception:
llm_defaults = {"providers": {}}
from services.gateway.routing import gateway_covers
from services.llm.config import curated_models
providers = []
for provider in AI_PROVIDERS:
if await auth_service.has_valid_key(provider, data.get("session_id", "default"), principal=principal):
stored_models = await auth_service.get_stored_models(provider, data.get("session_id", "default"), principal=principal)
elif await gateway_covers(provider):
# No key of the install's own; the OpenCompany Gateway serves it.
stored_models = curated_models(provider)
else:
continue
provider_config = llm_defaults.get("providers", {}).get(provider, {})
default_model = provider_config.get("default_model", "")
popular_models = provider_config.get("popular_models") or [
m for m in provider_config.get("max_output_tokens", {}).keys() if m != "_default"
]
provider_defaults = await database.get_provider_defaults(provider)
if provider_defaults and provider_defaults.get("default_model"):
default_model = provider_defaults["default_model"]
providers.append(
{
"provider": provider,
# Serialized so the client never needs its own id -> label table.
# This list is built from PROVIDER_CONFIGS, so it can legitimately
# contain a provider (xai) that has no chat-model node and no
# credential-catalogue entry; without a name from here the UI fell
# back to rendering the raw id.
"display_name": provider_config.get("display_name") or provider,
"models": stored_models or [],
"popular_models": popular_models,
"default_model": default_model,
}
)
# Each named endpoint is its own provider, so one can be the global
# default (RFC-0003 D13). The bare ``openai_compatible`` id holds no
# key, so the loop above already skipped it.
from services.llm.endpoints import list_endpoints
for endpoint in await list_endpoints(auth_service, principal=principal):
endpoint_defaults = await database.get_provider_defaults(endpoint.ref)
providers.append(
{
"provider": endpoint.ref,
"display_name": f"{endpoint.label} (OpenAI-compatible)",
"models": endpoint.models,
"popular_models": [],
"default_model": (endpoint_defaults or {}).get("default_model", ""),
}
)
user_id = data.get("user_id", "default")
settings = await database.get_user_settings(user_id)
global_provider = settings.get("default_llm_provider") if settings else None
global_model = settings.get("default_llm_model") if settings else None
if not (global_provider and global_model):
# The model that applies: the OpenCompany Gateway's default while it serves it.
from services.gateway.routing import gateway_default
global_provider, global_model = await gateway_default() or (global_provider, global_model)
return {
"providers": providers,
"global_provider": global_provider,
"global_model": global_model,
}
@ws_handler()
async def handle_save_global_model(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
"""Save the global default provider + model to UserSettings."""
from core.container import container
database = container.database()
provider = data.get("provider", "")
model = data.get("model", "")
user_id = data.get("user_id", "default")
success = await database.save_user_settings(
{
"default_llm_provider": provider,
"default_llm_model": model,
},
user_id,
)
return {"success": success, "provider": provider, "model": model}
@ws_handler("session_id")
async def handle_get_compaction_stats(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
"""Get compaction statistics for a session.
Optional model/provider params enable the model-aware threshold (the
compaction ratio times the model's context window).
"""
from services.compaction import get_compaction_service
svc = get_compaction_service()
if not svc:
return {"success": False, "error": "Compaction service not initialized"}
return await svc.stats(
data["session_id"],
model=data.get("model", ""),
provider=data.get("provider", ""),
)
@ws_handler("session_id")
async def handle_configure_compaction(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
"""Configure compaction settings for a session."""
from services.compaction import get_compaction_service
svc = get_compaction_service()
if not svc:
return {"success": False, "error": "Compaction service not initialized"}
success = await svc.configure(data["session_id"], data.get("threshold"), data.get("enabled"))
return {"success": success}
@ws_handler()
async def handle_get_provider_usage_summary(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
"""Get aggregated token usage and cost by provider for Credentials Modal.
Lives in settings/ for now (Wave 13.3). Wave 13.8 may move it to a
dedicated ``services/pricing/handlers.py`` module alongside
``get_pricing_config`` / ``save_pricing_config`` / ``get_api_usage_summary``.
"""
from core.container import container
database = container.database()
providers = await database.get_provider_usage_summary()
return {"success": True, "providers": providers}
WS_HANDLERS: Dict[str, Any] = {
"get_user_settings": handle_get_user_settings,
"save_user_settings": handle_save_user_settings,
"get_provider_defaults": handle_get_provider_defaults,
"save_provider_defaults": handle_save_provider_defaults,
"get_validated_ai_providers": handle_get_validated_ai_providers,
"save_global_model": handle_save_global_model,
"get_compaction_stats": handle_get_compaction_stats,
"configure_compaction": handle_configure_compaction,
"get_provider_usage_summary": handle_get_provider_usage_summary,
}
__all__ = [
"WS_HANDLERS",
"handle_configure_compaction",
"handle_get_compaction_stats",
"handle_get_provider_defaults",
"handle_get_provider_usage_summary",
"handle_get_user_settings",
"handle_get_validated_ai_providers",
"handle_save_global_model",
"handle_save_provider_defaults",
"handle_save_user_settings",
]