Skip to content

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.py
index 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 chats
diff --git a/api/message.py b/api/message.py
index 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 function
mq.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)), context
diff --git a/docs/developer/websockets.md b/docs/developer/websockets.md
index 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, ensurin
Handlers 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:
```javascript
import { 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()
```javascript
import { 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
```javascript
import { 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 broadcast
diff --git a/extensions/python/webui_ws_connect/_10_state_sync.py b/extensions/python/webui_ws_connect/_10_state_sync.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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_base
diff --git a/extensions/webui/ws_sync_push/clear_cache.js b/extensions/webui/webui_ws_push/clear_cache.js
similarity index 100%
rename from extensions/webui/ws_sync_push/clear_cache.js
rename to extensions/webui/webui_ws_push/clear_cache.js
diff --git a/helpers/plugins.py b/helpers/plugins.py
index 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.py
index 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
@classmethod
def requires_auth(cls) -> bool:
diff --git a/helpers/websocket_manager.py b/helpers/websocket_manager.py
index 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)
-
-
@dataclass
class BufferedEvent:
event_type: str
@@ -85,11 +85,11 @@ class WebSocketManager:
def __init__(self, socketio: socketio.AsyncServer, lock) -> None:
self.socketio = socketio
self.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 None
if 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 exc
normalized: 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_meta
exclude = 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: ignore
def 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: ignore
def 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.py
index 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.py
index 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, WebSocketResult
class 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.py
index 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 WebSocketHandler
class 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.py
deleted file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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.py
index 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_cur
snapshot_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 StateRequestV1
monitor = 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.py
index 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_c
from helpers.state_monitor import StateMonitor
from 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.py
index 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 WebuiHandler
from 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, FakeSocketI
socketio = FakeSocketIOServer()
manager = WebSocketManager(socketio, threading.RLock())
- from python.websocket_handlers.state_sync_handler import StateSyncHandler
+ from python.websocket_handlers.webui_handler import WebuiHandler
from 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, socketio
diff --git a/tests/test_state_sync_welcome_screen.py b/tests/test_state_sync_welcome_screen.py
index 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_c
from helpers.state_snapshot import validate_snapshot_schema_v1
from 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 WebuiHandler
socketio = 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.py
index 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.asyncio
async 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 WebuiHandler
from 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.py
index 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_namespace
manager = 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_namespace
assert "/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() -> Non
handlers_by_namespace = _build_websocket_handlers_by_namespace(object(), threading.RLock())
- assert "/state_sync" in handlers_by_namespace
+ assert "/webui" in handlers_by_namespace
assert "/dev_websocket_test" in handlers_by_namespace
assert 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_result
manager = 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_a
manager = 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.py
index 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_handle
socketio_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.js
index 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.js
index 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-sto
import { 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 extensions
await 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 = {}) {