Update engine

core/session.py

@@ -1,15 +1,16 @@
 """Session management for active calls."""
 
 import asyncio
-import uuid
+import hashlib
 import json
-import time
 import re
+import time
 from enum import Enum
 from typing import Optional, Dict, Any, List
 from loguru import logger
 
 from app.backend_client import (
+    fetch_assistant_config,
     create_history_call_record,
     add_history_transcript,
     finalize_history_call_record,
@@ -49,6 +50,32 @@ class Session:
     Uses full duplex voice conversation pipeline.
     """
 
+    TRACK_AUDIO_IN = "audio_in"
+    TRACK_AUDIO_OUT = "audio_out"
+    TRACK_CONTROL = "control"
+    AUDIO_FRAME_BYTES = 640  # 16k mono pcm_s16le, 20ms
+    _CLIENT_METADATA_OVERRIDES = {
+        "firstTurnMode",
+        "greeting",
+        "generatedOpenerEnabled",
+        "systemPrompt",
+        "output",
+        "bargeIn",
+        "knowledge",
+        "knowledgeBaseId",
+        "history",
+        "userId",
+        "assistantId",
+        "source",
+    }
+    _CLIENT_METADATA_ID_KEYS = {
+        "appId",
+        "app_id",
+        "channel",
+        "configVersionId",
+        "config_version_id",
+    }
+
     def __init__(self, session_id: str, transport: BaseTransport, use_duplex: bool = None):
         """
         Initialize session.
@@ -78,7 +105,10 @@ class Session:
         self.authenticated: bool = False
 
         # Track IDs
-        self.current_track_id: Optional[str] = str(uuid.uuid4())
+        self.current_track_id: str = self.TRACK_CONTROL
+        self._event_seq: int = 0
+        self._audio_ingress_buffer: bytes = b""
+        self._audio_frame_error_reported: bool = False
         self._history_call_id: Optional[str] = None
         self._history_turn_index: int = 0
         self._history_call_started_mono: Optional[float] = None
@@ -89,6 +119,7 @@ class Session:
         self._workflow_last_user_text: str = ""
         self._workflow_initial_node: Optional[WorkflowNodeDef] = None
 
+        self.pipeline.set_event_sequence_provider(self._next_event_seq)
         self.pipeline.conversation.on_turn_complete(self._on_turn_complete)
 
         logger.info(f"Session {self.id} created (duplex={self.use_duplex})")
@@ -129,13 +160,52 @@ class Session:
                 "client",
                 "Audio received before session.start",
                 "protocol.order",
+                stage="protocol",
+                retryable=False,
             )
             return
 
         try:
-            await self.pipeline.process_audio(audio_bytes)
+            if not audio_bytes:
+                return
+            if len(audio_bytes) % 2 != 0:
+                await self._send_error(
+                    "client",
+                    "Invalid PCM payload: odd number of bytes",
+                    "audio.invalid_pcm",
+                    stage="audio",
+                    retryable=False,
+                )
+                return
+
+            frame_bytes = self.AUDIO_FRAME_BYTES
+            self._audio_ingress_buffer += audio_bytes
+
+            # Protocol v1 audio framing: 20ms PCM frame (640 bytes).
+            # Allow aggregated frames in one WS message (multiple of 640).
+            if len(audio_bytes) % frame_bytes != 0 and not self._audio_frame_error_reported:
+                self._audio_frame_error_reported = True
+                await self._send_error(
+                    "client",
+                    f"Audio frame size should be multiple of {frame_bytes} bytes (20ms PCM)",
+                    "audio.frame_size_mismatch",
+                    stage="audio",
+                    retryable=True,
+                )
+
+            while len(self._audio_ingress_buffer) >= frame_bytes:
+                frame = self._audio_ingress_buffer[:frame_bytes]
+                self._audio_ingress_buffer = self._audio_ingress_buffer[frame_bytes:]
+                await self.pipeline.process_audio(frame)
         except Exception as e:
             logger.error(f"Session {self.id} handle_audio error: {e}", exc_info=True)
