ltcai 9.0.0 → 9.1.0

package/latticeai/api/chat_helpers.py

@@ -26,6 +26,13 @@ def pair_user_history(history: List[Dict], user_email: str) -> List[Dict]:
     for item in history:
         if item.get("role") == "assistant":
             if include_next_assistant:
+                assistant_user = item.get("user_email")
+                if assistant_user and assistant_user != user_email:
+                    # Concurrent requests can interleave rows in the global
+                    # history order.  A reply explicitly owned by somebody
+                    # else is never this user's reply; keep waiting for the
+                    # next correctly-owned (or legacy ownerless) assistant.
+                    continue
                 paired.append(item)
                 include_next_assistant = False
         elif item.get("user_email") == user_email:
@@ -205,8 +212,24 @@ def build_recent_chat_context(
     include_image_missing_replies: bool = True,
     user_email: Optional[str] = None,
     conversation_id: Optional[str] = None,
+    workspace_id: Optional[str] = None,
 ) -> str:
-    history = get_history()
+    if user_email:
+        # Apply identity/workspace isolation in the durable query rather than
+        # relying only on positional post-filtering.  In particular, never
+        # admit legacy-global rows into an authenticated model prompt.
+        history = get_history(
+            user_email=user_email,
+            allowed_workspaces={workspace_id} if workspace_id is not None else None,
+            include_legacy_global=False,
+        )
+    else:
+        history = get_history()
+    if workspace_id is not None:
+        history = [
+            item for item in history
+            if str(item.get("workspace_id") or "personal") == str(workspace_id)
+        ]
     if conversation_id:
         history = [item for item in history if item.get("conversation_id") == conversation_id]
     if user_email:

package/latticeai/api/chat_history.py

@@ -0,0 +1,99 @@
+"""Conversation-history HTTP routes.
+
+Persistence and search grouping live in :mod:`latticeai.services.chat_service`;
+this module only authenticates requests and shapes HTTP responses.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Dict
+
+from fastapi import APIRouter, HTTPException, Request
+
+
+@dataclass(frozen=True)
+class HistoryRouteDependencies:
+    chat_service: Any
+    require_user: Callable[[Request], str]
+    scope_for_user: Callable[[str], Dict[str, Any]]
+    group_conversations: Callable[[list], Any]
+    get_conversation_messages: Callable[..., list]
+    conversation_title: Callable[[Dict[str, Any]], str]
+    clear_conversation: Callable[..., Dict[str, Any]]
+    clear_history: Callable[..., Dict[str, Any]]
+    append_audit_event: Callable[..., None]
+
+
+def register_history_routes(router: APIRouter, deps: HistoryRouteDependencies) -> None:
+    @router.get("/history")
+    async def fetch_history(request: Request):
+        """웹 화면에서 이전 대화를 불러올 수 있도록 히스토리를 반환합니다."""
+        current_user = deps.require_user(request)
+        return deps.chat_service.history(**deps.scope_for_user(current_user))
+
+    @router.get("/history/conversations")
+    async def fetch_history_conversations(request: Request):
+        """저장된 히스토리를 대화 단위로 묶어 반환합니다."""
+        current_user = deps.require_user(request)
+        history = deps.chat_service.history(**deps.scope_for_user(current_user))
+        return deps.group_conversations(history)
+
+    @router.get("/history/conversations/{conversation_id:path}")
+    async def fetch_history_conversation(conversation_id: str, request: Request):
+        """선택한 대화의 메시지를 반환합니다."""
+        current_user = deps.require_user(request)
+        messages = deps.get_conversation_messages(
+            conversation_id,
+            **deps.scope_for_user(current_user),
+        )
+        if not messages:
+            raise HTTPException(status_code=404, detail="대화를 찾을 수 없습니다.")
+        return {"id": conversation_id, "messages": messages}
+
+    @router.delete("/history/conversations/{conversation_id:path}")
+    async def delete_history_conversation(conversation_id: str, request: Request):
+        """선택한 대화방의 메시지만 삭제합니다."""
+        email = deps.require_user(request)
+        started_at = request.query_params.get("started_at")
+        result = deps.clear_conversation(
+            conversation_id,
+            started_at,
+            **deps.scope_for_user(email),
+        )
+        deps.append_audit_event(
+            "conversation_delete",
+            user_email=email,
+            conversation_id=conversation_id,
+            started_at=started_at,
+            removed=result.get("removed", 0),
+            kept=result.get("kept", 0),
+        )
+        return result
+
+    @router.delete("/history")
+    async def delete_history(request: Request, keep_last: int = 0):
+        email = deps.require_user(request)
+        result = deps.clear_history(keep_last, **deps.scope_for_user(email))
+        deps.append_audit_event(
+            "history_delete",
+            user_email=email,
+            keep_last=keep_last,
+            removed=result.get("removed", 0),
+            kept=result.get("kept", 0),
+        )
+        return result
+
+    @router.get("/history/search")
+    async def search_history(q: str, request: Request):
+        """키워드로 채팅 히스토리를 검색합니다."""
+        current_user = deps.require_user(request)
+        results = deps.chat_service.search_history(
+            q,
+            scope=deps.scope_for_user(current_user),
+            conversation_title=deps.conversation_title,
+        )
+        return {"results": results, "query": q}
+
+
+__all__ = ["HistoryRouteDependencies", "register_history_routes"]

package/latticeai/api/chat_intents.py

@@ -0,0 +1,302 @@
+"""Fast-path intent and governed file-action handlers for chat."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from fastapi import HTTPException, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from latticeai.api.chat_contracts import AgentRequest
+from latticeai.api.chat_helpers import (
+    file_action_target,
+    format_network_status,
+    inline_file_action_content,
+    strip_generated_file_content,
+)
+from latticeai.api.chat_stream import agent_payload_stream, single_answer_response
+from latticeai.core.agent import AgentState
+
+
+class ChatIntentController:
+    def __init__(
+        self,
+        *,
+        model_router: Any,
+        config: Any,
+        public_model: str,
+        chat_service: Any,
+        notify: Any,
+        clear_history: Any,
+        clear_conversation: Any,
+        history_scope_for_user: Any,
+        append_audit_event: Any,
+        enable_graph: bool,
+        knowledge_graph: Any,
+        enforce_tool_policy: Any,
+        network_status: Any,
+        tool_error: type[Exception],
+        execute_tool: Any,
+        agent_controller: Any,
+        agent_root: Path,
+    ) -> None:
+        self.router = model_router
+        self.config = config
+        self.public_model = public_model
+        self.chat_service = chat_service
+        self.notify = notify
+        self.clear_history = clear_history
+        self.clear_conversation = clear_conversation
+        self.history_scope_for_user = history_scope_for_user
+        self.append_audit_event = append_audit_event
+        self.enable_graph = enable_graph
+        self.knowledge_graph = knowledge_graph
+        self.enforce_tool_policy = enforce_tool_policy
+        self.network_status = network_status
+        self.tool_error = tool_error
+        self.execute_tool = execute_tool
+        self.agent_controller = agent_controller
+        self.agent_root = Path(agent_root)
+
+    def no_model_response(self) -> JSONResponse:
+        detail = "No model loaded. Call /models/load first."
+        if self.config.is_public:
+            detail = (
+                "No public model loaded. Set OPENAI_API_KEY and "
+                f"LATTICEAI_PUBLIC_MODEL={self.public_model}, or call /models/load "
+                "with an OpenAI-compatible model."
+            )
+        return JSONResponse(
+            status_code=400,
+            content={
+                "error": "no_model_loaded",
+                "detail": detail,
+                "message": detail,
+                "action": "load_model",
+            },
+        )
+
+    async def network(
+        self,
+        req: Any,
+        *,
+        current_user: str,
+        history_meta: Dict[str, Any],
+        history_user: Dict[str, Any],
+    ):
+        history_message = (
+            f"{req.message}\n[Image attached]" if req.image_data else req.message
+        )
+        self.enforce_tool_policy(
+            "network_status",
+            {},
+            current_user=current_user,
+            source="chat_intent",
+            trusted_admin=not bool(getattr(self.config, "require_auth", False)),
+        )
+        try:
+            answer = format_network_status(self.network_status())
+        except self.tool_error as exc:
+            answer = f"네트워크 정보를 확인하지 못했습니다: {exc}"
+        await self.chat_service.persist_exchange(
+            request_message=req.message,
+            stored_user_message=history_message,
+            answer=answer,
+            source=req.source,
+            history_meta=history_meta,
+            history_user=history_user,
+            notify=self.notify,
+        )
+        return single_answer_response(req, answer, model="network_status")
+
+    async def clear(
+        self,
+        req: Any,
+        *,
+        effective_email: Optional[str],
+        workspace_id: Optional[str],
+    ):
+        command = req.message.strip().lower()
+        clear_scope = "all" if command == "/clear_all" else "conversation"
+        if self.enable_graph and self.knowledge_graph:
+            try:
+                self.knowledge_graph.ingest_event(
+                    "ClearEvent",
+                    f"{command} requested",
+                    user_email=effective_email,
+                    user_nickname=req.user_nickname,
+                    source=req.source or "web",
+                    conversation_id=req.conversation_id,
+                    workspace_id=workspace_id,
+                    metadata={"command": command, "scope": clear_scope},
+                )
+            except Exception as exc:
+                # Clear remains available even when optional graph audit ingest
+                # is unhealthy; the primary audit event below is authoritative.
+                logging.warning("knowledge graph clear event ingest failed: %s", exc)
+        scope = self.history_scope_for_user(effective_email)
+        if command == "/clear_all":
+            result = self.clear_history(0, **scope)
+            prefix = "채팅창을 정리했습니다."
+        elif req.conversation_id:
+            result = self.clear_conversation(req.conversation_id, **scope)
+            prefix = "현재 대화방 채팅창을 정리했습니다."
+        else:
+            result = self.clear_history(0, **scope)
+            prefix = "채팅창을 정리했습니다."
+        answer = (
+            f"{prefix} 화면에서 제거 {result.get('removed', 0)}개. "
+            "감사 로그와 지식 그래프/RAG 데이터는 유지됩니다."
+        )
+        self.append_audit_event(
+            "clear_command",
+            user_email=effective_email,
+            user_nickname=req.user_nickname,
+            source=req.source or "web",
+            conversation_id=req.conversation_id,
+            command=command,
+            scope=clear_scope,
+            removed=result.get("removed", 0),
+            kept=result.get("kept", 0),
+        )
+        self.notify("user", req.message, req.source)
+        self.notify("assistant", answer, req.source)
+        return single_answer_response(req, answer, model="history")
+
+    async def current_url(
+        self,
+        req: Any,
+        *,
+        history_meta: Dict[str, Any],
+        history_user: Dict[str, Any],
+    ):
+        answer = f"현재 페이지 URL: {req.client_url}"
+        await self.chat_service.persist_exchange(
+            request_message=req.message,
+            stored_user_message=req.message,
+            answer=answer,
+            source=req.source,
+            history_meta=history_meta,
+            history_user=history_user,
+            notify=self.notify,
+        )
+        return single_answer_response(req, answer, model="client_url")
+
+    async def direct_file_action(self, req: Any, *, model_id: Optional[str]):
+        target_path = file_action_target(req.message)
+        if not target_path:
+            return None
+        content = inline_file_action_content(req.message)
+        if content is None and not model_id:
+            return self.no_model_response()
+        if content is None and model_id:
+            generation_context = (
+                "Create the exact content for the requested file. "
+                "Return only the file bytes as plain text. "
+                "Do not wrap the answer in Markdown fences, commentary, or explanations.\n\n"
+                f"Target path: {target_path}\n"
+                f"User request: {req.message}"
+            )
+            raw_content = await self.router.generate_as(
+                model_id,
+                message="Return only the requested file content.",
+                context=generation_context,
+                max_tokens=req.max_tokens,
+                temperature=req.temperature,
+            )
+            content = strip_generated_file_content(str(raw_content))
+        if content is None:
+            raise HTTPException(
+                status_code=400,
+                detail="File content could not be generated.",
+            )
+        try:
+            result = self.execute_tool(
+                "write_file",
+                {"path": target_path, "content": content},
+            )
+        except self.tool_error as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        answer = f"{result.get('path') or target_path} 파일을 만들었습니다."
+        created_files = [
+            {
+                "path": result.get("path") or target_path,
+                "filename": Path(result.get("path") or target_path).name,
+                "bytes": result.get("bytes", 0),
+                "action": "write_file",
+            }
+        ]
+        self.notify("user", req.message, req.source)
+        self.notify("assistant", answer, req.source)
+        payload = {
+            "status": "ok",
+            "response": answer,
+            "workspace": str(self.agent_root),
+            "steps": [
+                {
+                    "state": AgentState.EXECUTING.value,
+                    "action": "write_file",
+                    "args": {"path": target_path},
+                    "result": result,
+                }
+            ],
+            "state_history": [AgentState.EXECUTING.value, AgentState.DONE.value],
+            "final_state": AgentState.DONE.value,
+            "created_files": created_files,
+            "routed_to_agent": True,
+            "action_route": "direct_write_file",
+        }
+        if req.stream:
+            return StreamingResponse(
+                agent_payload_stream(
+                    answer,
+                    payload,
+                    router=self.router,
+                    model_id=model_id,
+                ),
+                media_type="text/event-stream",
+                headers={"X-Model": model_id or "tool", "X-Routed-To": "agent"},
+            )
+        return JSONResponse(content=payload)
+
+    async def route_file_to_agent(
+        self,
+        req: Any,
+        request: Request,
+        *,
+        effective_email: Optional[str],
+        workspace_id: Optional[str],
+        model_id: Optional[str],
+    ):
+        agent_request = AgentRequest(
+            message=req.message,
+            conversation_id=req.conversation_id,
+            source=req.source or "web",
+            max_steps=25,
+            temperature=min(req.temperature, 0.2),
+            user_email=effective_email,
+            user_nickname=req.user_nickname,
+            workspace_id=workspace_id,
+        )
+        result = await self.agent_controller.agent(agent_request, request)
+        answer = str(result.get("response") or "파일 작업을 처리했습니다.")
+        self.notify("user", req.message, req.source)
+        self.notify("assistant", answer, req.source)
+        result["routed_to_agent"] = True
+        if req.stream:
+            return StreamingResponse(
+                agent_payload_stream(
+                    answer,
+                    result,
+                    router=self.router,
+                    model_id=model_id,
+                ),
+                media_type="text/event-stream",
+                headers={"X-Model": model_id or "agent", "X-Routed-To": "agent"},
+            )
+        return JSONResponse(content=result)
+
+
+__all__ = ["ChatIntentController"]

