Agent Zero AI framework
refactor: rename state_sync namespace to webui and simplify handler event registration
frdela5620506d511
diff --git a/api/api_message.py b/api/api_message.pyindex 1fbe66b41..cf20b937f 100644--- a/api/api_message.py+++ b/api/api_message.py@@ -142,7 +142,7 @@ class ApiMessage(ApiHandler):)# Send message to agent- task = context.communicate(UserMessage(message, attachment_paths))+ task = context.communicate(UserMessage(message=message, attachments=attachment_paths))result = await task.result()# Clean up expired chatsdiff --git a/api/message.py b/api/message.pyindex 7eaef1d57..27a5a7677 100644--- a/api/message.py+++ b/api/message.py@@ -68,4 +68,4 @@ class Message(ApiHandler):# Log to console and UI using helper functionmq.log_user_message(context, message, attachment_paths, message_id)- return context.communicate(UserMessage(message, attachment_paths)), context+ return context.communicate(UserMessage(message=message, attachments=attachment_paths)), contextdiff --git a/docs/developer/websockets.md b/docs/developer/websockets.mdindex 1527a74c6..e10b63ee9 100644--- a/docs/developer/websockets.md+++ b/docs/developer/websockets.md@@ -139,7 +139,7 @@ These expanded flows complement the operation matrix later in the guide, ensurinHandlers are discovered deterministically from `python/websocket_handlers/`:-- **File entry**: `python/websocket_handlers/state_sync_handler.py` → namespace `/state_sync`+- **File entry**: `python/websocket_handlers/webui_handler.py` → namespace `/webui`- **Folder entry**: `python/websocket_handlers/orders/` or `python/websocket_handlers/orders_handler/` → namespace `/orders` (loads `*.py` one level deep; ignores `__init__.py` and deeper nesting)- **Reserved root**: `python/websocket_handlers/_default.py` → namespace `/` (diagnostics-only by default)@@ -273,7 +273,7 @@ console.log(window.runtimeInfo.id, window.runtimeInfo.isDevelopment);### Namespaces (end-state)-- The root namespace (`/`) is reserved and intentionally unhandled by default for application events. Feature code should connect to an explicit namespace (for example `/state_sync`).+- The root namespace (`/`) is reserved and intentionally unhandled by default for application events. Feature code should connect to an explicit namespace (for example `/webui`).- The frontend exposes `createNamespacedClient(namespace)` and `getNamespacedClient(namespace)` (one client instance per namespace per tab). Namespaced clients expose the same minimal API: `emit`, `request`, `on`, `off`.- Unknown namespaces are rejected deterministically during the Socket.IO connect handshake with a `connect_error` payload:- `err.message === "UNKNOWN_NAMESPACE"`@@ -342,7 +342,7 @@ Example:```javascriptimport { getNamespacedClient, createCorrelationId, validateServerEnvelope } from '/js/websocket.js';-const websocket = getNamespacedClient('/state_sync');+const websocket = getNamespacedClient('/webui');const { results } = await websocket.request('hello_request',@@ -381,7 +381,7 @@ Example – request()```javascriptimport { getNamespacedClient } from '/js/websocket.js'-const websocket = getNamespacedClient('/state_sync')+const websocket = getNamespacedClient('/webui')function renderError(code, message) {// Map codes to UI copy; keep messages concise@@ -409,7 +409,7 @@ Subscriptions – envelope handler```javascriptimport { getNamespacedClient } from '/js/websocket.js'-const websocket = getNamespacedClient('/state_sync')+const websocket = getNamespacedClient('/webui')websocket.on('example_broadcast', ({ data, handlerId, eventId, correlationId }) => {// handle data; errors should not typically arrive via broadcastdiff --git a/extensions/python/webui_ws_connect/_10_state_sync.py b/extensions/python/webui_ws_connect/_10_state_sync.pynew file mode 100644index 000000000..f5263221f--- /dev/null+++ b/extensions/python/webui_ws_connect/_10_state_sync.py@@ -0,0 +1,15 @@+from helpers.extension import Extension+from helpers.print_style import PrintStyle+from helpers.state_monitor import get_state_monitor, _ws_debug_enabled+++class StateSync(Extension):+ async def execute(self, instance=None, sid: str = "", **kwargs):+ if instance is None:+ return++ monitor = get_state_monitor()+ monitor.bind_manager(instance.manager, handler_id=instance.identifier)+ monitor.register_sid(instance.namespace, sid)+ if _ws_debug_enabled():+ PrintStyle.debug(f"[WebuiHandler] connect sid={sid}")diff --git a/extensions/python/webui_ws_disconnect/_10_state_sync.py b/extensions/python/webui_ws_disconnect/_10_state_sync.pynew file mode 100644index 000000000..adde8fdab--- /dev/null+++ b/extensions/python/webui_ws_disconnect/_10_state_sync.py@@ -0,0 +1,13 @@+from helpers.extension import Extension+from helpers.print_style import PrintStyle+from helpers.state_monitor import get_state_monitor, _ws_debug_enabled+++class StateSync(Extension):+ async def execute(self, instance=None, sid: str = "", **kwargs):+ if instance is None:+ return++ get_state_monitor().unregister_sid(instance.namespace, sid)+ if _ws_debug_enabled():+ PrintStyle.debug(f"[WebuiHandler] disconnect sid={sid}")diff --git a/extensions/python/webui_ws_event/_10_state_sync.py b/extensions/python/webui_ws_event/_10_state_sync.pynew file mode 100644index 000000000..c29f1c0d8--- /dev/null+++ b/extensions/python/webui_ws_event/_10_state_sync.py@@ -0,0 +1,66 @@+from helpers import runtime+from helpers.extension import Extension+from helpers.print_style import PrintStyle+from helpers.state_monitor import get_state_monitor, _ws_debug_enabled+from helpers.state_snapshot import (+ StateRequestValidationError,+ parse_state_request_payload,+)+++class StateSync(Extension):+ async def execute(+ self,+ instance=None,+ sid: str = "",+ event_type: str = "",+ data: dict | None = None,+ response_data: dict | None = None,+ **kwargs,+ ):+ if instance is None or data is None:+ return++ if event_type != "state_request":+ return++ correlation_id = data.get("correlationId")+ try:+ request = parse_state_request_payload(data)+ except StateRequestValidationError as exc:+ PrintStyle.warning(+ f"[WebuiHandler] INVALID_REQUEST sid={sid} reason={exc.reason} details={exc.details!r}"+ )+ if response_data is not None:+ response_data["code"] = "INVALID_REQUEST"+ response_data["message"] = str(exc)+ return++ if _ws_debug_enabled():+ PrintStyle.debug(+ f"[WebuiHandler] state_request sid={sid} context={request.context!r} "+ f"log_from={request.log_from} notifications_from={request.notifications_from} timezone={request.timezone!r} "+ f"correlation_id={correlation_id}"+ )++ seq_base = 1+ monitor = get_state_monitor()+ monitor.update_projection(+ instance.namespace,+ sid,+ request=request,+ seq_base=seq_base,+ )+ monitor.mark_dirty(+ instance.namespace,+ sid,+ reason="webui_ws_event.StateSync.state_request",+ )+ if _ws_debug_enabled():+ PrintStyle.debug(+ f"[WebuiHandler] state_request accepted sid={sid} seq_base={seq_base}"+ )++ if response_data is not None:+ response_data["runtime_epoch"] = runtime.get_runtime_id()+ response_data["seq_base"] = seq_basediff --git a/extensions/webui/ws_sync_push/clear_cache.js b/extensions/webui/webui_ws_push/clear_cache.jssimilarity index 100%rename from extensions/webui/ws_sync_push/clear_cache.jsrename to extensions/webui/webui_ws_push/clear_cache.jsdiff --git a/helpers/plugins.py b/helpers/plugins.pyindex 089ed2c82..5cd0e73c1 100644--- a/helpers/plugins.py+++ b/helpers/plugins.py@@ -186,7 +186,7 @@ def clear_plugin_cache():DeferredTask().start_task(send_data,- endpoint_name="/state_sync",+ endpoint_name="/webui",event_name="clear_cache",data={"areas": areas},)diff --git a/helpers/websocket.py b/helpers/websocket.pyindex fcc8108fd..cbae4ae03 100644--- a/helpers/websocket.py+++ b/helpers/websocket.py@@ -273,8 +273,9 @@ class WebSocketHandler(ABC):"""Base class for WebSocket event handlers.The interface mirrors :class:`helpers.api.ApiHandler` with declarative- security configuration and lifecycle hooks while enforcing event-naming- conventions.+ security configuration and lifecycle hooks. Handlers are namespace-wide:+ every inbound event for the bound namespace is dispatched to+ :meth:`process_event`, which decides whether and how to respond."""_instances: dict[type["WebSocketHandler"], "WebSocketHandler"] = {}@@ -343,39 +344,20 @@ class WebSocketHandler(ABC):WebSocketHandler._construction_tokens.pop(cls, None)@classmethod- @abstractmethod- def get_event_types(cls) -> list[str]:- """Return the list of event types this handler subscribes to."""-- @classmethod- def validate_event_types(cls, event_types: Iterable[str]) -> list[str]:- """Validate event type declarations.-- Ensures that every event name follows ``lowercase_snake_case`` naming,- does not collide with Socket.IO reserved events, and that the handler- does not declare duplicates.- """-- validated: list[str] = []- seen: set[str] = set()- for event in event_types:- if not isinstance(event, str):- raise TypeError("Event type declarations must be strings")- if not _EVENT_NAME_PATTERN.fullmatch(event):- raise ValueError(- f"Invalid event type '{event}' – must match lowercase_snake_case"- )- if event in _RESERVED_EVENT_NAMES:- raise ValueError(- f"Event type '{event}' is reserved by Socket.IO and cannot be used"- )- if event in seen:- raise ValueError(f"Duplicate event type '{event}' declared in handler")- seen.add(event)- validated.append(event)- if not validated:- raise ValueError("Handlers must declare at least one event type")- return validated+ def validate_event_type(cls, event_type: str) -> str:+ """Validate a runtime event name before dispatch."""++ if not isinstance(event_type, str):+ raise TypeError("Event type must be a string")+ if not _EVENT_NAME_PATTERN.fullmatch(event_type):+ raise ValueError(+ f"Invalid event type '{event_type}' – must match lowercase_snake_case"+ )+ if event_type in _RESERVED_EVENT_NAMES:+ raise ValueError(+ f"Event type '{event_type}' is reserved by Socket.IO and cannot be used"+ )+ return event_type@classmethoddef requires_auth(cls) -> bool:diff --git a/helpers/websocket_manager.py b/helpers/websocket_manager.pyindex 1b6fc39bf..67d9fd782 100644--- a/helpers/websocket_manager.py+++ b/helpers/websocket_manager.py@@ -22,6 +22,17 @@ BUFFER_TTL = timedelta(hours=1)_shared_websocket_manager: WebSocketManager | None = None+async def send_data(+ event_name: str,+ data: dict[str, Any],+ endpoint_name: str = "/webui",+ connection_id: str | None = None,+) -> None:+ manager = get_shared_websocket_manager()+ print(f"Sending data to {endpoint_name}/{event_name} with data {data}")+ await manager.send_data(endpoint_name, event_name, data, connection_id)++def _utcnow() -> datetime:return datetime.now(timezone.utc)@@ -38,17 +49,6 @@ def get_shared_websocket_manager() -> "WebSocketManager":return manager-async def send_data(- endpoint_name: str,- event_name: str,- data: dict[str, Any],- connection_id: str | None = None,-) -> None:- manager = get_shared_websocket_manager()- print(f"Sending data to {endpoint_name}/{event_name} with data {data}")- await manager.send_data(endpoint_name, event_name, data, connection_id)--@dataclassclass BufferedEvent:event_type: str@@ -85,11 +85,11 @@ class WebSocketManager:def __init__(self, socketio: socketio.AsyncServer, lock) -> None:self.socketio = socketioself.lock = lock- self.handlers: defaultdict[str, defaultdict[str, List[WebSocketHandler]]] = defaultdict(- lambda: defaultdict(list)- )+ self.handlers: defaultdict[str, List[WebSocketHandler]] = defaultdict(list)self.connections: Dict[ConnectionIdentity, ConnectionInfo] = {}- self.buffers: defaultdict[ConnectionIdentity, Deque[BufferedEvent]] = defaultdict(deque)+ self.buffers: defaultdict[ConnectionIdentity, Deque[BufferedEvent]] = (+ defaultdict(deque)+ )self._known_sids: Set[ConnectionIdentity] = set()self._identifier: str = f"{self.__class__.__module__}.{self.__class__.__name__}"# Session tracking (single-user default)@@ -261,9 +261,7 @@ class WebSocketManager:asyncio.create_task(_broadcast())- def _normalize_handler_filter(- self, value: Any, field_name: str- ) -> Set[str] | None:+ def _normalize_handler_filter(self, value: Any, field_name: str) -> Set[str] | None:if value is None:return Noneif isinstance(value, str):@@ -271,7 +269,9 @@ class WebSocketManager:try:iterator = iter(value)except TypeError as exc: # pragma: no cover - defensive- raise ValueError(f"{field_name} must be an array of handler identifiers") from exc+ raise ValueError(+ f"{field_name} must be an array of handler identifiers"+ ) from excnormalized: Set[str] = set()for item in iterator:@@ -282,9 +282,7 @@ class WebSocketManager:normalized.add(item)return normalized- def _normalize_sid_filter(- self, value: str | Iterable[str] | None- ) -> Set[str]:+ def _normalize_sid_filter(self, value: str | Iterable[str] | None) -> Set[str]:if value is None:return set()if isinstance(value, str):@@ -297,12 +295,11 @@ class WebSocketManager:def _select_handlers(self,namespace: str,- event_type: str,*,include: Set[str] | None,exclude: Set[str] | None,) -> tuple[list[WebSocketHandler], Set[str]]:- registered = self.handlers.get(namespace, {}).get(event_type, [])+ registered = self.handlers.get(namespace, [])available_ids = {handler.identifier for handler in registered}if include is not None:@@ -346,33 +343,23 @@ class WebSocketManager:for namespace, handlers in handlers_by_namespace.items():for handler in handlers:handler.bind_manager(self, namespace=namespace)- declared = handler.get_event_types()- try:- validated_events = handler.validate_event_types(declared)- except Exception as exc:- PrintStyle.error(- f"Failed to register handler {handler.identifier}: {exc}"- )- raise-if _ws_debug_enabled():PrintStyle.info(- "Registered WebSocket handler %s namespace=%s for events: %s"- % (handler.identifier, namespace, ", ".join(validated_events))+ "Registered WebSocket handler %s namespace=%s"+ % (handler.identifier, namespace))- for event_type in validated_events:- existing = self.handlers[namespace].get(event_type)- if existing:- PrintStyle.warning(- f"Duplicate handler registration for namespace '{namespace}' event '{event_type}'"- )- self.handlers[namespace][event_type].append(handler)- self._debug(- f"Registered handler {handler.identifier} namespace={namespace} event='{event_type}'"+ existing = self.handlers.get(namespace, [])+ if handler in existing:+ PrintStyle.warning(+ f"Duplicate handler registration for namespace '{namespace}'")+ self.handlers[namespace].append(handler)+ self._debug(+ f"Registered handler {handler.identifier} namespace={namespace}"+ )def iter_event_types(self, namespace: str) -> Iterable[str]:- return list(self.handlers.get(namespace, {}).keys())+ return []def iter_namespaces(self) -> list[str]:return list(self.handlers.keys())@@ -592,13 +579,26 @@ class WebSocketManager:include = include_handlers or include_metaexclude = exclude_handlers or (exclude_meta if allow_exclude else None)- registered = self.handlers.get(namespace, {}).get(event_type, [])+ try:+ WebSocketHandler.validate_event_type(event_type)+ except (TypeError, ValueError) as exc:+ error = self._build_error_result(+ handler_id=handler_id or self._identifier,+ code="INVALID_EVENT",+ message=str(exc),+ correlation_id=correlation_id,+ )+ if ack:+ ack({"correlationId": correlation_id, "results": [error]})+ return {"correlationId": correlation_id, "results": [error]}++ registered = self.handlers.get(namespace, [])if not registered:- PrintStyle.warning(f"No handlers registered for event '{event_type}'")+ PrintStyle.warning(f"No handlers registered for namespace '{namespace}'")error = self._build_error_result(handler_id=handler_id or self._identifier,code="NO_HANDLERS",- message=f"No handler for namespace '{namespace}' event '{event_type}'",+ message=f"No handler for namespace '{namespace}'",correlation_id=correlation_id,)if ack:@@ -607,7 +607,7 @@ class WebSocketManager:try:selected_handlers, _ = self._select_handlers(- namespace, event_type, include=include, exclude=exclude+ namespace, include=include, exclude=exclude)except ValueError as exc:error = self._build_error_result(@@ -862,7 +862,9 @@ class WebSocketManager:try:task = asyncio.create_task(_dispatch())- return await asyncio.wait_for(asyncio.shield(task), timeout=timeout_seconds)+ return await asyncio.wait_for(+ asyncio.shield(task), timeout=timeout_seconds+ )except asyncio.TimeoutError:PrintStyle.warning(f"requestAll timeout for sid {target_sid} correlation={correlation_id}"@@ -885,9 +887,7 @@ class WebSocketManager:],}- tasks = {- sid: asyncio.create_task(_invoke_for_sid(sid)) for sid in active_sids- }+ tasks = {sid: asyncio.create_task(_invoke_for_sid(sid)) for sid in active_sids}aggregated: list[dict[str, Any]] = []for sid, task in tasks.items():@@ -1064,15 +1064,16 @@ class WebSocketManager:})- async def _run_lifecycle(self, namespace: str, fn: Callable[[WebSocketHandler], Any]) -> None:+ async def _run_lifecycle(+ self, namespace: str, fn: Callable[[WebSocketHandler], Any]+ ) -> None:seen: Set[WebSocketHandler] = set()coros: list[Any] = []- for handler_list in self.handlers.get(namespace, {}).values():- for handler in handler_list:- if handler in seen:- continue- seen.add(handler)- coros.append(self._get_handler_worker().execute_inside(fn, handler))+ for handler in self.handlers.get(namespace, []):+ if handler in seen:+ continue+ seen.add(handler)+ coros.append(self._get_handler_worker().execute_inside(fn, handler))if coros:await asyncio.gather(*coros, return_exceptions=True)@@ -1175,12 +1176,12 @@ class WebSocketManager:"""Return SIDs for a user; single-user default returns all active SIDs."""with self.lock:bucket = self._ALL_USERS_BUCKET if user is None else user- return list(self.user_to_sids.get(bucket, set())) # type: ignore+ return list(self.user_to_sids.get(bucket, set())) # type: ignoredef get_user_for_sid(self, sid: str) -> str | None:"""Return user identifier for a SID or None."""with self.lock:- return self.sid_to_user.get(sid) # type: ignore+ return self.sid_to_user.get(sid) # type: ignoredef set_server_restart_broadcast(self, enabled: bool) -> None:"""Enable or disable automatic server restart broadcasts."""diff --git a/python/websocket_handlers/_default.py b/python/websocket_handlers/_default.pyindex 6de5421d6..7fdbc4505 100644--- a/python/websocket_handlers/_default.py+++ b/python/websocket_handlers/_default.py@@ -20,11 +20,6 @@ class RootDefaultHandler(WebSocketHandler):def requires_csrf(cls) -> bool:return False- @classmethod- def get_event_types(cls) -> list[str]:- # Diagnostics-only noop endpoint.- return ["ws_root_echo"]-async def process_event(self, event_type: str, data: dict[str, Any], sid: str) -> dict[str, Any] | WebSocketResult | None:diff --git a/python/websocket_handlers/dev_websocket_test_handler.py b/python/websocket_handlers/dev_websocket_test_handler.pyindex 2ea49f587..a55546e3a 100644--- a/python/websocket_handlers/dev_websocket_test_handler.py+++ b/python/websocket_handlers/dev_websocket_test_handler.py@@ -11,19 +11,6 @@ from helpers.websocket import WebSocketHandler, WebSocketResultclass DevWebsocketTestHandler(WebSocketHandler):"""Test harness handler powering the developer WebSocket validation component."""- @classmethod- def get_event_types(cls) -> list[str]:- return [- "ws_tester_emit",- "ws_tester_request",- "ws_tester_request_delayed",- "ws_tester_trigger_persistence",- "ws_tester_request_all",- "ws_tester_broadcast_demo_trigger",- "ws_event_console_subscribe",- "ws_event_console_unsubscribe",- ]-async def process_event(self, event_type: str, data: Dict[str, Any], sid: str) -> dict[str, Any] | WebSocketResult | None:diff --git a/python/websocket_handlers/hello_handler.py b/python/websocket_handlers/hello_handler.pyindex 07eb0ed97..58eb51d77 100644--- a/python/websocket_handlers/hello_handler.py+++ b/python/websocket_handlers/hello_handler.py@@ -7,10 +7,6 @@ from helpers.websocket import WebSocketHandlerclass HelloHandler(WebSocketHandler):"""Sample handler used for foundational testing."""- @classmethod- def get_event_types(cls) -> list[str]:- return ["hello_request"]-async def process_event(self, event_type: str, data: dict, sid: str):name = data.get("name") or "stranger"PrintStyle.info(f"hello_request from {sid} ({name})")diff --git a/python/websocket_handlers/state_sync_handler.py b/python/websocket_handlers/state_sync_handler.pydeleted file mode 100644index 353951613..000000000--- a/python/websocket_handlers/state_sync_handler.py+++ /dev/null@@ -1,76 +0,0 @@-from __future__ import annotations--from helpers import runtime-from helpers.print_style import PrintStyle-from helpers.websocket import WebSocketHandler, WebSocketResult-from helpers.state_monitor import get_state_monitor, _ws_debug_enabled-from helpers.state_snapshot import (- StateRequestValidationError,- parse_state_request_payload,-)---class StateSyncHandler(WebSocketHandler):- @classmethod- def get_event_types(cls) -> list[str]:- return ["state_request"]-- async def on_connect(self, sid: str) -> None:- monitor = get_state_monitor()- monitor.bind_manager(self.manager, handler_id=self.identifier)- monitor.register_sid(self.namespace, sid)- if _ws_debug_enabled():- PrintStyle.debug(f"[StateSyncHandler] connect sid={sid}")-- async def on_disconnect(self, sid: str) -> None:- get_state_monitor().unregister_sid(self.namespace, sid)- if _ws_debug_enabled():- PrintStyle.debug(f"[StateSyncHandler] disconnect sid={sid}")-- async def process_event(self, event_type: str, data: dict, sid: str) -> dict | WebSocketResult | None:- correlation_id = data.get("correlationId")- try:- request = parse_state_request_payload(data)- except StateRequestValidationError as exc:- PrintStyle.warning(- f"[StateSyncHandler] INVALID_REQUEST sid={sid} reason={exc.reason} details={exc.details!r}"- )- return self.result_error(- code="INVALID_REQUEST",- message=str(exc),- correlation_id=correlation_id,- )-- if _ws_debug_enabled():- PrintStyle.debug(- f"[StateSyncHandler] state_request sid={sid} context={request.context!r} "- f"log_from={request.log_from} notifications_from={request.notifications_from} timezone={request.timezone!r} "- f"correlation_id={correlation_id}"- )-- # Baseline sequence must be reset on every state_request (new sync period).- # V1 policy: seq_base starts >0 to allow simple gating checks.- seq_base = 1- monitor = get_state_monitor()- monitor.update_projection(- self.namespace,- sid,- request=request,- seq_base=seq_base,- )- # INVARIANT.STATE.INITIAL_SNAPSHOT: schedule a full snapshot quickly after handshake.- monitor.mark_dirty(- self.namespace,- sid,- reason="state_sync_handler.StateSyncHandler.state_request",- )- if _ws_debug_enabled():- PrintStyle.debug(f"[StateSyncHandler] state_request accepted sid={sid} seq_base={seq_base}")-- return self.result_ok(- {- "runtime_epoch": runtime.get_runtime_id(),- "seq_base": seq_base,- },- correlation_id=correlation_id,- )diff --git a/python/websocket_handlers/webui_handler.py b/python/websocket_handlers/webui_handler.pynew file mode 100644index 000000000..016e5c4a3--- /dev/null+++ b/python/websocket_handlers/webui_handler.py@@ -0,0 +1,34 @@+from helpers.websocket import WebSocketHandler, WebSocketResult+from helpers import extension+++class WebuiHandler(WebSocketHandler):+ async def on_connect(self, sid: str) -> None:+ await extension.call_extensions_async(+ "webui_ws_connect", agent=None, instance=self, sid=sid+ )++ async def on_disconnect(self, sid: str) -> None:+ await extension.call_extensions_async(+ "webui_ws_disconnect", agent=None, instance=self, sid=sid+ )++ async def process_event(+ self, event_type: str, data: dict, sid: str+ ) -> dict | WebSocketResult | None:+ response_data: dict = {}++ await extension.call_extensions_async(+ "webui_ws_event",+ agent=None,+ instance=self,+ sid=sid,+ event_type=event_type,+ data=data,+ response_data=response_data,+ )++ return self.result_ok(+ response_data,+ correlation_id=data.get("correlationId"),+ )diff --git a/run_ui.py b/run_ui.pyindex 4681ae2d2..41fc9afc9 100644--- a/run_ui.py+++ b/run_ui.py@@ -336,22 +336,6 @@ def configure_websocket_namespaces(async def _disconnect(sid, _namespace: str = namespace): # type: ignore[override]await websocket_manager.handle_disconnect(_namespace, sid)- def _register_socketio_event(event_type: str) -> None:- @socketio_server.on(event_type, namespace=namespace)- async def _event_handler(- sid,- data,- _event_type: str = event_type,- _namespace: str = namespace,- ):- payload = data or {}- return await websocket_manager.route_event(- _namespace, _event_type, payload, sid- )-- for _event_type in websocket_manager.iter_event_types(namespace):- _register_socketio_event(_event_type)-@socketio_server.on("*", namespace=namespace)async def _catch_all(event, sid, data, _namespace: str = namespace):payload = data or {}diff --git a/tests/test_multi_tab_isolation.py b/tests/test_multi_tab_isolation.pyindex e28ab56a9..c9bdbce26 100644--- a/tests/test_multi_tab_isolation.py+++ b/tests/test_multi_tab_isolation.py@@ -18,7 +18,7 @@ async def test_state_monitor_per_sid_isolation_independent_snapshots_seq_and_cursnapshot_calls: list[dict[str, object]] = []emitted: list[dict[str, object]] = []- namespace = "/state_sync"+ namespace = "/webui"async def fake_build_snapshot_from_request(*, request):context = request.context@@ -133,7 +133,7 @@ async def test_state_monitor_mark_dirty_for_context_scopes_to_active_context():from helpers.state_snapshot import StateRequestV1monitor = StateMonitor(debounce_seconds=60.0)- namespace = "/state_sync"+ namespace = "/webui"monitor.register_sid(namespace, "sid-a")monitor.register_sid(namespace, "sid-b")diff --git a/tests/test_state_monitor.py b/tests/test_state_monitor.pyindex e0499287c..f510c25fa 100644--- a/tests/test_state_monitor.py+++ b/tests/test_state_monitor.py@@ -13,7 +13,7 @@ async def test_state_monitor_debounce_coalesces_without_postponing_and_cleanup_cfrom helpers.state_monitor import StateMonitorfrom helpers.state_snapshot import StateRequestV1- namespace = "/state_sync"+ namespace = "/webui"monitor = StateMonitor(debounce_seconds=10.0)monitor.register_sid(namespace, "sid-1")monitor.bind_manager(type("FakeManager", (), {"_dispatcher_loop": None})())diff --git a/tests/test_state_sync_handler.py b/tests/test_state_sync_handler.pyindex f9aa8362d..6a2640e0f 100644--- a/tests/test_state_sync_handler.py+++ b/tests/test_state_sync_handler.py@@ -12,7 +12,7 @@ if str(PROJECT_ROOT) not in sys.path:from helpers.websocket_manager import WebSocketManager-NAMESPACE = "/state_sync"+NAMESPACE = "/webui"class FakeSocketIOServer:@@ -27,12 +27,12 @@ async def _create_manager() -> WebSocketManager:socketio = FakeSocketIOServer()manager = WebSocketManager(socketio, threading.RLock())- from python.websocket_handlers.state_sync_handler import StateSyncHandler+ from python.websocket_handlers.webui_handler import WebuiHandlerfrom helpers.state_monitor import _reset_state_monitor_for_testing_reset_state_monitor_for_testing()- StateSyncHandler._reset_instance_for_testing()- handler = StateSyncHandler.get_instance(socketio, threading.RLock())+ WebuiHandler._reset_instance_for_testing()+ handler = WebuiHandler.get_instance(socketio, threading.RLock())manager.register_handlers({NAMESPACE: [handler]})await manager.handle_connect(NAMESPACE, "sid-1")return manager@@ -42,12 +42,12 @@ async def _create_manager_with_socketio() -> tuple[WebSocketManager, FakeSocketIsocketio = FakeSocketIOServer()manager = WebSocketManager(socketio, threading.RLock())- from python.websocket_handlers.state_sync_handler import StateSyncHandler+ from python.websocket_handlers.webui_handler import WebuiHandlerfrom helpers.state_monitor import _reset_state_monitor_for_testing_reset_state_monitor_for_testing()- StateSyncHandler._reset_instance_for_testing()- handler = StateSyncHandler.get_instance(socketio, threading.RLock())+ WebuiHandler._reset_instance_for_testing()+ handler = WebuiHandler.get_instance(socketio, threading.RLock())manager.register_handlers({NAMESPACE: [handler]})await manager.handle_connect(NAMESPACE, "sid-1")return manager, socketiodiff --git a/tests/test_state_sync_welcome_screen.py b/tests/test_state_sync_welcome_screen.pyindex f4971c188..132293cdd 100644--- a/tests/test_state_sync_welcome_screen.py+++ b/tests/test_state_sync_welcome_screen.py@@ -12,7 +12,7 @@ if str(PROJECT_ROOT) not in sys.path:from helpers.websocket_manager import WebSocketManager-NAMESPACE = "/state_sync"+NAMESPACE = "/webui"class FakeSocketIOServer:@@ -32,14 +32,14 @@ async def test_state_sync_handshake_and_initial_snapshot_work_with_no_selected_cfrom helpers.state_snapshot import validate_snapshot_schema_v1from helpers.state_monitor import _reset_state_monitor_for_testing- from python.websocket_handlers.state_sync_handler import StateSyncHandler+ from python.websocket_handlers.webui_handler import WebuiHandlersocketio = FakeSocketIOServer()manager = WebSocketManager(socketio, threading.RLock())_reset_state_monitor_for_testing()- StateSyncHandler._reset_instance_for_testing()- handler = StateSyncHandler.get_instance(socketio, threading.RLock())+ WebuiHandler._reset_instance_for_testing()+ handler = WebuiHandler.get_instance(socketio, threading.RLock())manager.register_handlers({NAMESPACE: [handler]})await manager.handle_connect(NAMESPACE, "sid-1")diff --git a/tests/test_websocket_handlers.py b/tests/test_websocket_handlers.pyindex 7f2c24410..9c965f299 100644--- a/tests/test_websocket_handlers.py+++ b/tests/test_websocket_handlers.py@@ -141,17 +141,17 @@ def test_get_instance_returns_singleton():@pytest.mark.asyncioasync def test_state_sync_handler_registers_and_routes_state_request():from helpers.websocket_manager import WebSocketManager- from python.websocket_handlers.state_sync_handler import StateSyncHandler+ from python.websocket_handlers.webui_handler import WebuiHandlerfrom helpers.state_monitor import _reset_state_monitor_for_testing_reset_state_monitor_for_testing()- StateSyncHandler._reset_instance_for_testing()+ WebuiHandler._reset_instance_for_testing()socketio = _FakeSocketIO()lock = threading.RLock()manager = WebSocketManager(socketio, lock)- handler = StateSyncHandler.get_instance(socketio, lock)- namespace = "/state_sync"+ handler = WebuiHandler.get_instance(socketio, lock)+ namespace = "/webui"manager.register_handlers({namespace: [handler]})await manager.handle_connect(namespace, "sid-1")diff --git a/tests/test_websocket_namespaces.py b/tests/test_websocket_namespaces.pyindex 4c3faca5d..9857e16e1 100644--- a/tests/test_websocket_namespaces.py+++ b/tests/test_websocket_namespaces.py@@ -102,7 +102,7 @@ async def test_namespace_isolation_state_sync_vs_dev_websocket_test() -> None:"""CONTRACT.INVARIANT.NS.ISOLATION: no cross-namespace delivery for application events.- Acceptance proof for `/state_sync` vs `/dev_websocket_test` namespaces.+ Acceptance proof for `/webui` vs `/dev_websocket_test` namespaces."""from flask import Flask@@ -161,7 +161,7 @@ async def test_namespace_isolation_state_sync_vs_dev_websocket_test() -> None:socketio_server=sio,websocket_manager=manager,handlers_by_namespace={- "/state_sync": [StateHandler.get_instance(sio, lock)],+ "/webui": [StateHandler.get_instance(sio, lock)],"/dev_websocket_test": [DevHandler.get_instance(sio, lock)],},)@@ -188,19 +188,19 @@ async def test_namespace_isolation_state_sync_vs_dev_websocket_test() -> None:async def _on_tester_broadcast_state(_payload: Any) -> None:tester_broadcast_state.set()- client.on("state_push", _on_state_push_state, namespace="/state_sync")+ client.on("state_push", _on_state_push_state, namespace="/webui")client.on("state_push", _on_state_push_dev, namespace="/dev_websocket_test")client.on("ws_tester_broadcast", _on_tester_broadcast_dev, namespace="/dev_websocket_test")- client.on("ws_tester_broadcast", _on_tester_broadcast_state, namespace="/state_sync")+ client.on("ws_tester_broadcast", _on_tester_broadcast_state, namespace="/webui")await client.connect(base_url,- namespaces=["/state_sync", "/dev_websocket_test"],+ namespaces=["/webui", "/dev_websocket_test"],headers={"Origin": base_url},wait_timeout=2,)try:- await client.call("state_request", {"context": None}, namespace="/state_sync", timeout=2)+ await client.call("state_request", {"context": None}, namespace="/webui", timeout=2)await asyncio.wait_for(state_push_state.wait(), timeout=2)await asyncio.sleep(0.05)assert state_push_dev.is_set() is False@@ -237,7 +237,7 @@ async def test_diagnostics_include_source_namespace_and_deliver_on_dev_namespacemanager = WebSocketManager(socketio, threading.RLock())manager._schedule_lifecycle_broadcast = lambda *_args, **_kwargs: None # type: ignore[assignment]- ns_state = "/state_sync"+ ns_state = "/webui"ns_dev = "/dev_websocket_test"handler = DummyHandler.get_instance(socketio, threading.RLock())@@ -275,13 +275,13 @@ def test_namespace_discovery_maps_core_handlers_to_expected_namespaces() -> None)by_namespace = {entry.namespace: entry for entry in discoveries}- assert "/state_sync" in by_namespace+ assert "/webui" in by_namespaceassert "/dev_websocket_test" in by_namespace- state_cls_names = [cls.__name__ for cls in by_namespace["/state_sync"].handler_classes]+ state_cls_names = [cls.__name__ for cls in by_namespace["/webui"].handler_classes]dev_cls_names = [cls.__name__ for cls in by_namespace["/dev_websocket_test"].handler_classes]- assert state_cls_names == ["StateSyncHandler"]+ assert state_cls_names == ["WebuiHandler"]assert dev_cls_names == ["DevWebsocketTestHandler"]@@ -290,15 +290,15 @@ def test_run_ui_builds_namespace_handler_map_without_cross_registration() -> Nonhandlers_by_namespace = _build_websocket_handlers_by_namespace(object(), threading.RLock())- assert "/state_sync" in handlers_by_namespace+ assert "/webui" in handlers_by_namespaceassert "/dev_websocket_test" in handlers_by_namespaceassert all(handler.__class__.__name__ != "DevWebsocketTestHandler"- for handler in handlers_by_namespace["/state_sync"]+ for handler in handlers_by_namespace["/webui"])assert all(- handler.__class__.__name__ != "StateSyncHandler"+ handler.__class__.__name__ != "WebuiHandler"for handler in handlers_by_namespace["/dev_websocket_test"])@@ -315,7 +315,7 @@ async def test_route_event_dispatches_only_within_connected_namespace_and_resultmanager = WebSocketManager(socketio, threading.RLock())manager._schedule_lifecycle_broadcast = lambda *_args, **_kwargs: None # type: ignore[assignment]- ns_state = "/state_sync"+ ns_state = "/webui"ns_dev = "/dev_websocket_test"calls: list[str] = []@@ -373,7 +373,7 @@ async def test_lifecycle_broadcasts_deliver_only_within_the_namespace() -> None:socketio = FakeSocketIOServer()manager = WebSocketManager(socketio, threading.RLock())- ns_state = "/state_sync"+ ns_state = "/webui"ns_dev = "/dev_websocket_test"# Connect events should broadcast only within their namespace.@@ -428,7 +428,7 @@ async def test_request_semantics_no_handlers_and_timeouts_are_namespace_scoped_amanager = WebSocketManager(socketio, threading.RLock())manager._schedule_lifecycle_broadcast = lambda *_args, **_kwargs: None # type: ignore[assignment]- ns_state = "/state_sync"+ ns_state = "/webui"ns_dev = "/dev_websocket_test"class Alpha(WebSocketHandler):diff --git a/tests/test_websocket_root_namespace.py b/tests/test_websocket_root_namespace.pyindex fc3ab0d43..4c23f5e69 100644--- a/tests/test_websocket_root_namespace.py+++ b/tests/test_websocket_root_namespace.py@@ -88,7 +88,7 @@ async def test_root_namespace_request_style_calls_resolve_with_no_handlers() ->socketio_server=sio,websocket_manager=manager,handlers_by_namespace={- "/state_sync": [HelloHandler.get_instance(sio, lock)],+ "/webui": [HelloHandler.get_instance(sio, lock)],},)@@ -161,7 +161,7 @@ async def test_root_namespace_fire_and_forget_does_not_invoke_application_handlesocketio_server=sio,websocket_manager=manager,handlers_by_namespace={- "/state_sync": [SideEffectHandler.get_instance(sio, lock)],+ "/webui": [SideEffectHandler.get_instance(sio, lock)],},)diff --git a/webui/components/settings/developer/websocket-test-store.js b/webui/components/settings/developer/websocket-test-store.jsindex d8868c9aa..3e1a4d989 100644--- a/webui/components/settings/developer/websocket-test-store.js+++ b/webui/components/settings/developer/websocket-test-store.js@@ -12,7 +12,7 @@ const MAX_PAYLOAD_BYTES = 50 * 1024 * 1024;const TOAST_DURATION = 5;const websocket = getNamespacedClient("/dev_websocket_test");-const stateSocket = getNamespacedClient("/state_sync");+const stateSocket = getNamespacedClient("/webui");function now() {return new Date().toISOString();diff --git a/webui/components/sync/sync-store.js b/webui/components/sync/sync-store.jsindex 14a13355f..94a22be1a 100644--- a/webui/components/sync/sync-store.js+++ b/webui/components/sync/sync-store.js@@ -6,7 +6,7 @@ import { store as chatTopStore } from "/components/chat/top-section/chat-top-stoimport { store as notificationStore } from "/components/notifications/notification-store.js";import * as Extensions from "/js/extensions.js"-const stateSocket = getNamespacedClient("/state_sync");+const stateSocket = getNamespacedClient("/webui");const SYNC_MODES = {DISCONNECTED: "DISCONNECTED",@@ -317,7 +317,7 @@ const model = {// handle all requests with extensionsawait stateSocket.on("*", (eventType, envelope) => {- console.log(`[syncStore] *${eventType} received`);+ // console.log(`[syncStore] *${eventType} received`);this.handleEvent(eventType, envelope)});@@ -330,7 +330,7 @@ const model = {},async handleEvent(eventType, envelope){- await Extensions.callJsExtensions("ws_sync_push", eventType, envelope);+ await Extensions.callJsExtensions("webui_ws_push", eventType, envelope);},async sendStateRequest(options = {}) {