feat: wired up the ui with the backend

runtime/src/orion/events/base.py

@@ -4,6 +4,8 @@
 
 from pydantic import BaseModel, Field
 
+from orion.transport.messages import MessageType
+
 
 # ============================================================
 # Event Status
@@ -49,5 +51,8 @@ class Event(BaseModel):
     #: Human-readable description of the event.
     message: str = ""
 
+    #: Message type
+    type: MessageType | None = None
+
     #: Severity of the event.
     status: EventStatus = EventStatus.INFO

runtime/src/orion/events/events.py

@@ -1,4 +1,5 @@
 from orion.events.base import Event, EventStatus
+from orion.transport.messages import MessageType
 
 # ============================================================
 # Pipeline Events
@@ -16,6 +17,7 @@ class VoicePipelineStartEvent(PipelineStartEvent):
 class ChatPipelineStartEvent(PipelineStartEvent):
     """Published when a chat processing pipeline is started."""
 
+    type: MessageType = MessageType.SUBMIT_PROMPT
     text: str
 
 
@@ -44,10 +46,13 @@ class PipelineRestartEvent(Event):
 class VoiceRecordingStartEvent(Event):
     """Published when voice recording begins."""
 
+    type: MessageType = MessageType.VOICE_START
+
 
 class VoiceRecordingCompletedEvent(Event):
     """Published when voice recording has completed."""
 
+    type: MessageType = MessageType.VOICE_END
     audio_path: str | None = None
 
 
@@ -98,24 +103,28 @@ class AgentProcessingStartEvent(Event):
 class ResponseStartedEvent(Event):
     """Published when the assistant starts generating a response."""
 
+    type: MessageType = MessageType.ASSISTANT_START
+
 
 class ResponseChunkEvent(Event):
     """Published for each streamed response chunk."""
 
+    type: MessageType = MessageType.ASSISTANT_CHUNK
     text: str
 
 
 class ResponseCompletedEvent(Event):
     """Published when the assistant has finished generating a response."""
 
+    type: MessageType = MessageType.ASSISTANT_END
     status: EventStatus = EventStatus.SUCCESS
-
     text: str
 
 
 class ResponseGenerationFailedEvent(Event):
     """Published when response generation fails."""
 
+    type: MessageType = MessageType.ERROR
     status: EventStatus = EventStatus.ERROR
     error: str
 

runtime/src/orion/orchestrator/config.py

@@ -5,6 +5,7 @@
 from langchain_groq import ChatGroq
 
 from orion.memory.module import MemoryModule
+from orion.transport.bridge import IPCBridge
 
 
 @dataclass(slots=True)
@@ -15,3 +16,4 @@ class OrchestratorConfig:
 
     llm: ChatGroq
     memory: MemoryModule
+    bridge: IPCBridge

runtime/src/orion/orchestrator/orchestrator.py

@@ -1,18 +1,23 @@
-from orion.bus.event_bus import EventBus
+from __future__ import annotations
 
+from orion.bus.event_bus import EventBus
 from orion.orchestrator.config import OrchestratorConfig
-from orion.services.logging import LoggingService
-from orion.services.setup import ServiceContext, setup_services
 from orion.runtime.lifecycle import Lifecycle