+            await self._send_error(
+                "server",
+                f"Audio processing failed: {e}",
+                "audio.processing_failed",
+                stage="audio",
+                retryable=True,
+            )
 
     async def _handle_v1_message(self, message: Any) -> None:
         """Route validated WS v1 message to handlers."""
@@ -217,10 +287,9 @@ class Session:
         self.authenticated = True
         self.protocol_version = message.version
         self.ws_state = WsSessionState.WAIT_START
-        await self.transport.send_event(
+        await self._send_event(
             ev(
                 "hello.ack",
-                sessionId=self.id,
                 version=self.protocol_version,
             )
         )
@@ -231,8 +300,12 @@ class Session:
             await self._send_error("client", "Duplicate session.start", "protocol.order")
             return
 
-        metadata = message.metadata or {}
-        metadata = self._merge_runtime_metadata(metadata, self._bootstrap_workflow(metadata))
+        raw_metadata = message.metadata or {}
+        workflow_runtime = self._bootstrap_workflow(raw_metadata)
+        server_runtime = await self._load_server_runtime_metadata(raw_metadata, workflow_runtime)
+        client_runtime = self._sanitize_client_metadata(raw_metadata)
+        metadata = self._merge_runtime_metadata(server_runtime, self._sanitize_untrusted_runtime_metadata(workflow_runtime))
+        metadata = self._merge_runtime_metadata(metadata, client_runtime)
 
         # Create history call record early so later turn callbacks can append transcripts.
         await self._start_history_bridge(metadata)
@@ -248,28 +321,37 @@ class Session:
 
         self.state = "accepted"
         self.ws_state = WsSessionState.ACTIVE
-        await self.transport.send_event(
+        await self._send_event(
             ev(
                 "session.started",
-                sessionId=self.id,
                 trackId=self.current_track_id,
+                tracks={
+                    "audio_in": self.TRACK_AUDIO_IN,
+                    "audio_out": self.TRACK_AUDIO_OUT,
+                    "control": self.TRACK_CONTROL,
+                },
                 audio=message.audio or {},
             )
         )
+        await self._send_event(
+            ev(
+                "config.resolved",
+                trackId=self.TRACK_CONTROL,
+                config=self._build_config_resolved(metadata),
+            )
+        )
         if self.workflow_runner and self._workflow_initial_node:
-            await self.transport.send_event(
+            await self._send_event(
                 ev(
                     "workflow.started",
-                    sessionId=self.id,
                     workflowId=self.workflow_runner.workflow_id,
                     workflowName=self.workflow_runner.name,
                     nodeId=self._workflow_initial_node.id,
                 )
             )
-            await self.transport.send_event(
+            await self._send_event(
                 ev(
                     "workflow.node.entered",
-                    sessionId=self.id,
                     workflowId=self.workflow_runner.workflow_id,
                     nodeId=self._workflow_initial_node.id,
                     nodeName=self._workflow_initial_node.name,
@@ -285,17 +367,23 @@ class Session:
         stop_reason = reason or "client_requested"
         self.state = "hungup"
         self.ws_state = WsSessionState.STOPPED
-        await self.transport.send_event(
+        await self._send_event(
             ev(
                 "session.stopped",
-                sessionId=self.id,
                 reason=stop_reason,
             )
         )
         await self._finalize_history(status="connected")
         await self.transport.close()
 
-    async def _send_error(self, sender: str, error_message: str, code: str) -> None:
+    async def _send_error(
+        self,
+        sender: str,
+        error_message: str,
+        code: str,
+        stage: Optional[str] = None,
+        retryable: Optional[bool] = None,
+    ) -> None:
         """
         Send error event to client.
 
@@ -304,13 +392,25 @@ class Session:
             error_message: Error message
             code: Machine-readable error code
         """
-        await self.transport.send_event(
+        resolved_stage = stage or self._infer_error_stage(code)
+        resolved_retryable = retryable if retryable is not None else (resolved_stage in {"asr", "llm", "tts", "tool", "audio"})
+        await self._send_event(
             ev(
                 "error",
                 sender=sender,
                 code=code,
                 message=error_message,
+                stage=resolved_stage,
+                retryable=resolved_retryable,
                 trackId=self.current_track_id,
+                data={
+                    "error": {
+                        "stage": resolved_stage,
+                        "code": code,
+                        "message": error_message,
+                        "retryable": resolved_retryable,
+                    }
+                },
             )
         )
 
@@ -483,10 +583,9 @@ class Session:
         node = transition.node
         edge = transition.edge
 
-        await self.transport.send_event(
+        await self._send_event(
             ev(
                 "workflow.edge.taken",
-                sessionId=self.id,
                 workflowId=self.workflow_runner.workflow_id,
                 edgeId=edge.id,
                 fromNodeId=edge.from_node_id,
@@ -494,10 +593,9 @@ class Session:
                 reason=reason,
             )
         )
-        await self.transport.send_event(
+        await self._send_event(
             ev(
                 "workflow.node.entered",
-                sessionId=self.id,
                 workflowId=self.workflow_runner.workflow_id,
                 nodeId=node.id,
                 nodeName=node.name,
@@ -510,10 +608,9 @@ class Session:
             self.pipeline.apply_runtime_overrides(node_runtime)
 
         if node.node_type == "tool":
-            await self.transport.send_event(
+            await self._send_event(
                 ev(
                     "workflow.tool.requested",
-                    sessionId=self.id,
                     workflowId=self.workflow_runner.workflow_id,
                     nodeId=node.id,
                     tool=node.tool or {},
@@ -522,10 +619,9 @@ class Session:
             return
 
         if node.node_type == "human_transfer":
-            await self.transport.send_event(
+            await self._send_event(
                 ev(
                     "workflow.human_transfer",
-                    sessionId=self.id,
                     workflowId=self.workflow_runner.workflow_id,
                     nodeId=node.id,
                 )
@@ -534,16 +630,68 @@ class Session:
             return
 
         if node.node_type == "end":
-            await self.transport.send_event(
+            await self._send_event(
                 ev(
                     "workflow.ended",
-                    sessionId=self.id,
                     workflowId=self.workflow_runner.workflow_id,
                     nodeId=node.id,
                 )
             )
             await self._handle_session_stop("workflow_end")
 
+    def _next_event_seq(self) -> int:
+        self._event_seq += 1
+        return self._event_seq
+
+    def _event_source(self, event_type: str) -> str:
+        if event_type.startswith("workflow."):
+            return "system"
+        if event_type.startswith("session.") or event_type.startswith("hello.") or event_type == "heartbeat":
+            return "system"
+        if event_type == "error":
+            return "system"
+        return "system"
+
+    def _infer_error_stage(self, code: str) -> str:
+        normalized = str(code or "").strip().lower()
+        if normalized.startswith("audio."):
+            return "audio"
+        if normalized.startswith("tool."):
+            return "tool"
+        if normalized.startswith("asr."):
+            return "asr"
+        if normalized.startswith("llm."):
+            return "llm"
+        if normalized.startswith("tts."):
+            return "tts"
+        return "protocol"
+
+    def _envelope_event(self, event: Dict[str, Any]) -> Dict[str, Any]:
+        event_type = str(event.get("type") or "")
+        source = str(event.get("source") or self._event_source(event_type))
+        track_id = event.get("trackId") or self.TRACK_CONTROL
+
+        data = event.get("data")
+        if not isinstance(data, dict):
+            data = {}
+        for k, v in event.items():
+            if k in {"type", "timestamp", "sessionId", "seq", "source", "trackId", "data"}:
+                continue
+            data.setdefault(k, v)
+
+        event["sessionId"] = self.id
+        event["seq"] = self._next_event_seq()
+        event["source"] = source
+        event["trackId"] = track_id
+        event["data"] = data
+        return event
+
+    async def _send_event(self, event: Dict[str, Any]) -> None:
+        await self.transport.send_event(self._envelope_event(event))
+
+    async def send_heartbeat(self) -> None:
+        await self._send_event(ev("heartbeat", trackId=self.TRACK_CONTROL))
+
     async def _workflow_llm_route(
         self,
         node: WorkflowNodeDef,
@@ -629,6 +777,100 @@ class Session:
                 merged[key] = value
         return merged
 
+    async def _load_server_runtime_metadata(
+        self,
+        client_metadata: Dict[str, Any],
+        workflow_runtime: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Load trusted runtime metadata from backend assistant config."""
+        assistant_id = (
+            workflow_runtime.get("assistantId")
+            or client_metadata.get("assistantId")
+            or client_metadata.get("appId")
+            or client_metadata.get("app_id")
+        )
+        if assistant_id is None:
+            return {}
+        if not settings.backend_url:
+            return {}
+
+        payload = await fetch_assistant_config(str(assistant_id).strip())
+        if not isinstance(payload, dict):
+            return {}
+
+        assistant_cfg = payload.get("assistant") if isinstance(payload.get("assistant"), dict) else payload
+        if not isinstance(assistant_cfg, dict):
+            return {}
+
+        runtime: Dict[str, Any] = {}
+        if assistant_cfg.get("systemPrompt") is not None:
+            runtime["systemPrompt"] = str(assistant_cfg.get("systemPrompt") or "")
+        elif assistant_cfg.get("prompt") is not None:
+            runtime["systemPrompt"] = str(assistant_cfg.get("prompt") or "")
+
+        if assistant_cfg.get("greeting") is not None:
+            runtime["greeting"] = assistant_cfg.get("greeting")
+        elif assistant_cfg.get("opener") is not None:
+            runtime["greeting"] = assistant_cfg.get("opener")
+
+        if isinstance(assistant_cfg.get("services"), dict):
+            runtime["services"] = assistant_cfg.get("services")
+        if isinstance(assistant_cfg.get("tools"), list):
+            runtime["tools"] = assistant_cfg.get("tools")
+
+        runtime["assistantId"] = str(assistant_id)
+        return runtime
+
+    def _sanitize_untrusted_runtime_metadata(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Sanitize untrusted metadata sources.
+
+        This keeps only a small override whitelist and stable config ID fields.
+        """
+        if not isinstance(metadata, dict):
+            return {}
+
+        sanitized: Dict[str, Any] = {}
+        for key in self._CLIENT_METADATA_ID_KEYS:
+            if key in metadata:
+                sanitized[key] = metadata[key]
+        for key in self._CLIENT_METADATA_OVERRIDES:
+            if key in metadata:
+                sanitized[key] = metadata[key]
+
+        return sanitized
+
+    def _sanitize_client_metadata(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """Apply client metadata whitelist and remove forbidden secrets."""
+        sanitized = self._sanitize_untrusted_runtime_metadata(metadata)
+        if isinstance(metadata.get("services"), dict):
+            logger.warning(
+                "Session {} provided metadata.services from client; client-side service config is ignored",
+                self.id,
+            )
+        return sanitized
+
+    def _build_config_resolved(self, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        """Build public resolved config payload (secrets removed)."""
+        system_prompt = str(metadata.get("systemPrompt") or self.pipeline.conversation.system_prompt or "")
+        prompt_hash = hashlib.sha256(system_prompt.encode("utf-8")).hexdigest() if system_prompt else None
+        runtime = self.pipeline.resolved_runtime_config()
+
+        return {
+            "appId": metadata.get("appId") or metadata.get("app_id") or metadata.get("assistantId"),
+            "channel": metadata.get("channel"),
+            "configVersionId": metadata.get("configVersionId") or metadata.get("config_version_id"),
+            "prompt": {"sha256": prompt_hash},
+            "output": runtime.get("output", {}),
+            "services": runtime.get("services", {}),
+            "tools": runtime.get("tools", {}),
+            "tracks": {
+                "audio_in": self.TRACK_AUDIO_IN,
+                "audio_out": self.TRACK_AUDIO_OUT,
+                "control": self.TRACK_CONTROL,
+            },
+        }
+
     def _extract_json_obj(self, text: str) -> Optional[Dict[str, Any]]:
         """Best-effort extraction of a JSON object from freeform text."""
         try: