ltcai 9.9.3 → 9.9.5

package/latticeai/api/chat_agent_http.py

@@ -11,7 +11,7 @@ import threading
 import time
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 from fastapi import APIRouter, HTTPException, Request
 
@@ -19,6 +19,11 @@ from lattice_brain.runtime.hooks import dispatch_tool
 from latticeai.api.chat_contracts import AgentEvalRequest, AgentRequest, AgentResumeRequest
 from latticeai.api.chat_helpers import _LANG_HINT, detect_language, workspace_scope_from_request
 from latticeai.core.agent import AgentRunContext, AgentState, normalize_plan
+from latticeai.core.run_store import (
+    AgentRunStore,
+    hash_approval_token,
+    restore_run_context,
+)
 from latticeai.services.tool_dispatch import collect_artifacts, collect_created_files
 
 
@@ -42,6 +47,7 @@ class AgentHTTPController:
         agent_root: Path,
         ensure_agent_root: Any,
         funnel_metrics: Any = None,
+        run_store: Any = None,
     ) -> None:
         self.runtime = runtime
         self.model_router = model_router
@@ -59,15 +65,23 @@ class AgentHTTPController:
         self.agent_root = Path(agent_root)
         self.ensure_agent_root = ensure_agent_root
         self.funnel_metrics = funnel_metrics
-        self._pending: Dict[str, tuple] = {}
         self._pending_lock = threading.Lock()
-        self._pending_ttl_seconds = 15 * 60
         # awaiting_approval runs: run_id -> paused run state + approval token.
         # Fail-closed: governed steps only ever execute after resume presents
         # the matching, unexpired token for this run (or via the legacy
         # explicit human-in-loop context flow above).
         self._approvals: Dict[str, Dict[str, Any]] = {}
         self._approval_ttl_seconds = 10 * 60
+        # Durable side of the approval loop (review Wave 0.1): paused runs are
+        # mirrored to disk so a valid token still resumes after a restart or
+        # from another worker process. In-memory stays the fast path.
+        self.run_store = run_store if run_store is not None else AgentRunStore(
+            Path(base_dir) / "data" / "agent_runs"
+        )
+        try:
+            self.run_store.sweep_expired()
+        except Exception as exc:  # noqa: BLE001 — hygiene must not break startup
+            logging.warning("agent run store sweep failed: %s", exc)
         self._background_tasks: set[asyncio.Task] = set()
 
     def register_routes(self, router: APIRouter) -> None:
@@ -83,6 +97,10 @@ class AgentHTTPController:
         async def agent_resume(req: AgentResumeRequest, request: Request):
             return await self.resume(req, request)
 
+        @router.get("/agent/approvals")
+        async def agent_approvals(request: Request):
+            return self.pending_approvals(request)
+
     def _schedule_background_task(self, coro: Any) -> None:
         task = asyncio.create_task(coro)
         self._background_tasks.add(task)
@@ -180,8 +198,17 @@ class AgentHTTPController:
             "results": results,
         }
 
-    async def agent(self, req: AgentRequest, request: Request) -> Dict[str, Any]:
-        """Plan and execute a natural-language local agent run."""
+    async def agent(
+        self,
+        req: AgentRequest,
+        request: Request,
+        on_step: Any = None,
+    ) -> Dict[str, Any]:
+        """Plan and execute a natural-language local agent run.
+
+        ``on_step`` (optional) is a per-run step observer — the live SSE
+        route attaches one so the client sees progress while EXECUTING.
+        """
         current_user = self.require_user(request)
         self.enforce_rate_limit(current_user, "agent")
         effective_email = self.authenticated_identity(current_user, req.user_email)
@@ -207,6 +234,8 @@ class AgentHTTPController:
         max_steps = max(1, min(req.max_steps, 50))
         max_retry = 3
         ctx = AgentRunContext()
+        if on_step is not None:
+            ctx.on_step = on_step
         ctx.executing_model = req.executing_model
         ctx.reviewing_model = req.reviewing_model
         ctx.state = AgentState.PLANNING
@@ -219,33 +248,29 @@ class AgentHTTPController:
             model_id=req.planning_model,
         )
 
+        requirements_probe = getattr(self.runtime, "approval_requirements", None)
+
         if req.human_in_loop:
