ltcai 6.0.0 → 6.2.0

package/latticeai/app_factory.py

@@ -17,7 +17,6 @@ from __future__ import annotations
 import threading
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
-from latticeai.runtime.automation_runtime import build_automation_runtime
 from latticeai.runtime.app_context_runtime import build_app_context
 from latticeai.runtime.bootstrap import build_session_runtime
 from latticeai.runtime.brain_runtime import build_brain_runtime
@@ -33,6 +32,7 @@ from latticeai.runtime.platform_services_runtime import (
     build_brain_network,
     build_model_service,
 )
+from latticeai.runtime.platform_runtime_wiring import build_platform_automation_runtime
 from latticeai.runtime.persistence_runtime import build_persistence_runtime
 from latticeai.runtime.router_registration import (
     build_auth_admin_security_router_bundle,
@@ -45,6 +45,7 @@ from latticeai.runtime.router_registration import (
 )
 from latticeai.runtime.security_runtime import build_security_runtime
 from latticeai.runtime.web_runtime import build_web_runtime
+from latticeai.services.router_context import InteractionRouterContext, ToolRouterContext
 
 if TYPE_CHECKING:  # imports for annotations only — keep module import light
     from fastapi import FastAPI
@@ -145,7 +146,6 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from latticeai.api.workspace import create_workspace_router, _workspace_scope_from_request
     from latticeai.api.health import create_health_router
     # ── v2 Agentic Workspace Platform layers ─────────────────────────────────────
-    from latticeai.services.platform_runtime import PlatformRuntime
     from latticeai.api.plugins import create_plugins_router
     from latticeai.api.workflow_designer import create_workflow_designer_router
     from latticeai.api.agents import create_agents_router
@@ -153,7 +153,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from latticeai.api.invitations import create_invitations_router
     from latticeai.api.marketplace import create_marketplace_router
     from latticeai.api.models import create_models_router
-    from latticeai.api.chat import create_chat_router
+    from latticeai.api.chat import build_recent_chat_context, create_chat_router
     from latticeai.api.search import create_search_router
     from latticeai.api.tools import create_tools_router
     from latticeai.api.static_routes import create_static_routes_router
@@ -181,6 +181,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         configure_tool_dispatch,
         get_tool_permission,
         list_tool_permissions,
+        build_agent_runtime,
         tool_response as _tool_response,
     )
     from latticeai.core.tool_registry import TOOL_CATALOG_BRIEF as _TOOL_CATALOG_BRIEF  # noqa: F401
@@ -188,9 +189,9 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         _get_combined_registry,
         _fetch_skills_marketplace, install_skill, SKILLS_DIR,
     )
-    from p_reinforce import PReinforceGardener
+    from latticeai.services.p_reinforce import PReinforceGardener
     from setup_wizard import get_recommendations, scan_environment
-    from tools import ensure_agent_root
+    from tools import ensure_agent_root, execute_tool, knowledge_save
 
     try:
         import keyring
@@ -1238,10 +1239,35 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     on_chat_message = None
     if ENABLE_TELEGRAM:
         def _telegram_chat_mirror(role: str, text: str, source: Optional[str] = None) -> None:
-            from telegram_bot import broadcast_web_chat
+            from latticeai.integrations.telegram_bot import broadcast_web_chat
             _spawn(broadcast_web_chat(role, text), name="telegram_broadcast")
         on_chat_message = _telegram_chat_mirror
 
