ltcai 8.2.0 → 8.4.0

package/lattice_brain/workflow.py

@@ -27,7 +27,7 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
-from lattice_brain.runtime.contracts import workflow_run_contract
+from lattice_brain.runtime.contracts import runtime_boundary_contract, workflow_run_contract
 
 
 WORKFLOW_ENGINE_VERSION = "2.2.0"
@@ -106,6 +106,11 @@ def normalize_definition(workflow: Dict[str, Any]) -> Dict[str, Any]:
     }
 
 
+def legacy_steps_from_nodes(nodes: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Return the compact legacy ``steps`` projection for node workflows."""
+    return [{"action": node.get("type"), "node": node.get("id")} for node in nodes]
+
+
 def validate_definition(workflow: Dict[str, Any]) -> List[str]:
     """Return a list of validation errors ([] means valid)."""
     errors: List[str] = []
@@ -269,6 +274,26 @@ class WorkflowEngine:
         # against the workflow lifecycle actually executes.
         self.hooks = hooks
 
+    def boundary(self) -> Dict[str, Any]:
+        return runtime_boundary_contract(
+            name="WorkflowEngine",
+            runtime="workflow",
+            entrypoint="lattice_brain.workflow.WorkflowEngine",
+            surface="/workflows",
+            owns="typed workflow validation, execution, approval suspension, resume, export, and import",
+        )
+
+    def config(self) -> Dict[str, Any]:
+        return {
+            "version": WORKFLOW_ENGINE_VERSION,
+            "boundary": self.boundary(),
+            "node_types": list(NODE_TYPES),
+            "runner_families": dict(_RUNNER_FOR),
+            "max_steps": _MAX_STEPS,
+            "approval_suspend": True,
+            "legacy_steps_projection": "lattice_brain.workflow.legacy_steps_from_nodes",
+        }
+
     def run(self, workflow: Dict[str, Any], *, inputs: Optional[Dict[str, Any]] = None) -> WorkflowRun:
         definition = normalize_definition(workflow)
         errors = validate_definition(definition)

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "8.2.0"
+__version__ = "8.4.0"

package/latticeai/api/chat.py

@@ -123,6 +123,90 @@ def is_current_url_request(text: str) -> bool:
 def is_clear_command(text: str) -> bool:
     return (text or "").strip().lower() in {"/clear", "/clear_all"}
 
+# Path segments intentionally exclude spaces: allowing spaces let the target
+# match swallow preceding words (e.g. "create a text file report.txt" resolved
+# to the whole phrase as the path). Chat file targets are single tokens.
+_FILE_TARGET_RE = re.compile(
+    r"(?<![\w.-])(?:[~./\\]?[\w.@()+-]+[\\/])*[\w.@()+-]+"
+    r"\.(?:py|js|jsx|ts|tsx|md|markdown|txt|json|yaml|yml|toml|html|css|csv|xml|pdf|docx|xlsx|pptx|sh|sql)",
+    re.IGNORECASE,
+)
+
+
+def is_file_action_request(text: str) -> bool:
+    """Return True for chat requests that should execute file tools, not prose.
+
+    The Brain chat composer posts to ``/chat``. Without this gate, explicit
+    side-effect requests such as "create hello.md" are handled as plain model
+    generation, which commonly produces a code block instead of a real file.
+    Keep the gate narrow so normal Q&A and "how do I create a file?" stay in
+    ordinary chat.
+    """
+    raw = (text or "").strip()
+    if not raw:
+        return False
+    lower = raw.lower()
+
+    if any(phrase in lower for phrase in (
+        "how to ", "how do i ", "방법", "어떻게", "예시", "sample", "example",
+    )) and not any(phrase in lower for phrase in (
+        "actually create", "real file", "실제로", "파일로", "저장해", "만들어",
+    )):
+        return False
+
+    has_target = bool(_FILE_TARGET_RE.search(raw))
+    has_file_word = any(word in lower for word in (
+        "file", "파일", "문서", "artifact", "아티팩트", "save as", "저장",
+    ))
+    has_action = any(word in lower for word in (
+        "create", "make", "write", "save", "generate", "edit", "update",
+        "만들", "생성", "작성", "저장", "수정", "써줘", "만들어줘",
+    ))
+
+    if not has_action:
+        return False
+    if has_target and has_action:
+        return True
+    return has_file_word and has_action
+
+
+def file_action_target(text: str) -> Optional[str]:
+    """Extract the first explicit workspace file target from a request."""
+    match = _FILE_TARGET_RE.search(text or "")
+    if not match:
+        return None
+    return match.group(0).strip().strip("`'\".,:;)]}")
+
+
+def inline_file_action_content(text: str) -> Optional[str]:
+    """Extract short user-provided content for deterministic file writes."""
+    raw = (text or "").strip()
+    # Each pattern requires an explicit binder so ambiguous words like "text"
+    # ("create a text file report.txt") or a bare "with" ("report.md with a
+    # summary of X") do not get captured as literal file content.
+    patterns = [
+        r"(?:내용|본문)\s*(?:은|는|이에요|입니다)\s*(.+)$",
+        r"(?:내용|본문|content|body|text)\s*[:=]\s*(.+)$",
+        r"(?:content|body)\s+(?:is|as)\s+(.+)$",
+        r"(?:with the content|with content|containing)\s+(.+)$",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, raw, flags=re.IGNORECASE | re.DOTALL)
+        if match:
+            content = match.group(1).strip()
+            return content.strip("`'\"")
+    return None
+
+
+def strip_generated_file_content(text: str) -> str:
+    """Remove common chat wrappers when a model is asked for file content only."""
+    content = (text or "").strip()
+    fenced = re.search(r"```(?:[\w.+-]+)?\s*(.*?)\s*```", content, flags=re.DOTALL)
+    if fenced:
+        content = fenced.group(1).strip()
+    return content
+
+
 def format_network_status(info: Dict) -> str:
     lines = [
         f"내부 IP: {info.get('local_ip') or '확인 안 됨'}",
@@ -243,11 +327,11 @@ def create_chat_router(context: AppContext) -> APIRouter:
             user_email=user_email,
             conversation_id=conversation_id,
         )
-    
+
     def extract_screenshot_context(image_data: Optional[str]) -> str:
         if not image_data:
             return ""
-    
+
         lines = ["[SCREENSHOT INGESTION]"]
         image_bytes = b""
         try:
@@ -258,18 +342,18 @@ def create_chat_router(context: AppContext) -> APIRouter:
         except Exception as e:
             lines.append(f"- image_decode_error: {e}")
             return "\n".join(lines)
-    
+
         tesseract_path = shutil.which("tesseract")
         if not tesseract_path:
             lines.append("- ocr: unavailable; install `tesseract` to enable OCR text extraction.")
             return "\n".join(lines)
-    
+
         temp_path = None
         try:
             with tempfile.NamedTemporaryFile(prefix="ltcai-screenshot-", suffix=".png", delete=False) as temp:
                 temp.write(image_bytes)
                 temp_path = temp.name
-    
+
             ocr_text = ""
             for lang in ("kor+eng", "eng"):
                 completed = subprocess.run(
@@ -283,7 +367,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
                     ocr_text = completed.stdout.strip()
                     lines.append(f"- ocr_language: {lang}")
                     break
-    
+
             if ocr_text:
                 lines.append("- ocr_text:")
                 lines.append(ocr_text[:4000])
@@ -297,7 +381,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
                     Path(temp_path).unlink()
                 except OSError:
                     pass
-    
+
         return "\n".join(lines)
 
     _AGENT_RUNTIME = context.chat_agent_runtime
@@ -329,7 +413,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
             "conversation_id": req.conversation_id,
             "workspace_id": workspace_scope_from_request(request),
         }
-    
+
         if is_network_status_request(req.message):
             history_message = f"{req.message}\n[Image attached]" if req.image_data else req.message
             save_to_history("user", history_message, **history_meta, **history_user)
@@ -347,7 +431,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
                     headers={"X-Model": "network_status"},
                 )
             return JSONResponse(content={"response": answer})
-    
+
         if is_clear_command(req.message):
             command = req.message.strip().lower()
             clear_scope = "all" if command == "/clear_all" else "conversation"
@@ -392,7 +476,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
                     headers={"X-Model": "history"},
                 )
             return JSONResponse(content={"response": answer})
-    
+
         if is_current_url_request(req.message) and req.client_url:
             answer = f"현재 페이지 URL: {req.client_url}"
             save_to_history("user", req.message, **history_meta, **history_user)
@@ -406,7 +490,74 @@ def create_chat_router(context: AppContext) -> APIRouter:
                     headers={"X-Model": "client_url"},
                 )
             return JSONResponse(content={"response": answer})
-    
+
+        if is_file_action_request(req.message):
+            target_path = file_action_target(req.message)
+            if target_path:
+                content = inline_file_action_content(req.message)
+                if content is None and router.current_model_id:
+                    if req.model and req.model != router.current_model_id:
+                        if req.model not in router.loaded_model_ids:
+                            raise HTTPException(status_code=404, detail=f"Model '{req.model}' not loaded.")
+                        router.switch_model(req.model)
+                    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 router.generate_as(
+                        router.current_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:
+                    content = ""
+                try:
+                    result = execute_tool("write_file", {"path": target_path, "content": content})
+                except ToolError 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",
+                }]
+                notify_chat_message("user", req.message, req.source)
+                notify_chat_message("assistant", answer, req.source)
+                payload = {
+                    "status": "ok",
+                    "response": answer,
+                    "workspace": str(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:
+                    async def _stream_file_result():
+                        yield f"data: {json.dumps({'chunk': answer, 'model': router.current_model_id, 'agent': payload}, ensure_ascii=False)}\n\n"
+                        yield f"data: {json.dumps({'chunk': '', 'model': router.current_model_id, 'agent': payload}, ensure_ascii=False)}\n\n"
+                        yield "data: [DONE]\n\n"
+                    return StreamingResponse(
+                        _stream_file_result(),
+                        media_type="text/event-stream",
+                        headers={"X-Model": router.current_model_id or "tool", "X-Routed-To": "agent"},
+                    )
+                return JSONResponse(content=payload)
+
         if not router.current_model_id:
             detail = "No model loaded. Call /models/load first."
             if CONFIG.is_public:
@@ -420,12 +571,40 @@ def create_chat_router(context: AppContext) -> APIRouter:
                     "action": "load_model",
                 },
             )
-    
+
         if req.model and req.model != router.current_model_id:
             if req.model not in router.loaded_model_ids:
                 raise HTTPException(status_code=404, detail=f"Model '{req.model}' not loaded.")
             router.switch_model(req.model)
-    
+
+        if is_file_action_request(req.message):
+            agent_req = 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_scope_from_request(request),
+            )
+            result = await agent(agent_req, request)
+            answer = str(result.get("response") or "파일 작업을 처리했습니다.")
+            notify_chat_message("user", req.message, req.source)
+            notify_chat_message("assistant", answer, req.source)
+            result["routed_to_agent"] = True
+            if req.stream:
+                async def _stream_agent_result():
+                    yield f"data: {json.dumps({'chunk': answer, 'model': router.current_model_id, 'agent': result}, ensure_ascii=False)}\n\n"
+                    yield f"data: {json.dumps({'chunk': '', 'model': router.current_model_id, 'agent': result}, ensure_ascii=False)}\n\n"
+                    yield "data: [DONE]\n\n"
+                return StreamingResponse(
+                    _stream_agent_result(),
+                    media_type="text/event-stream",
+                    headers={"X-Model": router.current_model_id, "X-Routed-To": "agent"},
+                )
+            return JSONResponse(content=result)
+
         lang = detect_language(req.message)
         context = f"[LANGUAGE: {_LANG_HINT[lang]}]\n" + (req.context or "")
         # v4 Context System: one budgeted, provenance-carrying assembly
@@ -462,12 +641,12 @@ def create_chat_router(context: AppContext) -> APIRouter:
                     print("📝 Document generation context retrieved from knowledge graph.")
         except Exception as e:
             logging.warning("Knowledge graph reinforcement skipped: %s", e)
-    
+
         if req.image_data:
             screenshot_context = extract_screenshot_context(req.image_data)
             if screenshot_context:
                 context += f"\n\n{screenshot_context}"
-    
+
         if CONFIG.auto_read_chat_paths:
             _file_path_re = re.compile(r'(?:^|[\s\'\"(])((~|/[\w.])[^\s\'")\]]*)', re.MULTILINE)
             requested_paths = [_m.group(1).strip() for _m in _file_path_re.finditer(req.message or "")]
@@ -487,7 +666,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
                             "Attach the file, upload it, or use an approved local-file tool flow."
                         ),
                     )
-    
+
         trace_seed = CHAT_SERVICE.build_graph_trace(
             req.message,
             KNOWLEDGE_GRAPH if (ENABLE_GRAPH and KNOWLEDGE_GRAPH) else None,
@@ -497,11 +676,11 @@ def create_chat_router(context: AppContext) -> APIRouter:
             # Persisted with the answer trace: 'why is this in my context?'
             # is answerable from the stored record (UI surface lands in T9b).
             trace_seed["context_assembly"] = context_trace
-    
+
         history_message = f"{req.message}\n[Image attached]" if req.image_data else req.message
         save_to_history("user", history_message, **history_meta, **history_user)
         notify_chat_message("user", req.message, req.source)
-    
+
         if is_doc_gen and ENABLE_GRAPH and KNOWLEDGE_GRAPH:
             conv_key = req.conversation_id or "default"
             session = _doc_gen_sessions.get(conv_key)
@@ -512,7 +691,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
             system_prompt = session.get_system_prompt(graph_md)
             sources = (doc_gen_context_result or {}).get("sources", [])
             footnote = format_sources_footnote(sources)
-    
+
             if req.stream:
                 async def _stream_doc_gen():
                     collected = []
@@ -563,7 +742,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
                 )
                 notify_chat_message("assistant", str(result), req.source)
                 return JSONResponse(content={"response": str(result), "trace_id": trace_record["id"], "trace": trace_record})
-    
+
         if req.stream:
             recent_context = recent_chat_context(user_email=effective_email, conversation_id=req.conversation_id)
             stream_context = context
@@ -593,9 +772,9 @@ def create_chat_router(context: AppContext) -> APIRouter:
             else:
                 history_context = recent_chat_context(user_email=effective_email, conversation_id=req.conversation_id)
                 full_context = f"{history_context}\n{context}" if context else history_context
-    
+
             result = await router.generate(req.message, full_context, req.max_tokens, req.temperature, req.image_data)
-    
+
             save_to_history("assistant", str(result), **history_meta, **history_user)
             trace_record = CHAT_SERVICE.record_trace(
                 question=req.message,
@@ -605,22 +784,22 @@ def create_chat_router(context: AppContext) -> APIRouter:
                 trace=trace_seed,
             )
             notify_chat_message("assistant", str(result), req.source)
-    
+
             return JSONResponse(content={"response": str(result), "trace_id": trace_record["id"], "trace": trace_record})
-    
+
     
     @api_router.get("/history")
     async def fetch_history(request: Request):
         """웹 화면에서 이전 대화를 불러올 수 있도록 히스토리를 반환합니다."""
         require_user(request)
         return get_history()
-    
+
     @api_router.get("/history/conversations")
     async def fetch_history_conversations(request: Request):
         """저장된 히스토리를 대화 단위로 묶어 반환합니다."""
         require_user(request)
         return group_history_conversations()
-    
+
     @api_router.get("/history/conversations/{conversation_id:path}")
     async def fetch_history_conversation(conversation_id: str, request: Request):
         """선택한 대화의 메시지를 반환합니다."""
@@ -629,7 +808,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
         if not messages:
             raise HTTPException(status_code=404, detail="대화를 찾을 수 없습니다.")
         return {"id": conversation_id, "messages": messages}
-    
+
     
     @api_router.delete("/history/conversations/{conversation_id:path}")
     async def delete_history_conversation(conversation_id: str, request: Request):
@@ -645,7 +824,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
             kept=result.get("kept", 0),
         )
         return result
-    
+
     
     @api_router.delete("/history")
     async def delete_history(request: Request, keep_last: int = 0):
@@ -659,7 +838,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
             kept=result.get("kept", 0),
         )
         return result
-    
+
     @api_router.get("/history/search")
     async def search_history(q: str, request: Request):
         """키워드로 채팅 히스토리를 검색합니다."""
@@ -676,7 +855,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
                 grouped[cid] = {"conversation_id": cid, "title": conversation_title(item), "messages": []}
             grouped[cid]["messages"].append(item)
         return {"results": list(grouped.values())[-30:], "query": q}
-    
+
     async def _stream_chat(
         req: ChatRequest,
         context: str = "",
@@ -696,7 +875,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
                     clean_chunk = chunk.split("text='")[1].split("', token=")[0].replace('\\n', '\n').replace('\\\\n', '\n')
                 except Exception:
                     pass
-    
+
             full_response += str(clean_chunk)
             yield f"data: {json.dumps({'chunk': clean_chunk, 'model': router.current_model_id}, ensure_ascii=False)}\n\n"
         history_user = get_history_user(effective_email or req.user_email, req.user_nickname)
@@ -724,7 +903,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
         schema_path = skill_dir / "schema.json"
         if not schema_path.exists():
             raise HTTPException(404, detail=f"Skill '{req.skill}' not found or missing schema.json")
-    
+
         schema = json.loads(schema_path.read_text(encoding="utf-8"))
         eval_cases = schema.get("evals", [])
         if req.case_id:
@@ -732,7 +911,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
         if not eval_cases:
             return {"skill": req.skill, "total": 0, "passed": 0, "failed": 0, "results": [],
                     "message": "No eval cases defined in schema.json"}
-    
+
         action_name = schema.get("action", req.skill)
         results = []
         for case in eval_cases:
@@ -754,19 +933,19 @@ def create_chat_router(context: AppContext) -> APIRouter:
                 results.append({"id": case_id, "description": case.get("description", ""),
                                 "passed": False, "error": str(exc),
                                 "pass_criteria": case.get("pass_criteria", "")})
-    
+
         n_passed = sum(1 for r in results if r.get("passed") is True)
         return {
             "skill": req.skill, "action": action_name,
             "total": len(results), "passed": n_passed, "failed": len(results) - n_passed,
             "results": results,
         }
-    
+
     
     @api_router.post("/agent")
     async def agent(req: AgentRequest, request: Request):
         """Natural-language local agent.
-    
+
         State machine:
             IDLE → PLANNING → WAITING_APPROVAL → EXECUTING → VERIFYING
                                            ↓                     ↓
@@ -779,22 +958,22 @@ def create_chat_router(context: AppContext) -> APIRouter:
         req.workspace_id = req.workspace_id or workspace_scope_from_request(request)
         if not router.current_model_id:
             raise HTTPException(status_code=400, detail="No model loaded. Call /models/load first.")
-    
+
         ensure_agent_root()
         lang = detect_language(req.message)
         lang_hint = _LANG_HINT[lang]
         max_steps = max(1, min(req.max_steps, 50))
         max_retry = 3
-    
+
         ctx = AgentRunContext()
         ctx.executing_model = req.executing_model
         ctx.reviewing_model = req.reviewing_model
-    
+
         # PLANNING phase
         ctx.state = AgentState.PLANNING
         ctx.state_history.append(ctx.state.value)
         await _AGENT_RUNTIME.plan(ctx, req, lang_hint, current_user, model_id=req.planning_model)
-    
+
         # Human-in-the-loop: pause after planning, return plan to UI
         if req.human_in_loop:
             context_id = secrets.token_urlsafe(16)
@@ -810,11 +989,11 @@ def create_chat_router(context: AppContext) -> APIRouter:
                 "executing_model": req.executing_model or router.current_model_id,
                 "reviewing_model": req.reviewing_model or router.current_model_id,
             }