-            context_id = secrets.token_urlsafe(16)
-            with self._pending_lock:
-                self._pending[context_id] = (
-                    ctx,
-                    req,
-                    language_hint,
-                    current_user,
-                    time.monotonic(),
-                )
-            return {
-                "status": "waiting_approval",
-                "context_id": context_id,
-                "plan": ctx.plan,
-                "steps": ctx.transcript,
-                "state_history": ctx.state_history,
-                "planning_model": req.planning_model or self.model_router.current_model_id,
-                "executing_model": req.executing_model or self.model_router.current_model_id,
-                "reviewing_model": req.reviewing_model or self.model_router.current_model_id,
-                "loop": ctx.trace.summary(),
-            }
+            # Deprecated explicit pause (L1 unification, 9.9.5): the legacy
+            # ``human_in_loop`` flow now rides the same durable approval
+            # store as ``awaiting_approval`` — one pause path, one resume
+            # path, restart-safe. The legacy wire contract is preserved:
+            # ``status="waiting_approval"`` + ``context_id`` (token-less,
+            # same-user resume).
+            requirements = (
+                requirements_probe(ctx)
+                if callable(requirements_probe)
+                else {"requires_approval": True, "non_auto_steps": [], "plan_summary": ""}
+            )
+            return self._pause_for_approval(
+                ctx, req, language_hint, current_user, requirements,
+                legacy_context=True,
+            )
 
         # Interactive approval: when the plan needs human approval, pause the
         # run as awaiting_approval (short-TTL token) instead of failing it.
         # ``getattr`` keeps injected fake runtimes without the preview method
         # on the historical fail-closed path.
-        requirements_probe = getattr(self.runtime, "approval_requirements", None)
         if callable(requirements_probe):
             requirements = requirements_probe(ctx)
             if requirements.get("requires_approval"):
@@ -270,8 +295,16 @@ class AgentHTTPController:
         language_hint: str,
         current_user: str,
         requirements: Dict[str, Any],
+        *,
+        legacy_context: bool = False,
     ) -> Dict[str, Any]:
-        """Park a plan that needs approval and hand the user a resume token."""
+        """Park a plan that needs approval and hand the user a resume token.
+
+        ``legacy_context=True`` marks a deprecated ``human_in_loop`` pause:
+        same durable storage, but the response speaks the historical
+        ``waiting_approval``/``context_id`` contract and resume may present
+        the ``context_id`` instead of the approval token (same user only).
+        """
         run_id = secrets.token_urlsafe(16)
         approval_token = secrets.token_urlsafe(32)
         now_monotonic = time.monotonic()
@@ -288,14 +321,36 @@ class AgentHTTPController:
                 "token": approval_token,
                 "expires_monotonic": now_monotonic + self._approval_ttl_seconds,
                 "expires_at": expires_at,
+                "legacy_context": legacy_context,
             }
+        # Durable mirror: a restart between pause and resume must not orphan
+        # the run. Best-effort — the in-memory pause still answers on failure.
+        try:
+            self.run_store.save(
+                run_id,
+                ctx=ctx,
+                req_payload=req.model_dump(),
+                language_hint=language_hint,
+                user=current_user,
+                token=approval_token,
+                expires_epoch=time.time() + self._approval_ttl_seconds,
+                expires_at=expires_at,
+                legacy_context=legacy_context,
+            )
+        except Exception as exc:  # noqa: BLE001
+            logging.warning("agent run store persist failed: %s", exc)
+        if self.funnel_metrics is not None:
+            try:
+                self.funnel_metrics.increment("approval_pauses")
+            except Exception as exc:  # noqa: BLE001 — advisory only
+                logging.warning("funnel metrics increment failed: %s", exc)
         ctx.state_history.append(AgentState.WAITING_APPROVAL.value)
         message = (
             "이 작업에는 승인이 필요한 단계가 있어 실행을 잠시 멈췄습니다. "
             "계획을 확인한 뒤 승인하면 이어서 실행합니다."
         )