+    def _recent_chat_context(
+        limit: int = 10,
+        include_image_missing_replies: bool = True,
+        user_email: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+    ) -> str:
+        return build_recent_chat_context(
+            get_history=get_history,
+            limit=limit,
+            include_image_missing_replies=include_image_missing_replies,
+            user_email=user_email,
+            conversation_id=conversation_id,
+        )
+
+    CHAT_AGENT_RUNTIME = build_agent_runtime(
+        model_router=router,
+        execute_tool=execute_tool,
+        recent_chat_context=_recent_chat_context,
+        clear_history=clear_history,
+        knowledge_save=knowledge_save,
+        audit=append_audit_event,
+        hooks=HOOKS_REGISTRY,
+        brain_memory=BRAIN_MEMORY,
+    )
+
     # ── Typed dependency context (latticeai.services.app_context) ────────────────
     # One context object replaces the historical 25-30-kwarg router wiring.
     context = build_app_context(
@@ -1258,6 +1284,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         chat_service=CHAT_SERVICE,
         context_assembler=CONTEXT_ASSEMBLER,
         brain_memory=BRAIN_MEMORY,
+        chat_agent_runtime=CHAT_AGENT_RUNTIME,
         gardener=gardener,
         hooks=HOOKS_REGISTRY,
         realtime_bus=REALTIME_BUS,
@@ -1311,20 +1338,9 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
 
 
     # ── v2 Agentic Workspace Platform: cross-system wiring ───────────────────────
-    # All cross-subsystem closures live in latticeai.services.platform_runtime to
-    # keep this assembly file lean; server_app only constructs it and mounts routers.
-    def _llm_generate_sync(message: str, context: str = "", max_tokens: int = 1024, temperature: float = 0.1) -> str:
-        # Synchronous model bridge for the orchestrator's role runner. Safe
-        # because the agents run endpoint executes start() in a worker thread
-        # (asyncio.to_thread), where no event loop is running.
-        import asyncio as _asyncio
-
-        return str(_asyncio.run(router.generate(
-            message, context=context, max_tokens=max_tokens, temperature=temperature,
-        )))
-
-    PLATFORM = PlatformRuntime(
-        store=WORKSPACE_OS,
+    _platform_automation_runtime = build_platform_automation_runtime(
+        model_router=router,
+        workspace_store=WORKSPACE_OS,
         workspace_service=WORKSPACE_SERVICE,
         plugin_registry=PLUGIN_REGISTRY,
         get_current_user=get_current_user,
@@ -1332,23 +1348,17 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         workspace_scope_from_request=_workspace_scope_from_request,
         get_tool_permission=get_tool_permission,
         hooks=HOOKS_REGISTRY,
-        llm_generate=_llm_generate_sync,
-        llm_available=lambda: bool(getattr(router, "current_model_id", None)),
         agent_registry=AGENT_REGISTRY,
-    )
-
-    _automation_runtime = build_automation_runtime(
-        store=WORKSPACE_OS,
-        platform=PLATFORM,
         data_dir=DATA_DIR,
-        workspace_graph=_workspace_graph,
         append_audit_event=append_audit_event,
-        hooks=HOOKS_REGISTRY,
     )
-    REVIEW_QUEUE = _automation_runtime["REVIEW_QUEUE"]
-    TRIGGER_SERVICE = _automation_runtime["TRIGGER_SERVICE"]
-    AGENT_RUNTIME = _automation_runtime["AGENT_RUNTIME"]
-    RUN_EXECUTOR = _automation_runtime["RUN_EXECUTOR"]
+    _llm_generate_sync = _platform_automation_runtime["_llm_generate_sync"]
+    PLATFORM = _platform_automation_runtime["PLATFORM"]
+    _automation_runtime = _platform_automation_runtime["_automation_runtime"]
+    REVIEW_QUEUE = _platform_automation_runtime["REVIEW_QUEUE"]
+    TRIGGER_SERVICE = _platform_automation_runtime["TRIGGER_SERVICE"]
+    AGENT_RUNTIME = _platform_automation_runtime["AGENT_RUNTIME"]
+    RUN_EXECUTOR = _platform_automation_runtime["RUN_EXECUTOR"]
     bind_trigger_hook_runner(registry=HOOKS_REGISTRY, trigger_service=TRIGGER_SERVICE)
     app.state.run_executor = RUN_EXECUTOR
     app.state.run_reconciliation = RUN_EXECUTOR.reconcile_startup()
@@ -1451,21 +1461,13 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             return None
         return PLATFORM.allowed_scopes(user)
 
-    register_interaction_routers(
-        app,
-        create_chat_router=create_chat_router,
-        context=context,
-        create_search_router=create_search_router,
-        search_service=SEARCH_SERVICE,
-        allowed_workspaces_for=_allowed_workspaces_for,
-        require_user=require_user,
-        embedding_info=_embedding_info,
-        create_tools_router=create_tools_router,
-        ingestion_pipeline=INGESTION_PIPELINE,
+    tool_router_context = ToolRouterContext(
         config=CONFIG,
+        ingestion_pipeline=INGESTION_PIPELINE,
         data_dir=DATA_DIR,
         static_dir=STATIC_DIR,
         model_router=router,
+        require_user=require_user,
         require_admin=require_admin,
         get_current_user=get_current_user,
         clear_history=clear_history,
@@ -1483,13 +1485,29 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         install_mcp=install_mcp,
         mcp_public_item=mcp_public_item,
         hooks=HOOKS_REGISTRY,
-        create_hooks_router=create_hooks_router,
-        create_agent_registry_router=create_agent_registry_router,
+    )
+    interaction_router_context = InteractionRouterContext(
+        chat_context=context,
+        search_service=SEARCH_SERVICE,
+        allowed_workspaces_for=_allowed_workspaces_for,
+        require_user=require_user,
+        embedding_info=_embedding_info,
+        tool_context=tool_router_context,
+        hooks=HOOKS_REGISTRY,
         agent_registry=AGENT_REGISTRY,
-        create_memory_router=create_memory_router,
         memory_service=MEMORY_SERVICE,
         platform=PLATFORM,
     )
+    register_interaction_routers(
+        app,
+        interaction_context=interaction_router_context,
+        create_chat_router=create_chat_router,
+        create_search_router=create_search_router,
+        create_tools_router=create_tools_router,
+        create_hooks_router=create_hooks_router,
+        create_agent_registry_router=create_agent_registry_router,
+        create_memory_router=create_memory_router,
+    )
 
     from latticeai.api.review_queue import create_review_queue_router
 

package/latticeai/cli/__init__.py

@@ -0,0 +1 @@
+"""LatticeAI CLI package."""

package/latticeai/cli/entrypoint.py

@@ -0,0 +1,283 @@
+"""Command line entrypoint for Lattice AI."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import platform
+import re
+import shutil
+import socket
+import stat
+import subprocess
+import sys
+import threading
+import time
+import urllib.request
+from pathlib import Path
+
+from latticeai.cli.runtime import (
+    _apply_extra_path,
+    _has_module,
+    _load_env_file,
+)
+
+def _local_ips() -> list[str]:
+    ips: list[str] = []
+    try:
+        hostname = socket.gethostname()
+        for info in socket.getaddrinfo(hostname, None):
+            addr = info[4][0]
+            if ":" not in addr and not addr.startswith("127."):
+                if addr not in ips:
+                    ips.append(addr)
+    except Exception:
+        pass
+    if not ips:
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            s.connect(("8.8.8.8", 80))
+            ips.append(s.getsockname()[0])
+            s.close()
+        except Exception:
+            pass
+    return ips
+
+
+def _print_banner(host: str, port: int, tunnel_url: str | None = None) -> None:
+    local_url = f"http://localhost:{port}"
+    print()
+    print("=" * 56)
+    print("  Lattice AI is running")
+    print(f"  Local:    {local_url}")
+    if host == "0.0.0.0":
+        for ip in _local_ips():
+            print(f"  Network:  http://{ip}:{port}")
+        print()
+        print("  Other devices on the same Wi-Fi can open the")
+        print("  Network URL above in their browser.")
+        print("  On iPad/Android: browser menu → 'Add to Home Screen'")
+    if tunnel_url:
+        print()
+        print(f"  Tunnel:   {tunnel_url}")
+        print("  Anyone on the internet can access via the Tunnel URL.")
+    print("=" * 56)
+    print()
+
+
+def doctor() -> int:
+    checks = [
+        ("Python 3.11+", sys.version_info >= (3, 11), sys.version.split()[0], True),
+        ("FastAPI", _has_module("fastapi"), "required server dependency", True),
+        ("Uvicorn", _has_module("uvicorn"), "required server dependency", True),
+        ("OpenAI SDK", _has_module("openai"), "required for cloud providers", False),
+        ("MLX", _has_module("mlx"), "required for Apple Silicon multimodal models", False),
+        ("MLX-VLM", _has_module("mlx_vlm"), "required for Gemma-4/VLM models", False),
+        ("Ollama binary", shutil.which("ollama") is not None, "optional local-server engine", False),
+    ]
+    data_dir = Path(os.getenv("LATTICEAI_DATA_DIR") or Path.home() / ".ltcai")
+    static_dir = Path(os.getenv("LATTICEAI_STATIC_DIR") or Path(__file__).resolve().parent / "static")
+    checks.extend([
+        ("Data dir", data_dir.exists() or data_dir.parent.exists(), str(data_dir), True),
+        ("Static UI", static_dir.exists(), str(static_dir), True),
+    ])
+
+    ok = True
+    for label, passed, detail, required in checks:
+        icon = "OK" if passed else ("MISS" if required else "OPTIONAL")
+        print(f"[{icon}] {label}: {detail}")
+        ok = ok and (passed or not required)
+
+    cloud_keys = ["OPENAI_API_KEY", "OPENROUTER_API_KEY", "GROQ_API_KEY", "TOGETHER_API_KEY"]
+    configured = [key for key in cloud_keys if os.getenv(key)]
+    print(f"[INFO] Cloud keys configured: {', '.join(configured) if configured else 'none'}")
+    return 0 if ok else 1
+
+
+# ── Cloudflare Tunnel ─────────────────────────────────────────────────────────
+
+def _cloudflared_url() -> str:
+    system = sys.platform
+    machine = platform.machine().lower()
+    base = "https://github.com/cloudflare/cloudflared/releases/latest/download"
+    if system == "darwin":
+        arch = "arm64" if machine in ("arm64", "aarch64") else "amd64"
+        return f"{base}/cloudflared-darwin-{arch}"
+    if system == "win32":
+        return f"{base}/cloudflared-windows-amd64.exe"
+    arch = "arm64" if machine in ("arm64", "aarch64") else "amd64"
+    return f"{base}/cloudflared-linux-{arch}"
+
+
+def _cloudflared_bin() -> Path:
+    suffix = ".exe" if sys.platform == "win32" else ""
+    return Path.home() / ".latticeai" / "bin" / f"cloudflared{suffix}"
+
+
+def _ensure_cloudflared() -> str:
+    found = shutil.which("cloudflared")
+    if found:
+        return found
+    dest = _cloudflared_bin()
+    if dest.exists():
+        return str(dest)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    url = _cloudflared_url()
+    print("  cloudflared not found — downloading from GitHub...")
+    try:
+        urllib.request.urlretrieve(url, dest)
+        if sys.platform != "win32":
+            dest.chmod(dest.stat().st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+        print(f"  cloudflared installed at {dest}")
+        return str(dest)
+    except Exception as e:
+        print(f"  cloudflared download failed: {e}")
+        print("  Install manually: https://developers.cloudflare.com/cloudflared/install")
+        return ""
+
+
+def _send_telegram(token: str, chat_id: str, text: str) -> None:
+    try:
+        data = urllib.parse.urlencode({"chat_id": chat_id, "text": text}).encode()
+        req = urllib.request.Request(
+            f"https://api.telegram.org/bot{token}/sendMessage",
+            data=data,
+        )
+        urllib.request.urlopen(req, timeout=10)
+    except Exception:
+        pass
+
+
+def _start_tunnel(port: int) -> str | None:
+
+    bin_path = _ensure_cloudflared()
+    if not bin_path:
+        return None
+
+    log_path = Path.home() / ".latticeai" / "tunnel.log"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    proc = subprocess.Popen(
+        [bin_path, "tunnel", "--url", f"http://localhost:{port}"],
+        stdout=open(log_path, "w"),
+        stderr=subprocess.STDOUT,
+    )
+
+    # Wait for the public URL (up to 30s)
+    pattern = re.compile(r"https://[a-z0-9-]+\.trycloudflare\.com")
+    deadline = time.time() + 30
+    url: str | None = None
+    while time.time() < deadline:
+        time.sleep(0.5)
+        try:
+            text = log_path.read_text(errors="replace")
+            m = pattern.search(text)
+            if m:
+                url = m.group(0)
+                break
+        except Exception:
+            pass
+
+    if not url:
+        return None
+
+    # Telegram notification if configured
+    token = os.getenv("LATTICEAI_TELEGRAM_BOT_TOKEN", "")
+    chat_id = os.getenv("LATTICEAI_TELEGRAM_CHAT_ID", "")
+    if token and chat_id:
+        msg = (
+            f"✅ Lattice AI 시작됨\n\n"
+            f"🌐 외부 URL: {url}\n"
+            f"🏠 로컬: http://localhost:{port}"
+        )
+        threading.Thread(target=_send_telegram, args=(token, chat_id, msg), daemon=True).start()
+
+    return url
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    app_dir = Path(__file__).resolve().parent
+    _load_env_file(app_dir / ".env")
+    _apply_extra_path()
+
+    parser = argparse.ArgumentParser(prog="LTCAI", description="Run the Lattice AI local server.")
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("doctor", help="Check local runtime dependencies and configuration.")
+    parser.add_argument("--host", default=os.getenv("LATTICEAI_HOST") or "127.0.0.1")
+    parser.add_argument("--port", type=int, default=int(os.getenv("LATTICEAI_PORT") or "4825"))
+    parser.add_argument("--reload", action="store_true", help="Enable uvicorn reload for local development.")
+    parser.add_argument(
+        "--tunnel",
+        action="store_true",
+        help="Open a public Cloudflare tunnel so anyone can access this server from the internet.",
+    )
+    args = parser.parse_args()
+
+    if args.command == "doctor":
+        raise SystemExit(doctor())
+
+    os.chdir(app_dir)
+
+    if not args.tunnel and os.getenv("LATTICEAI_TUNNEL", "").lower() in (
+        "1",
+        "true",
+        "yes",
+    ):
+        print(
+            "  LATTICEAI_TUNNEL is ignored during default local startup; "
+            "restart with --tunnel to expose this server."
+        )
+
+    # --tunnel forces 0.0.0.0 so cloudflared can reach the server
+    if args.tunnel and args.host == "127.0.0.1":
+        args.host = "0.0.0.0"
+        os.environ.setdefault("LATTICEAI_HOST", "0.0.0.0")
+        os.environ.setdefault("LATTICEAI_CORS_ALLOW_NETWORK", "true")
+        os.environ.setdefault("LATTICEAI_REQUIRE_AUTH", "true")
+
+    # Keep the app config in sync with CLI flags. ``Config.from_env`` is the
+    # source of truth for /mode, /health.features, SSO defaults, and routers.
+    os.environ["LATTICEAI_HOST"] = str(args.host)
+    os.environ["LATTICEAI_PORT"] = str(args.port)
+
+    tunnel_url: str | None = None
+    if args.tunnel:
+        print()
+        print("  Starting Cloudflare tunnel...")
+        tunnel_url = _start_tunnel(args.port)
+        if not tunnel_url:
+            print("  ⚠️  Tunnel URL not obtained — server will start without tunnel.")
+
+    _print_banner(args.host, args.port, tunnel_url)
+
+    # Telegram startup notification (local start, tunnel handled separately inside _start_tunnel)
+    if not args.tunnel:
+        _tg_enabled = os.getenv("LATTICEAI_ENABLE_TELEGRAM", "").strip().lower() in ("1", "true", "yes", "on")
+        _tg_token = os.getenv("LATTICEAI_TELEGRAM_BOT_TOKEN", "")
+        _tg_chat  = os.getenv("LATTICEAI_TELEGRAM_CHAT_ID", "")
+        if _tg_enabled and _tg_token and _tg_chat:
+            _local_msg = (
+                f"✅ Lattice AI 시작됨\n\n"
+                f"🏠 로컬: http://localhost:{args.port}"
+            )
+            threading.Thread(
+                target=_send_telegram,
+                args=(_tg_token, _tg_chat, _local_msg),
+                daemon=True,
+            ).start()
+
+    import uvicorn
+
+    uvicorn.run(
+        "server:app",
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        log_level="info",
+    )
+
+
+if __name__ == "__main__":
+    main()

package/latticeai/cli/runtime.py

@@ -0,0 +1,37 @@
+"""Pure runtime helpers extracted from ltcai_cli entrypoint."""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+from pathlib import Path
+
+
+def _load_env_file(path: Path) -> None:
+    if not path.exists():
+        return
+    for raw_line in path.read_text(encoding="utf-8").splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        key = key.strip()
+        value = value.strip().strip('"').strip("'")
+        if key and key not in os.environ:
+            os.environ[key] = value
+
+
+def _apply_extra_path() -> None:
+    extra = os.getenv("LATTICEAI_EXTRA_PATH", "")
+    if not extra:
+        return
+    current = [p for p in os.environ.get("PATH", "").split(os.pathsep) if p]
+    for item in reversed([p for p in extra.split(os.pathsep) if p]):
+        expanded = str(Path(item).expanduser())
+        if Path(expanded).exists() and expanded not in current:
+            current.insert(0, expanded)
+    os.environ["PATH"] = os.pathsep.join(current)
+
+
+def _has_module(name: str) -> bool:
+    return importlib.util.find_spec(name) is not None

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "6.0.0"
+MARKETPLACE_VERSION = "6.2.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/workspace_os.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "6.0.0"
+WORKSPACE_OS_VERSION = "6.2.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type