package/latticeai/api/chat_stream.py

@@ -0,0 +1,115 @@
+"""SSE framing and streamed-answer finalization for chat routes."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, AsyncIterator, Dict, Optional
+
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from latticeai.api.chat_helpers import single_text_stream
+
+
+def single_answer_response(req: Any, answer: str, *, model: str):
+    if req.stream:
+        return StreamingResponse(
+            single_text_stream(answer),
+            media_type="text/event-stream",
+            headers={"X-Model": model},
+        )
+    return JSONResponse(content={"response": answer})
+
+
+def agent_payload_stream(
+    answer: str,
+    payload: Dict[str, Any],
+    *,
+    router: Any,
+    model_id: Optional[str] = None,
+) -> AsyncIterator[str]:
+    async def _stream() -> AsyncIterator[str]:
+        response_model = model_id or router.current_model_id
+        yield f"data: {json.dumps({'chunk': answer, 'model': response_model, 'agent': payload}, ensure_ascii=False)}\n\n"
+        yield f"data: {json.dumps({'chunk': '', 'model': response_model, 'agent': payload}, ensure_ascii=False)}\n\n"
+        yield "data: [DONE]\n\n"
+
+    return _stream()
+
+
+async def stream_chat(
+    req: Any,
+    context: str,
+    image_data: Optional[str],
+    *,
+    router: Any,
+    chat_service: Any,
+    knowledge_graph: Any,
+    enable_graph: bool,
+    notify: Any,
+    trace_seed: Optional[Dict[str, Any]] = None,
+    effective_email: Optional[str] = None,
+    history_meta: Optional[Dict[str, Any]] = None,
+    model_id: Optional[str] = None,
+    workspace_id: Optional[str] = None,
+) -> AsyncIterator[str]:
+    """Stream model chunks and persist exactly one finalized answer."""
+
+    full_response = ""
+    stream_error: Optional[str] = None
+    try:
+        async for chunk in router.stream_generate_as(
+            model_id,
+            req.message,
+            context,
+            req.max_tokens,
+            req.temperature,
+            image_data,
+        ):
+            clean_chunk = chunk.text if hasattr(chunk, "text") else chunk
+            full_response += str(clean_chunk)
+            yield f"data: {json.dumps({'chunk': clean_chunk, 'model': model_id}, ensure_ascii=False)}\n\n"
+    except Exception as exc:
+        stream_error = str(exc)
+        logging.warning("chat stream failed: %s", exc)
+        yield f"data: {json.dumps({'error': stream_error, 'model': model_id}, ensure_ascii=False)}\n\n"
+
+    persisted_response = full_response
+    if stream_error and not persisted_response:
+        persisted_response = f"[stream_error] {stream_error}"
+    elif stream_error:
+        persisted_response = f"{persisted_response}\n\n[stream_error] {stream_error}"
+
+    trace_record = None
+    try:
+        answer_trace = trace_seed or chat_service.build_graph_trace(
+            req.message,
+            knowledge_graph if (enable_graph and knowledge_graph) else None,
+            context,
+            allowed_workspaces={workspace_id} if workspace_id else None,
+        )
+        trace_record = await chat_service.persist_answer(
+            question=req.message,
+            response=persisted_response,
+            conversation_id=req.conversation_id,
+            user_email=effective_email or req.user_email,
+            user_nickname=req.user_nickname,
+            source=req.source,
+            trace=answer_trace,
+            workspace_id=workspace_id,
+            history_meta=history_meta or {},
+            notify=notify,
+        )
+    except Exception as exc:
+        logging.warning("chat stream persistence failed: %s", exc)
+
+    trailer: Dict[str, Any] = {"chunk": "", "model": model_id}
+    if trace_record:
+        trailer.update({"trace_id": trace_record["id"], "trace": trace_record})
+    if stream_error:
+        trailer["error"] = stream_error
+    yield f"data: {json.dumps(trailer, ensure_ascii=False)}\n\n"
+    yield "data: [DONE]\n\n"
+
+
+__all__ = ["agent_payload_stream", "single_answer_response", "stream_chat"]

package/latticeai/api/computer_use.py

@@ -13,7 +13,7 @@ from pydantic import BaseModel
 from latticeai.core.agent import extract_action as _extract_agent_action
 from lattice_brain.runtime.hooks import dispatch_tool
 from latticeai.services.tool_dispatch import enforce_tool_policy
-from tools import (
+from latticeai.tools import (
     AGENT_ROOT,
     ToolError,
     computer_click,
@@ -118,9 +118,39 @@ def create_computer_use_router(
     save_to_history,
     hooks=None,
     append_audit_event=None,
+    workspace_service=None,
 ) -> APIRouter:
     router = APIRouter()
 
+    def _requested_workspace(request: Request) -> Optional[str]:
+        header = request.headers.get("X-Workspace-Id")
+        if header and header.strip():
+            return header.strip()
+        query = request.query_params.get("workspace_id")
+        return query.strip() if query and query.strip() else None
+
+    def _write_workspace(request: Request, current_user: str) -> Optional[str]:
+        """Resolve only the CU agent's durable write scope.
+
+        The other ``/cu`` actions remain host operations and do not acquire a
+        workspace dependency.  A no-auth local request without an explicit
+        scope preserves its legacy unscoped history behavior; explicit scopes
+        and every authenticated request go through the normal write gate.
+        """
+
+        requested = _requested_workspace(request)
+        if workspace_service is None:
+            return requested
+        if not current_user and requested is None:
+            return None
+        try:
+            return workspace_service.resolve_write_scope(
+                requested,
+                current_user or None,
+            )
+        except PermissionError as exc:
+            raise HTTPException(status_code=403, detail=str(exc)) from exc
+
     def _audit_args(name: str, args: dict) -> dict:
         """Return audit-safe argument metadata without storing typed text."""
         args = dict(args or {})
@@ -171,13 +201,25 @@ def create_computer_use_router(
 
     @router.get("/tools/chrome_status")
     async def tools_chrome_status(request: Request):
-        require_user(request)
-        return tool_response(desktop_bridge_status)
+        current_user = require_user(request)
+        result = _dispatch(
+            "chrome_status",
+            {},
+            desktop_bridge_status,
+            current_user=current_user,
+        )
+        return _response(result)
 
     @router.get("/tools/computer_use_status")
     async def tools_computer_use_status(request: Request):
-        require_user(request)
-        return tool_response(computer_status)
+        current_user = require_user(request)
+        result = _dispatch(
+            "computer_use_status",
+            {},
+            computer_status,
+            current_user=current_user,
+        )
+        return _response(result)
 
     @router.get("/cu/status")
     async def cu_status(request: Request):
@@ -294,6 +336,17 @@ def create_computer_use_router(
     @router.post("/cu/agent")
     async def cu_agent(req: CuAgentRequest, request: Request):
         current_user = require_user(request)
+        workspace_id = _write_workspace(request, current_user)
+
+        def _save_completed(role: str, message: str) -> None:
+            save_to_history(
+                role,
+                message,
+                source="web",
+                conversation_id=req.conversation_id,
+                user_email=current_user,
+                workspace_id=workspace_id,
+            )
 
         async def _stream():
             task_lower = (req.task or "").lower()
@@ -336,8 +389,8 @@ def create_computer_use_router(
                         yield _send("result", {"step": 1, "action": "computer_open_app", "result": result})
                         message = "Google Chrome을 열었습니다."
                         action_name = "computer_open_app"
-                    save_to_history("user", req.task, source="web", conversation_id=req.conversation_id)
-                    save_to_history("assistant", message, source="web", conversation_id=req.conversation_id)
+                    _save_completed("user", req.task)
+                    _save_completed("assistant", message)
                     yield _send("final", {"message": message, "steps": [{"step": 1, "action": action_name, "result": result}]})
                 except HTTPException as exc:
                     yield _send("tool_error", {"step": 1, "action": "computer_open_app", "error": str(exc.detail)})
@@ -378,8 +431,8 @@ def create_computer_use_router(
                 args = action.get("args") or {}
                 if name == "final":
                     message = action.get("message", "작업을 완료했습니다.")
-                    save_to_history("user", req.task, source="web", conversation_id=req.conversation_id)
-                    save_to_history("assistant", message, source="web", conversation_id=req.conversation_id)
+                    _save_completed("user", req.task)
+                    _save_completed("assistant", message)
                     yield _send("final", {"message": message, "steps": transcript})
                     return