-    
+
         # Auto-approve and run to completion (default behaviour)
         _AGENT_RUNTIME.approve(ctx, current_user)
         return await _agent_finish(ctx, req, lang_hint, current_user, max_steps, max_retry)
-    
+
     
     async def _agent_finish(
         ctx: AgentRunContext, req: AgentRequest, lang_hint: str,
@@ -823,7 +1002,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
         """HTTP glue: drive the runtime to a terminal state, persist, shape the response."""
         await _AGENT_RUNTIME.run_to_completion(ctx, req, lang_hint, current_user, max_steps, max_retry)
         asyncio.create_task(_AGENT_RUNTIME.memory_update(ctx, req, current_user))
-    
+
         message = ctx.final_message or "작업을 완료했습니다."
         save_to_history("user", req.message, source=req.source or "web", conversation_id=req.conversation_id, workspace_id=req.workspace_id)
         save_to_history("assistant", message, source=req.source or "web", conversation_id=req.conversation_id, workspace_id=req.workspace_id)
@@ -850,33 +1029,33 @@ def create_chat_router(context: AppContext) -> APIRouter:
             "final_state": ctx.state.value,
             "created_files": created_files,
         }
-    
+
     
     @api_router.post("/agent/resume")
     async def agent_resume(req: AgentResumeRequest, request: Request):
         """Resume a paused agent after human approval of the plan."""
         current_user = require_user(request)
