machinaos 0.0.78 → 0.0.80

package/server/services/proxy/service.py

@@ -18,7 +18,6 @@ from core.logging import get_logger
 from services.proxy.exceptions import (
     BudgetExceededError,
     NoHealthyProviderError,
-    ProxyConfigError,
     ProviderError,
 )
 from services.proxy.models import (
@@ -86,10 +85,10 @@ class _ProviderRuntime:
         freshness_score = min(1.0, len(results) / 10)
 
         score = (
-            _WEIGHT_SUCCESS * success_rate +
-            _WEIGHT_LATENCY * latency_score +
-            _WEIGHT_COST * cost_score +
-            _WEIGHT_FRESHNESS * freshness_score
+            _WEIGHT_SUCCESS * success_rate
+            + _WEIGHT_LATENCY * latency_score
+            + _WEIGHT_COST * cost_score
+            + _WEIGHT_FRESHNESS * freshness_score
         )
         return round(max(0.0, min(1.0, score)), 4)
 
@@ -154,9 +153,7 @@ class ProxyService:
 
             self._initialized = True
             provider_names = [p.config.name for p in self._providers.values() if p.config.enabled]
-            logger.info("Proxy service started",
-                       providers=provider_names,
-                       rules=len(self._routing_rules))
+            logger.info("Proxy service started", providers=provider_names, rules=len(self._routing_rules))
 
         except Exception as e:
             logger.error("Failed to start proxy service", error=str(e))
@@ -229,9 +226,7 @@ class ProxyService:
         # None unless a caller hand-passes them via the same
         # snake_case convention as the rest of the schema.
         geo = GeoTarget(
-            country=parameters.get("proxy_country") or
-                    (rule.required_country if rule else None) or
-                    self._settings.proxy_default_country,
+            country=parameters.get("proxy_country") or (rule.required_country if rule else None) or self._settings.proxy_default_country,
             city=parameters.get("proxy_city"),
             state=parameters.get("proxy_state"),
         )
@@ -255,10 +250,7 @@ class ProxyService:
             session_id=session_id,
         )
 
-        logger.debug("Proxy URL generated",
-                     provider=runtime.config.name,
-                     domain=domain,
-                     country=geo.country)
+        logger.debug("Proxy URL generated", provider=runtime.config.name, domain=domain, country=geo.country)
 
         return proxy_url
 
@@ -279,7 +271,7 @@ class ProxyService:
 
         # Track daily spend
         if result.bytes_transferred > 0 and runtime.config.cost_per_gb > 0:
-            gb = result.bytes_transferred / (1024 ** 3)
+            gb = result.bytes_transferred / (1024**3)
             self._daily_spend_usd += gb * runtime.config.cost_per_gb
 
     def get_providers(self) -> List[ProviderStats]:
@@ -356,10 +348,7 @@ class ProxyService:
             "daily_budget_usd": self._settings.proxy_budget_daily_usd,
             "total_requests": sum(p.total_requests for p in self._providers.values()),
             "total_bytes": sum(p.total_bytes for p in self._providers.values()),
-            "providers": {
-                name: rt.to_stats().model_dump()
-                for name, rt in self._providers.items()
-            },
+            "providers": {name: rt.to_stats().model_dump() for name, rt in self._providers.items()},
         }
 
     def reset_daily_spend(self) -> None:
@@ -370,8 +359,7 @@ class ProxyService:
         """Reload provider configs from database (called after tool/UI changes)."""
         db_providers = await self._database.get_proxy_providers()
         await self._load_providers(db_providers)
-        logger.info("Proxy providers reloaded",
-                     count=len(self._providers))
+        logger.info("Proxy providers reloaded", count=len(self._providers))
 
     async def _load_providers(self, db_providers: list) -> None:
         """Build _ProviderRuntime instances from database rows."""
@@ -405,8 +393,7 @@ class ProxyService:
                 runtime.username = username
                 runtime.password = password
             else:
-                logger.warning("No credentials for proxy provider",
-                               name=config.name)
+                logger.warning("No credentials for proxy provider", name=config.name)
 
             self._providers[config.name] = runtime
 
@@ -441,10 +428,7 @@ class ProxyService:
 
     def _pick_best_provider(self) -> Optional[_ProviderRuntime]:
         """Pick the best healthy provider by composite score."""