+from orion.services.base import BaseService
+from orion.services.ipc_publisher import IPCPublisherService
+from orion.services.logging import LoggingService
+from orion.services.setup import ServiceContext, setup_runtime_services
 
 
 class Orchestrator(Lifecycle):
     """
     Coordinates the ORION runtime.
 
     Responsibilities:
-    - Startup / shutdown services
-    - Wire global observers
+    - Create runtime services
+    - Create global services
+    - Start and stop all services
+    - Register global observers
     """
 
     def __init__(
@@ -23,9 +28,12 @@ def __init__(
         self.bus = bus
         self.config = config
 
-        self.logger = LoggingService()
+        self.runtime_services: list[BaseService] = []
+        self.global_services: list[BaseService] = []
+        self.services: list[BaseService] = []
+
+        self.bridge = self.config.bridge
 
-        self.services = []
         self._started = False
 
     async def startup(self) -> None:
@@ -36,33 +44,49 @@ async def startup(self) -> None:
         if self._started:
             return
 
-        service_context = ServiceContext(
+        context = ServiceContext(
             llm=self.config.llm,
             memory=self.config.memory,
         )
 
+        self.runtime_services = setup_runtime_services(context)
+
+        self.global_services = [
+            LoggingService(),
+            IPCPublisherService(bridge=self.bridge),
+            # MetricsService(...),
+            # TracingService(...),
+        ]
+
         self.services = [
-            *setup_services(service_context),
-            self.logger,
+            *self.runtime_services,
+            *self.global_services,
         ]
 
         for service in self.services:
             await service.startup()
 
-        self.bus.subscribe_all(self.logger.handle)
+        for service in self.global_services:
+            self.bus.subscribe_all(service.handle)
 
         self._started = True
 
     async def shutdown(self) -> None:
         """
-        Gracefully shutdown the runtime.
+        Gracefully shutdown the ORION runtime.
         """
 
+        if not self._started:
+            return
+
         for service in reversed(self.services):
             try:
                 await service.shutdown()
             except Exception as exc:
-                print(f"Failed to shutdown {service}: {exc}")
+                print(f"Failed to shutdown {service.__class__.__name__}: {exc}")
 
+        self.runtime_services.clear()
+        self.global_services.clear()
         self.services.clear()
+
         self._started = False

runtime/src/orion/runtime/run.py

@@ -80,15 +80,17 @@ async def run() -> None:
         planner=RetrievalPlanner(llm=llm),
     )
 
+    bridge = IPCBridge(bus)
+
     orchestrator = Orchestrator(
         bus=bus,
         config=OrchestratorConfig(
             llm=llm,
             memory=memory,
+            bridge=bridge,
         ),
     )
 
-    bridge = IPCBridge(bus)
 
     server = IPCServer(
         socket_path="/tmp/orion.sock",

runtime/src/orion/services/ipc_publisher.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from orion.events.base import Event
+from orion.services.base import BaseService
+from orion.transport.bridge import IPCBridge
+from orion.transport.messages import Envelope
+
+
+class IPCPublisherService(BaseService):
+    """
+    Publishes runtime events to connected IPC clients.
+
+    Events that do not define an IPC message type are considered
+    internal runtime events and are not forwarded to clients.
+    """
+
+    service_name = "ipc"
+
+    def __init__(self, bridge: IPCBridge) -> None:
+        super().__init__()
+        self._bridge = bridge
+
+    async def handle(self, event: Event) -> None:
+        """
+        Publish a runtime event over IPC.
+        """
+
+        if event.type is None:
+            return
+
+        envelope = Envelope(
+            correlation_id=event.correlation_id,
+            type=event.type,
+            payload=event.model_dump(
+                exclude={
+                    "event_id",
+                    "correlation_id",
+                    "session_id",
+                    "timestamp",
+                    "source",
+                    "type",
+                },
+                exclude_none=True,
+            ),
+        )
+
+        await self._bridge.send(
+            session_id=event.session_id,
+            envelope=envelope,
+        )

runtime/src/orion/services/setup.py

@@ -1,4 +1,3 @@
-from collections.abc import Sequence
 from dataclasses import dataclass
 
 from langchain_groq import ChatGroq
@@ -18,8 +17,8 @@ class ServiceContext:
     memory: MemoryModule
 
 
-def setup_services(ctx: ServiceContext) -> Sequence[BaseService]:
-    services = [
+def setup_runtime_services(ctx: ServiceContext) -> list[BaseService]:
+    services: list[BaseService] = [
         VoiceRecordingService(),
         TranscriptGenerationService(),
         AgentService(