-    
+
         with _pending_agents_lock:
             entry = _pending_agents.pop(req.context_id, None)
         if not entry:
             raise HTTPException(status_code=404, detail="Agent context not found or expired. Start a new request.")
-    
+
         ctx, orig_req, lang_hint, _orig_user = entry
-    
+
         if not req.approved:
             return {"status": "cancelled", "response": "사용자가 계획을 취소했습니다."}
-    
+
         if req.modified_plan:
             ctx.plan = req.modified_plan
             ctx.transcript[-1].update(ctx.plan)  # keep transcript in sync
-    
+
         # Apply model overrides from resume request (takes priority over original request)
         ctx.executing_model = req.executing_model or ctx.executing_model
         ctx.reviewing_model = req.reviewing_model or ctx.reviewing_model
-    
+
         _AGENT_RUNTIME.approve(ctx, current_user)
-    
+
         max_steps = max(1, min(orig_req.max_steps, 50))
         max_retry = 3
         return await _agent_finish(ctx, orig_req, lang_hint, current_user, max_steps, max_retry)

package/latticeai/api/knowledge_graph.py

@@ -13,6 +13,7 @@ from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
 
 from latticeai.api.ui_redirects import app_redirect
+from lattice_brain.ingestion import IngestionItem
 
 
 class KnowledgeGraphIngestRequest(BaseModel):