-        candidates = [
-            rt for rt in self._providers.values()
-            if rt.config.enabled and rt.has_credentials and rt.is_healthy()
-        ]
+        candidates = [rt for rt in self._providers.values() if rt.config.enabled and rt.has_credentials and rt.is_healthy()]
 
         if not candidates:
             return None
@@ -458,18 +442,20 @@ class ProxyService:
         db_rules = await self._database.get_proxy_routing_rules()
         self._routing_rules = []
         for row in db_rules:
-            self._routing_rules.append(RoutingRule(
-                id=row.get("id"),
-                domain_pattern=row["domain_pattern"],
-                preferred_providers=json.loads(row.get("preferred_providers", "[]")),
-                required_country=row.get("required_country"),
-                session_type=SessionType(row.get("session_type", "rotating")),
-                sticky_duration_seconds=row.get("sticky_duration_seconds", 300),
-                max_retries=row.get("max_retries", 3),
-                failover=row.get("failover", True),
-                min_success_rate=row.get("min_success_rate", 0.7),
-                priority=row.get("priority", 0),
-            ))
+            self._routing_rules.append(
+                RoutingRule(
+                    id=row.get("id"),
+                    domain_pattern=row["domain_pattern"],
+                    preferred_providers=json.loads(row.get("preferred_providers", "[]")),
+                    required_country=row.get("required_country"),
+                    session_type=SessionType(row.get("session_type", "rotating")),
+                    sticky_duration_seconds=row.get("sticky_duration_seconds", 300),
+                    max_retries=row.get("max_retries", 3),
+                    failover=row.get("failover", True),
+                    min_success_rate=row.get("min_success_rate", 0.7),
+                    priority=row.get("priority", 0),
+                )
+            )
         self._routing_rules.sort(key=lambda r: r.priority)
 
 

package/server/services/rlm/adapters.py

@@ -20,7 +20,7 @@ class BackendAdapter:
 
     @staticmethod
     def adapt(provider: str, model: str, api_key: str) -> Tuple[str, Dict[str, Any]]:
-        backend = PROVIDER_TO_BACKEND.get(provider, 'openai')
+        backend = PROVIDER_TO_BACKEND.get(provider, "openai")
         kwargs = {"model_name": model, "api_key": api_key}
         if provider in PROVIDER_BASE_URLS:
             kwargs["base_url"] = PROVIDER_BASE_URLS[provider]
@@ -37,20 +37,21 @@ class ChatModelExtractor:
     @staticmethod
     async def extract(tool_data: Optional[List[Dict[str, Any]]], auth) -> Tuple[List[str], List[Dict]]:
         from constants import AI_CHAT_MODEL_TYPES
+
         backends, kwargs_list = [], []
 
         if not tool_data:
             return backends, kwargs_list
 
         for tool_info in tool_data:
-            node_type = tool_info.get('node_type', '')
+            node_type = tool_info.get("node_type", "")
             if node_type not in AI_CHAT_MODEL_TYPES:
                 continue
 
-            params = tool_info.get('parameters', {})
-            provider = params.get('provider', '')
-            model = params.get('model', '')
-            api_key = params.get('api_key')
+            params = tool_info.get("parameters", {})
+            provider = params.get("provider", "")
+            model = params.get("model", "")
+            api_key = params.get("api_key")
 
             if not api_key and auth:
                 api_key = await auth.get_api_key(provider)
@@ -77,28 +78,30 @@ class ToolBridgeAdapter:
 
     # Brief descriptions for common tool types (used in RLM REPL context)
     TOOL_DESCRIPTIONS = {
-        'calculatorTool': 'Math operations: add, subtract, multiply, divide, power, sqrt, mod, abs. Args: operation, a, b',
-        'currentTimeTool': 'Get current date/time. Args: timezone (optional)',
-        'duckduckgoSearch': 'Web search via DuckDuckGo. Args: query, max_results (optional)',
-        'pythonExecutor': 'Execute Python code. Args: code (must set output variable)',
-        'httpRequest': 'HTTP request. Args: url, method (GET/POST/PUT/DELETE), body (optional)',
-        'httpRequestTool': 'HTTP request. Args: url, method (GET/POST/PUT/DELETE), body (optional)',
-        'braveSearch': 'Web search via Brave. Args: query',
-        'serperSearch': 'Web search via Google/Serper. Args: query',
-        'perplexitySearch': 'AI-powered web search via Perplexity. Args: query',
-        'crawleeScraper': 'Read/extract content from web pages. Args: url',
-        'gmail': 'Send/search/read emails. Args: operation, ...',
-        'calendar': 'Manage Google Calendar events. Args: operation, ...',
-        'drive': 'Manage Google Drive files. Args: operation, ...',
-        'sheets': 'Read/write Google Sheets. Args: operation, ...',
-        'tasks': 'Manage Google Tasks. Args: operation, ...',
-        'contacts': 'Manage Google Contacts. Args: operation, ...',
-        'taskManager': 'Track delegated tasks. Args: operation',
-        'timer': 'Wait for duration. Args: duration, unit',
+        "calculatorTool": "Math operations: add, subtract, multiply, divide, power, sqrt, mod, abs. Args: operation, a, b",
+        "currentTimeTool": "Get current date/time. Args: timezone (optional)",
+        "duckduckgoSearch": "Web search via DuckDuckGo. Args: query, max_results (optional)",
+        "pythonExecutor": "Execute Python code. Args: code (must set output variable)",
+        "httpRequest": "HTTP request. Args: url, method (GET/POST/PUT/DELETE), body (optional)",
+        "httpRequestTool": "HTTP request. Args: url, method (GET/POST/PUT/DELETE), body (optional)",
+        "braveSearch": "Web search via Brave. Args: query",
+        "serperSearch": "Web search via Google/Serper. Args: query",
+        "perplexitySearch": "AI-powered web search via Perplexity. Args: query",
+        "crawleeScraper": "Read/extract content from web pages. Args: url",
+        "gmail": "Send/search/read emails. Args: operation, ...",
+        "calendar": "Manage Google Calendar events. Args: operation, ...",
+        "drive": "Manage Google Drive files. Args: operation, ...",
+        "sheets": "Read/write Google Sheets. Args: operation, ...",
+        "tasks": "Manage Google Tasks. Args: operation, ...",
+        "contacts": "Manage Google Contacts. Args: operation, ...",
+        "taskManager": "Track delegated tasks. Args: operation",
+        "timer": "Wait for duration. Args: duration, unit",
     }
 
     @staticmethod
-    def bridge(tool_data: Optional[List[Dict[str, Any]]], context: Optional[Dict] = None, loop: Optional[asyncio.AbstractEventLoop] = None) -> Dict[str, Dict]:
+    def bridge(
+        tool_data: Optional[List[Dict[str, Any]]], context: Optional[Dict] = None, loop: Optional[asyncio.AbstractEventLoop] = None
+    ) -> Dict[str, Dict]:
         from constants import AI_AGENT_TYPES, AI_CHAT_MODEL_TYPES
         from services.handlers.tools import execute_tool
 
@@ -109,38 +112,38 @@ class ToolBridgeAdapter:
         tools = {}
 
         for tool_info in tool_data:
-            node_type = tool_info.get('node_type', '')
+            node_type = tool_info.get("node_type", "")
 
             # Skip agents (delegation) and chat models (handled by ChatModelExtractor)
             if node_type in AI_AGENT_TYPES or node_type in AI_CHAT_MODEL_TYPES:
                 continue
 
-            node_id = tool_info.get('node_id', '')
-            label = tool_info.get('label', node_type)
-            params = tool_info.get('parameters', {})
+            node_id = tool_info.get("node_id", "")
+            label = tool_info.get("label", node_type)
+            params = tool_info.get("parameters", {})
 
             def _make_sync_wrapper(t_type, t_id, t_params, t_label):
                 def wrapper(**kwargs):
                     config = {
-                        'node_type': t_type,
-                        'node_id': t_id,
-                        'parameters': t_params,
-                        'label': t_label,
+                        "node_type": t_type,
+                        "node_id": t_id,
+                        "parameters": t_params,
+                        "label": t_label,
                     }
                     if context:
-                        config['nodes'] = context.get('nodes', [])
-                        config['edges'] = context.get('edges', [])
+                        config["nodes"] = context.get("nodes", [])
+                        config["edges"] = context.get("edges", [])
                     future = asyncio.run_coroutine_threadsafe(
-                        execute_tool(t_label, kwargs, config), main_loop,
+                        execute_tool(t_label, kwargs, config),
+                        main_loop,
                     )
                     return future.result(timeout=60)
+
                 return wrapper
 
             # Clean tool name (same pattern as _build_tool_from_node ai.py:2567)
-            tool_name = re.sub(r'[^a-zA-Z0-9_]', '_', label.lower().replace(' ', '_'))
-            description = ToolBridgeAdapter.TOOL_DESCRIPTIONS.get(
-                node_type, f"Execute {label} ({node_type})"
-            )
+            tool_name = re.sub(r"[^a-zA-Z0-9_]", "_", label.lower().replace(" ", "_"))
+            description = ToolBridgeAdapter.TOOL_DESCRIPTIONS.get(node_type, f"Execute {label} ({node_type})")
 
             tools[tool_name] = {
                 "tool": _make_sync_wrapper(node_type, node_id, params, label),

package/server/services/rlm/constants.py

@@ -2,19 +2,19 @@
 
 # MachinaOS provider -> RLM backend mapping
 PROVIDER_TO_BACKEND = {
-    'openai': 'openai',
-    'anthropic': 'anthropic',
-    'gemini': 'gemini',
-    'groq': 'openai',
-    'openrouter': 'openrouter',
-    'cerebras': 'openai',
+    "openai": "openai",
+    "anthropic": "anthropic",
+    "gemini": "gemini",
+    "groq": "openai",
+    "openrouter": "openrouter",
+    "cerebras": "openai",
 }
 
 # Base URLs for OpenAI-compatible providers
 PROVIDER_BASE_URLS = {
-    'groq': 'https://api.groq.com/openai/v1',
-    'openrouter': 'https://openrouter.ai/api/v1',
-    'cerebras': 'https://api.cerebras.ai/v1',
+    "groq": "https://api.groq.com/openai/v1",
+    "openrouter": "https://openrouter.ai/api/v1",
+    "cerebras": "https://api.cerebras.ai/v1",
 }
 
 # Default RLM execution parameters

package/server/services/rlm/service.py

@@ -1,7 +1,7 @@
 """RLM execution service.
 
 Follows the same interface as AIService.execute_agent() / execute_chat_agent()
-but replaces LangGraph with RLM's REPL-based execution loop.
+but replaces the agent loop with RLM's REPL-based execution.
 """
 
 import asyncio
@@ -46,34 +46,34 @@ class RLMService:
 
         async def broadcast_status(phase: str, details: Dict[str, Any] = None):
             if broadcaster:
-                await broadcaster.update_node_status(node_id, "executing", {
-                    "phase": phase, "agent_type": "rlm", **(details or {})
-                }, workflow_id=workflow_id)
+                await broadcaster.update_node_status(
+                    node_id, "executing", {"phase": phase, "agent_type": "rlm", **(details or {})}, workflow_id=workflow_id
+                )
 
         try:
             # === Parameter extraction (same pattern as execute_chat_agent) ===
-            prompt = parameters.get('prompt', '')
-            system_message = parameters.get('system_message', '')
+            prompt = parameters.get("prompt", "")
+            system_message = parameters.get("system_message", "")
 
             # Skill injection (reuse ai.py:833 _build_skill_system_prompt)
             # Collected as supplementary context -- appended to RLM prompt, never replaces it
             from services.ai import _build_skill_system_prompt
+
             supplementary_context = ""
-            skill_prompt, has_personality = _build_skill_system_prompt(
-                skill_data, log_prefix="[RLM]"
-            )
+            skill_prompt, has_personality = _build_skill_system_prompt(skill_data, log_prefix="[RLM]")
             if skill_prompt:
                 supplementary_context += f"\n\n## Skill Instructions\n{skill_prompt}"
 
             # Options flattening (same as execute_chat_agent line 1995)
-            options = parameters.get('options', {})
+            options = parameters.get("options", {})
             flattened = {**parameters, **options}
 
             # Provider/model/API key resolution (same as lines 1998-2014)
             from services.ai import is_model_valid_for_provider, get_default_model_async
-            api_key = flattened.get('api_key')
-            provider = parameters.get('provider', 'openai')
-            model = parameters.get('model', '')
+
+            api_key = flattened.get("api_key")
+            provider = parameters.get("provider", "openai")
+            model = parameters.get("model", "")
 
             if not model or not is_model_valid_for_provider(model, provider):
                 model = await get_default_model_async(provider, database)
@@ -83,45 +83,49 @@ class RLMService:
             if not api_key:
                 raise ValueError(f"API key required for RLM Agent (provider: {provider})")
 
-            await broadcast_status("initializing", {
-                "message": f"Initializing RLM with {provider}/{model}",
-                "provider": provider, "model": model,
-            })
+            await broadcast_status(
+                "initializing",
+                {
+                    "message": f"Initializing RLM with {provider}/{model}",
+                    "provider": provider,
+                    "model": model,
+                },
+            )
 
             # === Memory injection (appended to supplementary context, not system prompt) ===
-            if memory_data and memory_data.get('memory_content'):
-                memory_text = memory_data['memory_content']
+            if memory_data and memory_data.get("memory_content"):
+                memory_text = memory_data["memory_content"]
                 supplementary_context += f"\n\n## Conversation History\n{memory_text}"
 
             # === Adapter: Map provider to RLM backend ===
             backend, backend_kwargs = BackendAdapter.adapt(provider, model, api_key)
 
             # === Adapter: Extract chat model nodes as other_backends ===
-            other_backends, other_backend_kwargs = await ChatModelExtractor.extract(
-                tool_data, self.auth
-            )
+            other_backends, other_backend_kwargs = await ChatModelExtractor.extract(tool_data, self.auth)
 
             # === Adapter: Bridge tool nodes as RLM custom_tools ===
-            await broadcast_status("building_tools", {
-                "message": "Bridging connected tools..."
-            })
+            await broadcast_status("building_tools", {"message": "Bridging connected tools..."})
             running_loop = asyncio.get_running_loop()
             custom_tools = ToolBridgeAdapter.bridge(tool_data, context, loop=running_loop)
 
             # === RLM-specific parameters ===
-            max_iterations = int(flattened.get('max_iterations', DEFAULT_MAX_ITERATIONS))
-            max_depth = int(flattened.get('max_depth', DEFAULT_MAX_DEPTH))
-            max_budget = flattened.get('max_budget')
-            max_timeout = flattened.get('max_timeout')
-            max_tokens = flattened.get('max_tokens')
-            verbose = flattened.get('verbose', DEFAULT_VERBOSE)
+            max_iterations = int(flattened.get("max_iterations", DEFAULT_MAX_ITERATIONS))
+            max_depth = int(flattened.get("max_depth", DEFAULT_MAX_DEPTH))
+            max_budget = flattened.get("max_budget")
+            max_timeout = flattened.get("max_timeout")
+            max_tokens = flattened.get("max_tokens")
+            verbose = flattened.get("verbose", DEFAULT_VERBOSE)
 
             # === Run RLM in thread pool (RLM is synchronous) ===
-            await broadcast_status("executing", {
-                "message": f"RLM executing (max {max_iterations} iterations)...",
-                "max_iterations": max_iterations, "max_depth": max_depth,
-                "tool_count": len(custom_tools),
-            })
+            await broadcast_status(
+                "executing",
+                {
+                    "message": f"RLM executing (max {max_iterations} iterations)...",
+                    "max_iterations": max_iterations,
+                    "max_depth": max_depth,
+                    "tool_count": len(custom_tools),
+                },
+            )
 
             # Build augmented prompt: MachinaOS context prepended to user prompt.
             # We do NOT pass custom_system_prompt to RLM because RLM_SYSTEM_PROMPT
@@ -140,36 +144,44 @@ class RLMService:
             def _run_rlm():
                 from rlm import RLM
                 from rlm.logger import RLMLogger
+
                 rlm_instance = RLM(
-                    backend=backend, backend_kwargs=backend_kwargs,
+                    backend=backend,
+                    backend_kwargs=backend_kwargs,
                     environment="local",
                     other_backends=other_backends if other_backends else None,
                     other_backend_kwargs=other_backend_kwargs if other_backend_kwargs else None,
-                    max_iterations=max_iterations, max_depth=max_depth,
+                    max_iterations=max_iterations,
+                    max_depth=max_depth,
                     max_budget=float(max_budget) if max_budget else None,
                     max_timeout=float(max_timeout) if max_timeout else None,
                     max_tokens=int(max_tokens) if max_tokens else None,
                     custom_tools=custom_tools if custom_tools else None,
-                    logger=RLMLogger(), verbose=verbose,
+                    logger=RLMLogger(),
+                    verbose=verbose,
                 )
                 return rlm_instance.completion(augmented_prompt)
 
             result = await asyncio.to_thread(_run_rlm)
 
             # === Memory save (same pattern as execute_chat_agent) ===
-            if memory_data and memory_data.get('node_id'):
+            if memory_data and memory_data.get("node_id"):
                 from services.memory_store import add_message
-                session_id = memory_data.get('session_id', 'default')
+
+                session_id = memory_data.get("session_id", "default")
                 add_message(session_id, "user", prompt)
                 add_message(session_id, "assistant", result.response or "")
 
             execution_time = time.time() - start_time
             iterations = len(result.metadata.get("iterations", [])) if result.metadata else 0
 
-            await broadcast_status("completed", {
-                "message": f"RLM completed in {execution_time:.1f}s",
-                "iterations": iterations,
-            })
+            await broadcast_status(
+                "completed",
+                {
+                    "message": f"RLM completed in {execution_time:.1f}s",
+                    "iterations": iterations,
+                },
+            )
 
             return {
                 "success": True,

package/server/services/scheduler.py

@@ -2,6 +2,7 @@
 Cron Scheduler Service using APScheduler.
 Manages scheduled jobs for workflow automation.
 """
+
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from apscheduler.triggers.cron import CronTrigger
 from apscheduler.jobstores.base import JobLookupError
@@ -37,13 +38,7 @@ def shutdown_scheduler():
         logger.info("[Scheduler] Shutdown")
 
 
-def register_cron_job(
-    job_id: str,
-    cron_expression: str,
-    callback: Callable,
-    timezone: str = "UTC",
-    **kwargs
-) -> str:
+def register_cron_job(job_id: str, cron_expression: str, callback: Callable, timezone: str = "UTC", **kwargs) -> str:
     """
     Register a cron job with the scheduler.
 
@@ -66,35 +61,17 @@ def register_cron_job(
     if len(parts) >= 6:
         # 6-field format: second minute hour day month weekday
         trigger = CronTrigger(
-            second=parts[0],
-            minute=parts[1],
-            hour=parts[2],
-            day=parts[3],
-            month=parts[4],
-            day_of_week=parts[5],
-            timezone=timezone
+            second=parts[0], minute=parts[1], hour=parts[2], day=parts[3], month=parts[4], day_of_week=parts[5], timezone=timezone
         )
     else:
         # 5-field format: minute hour day month weekday (default second=0)
         if len(parts) < 5:
-            parts.extend(['*'] * (5 - len(parts)))
+            parts.extend(["*"] * (5 - len(parts)))
         trigger = CronTrigger(
-            second='0',
-            minute=parts[0],
-            hour=parts[1],
-            day=parts[2],
-            month=parts[3],
-            day_of_week=parts[4],
-            timezone=timezone
+            second="0", minute=parts[0], hour=parts[1], day=parts[2], month=parts[3], day_of_week=parts[4], timezone=timezone
         )
 
-    scheduler.add_job(
-        callback,
-        trigger=trigger,
-        id=job_id,
-        replace_existing=True,
-        kwargs=kwargs
-    )
+    scheduler.add_job(callback, trigger=trigger, id=job_id, replace_existing=True, kwargs=kwargs)
 
     logger.info(f"[Scheduler] Registered cron job: {job_id} with expression: {cron_expression}")
     return job_id
@@ -133,11 +110,7 @@ def get_job_info(job_id: str) -> Optional[Dict]:
     scheduler = get_scheduler()
     job = scheduler.get_job(job_id)
     if job:
-        return {
-            "id": job.id,
-            "next_run_time": job.next_run_time.isoformat() if job.next_run_time else None,
-            "trigger": str(job.trigger)
-        }
+        return {"id": job.id, "next_run_time": job.next_run_time.isoformat() if job.next_run_time else None, "trigger": str(job.trigger)}
     return None
 
 
@@ -146,10 +119,6 @@ def get_all_jobs() -> list:
     scheduler = get_scheduler()
     jobs = scheduler.get_jobs()
     return [
-        {
-            "id": job.id,
-            "next_run_time": job.next_run_time.isoformat() if job.next_run_time else None,
-            "trigger": str(job.trigger)
-        }
+        {"id": job.id, "next_run_time": job.next_run_time.isoformat() if job.next_run_time else None, "trigger": str(job.trigger)}
         for job in jobs
     ]

package/server/services/settings/__init__.py

@@ -0,0 +1,16 @@
+"""Settings domain — Wave 13.3 extraction from ``routers/websocket.py``.
+
+Side-effect import registers the 8 settings handlers (user_settings +
+provider_defaults + validated_ai_providers + global_model + compaction
+stats/config) into ``ws_handler_registry``.
+"""
+
+from __future__ import annotations
+
+from services.ws_handler_registry import register_ws_handlers as _register_ws_handlers
+
+from .handlers import WS_HANDLERS as _SETTINGS_WS_HANDLERS
+
+_register_ws_handlers(_SETTINGS_WS_HANDLERS)
+
+__all__ = ["handlers"]