-        return {
-            "status": "awaiting_approval",
+        payload = {
+            "status": "waiting_approval" if legacy_context else "awaiting_approval",
             "run_id": run_id,
             "approval": {
                 "token": approval_token,
@@ -313,11 +368,111 @@ class AgentHTTPController:
             "reviewing_model": req.reviewing_model or self.model_router.current_model_id,
             "loop": ctx.trace.summary(),
         }
+        if legacy_context:
+            # Historical wire field — the run id doubles as the context id.
+            payload["context_id"] = run_id
+        return payload
 
     def _purge_expired_approvals_locked(self, now_monotonic: float) -> None:
         for run_id, entry in list(self._approvals.items()):
             if now_monotonic >= entry["expires_monotonic"]:
                 self._approvals.pop(run_id, None)
+                try:
+                    self.run_store.delete(run_id)
+                except Exception:  # noqa: BLE001 — hygiene only
+                    pass
+
+    def pending_approvals(self, request: Request) -> Dict[str, Any]:
+        """Unexpired paused runs for the current user (memory ∪ disk).
+
+        Lets the UI re-surface an approval card after a reload/restart instead
+        of the run silently vanishing.
+        """
+        current_user = self.require_user(request)
+        now_monotonic = time.monotonic()
+        pending: Dict[str, Dict[str, Any]] = {}
+        with self._pending_lock:
+            for run_id, entry in self._approvals.items():
+                if entry["user"] != current_user:
+                    continue
+                if now_monotonic >= entry["expires_monotonic"]:
+                    continue
+                plan = getattr(entry["ctx"], "plan", {}) or {}
+                pending[run_id] = {
+                    "run_id": run_id,
+                    "goal": str(plan.get("goal") or "")[:200],
+                    "expires_at": entry["expires_at"],
+                }
+        try:
+            for summary in self.run_store.pending_summaries(current_user):
+                run_id = summary.get("run_id")
+                if run_id and run_id not in pending:
+                    pending[run_id] = {
+                        "run_id": run_id,
+                        "goal": summary.get("goal") or "",
+                        "expires_at": summary.get("expires_at"),
+                    }
+        except Exception as exc:  # noqa: BLE001 — disk listing is best-effort
+            logging.warning("agent run store listing failed: %s", exc)
+        return {"pending": sorted(pending.values(), key=lambda p: p["run_id"])}
+
+    def _restore_persisted_approval(self, run_id: str) -> Optional[Dict[str, Any]]:
+        """Rebuild an approval entry from disk after a restart.
+
+        Returns an entry shaped like the in-memory ones but carrying
+        ``token_hash`` instead of the plaintext token. Expired records are
+        deleted and reported via the same 410 contract as the memory path.
+        """
+        try:
+            record = self.run_store.load(run_id)
+        except Exception as exc:  # noqa: BLE001 — load error == not found
+            logging.warning("agent run store load failed: %s", exc)
+            return None
+        if record is None:
+            return None
+        req_payload = record.get("req") or {}
+        if time.time() >= float(record.get("expires_epoch") or 0):
+            try:
+                self.run_store.delete(run_id)
+            except Exception:  # noqa: BLE001
+                pass
+            raise HTTPException(
+                status_code=410,
+                detail={
+                    "error": "approval_expired",
+                    "message": "Approval token expired. Start a new request.",
+                    "replan": {"message": str(req_payload.get("message") or "")},
+                },
+            )
+        try:
+            restored_req = AgentRequest(**req_payload)
+        except Exception as exc:  # noqa: BLE001 — unreconstructable == not found
+            logging.warning("agent run store request restore failed: %s", exc)
+            return None
+        remaining = max(1.0, float(record["expires_epoch"]) - time.time())
+        return {
+            "ctx": restore_run_context(record.get("ctx") or {}),
+            "req": restored_req,
+            "language_hint": str(record.get("language_hint") or "English"),
+            "user": record.get("user"),
+            "token_hash": str(record.get("token_hash") or ""),
+            "expires_monotonic": time.monotonic() + remaining,
+            "expires_at": record.get("expires_at"),
+            "legacy_context": bool(record.get("legacy_context")),
+        }
+
+    @staticmethod
+    def _token_matches(entry: Dict[str, Any], supplied: str) -> bool:
+        """Constant-time token check for both plaintext and hashed entries."""
+        if not supplied:
+            return False
+        stored = entry.get("token")
+        if stored is not None:
+            return secrets.compare_digest(str(stored), supplied)
+        stored_hash = str(entry.get("token_hash") or "")
+        return bool(stored_hash) and secrets.compare_digest(
+            stored_hash, hash_approval_token(supplied)
+        )
 
     async def _finish(
         self,
@@ -419,31 +574,63 @@ class AgentHTTPController:
                 status_code=400,
                 detail="run_id (with approval_token) or context_id is required.",
             )
+        # Deprecated context_id resume (L1 unification, 9.9.5): the legacy
+        # pause lives in the same durable approval store now. Token-less
+        # resume stays allowed for it — bound to the pausing user, and only
+        # for entries that were created through the legacy pause.
+        now_monotonic = time.monotonic()
         with self._pending_lock:
-            now = time.monotonic()
-            for context_id, pending in list(self._pending.items()):
-                if now - pending[4] >= self._pending_ttl_seconds:
-                    self._pending.pop(context_id, None)
-            entry = self._pending.get(req.context_id)
-            if entry and entry[3] == current_user:
-                self._pending.pop(req.context_id, None)
-        if not entry:
-            raise HTTPException(
-                status_code=404,
-                detail="Agent context not found or expired. Start a new request.",
-            )
+            entry = self._approvals.get(req.context_id)
+            if entry is None:
+                try:
+                    entry = self._restore_persisted_approval(req.context_id)
+                except HTTPException as exc:
+                    if exc.status_code == 410:
+                        # Legacy contract never had a distinct expiry answer.
+                        raise HTTPException(
+                            status_code=404,
+                            detail="Agent context not found or expired. Start a new request.",
+                        ) from exc
+                    raise
+            if entry is None or not entry.get("legacy_context"):
+                raise HTTPException(
+                    status_code=404,
+                    detail="Agent context not found or expired. Start a new request.",
+                )
+            if entry["user"] != current_user:
+                raise HTTPException(
+                    status_code=403,
+                    detail="Agent context belongs to another user.",
+                )
+            if now_monotonic >= entry["expires_monotonic"]:
+                self._approvals.pop(req.context_id, None)
+                try:
+                    self.run_store.delete(req.context_id)
+                except Exception:  # noqa: BLE001
+                    pass
+                raise HTTPException(
+                    status_code=404,
+                    detail="Agent context not found or expired. Start a new request.",
+                )
+            self._approvals.pop(req.context_id, None)
+            try:
+                self.run_store.delete(req.context_id)
+            except Exception as exc:  # noqa: BLE001
+                logging.warning("agent run store delete failed: %s", exc)
 
-        ctx, original_request, language_hint, original_user, _created_at = entry
-        if original_user != current_user:
-            raise HTTPException(
-                status_code=403,
-                detail="Agent context belongs to another user.",
-            )
+        ctx = entry["ctx"]
+        original_request = entry["req"]
+        language_hint = entry["language_hint"]
         if not req.approved:
             return {"status": "cancelled", "response": "사용자가 계획을 취소했습니다."}
         if req.modified_plan:
-            ctx.plan = req.modified_plan
-            ctx.transcript[-1].update(ctx.plan)
+            plan, plan_fixes = normalize_plan(req.modified_plan, original_request.message)
+            ctx.plan = plan
+            ctx.transcript.append({
+                "state": AgentState.WAITING_APPROVAL.value,
+                "edited_plan": True,
+                **({"plan_fixes": plan_fixes} if plan_fixes else {}),
+            })
         ctx.executing_model = req.executing_model or ctx.executing_model
         ctx.reviewing_model = req.reviewing_model or ctx.reviewing_model
         # The authenticated owner of this pending context explicitly approved
@@ -468,6 +655,10 @@ class AgentHTTPController:
         now_monotonic = time.monotonic()
         with self._pending_lock:
             entry = self._approvals.get(req.run_id or "")
+            if entry is None:
+                # Restart survival (review Wave 0.1): the in-memory dict is
+                # gone but the durable record may still be valid.
+                entry = self._restore_persisted_approval(req.run_id or "")
             if entry is None:
                 raise HTTPException(
                     status_code=404,
@@ -480,24 +671,43 @@ class AgentHTTPController:
                 )
             if now_monotonic >= entry["expires_monotonic"]:
                 self._approvals.pop(req.run_id, None)
+                try:
+                    self.run_store.delete(req.run_id or "")
+                except Exception:  # noqa: BLE001
+                    pass
                 raise HTTPException(
                     status_code=410,
-                    detail="Approval token expired. Start a new request.",
+                    detail={
+                        "error": "approval_expired",
+                        "message": "Approval token expired. Start a new request.",
+                        "replan": {"message": getattr(entry.get("req"), "message", "")},
+                    },
                 )
-            supplied = req.approval_token or ""
-            if not supplied or not secrets.compare_digest(entry["token"], supplied):
+            if not self._token_matches(entry, req.approval_token or ""):
                 raise HTTPException(
                     status_code=403,
                     detail="Invalid approval token for this run.",
                 )
             # Token validated — the pending run is consumed either way.
             self._approvals.pop(req.run_id, None)
+            try:
+                self.run_store.delete(req.run_id or "")
+            except Exception as exc:  # noqa: BLE001 — consumption must proceed
+                logging.warning("agent run store delete failed: %s", exc)
             self._purge_expired_approvals_locked(now_monotonic)
 
         ctx: AgentRunContext = entry["ctx"]
         original_request: AgentRequest = entry["req"]
         language_hint: str = entry["language_hint"]
 
+        if self.funnel_metrics is not None:
+            # approval_resume_rate = resumes / pauses (review §4.3): counted on
+            # every token-valid resume decision, approve and deny alike.
+            try:
+                self.funnel_metrics.increment("approval_resumes")
+            except Exception as exc:  # noqa: BLE001 — advisory only
+                logging.warning("funnel metrics increment failed: %s", exc)
+
         approved = req.approve if req.approve is not None else req.approved
         if not approved:
             message = "사용자가 계획을 취소했습니다."

package/latticeai/api/chat_contracts.py

@@ -45,7 +45,7 @@ class AgentResumeRequest(BaseModel):
     modified_plan: Optional[dict] = None
     executing_model: Optional[str] = None
     reviewing_model: Optional[str] = None
-    # awaiting_approval flow (v9.10): run_id + short-TTL approval token.
+    # awaiting_approval flow (v9.9.x): run_id + short-TTL approval token.
     run_id: Optional[str] = None
     approval_token: Optional[str] = None
     approve: Optional[bool] = None

package/latticeai/api/chat_intents.py

@@ -17,7 +17,11 @@ from latticeai.api.chat_helpers import (
     format_network_status,
     inline_file_action_content,
 )
-from latticeai.api.chat_stream import agent_payload_stream, single_answer_response
+from latticeai.api.chat_stream import (
+    agent_live_stream,
+    agent_payload_stream,
+    single_answer_response,
+)
 from latticeai.core.agent import AgentState
 from latticeai.core.file_generation import (
     PREVIEWABLE_EXTENSIONS,
@@ -596,31 +600,46 @@ class ChatIntentController:
             user_nickname=req.user_nickname,
             workspace_id=workspace_id,
         )
-        result = await self.agent_controller.agent(agent_request, request)
-        answer = str(result.get("response") or "파일 작업을 처리했습니다.")
-        # UX funnel (backlog #16): a file-intent request that the agent loop
-        # finished without producing a single artifact is the "code-only"
-        # failure mode the >95% real-file goal watches. Paused/failed runs
-        # count neither way — they did not answer with code instead of files.
-        delivered = bool(result.get("created_files") or result.get("artifacts"))
-        if delivered:
-            self._funnel_increment("real_file_delivered")
-        elif str(result.get("status") or "") == "ok":
-            self._funnel_increment("code_only_responses")
-        self.notify("user", req.message, req.source)
-        self.notify("assistant", answer, req.source)
-        result["routed_to_agent"] = True
+
+        def finalize(result: Dict) -> str:
+            """History/funnel side effects once the run has a terminal payload."""
+            answer = str(result.get("response") or "파일 작업을 처리했습니다.")
+            # UX funnel (backlog #16): a file-intent request that the agent loop
+            # finished without producing a single artifact is the "code-only"
+            # failure mode the >95% real-file goal watches. Paused/failed runs
+            # count neither way — they did not answer with code instead of files.
+            delivered = bool(result.get("created_files") or result.get("artifacts"))
+            if delivered:
+                self._funnel_increment("real_file_delivered")
+            elif str(result.get("status") or "") == "ok":
+                self._funnel_increment("code_only_responses")
+            self.notify("user", req.message, req.source)
+            self.notify("assistant", answer, req.source)
+            result["routed_to_agent"] = True
+            return answer
+
         if req.stream:
+            # Live loop visibility (review Wave 1.1): run the agent inside the
+            # SSE generator so step events stream while EXECUTING; the final
+            # frames keep the exact historical payload shape.
+            async def start(observer):
+                return await self.agent_controller.agent(
+                    agent_request, request, on_step=observer
+                )
+
             return StreamingResponse(
-                agent_payload_stream(
-                    answer,
-                    result,
+                agent_live_stream(
+                    start,
                     router=self.router,
                     model_id=model_id,
+                    finalize=finalize,
                 ),
                 media_type="text/event-stream",
                 headers={"X-Model": model_id or "agent", "X-Routed-To": "agent"},
             )
+
+        result = await self.agent_controller.agent(agent_request, request)
+        finalize(result)
         return JSONResponse(content=result)
 
 

package/latticeai/api/chat_stream.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
-from typing import Any, AsyncIterator, Dict, Optional
+from typing import Any, AsyncIterator, Awaitable, Callable, Dict, Optional
 
 from fastapi.responses import JSONResponse, StreamingResponse
 
@@ -37,6 +38,74 @@ def agent_payload_stream(
     return _stream()
 
 
+def agent_live_stream(
+    start: Callable[[Callable[[Dict[str, Any]], None]], Awaitable[Dict[str, Any]]],
+    *,
+    router: Any,
+    model_id: Optional[str] = None,
+    finalize: Optional[Callable[[Dict[str, Any]], str]] = None,
+) -> AsyncIterator[str]:
+    """Live SSE for an agent run (review Wave 1.1).
+
+    ``start(observer)`` runs the agent with a per-run step observer; every
+    observed step is emitted immediately as a named ``agent_step`` frame, so
+    the user watches the loop work instead of staring at silence. When the
+    run finishes, ``finalize(result)`` (history/funnel side effects) produces
+    the answer text and the classic final payload frames follow — clients
+    that ignore named events see exactly the historical stream shape.
+    """
+
+    async def _stream() -> AsyncIterator[str]:
+        response_model = model_id or router.current_model_id
+        queue: asyncio.Queue = asyncio.Queue()
+
+        def observer(event: Dict[str, Any]) -> None:
+            # Called synchronously from the agent coroutine on this loop.
+            queue.put_nowait(event)
+
+        task = asyncio.create_task(start(observer))
+        try:
+            while True:
+                getter = asyncio.create_task(queue.get())
+                done, _ = await asyncio.wait(
+                    {getter, task}, return_when=asyncio.FIRST_COMPLETED
+                )
+                if getter in done:
+                    step = getter.result()
+                    yield (
+                        "event: agent_step\n"
+                        f"data: {json.dumps(step, ensure_ascii=False)}\n\n"
+                    )
+                    continue
+                getter.cancel()
+                break
+            while not queue.empty():
+                step = queue.get_nowait()
+                yield (
+                    "event: agent_step\n"
+                    f"data: {json.dumps(step, ensure_ascii=False)}\n\n"
+                )
+            result = task.result()
+        except Exception as exc:  # noqa: BLE001 — already streaming a 200
+            logging.warning("agent live stream failed: %s", exc)
+            detail = getattr(exc, "detail", None) or str(exc)
+            yield f"data: {json.dumps({'error': str(detail), 'model': response_model}, ensure_ascii=False)}\n\n"
+            yield "data: [DONE]\n\n"
+            return
+
+        answer = str(result.get("response") or "작업을 완료했습니다.")
+        if finalize is not None:
+            try:
+                answer = finalize(result)
+            except Exception as exc:  # noqa: BLE001 — side effects must not kill the stream
+                logging.warning("agent live stream finalize failed: %s", exc)
+        yield f"data: {json.dumps({'chunk': answer, 'model': response_model, 'agent': result}, ensure_ascii=False)}\n\n"
+        yield f"data: {json.dumps({'chunk': '', 'model': response_model, 'agent': result}, ensure_ascii=False)}\n\n"
+        yield "data: [DONE]\n\n"
+
+    return _stream()
+
+
 async def stream_chat(
     req: Any,
     context: str,
@@ -136,4 +205,9 @@ async def stream_chat(
     yield "data: [DONE]\n\n"
 
 
-__all__ = ["agent_payload_stream", "single_answer_response", "stream_chat"]
+__all__ = [
+    "agent_live_stream",
+    "agent_payload_stream",
+    "single_answer_response",
+    "stream_chat",
+]