@@ -61,6 +62,7 @@ def create_knowledge_graph_router(
     require_user: Callable[[Request], str],
     static_dir: Path,
     allowed_workspaces_for: Optional[Callable[[Optional[str]], Any]] = None,
+    ingestion_pipeline: Any = None,
 ) -> APIRouter:
     router = APIRouter()
 
@@ -191,6 +193,37 @@ def create_knowledge_graph_router(
         if event_type not in {"message", "ai_response", "note"}:
             raise HTTPException(status_code=400, detail="지원하는 type: message, ai_response, note")
         role = req.role or ("assistant" if event_type == "ai_response" else "user")
+        if ingestion_pipeline is not None:
+            source_type = "chat_message" if event_type in {"message", "ai_response"} else "note"
+            result = ingestion_pipeline.ingest(
+                IngestionItem(
+                    source_type=source_type,
+                    title=req.title,
+                    text=req.content,
+                    source_uri=req.source,
+                    owner=req.user_email or current_user,
+                    workspace_id=workspace_id,
+                    conversation_id=req.conversation_id,
+                    metadata={
+                        "type": req.type,
+                        "role": role,
+                        "source": req.source or "mcp",
+                        "user_nickname": req.user_nickname,
+                        "raw": {
+                            "type": req.type,
+                            "title": req.title,
+                            "content": req.content,
+                            "workspace_id": workspace_id,
+                            "metadata": req.metadata or {},
+                        },
+                        **(req.metadata or {}),
+                    },
+                ),
+                user_email=req.user_email or current_user,
+            )
+            if result.status != "ok":
+                raise HTTPException(status_code=500, detail=result.detail or result.status)
+            return result.as_dict()
         return kg.ingest_message(
             role,
             req.content,