ltcai 6.1.0 → 6.3.0

package/latticeai/app_factory.py

@@ -17,10 +17,14 @@ 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
+from latticeai.runtime.chat_wiring import (
+    build_chat_agent_runtime_from_context,
+    build_interaction_contexts,
+    maybe_build_telegram_chat_mirror,
+)
 from latticeai.runtime.config_runtime import build_config_runtime
 from latticeai.runtime.context_runtime import build_context_runtime
 from latticeai.runtime.hooks_runtime import (
@@ -29,11 +33,16 @@ from latticeai.runtime.hooks_runtime import (
     build_hooks_runtime,
 )
 from latticeai.runtime.lifespan_runtime import build_lifespan_runtime
+from latticeai.runtime.model_wiring import (
+    configure_model_runtime_from_context,
+    register_model_runtime_routers,
+)
 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.review_wiring import build_review_run_now_runner
 from latticeai.runtime.router_registration import (
     build_auth_admin_security_router_bundle,
     build_static_routes_bundle,
@@ -44,6 +53,7 @@ from latticeai.runtime.router_registration import (
     register_review_and_brain_tail_routers,
 )
 from latticeai.runtime.security_runtime import build_security_runtime
+from latticeai.runtime.tail_wiring import register_tail_runtime_routers
 from latticeai.runtime.web_runtime import build_web_runtime
 
 if TYPE_CHECKING:  # imports for annotations only — keep module import light
@@ -145,7 +155,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
@@ -189,7 +198,7 @@ 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, execute_tool, knowledge_save
 
@@ -1089,7 +1098,8 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     OPEN_REGISTRATION = CONFIG.open_registration
     INVITE_CODE = CONFIG.invite_code
     INVITE_GATE_ENABLED = CONFIG.invite_gate_enabled
-    configure_model_runtime(
+    configure_model_runtime_from_context(
+        configure_model_runtime=configure_model_runtime,
         router=router,
         APP_MODE=APP_MODE,
         DEFAULT_HOST=DEFAULT_HOST,
@@ -1236,12 +1246,10 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     # ── Telegram chat mirror: registered only when ENABLE_TELEGRAM is truthy.
     # latticeai.api.chat no longer imports telegram_bot (a 45KB module that
     # mutates os.environ at import); it calls this injected callback instead.
-    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
-            _spawn(broadcast_web_chat(role, text), name="telegram_broadcast")
-        on_chat_message = _telegram_chat_mirror
+    on_chat_message = maybe_build_telegram_chat_mirror(
+        enable_telegram=ENABLE_TELEGRAM,
+        spawn=_spawn,
+    )
 
     def _recent_chat_context(
         limit: int = 10,
@@ -1257,7 +1265,8 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             conversation_id=conversation_id,
         )
 
-    CHAT_AGENT_RUNTIME = build_agent_runtime(
+    CHAT_AGENT_RUNTIME = build_chat_agent_runtime_from_context(
+        build_agent_runtime=build_agent_runtime,
         model_router=router,
         execute_tool=execute_tool,
         recent_chat_context=_recent_chat_context,
@@ -1338,20 +1347,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,
@@ -1359,23 +1357,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()
@@ -1421,22 +1413,19 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     # ── Health / status / engine-summary router (latticeai.api.health, v1.2.0) ───
     # /health, /mode, /runtime_features, /engines(GET) now live in the health router.
     # Heavier engine mutation endpoints remain below in server_app.
-    MODEL_SERVICE = build_model_service(
+    MODEL_SERVICE = register_model_runtime_routers(
+        app=app,
+        create_health_router=create_health_router,
+        create_models_router=create_models_router,
+        register_health_and_model_routers=register_health_and_model_routers,
         model_router=router,
         runtime_features=runtime_features,
-        is_public=IS_PUBLIC_MODE,
-    )
-    register_health_and_model_routers(
-        app,
-        create_health_router=create_health_router,
-        model_service=MODEL_SERVICE,
+        is_public_mode=IS_PUBLIC_MODE,
         engine_status=engine_status,
         get_current_user=get_current_user,
         require_auth=REQUIRE_AUTH,
         app_version=APP_VERSION,
         app_mode=APP_MODE,
-        create_models_router=create_models_router,
-        model_router=router,
         require_user=require_user,
         load_users=load_users,
         get_user_role=get_user_role,
@@ -1455,7 +1444,6 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         engine_model_catalog=ENGINE_MODEL_CATALOG,
         model_engine_aliases=MODEL_ENGINE_ALIASES,
         cloud_verify_ttl_seconds=CLOUD_VERIFY_TTL_SECONDS,
-        is_public_mode=IS_PUBLIC_MODE,
         allow_local_models=ALLOW_LOCAL_MODELS,
     )
 
@@ -1478,21 +1466,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, interaction_router_context = build_interaction_contexts(
         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,
@@ -1510,34 +1490,37 @@ 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,
+        chat_context=context,
+        search_service=SEARCH_SERVICE,
+        allowed_workspaces_for=_allowed_workspaces_for,
+        embedding_info=_embedding_info,
         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
+    run_review_item = build_review_run_now_runner(PLATFORM, HTTPException)
 
-    def _run_review_item(item, *, user_email, scope):
-        """run_now: re-execute the suggestion's source workflow (preview/regenerate)."""
-        wf_id = (item.get("payload") or {}).get("workflow_id") or (item.get("provenance") or {}).get("workflow_id")
-        if not wf_id:
-            raise HTTPException(status_code=409, detail="review item has no workflow to run")
-        return PLATFORM.run_workflow_by_id(
-            wf_id, user_email, scope, with_agent=False,
-            inputs={"__review_item__": item.get("id")},
-        )
-
-    BRAIN_NETWORK = register_review_and_brain_tail_routers(
-        app,
+    BRAIN_NETWORK = register_tail_runtime_routers(
+        app=app,
         create_review_queue_router=create_review_queue_router,
+        register_review_and_brain_tail_routers=register_review_and_brain_tail_routers,
         review_queue=REVIEW_QUEUE,
         require_user=require_user,
         gate_read=PLATFORM.gate_read,
         gate_write=PLATFORM.gate_write,
-        run_review_item=_run_review_item,
+        run_review_item=run_review_item,
         append_audit_event=append_audit_event,
         create_browser_router=create_browser_router,
         ingestion_pipeline=INGESTION_PIPELINE,

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/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "6.1.0"
+MARKETPLACE_VERSION = "6.3.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.1.0"
+WORKSPACE_OS_VERSION = "6.3.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type