ltcai 11.5.0 → 11.5.2

package/latticeai/models/router/documents.py

@@ -21,23 +21,6 @@ class _DocumentMixin(_Core):
 
     # ── Document Generation Pipeline ──────────────────────────────────────
 
-    async def generate_document(
-        self,
-        message: str,
-        system_prompt: str,
-        *,
-        max_tokens: int = 8192,
-        temperature: float = 0.3,
-    ) -> str:
-        """Generate a document using a specialized system prompt with graph context."""
-        return await self.generate_document_as(
-            None,
-            message,
-            system_prompt,
-            max_tokens=max_tokens,
-            temperature=temperature,
-        )
-
     async def generate_document_as(
         self,
         model_id: str | None,
@@ -98,24 +81,6 @@ class _DocumentMixin(_Core):
             raise RuntimeError(self._local_server_error_hint(cloud, e)) from e
         return normalize_branding(response.choices[0].message.content or "")
 
-    async def stream_generate_document(
-        self,
-        message: str,
-        system_prompt: str,
-        *,
-        max_tokens: int = 8192,
-        temperature: float = 0.3,
-    ) -> AsyncIterator[str]:
-        """Stream document generation with specialized system prompt."""
-        async for chunk in self.stream_generate_document_as(
-            None,
-            message,
-            system_prompt,
-            max_tokens=max_tokens,
-            temperature=temperature,
-        ):
-            yield chunk
-
     async def stream_generate_document_as(
         self,
         model_id: str | None,

package/latticeai/models/router/registry.py

@@ -107,10 +107,6 @@ class _RegistryMixin(_Core):
                 self.unload_model(victim)
                 local_ids = [model_id for model_id in self._cache if self._is_local_model(model_id)]
 
-    def _is_cloud_current(self) -> bool:
-        with self._lock:
-            return bool(self._current and isinstance(self._cache.get(self._current), CloudModel))
-
     def _local_server_error_hint(self, cloud: CloudModel, error: Exception) -> str:
         raw = str(error)
         if cloud.provider == "lmstudio":

package/latticeai/runtime/access_runtime.py

@@ -7,6 +7,21 @@ from typing import Any, Callable, Dict, Optional
 from latticeai.core.quiet import quiet
 
 
+def is_externally_reachable(config: Any) -> bool:
+    """Whether anything but this machine can open a socket to this worker.
+
+    The single definition of the second half of ``trusted_local_owner``.  It is
+    read here (to decide who the anonymous caller is) and by the ``/health``
+    router (to *state* the posture, so the Rust front door can mirror it on its
+    own native lanes instead of guessing).  Two derivations of one fact is how
+    a gateway ends up serving a graph the worker would have refused.
+    """
+    return bool(
+        getattr(config, "is_public", False)
+        or getattr(config, "network_exposed", False)
+    )
+
+
 def build_access_runtime(
     *,
     config: Any,
@@ -29,10 +44,7 @@ def build_access_runtime(
     # but project the identity as an owner at authorization boundaries.  Never
     # extend this trust to public or non-loopback bindings, even if an invalid
     # caller constructs this runtime with ``require_auth=False`` directly.
-    externally_reachable = bool(
-        getattr(config, "is_public", False)
-        or getattr(config, "network_exposed", False)
-    )
+    externally_reachable = is_externally_reachable(config)
     trusted_local_owner = not require_auth and not externally_reachable
     effective_require_auth = bool(require_auth or externally_reachable)
 

package/latticeai/runtime/build_phases/features.py

@@ -16,6 +16,7 @@ def phase_platform_features(ctx: RuntimeContext) -> None:
     """Workspace platform, automation, review queue, command centre, proposals."""
     ctx.enter("platform_features")
 
+    from latticeai.api.agent_worker_seam import create_agent_worker_seam_router
     from latticeai.api.agents import create_agents_router
     from latticeai.api.automation_intelligence import (
         create_automation_intelligence_router,
@@ -48,9 +49,12 @@ def phase_platform_features(ctx: RuntimeContext) -> None:
     from latticeai.services.chronicle import ChronicleService
     from latticeai.services.command_center import CommandCenterService
     from latticeai.services.evidence_actions import EvidenceActionService
-    from latticeai.services.tool_dispatch import get_tool_permission
+    from latticeai.services.tool_dispatch import (
+        DEFAULT_TOOL_DISPATCH_SERVICE,
+        get_tool_permission,
+    )
     from latticeai.services.voice_capture import VoiceCaptureService
-    from latticeai.tools import resolve_workspace_path
+    from latticeai.tools import execute_tool, resolve_workspace_path
 
     # v2 Agentic Workspace Platform: cross-system wiring.
     platform_automation_runtime = build_platform_automation_runtime(
@@ -210,6 +214,23 @@ def phase_platform_features(ctx: RuntimeContext) -> None:
         )
     )
 
+    # AI-Worker seam (v11.5.1, plan §Y1): the three calls the Rust agent loop
+    # makes back into Python once orchestration lives in ``lattice-agent``.
+    # Registered here because it needs the change governor above; the two
+    # side-effecting routes stay behind ``LATTICEAI_AGENT_TOOL_SEAM=1``, which
+    # only lattice-host injects into a worker it started.
+    ctx.app.include_router(
+        create_agent_worker_seam_router(
+            model_router=ctx.model_router,
+            dispatch_service=DEFAULT_TOOL_DISPATCH_SERVICE,
+            execute_tool=execute_tool,
+            hooks=ctx.HOOKS_REGISTRY,
+            change_proposals=ctx.CHANGE_PROPOSALS,
+            require_user=ctx.require_user,
+            enforce_rate_limit=ctx.enforce_rate_limit,
+        )
+    )
+
     # Evidence → action (v9.9.6): an answer's citations become ready-to-send,
     # evidence-scoped follow-ups. Deterministic composition only — execution
     # stays on the chat/file-generation path.
@@ -284,6 +305,7 @@ def phase_interaction(ctx: RuntimeContext) -> None:
     from latticeai.core.model_compat import (
         list_cached_profiles as _list_compat_profiles,
     )
+    from latticeai.runtime.access_runtime import is_externally_reachable
     from latticeai.runtime.chat_wiring import build_interaction_contexts
     from latticeai.runtime.model_wiring import register_model_runtime_routers
     from latticeai.runtime.platform_services_runtime import build_brain_network
@@ -319,6 +341,7 @@ def phase_interaction(ctx: RuntimeContext) -> None:
             engine_status=service.engine_status,
             get_current_user=ctx.get_current_user,
             require_auth=ctx.REQUIRE_AUTH,
+            externally_reachable=is_externally_reachable(ctx.CONFIG),
             app_version=ctx.APP_VERSION,
             app_mode=ctx.APP_MODE,
             require_user=ctx.require_user,

package/latticeai/runtime/build_phases/web.py

@@ -310,6 +310,7 @@ def phase_web(ctx: RuntimeContext) -> None:
         create_security_router as _create_security_router,
     )
     from latticeai.api.static_routes import create_static_routes_router
+    from latticeai.core.config import default_sso_redirect_uri
     from latticeai.core.policy import policy_matrix
     from latticeai.core.product_hardening import build_product_hardening_status
     from latticeai.core.security import hash_password
@@ -408,6 +409,7 @@ def phase_web(ctx: RuntimeContext) -> None:
 
     foundation_router_bundle = build_auth_admin_security_router_bundle(
         create_auth_router=create_auth_router,
+        sso_default_redirect_uri=default_sso_redirect_uri(ctx.DEFAULT_PORT),
         load_users=ctx.load_users,
         save_users=ctx.save_users,
         hash_password=hash_password,

package/latticeai/runtime/feature_toggle_wiring.py

@@ -1,9 +1,11 @@
 """Wire the feature switchboard into the running app (v11.2.0).
 
-Same shape as ``permission_mode_wiring``: one process-wide service, an
-idempotent router mount guarded on ``app.state``, and explicit arguments that
-*rebind* an already-created service rather than being dropped — a lazy first
-caller must not pin the store to a fallback data dir with no audit sink.
+Same shape as ``permission_mode_wiring``: one process-wide service and an
+idempotent router mount guarded on ``app.state``. The rebinding rule that shape
+turns on — explicit arguments *rebind* an already-created service rather than
+being dropped, so a lazy first caller cannot pin the store to a fallback data
+dir with no audit sink — is shared, in
+:mod:`latticeai.runtime.service_singletons`.
 
 The one job unique to this module is :func:`bind_feature_gates`: it points each
 opt-in gate's resolver at the service, which is the step that turns a persisted
@@ -18,11 +20,14 @@ them back, and "the environment answers again" has to be reachable.
 
 from __future__ import annotations
 
-import os
 import threading
 from pathlib import Path
 from typing import Any, Callable, List, Optional, Tuple
 
+from latticeai.runtime.service_singletons import (
+    rebind_singleton,
+    singleton_data_dir,
+)
 from latticeai.services.feature_toggles import FeatureToggleService
 
 _LOCK = threading.Lock()
@@ -47,13 +52,6 @@ GATE_BINDINGS: Tuple[Tuple[str, str, str], ...] = (
 CHOICE_FEATURE = "vector_backend"
 
 
-def _default_data_dir() -> Path:
-    raw = os.environ.get("LATTICEAI_DATA_DIR", "").strip()
-    if raw:
-        return Path(raw)
-    return Path.home() / ".ltcai"
-
-
 def _boolean_gates() -> List[Tuple[str, Any]]:
     """``[(feature id, gate)]`` — imports are here, not at module import."""
     from importlib import import_module
@@ -80,15 +78,11 @@ def get_feature_toggle_service(
     with _LOCK:
         if _SHARED is None:
             _SHARED = FeatureToggleService(
-                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                data_dir=singleton_data_dir(data_dir),
                 audit=audit,
             )
             return _SHARED
-        if data_dir is not None:
-            _SHARED.rebind_data_dir(Path(data_dir))
-        if audit is not None:
-            _SHARED.rebind_audit(audit)
-        return _SHARED
+        return rebind_singleton(_SHARED, data_dir=data_dir, audit=audit)
 
 
 def bind_feature_gates(service: Optional[FeatureToggleService] = None) -> None:

package/latticeai/runtime/network_boundary_wiring.py

@@ -11,6 +11,10 @@ from latticeai.core.network_boundary import (
     DEFAULT_NETWORK_MODE,
     normalize_network_mode,
 )
+from latticeai.runtime.service_singletons import (
+    rebind_singleton,
+    singleton_data_dir,
+)
 from latticeai.services.hybrid_policy import HybridPolicyService
 from latticeai.services.network_boundary_service import NetworkBoundaryService
 
@@ -19,13 +23,6 @@ _SHARED: Optional[NetworkBoundaryService] = None
 _POLICY: Optional[HybridPolicyService] = None
 
 
-def _default_data_dir() -> Path:
-    raw = os.environ.get("LATTICEAI_DATA_DIR", "").strip()
-    if raw:
-        return Path(raw)
-    return Path.home() / ".ltcai"
-
-
 def _env_default_mode() -> Any:
     return normalize_network_mode(
         os.environ.get("LATTICEAI_NETWORK_MODE", DEFAULT_NETWORK_MODE.value)
@@ -41,16 +38,12 @@ def get_network_boundary_service(
     with _LOCK:
         if _SHARED is None:
             _SHARED = NetworkBoundaryService(
-                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                data_dir=singleton_data_dir(data_dir),
                 default_mode=_env_default_mode(),
                 audit=audit,
             )
             return _SHARED
-        if data_dir is not None:
-            _SHARED.rebind_data_dir(Path(data_dir))
-        if audit is not None:
-            _SHARED.rebind_audit(audit)
-        return _SHARED
+        return rebind_singleton(_SHARED, data_dir=data_dir, audit=audit)
 
 
 def get_hybrid_policy_service(
@@ -62,15 +55,11 @@ def get_hybrid_policy_service(
     with _LOCK:
         if _POLICY is None:
             _POLICY = HybridPolicyService(
-                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                data_dir=singleton_data_dir(data_dir),
                 audit=audit,
             )
             return _POLICY
-        if data_dir is not None:
-            _POLICY.rebind_data_dir(Path(data_dir))
-        if audit is not None:
-            _POLICY.rebind_audit(audit)
-        return _POLICY
+        return rebind_singleton(_POLICY, data_dir=data_dir, audit=audit)
 
 
 def resolve_active_network_mode(

package/latticeai/runtime/permission_mode_wiring.py

@@ -15,19 +15,16 @@ from pathlib import Path
 from typing import Any, Callable, Optional
 
 from latticeai.core.permission_mode import DEFAULT_MODE, normalize_mode
+from latticeai.runtime.service_singletons import (
+    rebind_singleton,
+    singleton_data_dir,
+)
 from latticeai.services.permission_mode_service import PermissionModeService
 
 _LOCK = threading.Lock()
 _SHARED: Optional[PermissionModeService] = None
 
 
-def _default_data_dir() -> Path:
-    raw = os.environ.get("LATTICEAI_DATA_DIR", "").strip()
-    if raw:
-        return Path(raw)
-    return Path.home() / ".ltcai"
-
-
 def _env_default_mode() -> Any:
     return normalize_mode(os.environ.get("LATTICEAI_PERMISSION_MODE", DEFAULT_MODE.value))
 
@@ -48,16 +45,12 @@ def get_permission_mode_service(
     with _LOCK:
         if _SHARED is None:
             _SHARED = PermissionModeService(
-                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                data_dir=singleton_data_dir(data_dir),
                 default_mode=_env_default_mode(),
                 audit=audit,
             )
             return _SHARED
-        if data_dir is not None:
-            _SHARED.rebind_data_dir(Path(data_dir))
-        if audit is not None:
-            _SHARED.rebind_audit(audit)
-        return _SHARED
+        return rebind_singleton(_SHARED, data_dir=data_dir, audit=audit)
 
 
 def resolve_active_permission_mode(

package/latticeai/runtime/router_registration.py

@@ -83,6 +83,7 @@ def build_auth_admin_security_router_bundle(
     secure_cookies: bool,
     invite_authorized: Any,
     ensure_identity: Any,
+    sso_default_redirect_uri: str,
     create_admin_router: Any,
     require_admin: Any,
     get_history: Any,
@@ -138,6 +139,7 @@ def build_auth_admin_security_router_bundle(
         invite_gate_enabled=invite_gate_enabled,
         invite_authorized=invite_authorized,
         ensure_identity=ensure_identity,
+        default_redirect_uri=sso_default_redirect_uri,
     )
 
     def graph_stats_safe() -> dict[str, Any]:
@@ -376,6 +378,7 @@ def register_health_and_model_routers(
     engine_status: Any,
     get_current_user: Any,
     require_auth: bool,
+    externally_reachable: bool,
     app_version: str,
     app_mode: str,
     create_models_router: Any,
@@ -411,6 +414,7 @@ def register_health_and_model_routers(
             engine_status=engine_status,
             get_current_user=get_current_user,
             require_auth=require_auth,
+            externally_reachable=externally_reachable,
             app_version=app_version,
             app_mode=app_mode,
         ),

package/latticeai/runtime/runtime_context.py

@@ -25,7 +25,7 @@ Two properties keep it honest:
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Set
+from typing import Any, Dict, Set
 
 
 class RuntimeContext:
@@ -257,21 +257,9 @@ class RuntimeContext:
                 f"RuntimeContext.{name} was read before it was built{hint}"
             ) from None
 
-    @property
-    def produced_by(self) -> Dict[str, str]:
-        """Attribute name → the phase that published it, for the order test."""
-        return dict(self._produced)
-
     def names(self) -> Set[str]:
         return set(self._produced)
 
-    def phases_run(self) -> List[str]:
-        seen: List[str] = []
-        for phase in self._produced.values():
-            if phase not in seen:
-                seen.append(phase)
-        return seen
-
     def __repr__(self) -> str:  # pragma: no cover - debugging aid
         return f"<RuntimeContext phase={self._phase!r} names={len(self._produced)}>"
 

package/latticeai/runtime/service_singletons.py

@@ -0,0 +1,55 @@
+"""The rebinding half of the process-wide service singletons.
+
+Four wiring modules create one service each — the permission dial, the network
+boundary, the hybrid policy, the feature switchboard — and all four had the
+same problem and the same four-line answer to it: a lazy first caller (a tool
+dispatch, a feature gate) can ask for the service *before* routers know the
+configured data dir or the audit sink, and if the later explicit call were
+allowed to be a no-op the service would stay pinned to the fallback path with
+its audit events going nowhere.
+
+So explicit arguments rebind rather than being dropped. That rule was written
+out four times; it lives here once, because "the second caller silently loses"
+is precisely the kind of divergence that produces a second, invisible copy of
+the user's data and no failing test.
+
+The singleton *slot* deliberately stays a module global in each wiring module:
+the modules are the unit of process state, and the suite resets them by
+assigning ``_SHARED = None``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Optional, TypeVar
+
+from latticeai.core.config import default_data_dir
+
+ServiceT = TypeVar("ServiceT")
+
+__all__ = ["singleton_data_dir", "rebind_singleton"]
+
+
+def singleton_data_dir(data_dir: Optional[Path]) -> Path:
+    """Where a *first* lazy caller should put the store."""
+    return Path(data_dir) if data_dir is not None else default_data_dir()
+
+
+def rebind_singleton(
+    service: ServiceT,
+    *,
+    data_dir: Optional[Path] = None,
+    audit: Optional[Callable[..., None]] = None,
+) -> ServiceT:
+    """Apply explicit arguments to an already-created singleton, then return it.
+
+    ``None`` means "the caller did not say", never "unset it" — a router that
+    mounts without an audit sink must not silence a sink an earlier caller
+    already supplied.
+    """
+    rebindable: Any = service
+    if data_dir is not None:
+        rebindable.rebind_data_dir(Path(data_dir))
+    if audit is not None:
+        rebindable.rebind_audit(audit)
+    return service

package/latticeai/services/architecture_readiness.py

@@ -16,7 +16,7 @@ from typing import Any, Dict, List
 
 from latticeai.core.legacy_compatibility import legacy_shim_report
 
-ARCHITECTURE_VERSION_TARGET = "11.5.0"
+ARCHITECTURE_VERSION_TARGET = "11.5.2"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",

package/latticeai/services/brain_intelligence/proposals.py

@@ -31,11 +31,6 @@ class BrainProposalsMixin(_Core):
     # is absent they report ``available: False`` rather than falling back to a
     # direct write.
 
-    def attach_review_queue(self, review_queue: Any) -> None:
-        """Bind the review queue proposals are written to (composition root)."""
-        self._review_queue_service = review_queue
-        self._synthesizer = None
-
     def _review_queue(self) -> Any:
         """The queue to propose into, or ``None`` when there is none.
 

package/latticeai/services/change_proposals.py

@@ -21,7 +21,6 @@ change audit log. The classification itself lives in
 from __future__ import annotations
 
 import difflib
-import hashlib
 import logging
 import os
 import tempfile
@@ -30,6 +29,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from latticeai.core.quiet import quiet
+from latticeai.core.security import sha256_hex
 from latticeai.core.tool_governor import classify_tool_call
 from latticeai.core.workspace_reorganization import (
     REORG_KIND,
@@ -90,7 +90,7 @@ class ProposalConflictError(ValueError):
 
 
 def _sha256_text(content: str) -> str:
-    return hashlib.sha256(content.encode("utf-8")).hexdigest()
+    return sha256_hex(content)
 
 
 def _unified_diff(before: str, after: str, path: str) -> List[str]:
@@ -272,40 +272,6 @@ class ChangeProposalService:
         )
         return item
 
-    def propose_file_delete(
-        self,
-        *,
-        path: str,
-        proposed_by: str = "agent",
-        reason: str = "",
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        base_exists, before = self._snapshot(path)
-        item = self._review_queue.create(
-            title=f"파일 삭제 제안: {path}",
-            summary=reason or "기존 파일을 삭제하는 작업이라 검토 후 적용됩니다.",
-            source="change_proposal",
-            kind="file_delete",
-            payload={
-                "path": path,
-                "diff": _unified_diff(before, "", path),
-                "tier": "large",
-                "before_bytes": len(before.encode("utf-8")),
-                "after_bytes": 0,
-                "base_exists": base_exists,
-                "base_sha256": _sha256_text(before) if base_exists else "",
-            },
-            provenance={"proposed_by": proposed_by, "reason": reason},
-            user_email=user_email,
-            workspace_id=workspace_id,
-        )
-        self._audit(
-            "change_proposal_created", user_email=user_email,
-            proposal_id=item.get("id"), path=path, kind="file_delete", tier="large",
-        )
-        return item
-
     def propose_reorganization(
         self,
         *,

package/latticeai/services/chronicle.py

@@ -48,6 +48,7 @@ from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple
 
 from latticeai.core.timeutil import parse_iso
 from latticeai.core.timezones import get_timezone
+from latticeai.core.workspace_os_utils import graph_scope_kwargs
 
 LOGGER = logging.getLogger(__name__)
 
@@ -249,12 +250,9 @@ def _empty_lanes() -> Dict[str, int]:
     return {lane: 0 for lane in _LANES}
 
 
-def _scope_kwargs(workspace_id: Optional[str]) -> Dict[str, Any]:
-    """The scoped-read kwargs the graph store expects (house pattern)."""
-    return {
-        "allowed_workspaces": {workspace_id} if workspace_id is not None else None,
-        "include_legacy_global": workspace_id is None,
-    }
+
+#: Historical module-local name for the shared rule.
+_scope_kwargs = graph_scope_kwargs
 
 
 def _on_day(rows: Sequence[Any], day: str) -> List[Any]:

package/latticeai/services/command_center.py

@@ -28,6 +28,7 @@ from typing import Any, Dict, List, Optional
 
 from latticeai.core.timeutil import local_now, parse_iso
 from latticeai.core.timeutil import now_iso as _now
+from latticeai.core.workspace_os_utils import graph_scope_kwargs
 
 LOGGER = logging.getLogger(__name__)
 
@@ -48,6 +49,8 @@ def _clip(text: Any, limit: int = 160) -> str:
     return value[:limit]
 
 
+
+
 class CommandCenterService:
     def __init__(
         self,
@@ -73,10 +76,7 @@ class CommandCenterService:
     # ── scoped reads ─────────────────────────────────────────────────────
 
     def _scope_kwargs(self, workspace_id: Optional[str]) -> Dict[str, Any]:
-        return {
-            "allowed_workspaces": {workspace_id} if workspace_id is not None else None,
-            "include_legacy_global": workspace_id is None,
-        }
+        return graph_scope_kwargs(workspace_id)
 
     def _history(
         self, *, user_email: Optional[str], workspace_id: Optional[str], limit: int

package/latticeai/services/evidence_actions.py

@@ -28,6 +28,8 @@ import logging
 import re
 from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence
 
+from latticeai.core.messages import bilingual
+
 LOGGER = logging.getLogger(__name__)
 
 __all__ = ["EvidenceActionService", "EVIDENCE_ACTIONS"]
@@ -38,8 +40,9 @@ _EXCERPT_CHARS = 600
 _MAX_SOURCES = 8
 
 
-def _phrase(ko: str, en: str) -> Dict[str, str]:
-    return {"ko": ko, "en": en}
+
+#: Historical module-local name for the shared phrase-pair helper.
+_phrase = bilingual
 
 
 # The action catalog is closed and deterministic — the UI renders exactly

package/latticeai/services/hybrid_chat.py

@@ -13,7 +13,6 @@ auto-commit — so a headless caller stages nothing rather than writing.
 
 from __future__ import annotations
 
-import json
 import logging
 from typing import Any, AsyncIterator, Dict, Optional
 
@@ -21,6 +20,7 @@ from latticeai.core.network_boundary import (
     NetworkBoundaryMode,
     normalize_network_mode,
 )
+from latticeai.core.sse import sse_frame
 from latticeai.services.cloud_egress_audit import record_cloud_egress
 from latticeai.services.cloud_extraction import plan_kg_expansion_rich
 from latticeai.services.cloud_streaming import (
@@ -36,7 +36,7 @@ logger = logging.getLogger(__name__)
 
 
 def _sse(data: Dict[str, Any]) -> str:
-    return f"data: {json.dumps(data, ensure_ascii=False)}\n\n"
+    return sse_frame(None, data)
 
 
 def _scope_key(user_email: Optional[str], workspace_id: Optional[str]) -> str: