ltcai 11.2.0 → 11.4.0

package/latticeai/services/model_runtime/state.py

@@ -0,0 +1,131 @@
+"""The immutable dependency set one model runtime is configured with.
+
+``ModelRuntimeState`` replaced the process-wide module ``STATE`` object: every
+value the runtime needs — router, mode, paths, download/auth policy, the
+app-owned callables — is passed in explicitly and never mutated afterwards, so
+a second ASGI application in the same interpreter cannot inherit the first
+one's credentials or configuration.
+
+Also home to the two consent gates (:func:`_download_block`,
+:func:`_engine_install_block`): presence of a token or a model name never
+authorises network or installer activity on its own.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from latticeai.core.model_compat import (
+    SMOKE_PROMPT as _SMOKE_PROMPT,
+)
+from latticeai.core.model_compat import (
+    friendly_model_runtime_error as _friendly_model_runtime_error,
+)
+from latticeai.core.model_compat import (
+    model_runtime_compatibility as _model_runtime_compatibility,
+)
+from latticeai.services.model_errors import ModelRuntimeError
+
+# ``model_loading._get_model_runtime_deps`` imports these private names from
+# this module to preserve the historical model_runtime wiring surface.
+_MODEL_LOADING_COMPAT_EXPORTS = (
+    _friendly_model_runtime_error,
+    _model_runtime_compatibility,
+    _SMOKE_PROMPT,
+)
+
+
+def _missing_current_user(_request: Any) -> Optional[str]:
+    return None
+
+
+def _missing_user_api_key(_email: Optional[str], _provider: str) -> Optional[str]:
+    return None
+
+
+@dataclass(frozen=True, slots=True)
+class ModelRuntimeState:
+    """Immutable application-owned dependencies for one model runtime.
+
+    Upper-case configuration field names intentionally match the long-standing
+    composition-root vocabulary.  Unlike the former module ``STATE`` object,
+    instances are explicit, immutable, and safe to create more than once in a
+    process (for example in isolated tests or multiple ASGI applications).
+    """
+
+    router: Any = None
+    APP_MODE: str = "local"
+    DEFAULT_HOST: str = "127.0.0.1"
+    DEFAULT_PORT: int = 4825
+    DATA_DIR: Path = field(default_factory=lambda: Path.home() / ".latticeai")
+    BASE_DIR: Path = field(default_factory=Path.cwd)
+    ENABLE_TELEGRAM: bool = False
+    ENABLE_GRAPH: bool = True
+    AUTOLOAD_MODELS: bool = False
+    MODEL_IDLE_UNLOAD_SECONDS: int = 0
+    ALLOW_MODEL_DOWNLOADS: bool = False
+    MODEL_DOWNLOAD_TIMEOUT: int = 300
+    ALLOW_LOCAL_MODELS: bool = True
+    REQUIRE_AUTH: bool = False
+    INVITE_GATE_ENABLED: bool = False
+    ALLOW_PLAINTEXT_API_KEYS: bool = False
+    CORS_ALLOW_NETWORK: bool = False
+    PUBLIC_MODEL: str = "openai:gpt-4o-mini"
+    LOCAL_MODEL: str = "mlx-community/gemma-4-12B-it-4bit"
+    IS_PUBLIC_MODE: bool = False
+    keyring: Any = None
+    get_current_user: Callable[[Any], Optional[str]] = _missing_current_user
+    get_user_api_key: Callable[[Optional[str], str], Optional[str]] = _missing_user_api_key
+
+
+def create_model_runtime_state(**deps: Any) -> ModelRuntimeState:
+    """Create an immutable runtime dependency set with strict key validation."""
+
+    known = {item.name for item in fields(ModelRuntimeState)}
+    unknown = sorted(set(deps) - known)
+    if unknown:
+        raise TypeError(f"unknown model runtime dependencies: {', '.join(unknown)}")
+    return ModelRuntimeState(**deps)
+
+def _download_allowed(
+    allow_download: bool = False, *, state: ModelRuntimeState
+) -> bool:
+    autoload = state.AUTOLOAD_MODELS
+    configured = state.ALLOW_MODEL_DOWNLOADS
+    return bool(allow_download) or bool(configured) or bool(autoload)
+
+
+def _download_block(provider: str, model_name: str) -> None:
+    raise ModelRuntimeError(
+        status_code=409,
+        detail={
+            "status": "unavailable",
+            "capability": "model_download",
+            "provider": provider,
+            "model": model_name,
+            "reason": (
+                "Model files are not present locally. Lattice AI does not start "
+                "outbound model downloads by default, and token/model presence "
+                "alone never authorizes network activity."
+            ),
+            "action": "Use the explicit pull/prepare flow with download consent, or set LATTICEAI_ALLOW_MODEL_DOWNLOADS=true.",
+        },
+    )
+
+
+def _engine_install_block(engine: str) -> None:
+    raise ModelRuntimeError(
+        status_code=409,
+        detail={
+            "status": "unavailable",
+            "capability": "engine_install",
+            "engine": engine,
+            "reason": (
+                "The requested local runtime is not installed. Lattice AI does not "
+                "run package-manager or installer commands from Model Load by default."
+            ),
+            "action": "Install the runtime explicitly from Library/System setup, or enable explicit download/install consent for this request.",
+        },
+    )

package/latticeai/services/model_runtime/status.py

@@ -0,0 +1,255 @@
+"""What this machine can run: the engine/model status payload.
+
+:func:`engine_status` is the single answer the Library screen renders — every
+engine (local, local-server, cloud), whether it is installed, whether its
+install is even supported here, and which catalogue models are already pulled.
+:func:`runtime_features` is the same idea for the application itself, and
+:func:`install_engine` is the one write this module owns.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from latticeai.models.router import HF_MODELS_ROOT
+from latticeai.services.model_catalog import (
+    ENGINE_INSTALLERS,
+    ENGINE_MODEL_CATALOG,
+    filter_lower_family_versions,
+)
+from latticeai.services.model_engines import (
+    install_engine as _install_engine,
+)
+from latticeai.services.model_runtime.download import hf_model_ready
+from latticeai.services.model_runtime.engines import (
+    _safe_engine_install_plan,
+    engine_installed,
+    engine_support_status,
+    get_lmstudio_models,
+    get_ollama_pulled_models,
+)
+from latticeai.services.model_runtime.state import ModelRuntimeState
+
+
+def engine_status(
+    *,
+    state: ModelRuntimeState,
+    cloud_verify_cache: Optional[Dict[str, Dict[str, Any]]] = None,
+) -> List[Dict]:
+    r = state.router
+    verify_cache = cloud_verify_cache or {}
+    cloud_models = r.detected_cloud_models() if r else []
+    cloud_by_provider: Dict[str, List[Dict[str, Any]]] = {}
+    for model in cloud_models:
+        cloud_by_provider.setdefault(model["provider"], []).append(model)
+
+    ollama_installed = engine_installed("ollama")
+    pulled = get_ollama_pulled_models() if ollama_installed else set()
+    ollama_models = []
+    for m in ENGINE_MODEL_CATALOG["ollama"]:
+        pull_name = m["id"].removeprefix("ollama:")
+        ollama_models.append({**m, "pulled": pull_name in pulled})
+    ollama_models = filter_lower_family_versions(ollama_models)
+
+    HF_MODELS_ROOT.mkdir(parents=True, exist_ok=True)
+    mlx_models = []
+    for m in ENGINE_MODEL_CATALOG.get("local_mlx", []):
+        repo_id = m["id"]
+        mlx_models.append({**m, "pulled": hf_model_ready(repo_id, "local_mlx")})
+    mlx_models = filter_lower_family_versions(mlx_models)
+
+    vllm_models = []
+    for m in ENGINE_MODEL_CATALOG.get("vllm", []):
+        repo_id = m["id"].removeprefix("vllm:")
+        vllm_models.append({**m, "pulled": hf_model_ready(repo_id, "vllm")})
+    vllm_models = filter_lower_family_versions(vllm_models)
+
+    lmstudio_models = []
+    downloaded_lmstudio = get_lmstudio_models()
+    downloaded_by_key: Dict[str, Dict[str, Any]] = {}
+    for item in downloaded_lmstudio:
+        key = str(item.get("key") or "").strip()
+        if not key:
+            continue
+        downloaded_by_key[key] = item
+        loaded_instances = item.get("loaded_instances") or []
+        lmstudio_models.append({
+            "id": f"lmstudio:{key}",
+            "name": item.get("display_name") or f"LM Studio · {key}",
+            "family": item.get("architecture") or item.get("publisher") or "LM Studio",
+            "tag": "loaded-server-model" if loaded_instances else "downloaded",
+            "size": item.get("params_string") or item.get("format") or "LM Studio",
+            "pullable": True,
+            "pulled": True,
+        })
+
+    if not lmstudio_models:
+        for m in ENGINE_MODEL_CATALOG.get("lmstudio", []):
+            lmstudio_models.append({**m, "pulled": False})
+    else:
+        known_ids = {item["id"] for item in lmstudio_models}
+        for m in ENGINE_MODEL_CATALOG.get("lmstudio", []):
+            repo_id = m["id"].removeprefix("lmstudio:")
+            if f"lmstudio:{repo_id}" not in known_ids and repo_id not in downloaded_by_key:
+                lmstudio_models.append({**m, "pulled": False})
+    lmstudio_models = filter_lower_family_versions(lmstudio_models)
+
+    llamacpp_models = []
+    for m in ENGINE_MODEL_CATALOG.get("llamacpp", []):
+        repo_id = m["id"].removeprefix("llamacpp:")
+        llamacpp_models.append({**m, "pulled": hf_model_ready(repo_id, "llamacpp")})
+    llamacpp_models = filter_lower_family_versions(llamacpp_models)
+
+    local_server_specs: List[Dict[str, Any]] = [
+        {
+            "id": "vllm",
+            "name": "vLLM",
+            "description": "vLLM OpenAI 호환 서버(예: http://localhost:8000/v1)에 연결합니다.",
+            "requires": "VLLM_BASE_URL",
+            "note": engine_support_status("vllm").get("reason"),
+        },
+        {
+            "id": "lmstudio",
+            "name": "LM Studio",
+            "description": "LM Studio 로컬 OpenAI 호환 서버에 연결합니다.",
+            "requires": "LMSTUDIO_BASE_URL",
+            "note": (
+                "다운로드된 모델은 자동 감지하고, 선택 시 필요하면 다운로드 후 바로 로드합니다."
+                if downloaded_lmstudio else
+                "LM Studio 설치 후 모델을 선택하면 Local Server 시작, 다운로드, 로드를 자동으로 진행합니다."
+            ),
+            "server_ready": bool(downloaded_lmstudio),
+        },
+        {
+            "id": "llamacpp",
+            "name": "llama.cpp",
+            "description": "llama.cpp 서버(OpenAI 호환 /v1)에 연결합니다.",
+            "requires": "LLAMACPP_BASE_URL",
+        },
+    ]
+
+    engines = [
+        {
+            "id": "local_mlx",
+            "name": "MLX",
+            "kind": "local",
+            "description": "Apple Silicon GPU에서 MLX-VLM 모델을 직접 실행하고, Gemma 4는 필요 시 MLX-LM 텍스트 경로로 재시도합니다.",
+            "installed": engine_installed("local_mlx"),
+            "installable": True,
+            "install_label": ENGINE_INSTALLERS["local_mlx"]["label"],
+            "install_plan": _safe_engine_install_plan("local_mlx", base_dir=state.BASE_DIR),
+            "models": mlx_models,
+        },
+        {
+            "id": "ollama",
+            "name": "Ollama",
+            "kind": "local-server",
+            "description": "Ollama 로컬 서버를 OpenAI 호환 엔진처럼 사용합니다.",
+            "installed": ollama_installed,
+            "installable": True,
+            "install_label": ENGINE_INSTALLERS["ollama"]["label"],
+            "install_plan": _safe_engine_install_plan("ollama", base_dir=state.BASE_DIR),
+            "models": ollama_models,
+        },
+    ]
+    for spec in local_server_specs:
+        support = engine_support_status(spec["id"])
+        engines.append({
+            "id": spec["id"],
+            "name": spec["name"],
+            "kind": "local-server",
+            "description": spec["description"],
+            "installed": engine_installed(spec["id"]),
+            "supported": support["supported"],
+            "support_reason": support["reason"],
+            "installable": support["supported"] and spec["id"] in ENGINE_INSTALLERS,
+            "install_label": ENGINE_INSTALLERS.get(spec["id"], {}).get("label"),
+            "install_plan": (
+                _safe_engine_install_plan(spec["id"], base_dir=state.BASE_DIR)
+                if spec["id"] in ENGINE_INSTALLERS
+                else None
+            ),
+            "requires": spec["requires"],
+            "models": (
+                vllm_models if spec["id"] == "vllm"
+                else lmstudio_models if spec["id"] == "lmstudio"
+                else llamacpp_models if spec["id"] == "llamacpp"
+                else ENGINE_MODEL_CATALOG.get(spec["id"], [])
+            ),
+            "note": spec.get("note") or support["reason"] or f"{spec['requires']} 설정 시 활성화됩니다.",
+            "server_ready": spec.get("server_ready"),
+        })
+    for provider in ["openai", "openrouter", "groq", "together", "xai"]:
+        env_key = next((item.get("requires") for item in cloud_by_provider.get(provider, []) if item.get("requires")), None)
+        provider_models = []
+        for model in cloud_by_provider.get(provider, []):
+            cache = verify_cache.get(str(model.get("id") or ""))
+            provider_models.append({
+                **model,
+                "verified": cache.get("ok") if cache else None,
+                "verify_reason": cache.get("reason") if cache else None,
+            })
+        engines.append({
+            "id": provider,
+            "name": provider.title(),
+            "kind": "cloud",
+            "description": "OpenAI 호환 Chat Completions API로 cloud LLM을 실행합니다.",
+            "installed": engine_installed(provider),
+            "installable": True,
+            "install_label": ENGINE_INSTALLERS[provider]["label"],
+            "install_plan": _safe_engine_install_plan(provider, base_dir=state.BASE_DIR),
+            "requires": env_key,
+            "models": provider_models,
+        })
+    return engines
+
+def runtime_features(*, state: ModelRuntimeState) -> Dict:
+    s = state
+    r = s.router
+    return {
+        "mode": s.APP_MODE,
+        "public": s.IS_PUBLIC_MODE,
+        "host": s.DEFAULT_HOST,
+        "port": s.DEFAULT_PORT,
+        "data_dir": str(s.DATA_DIR),
+        "telegram_enabled": s.ENABLE_TELEGRAM,
+        "graph_enabled": s.ENABLE_GRAPH,
+        "autoload_models": s.AUTOLOAD_MODELS,
+        "model_idle_unload_seconds": s.MODEL_IDLE_UNLOAD_SECONDS,
+        "allow_model_downloads": s.ALLOW_MODEL_DOWNLOADS,
+        "model_download_timeout": s.MODEL_DOWNLOAD_TIMEOUT,
+        "model_memory_policy": r.model_memory_policy() if r else None,
+        "allow_local_models": s.ALLOW_LOCAL_MODELS,
+        "security": {
+            "host": s.DEFAULT_HOST,
+            "require_auth": s.REQUIRE_AUTH,
+            "invite_gate_enabled": s.INVITE_GATE_ENABLED,
+            "keyring_available": s.keyring is not None,
+            "plaintext_api_keys_allowed": s.ALLOW_PLAINTEXT_API_KEYS,
+            "cors_allow_network": s.CORS_ALLOW_NETWORK,
+        },
+        "default_model": s.PUBLIC_MODEL if s.IS_PUBLIC_MODE else s.LOCAL_MODEL,
+        "local_only_features": {
+            "mlx": s.ALLOW_LOCAL_MODELS and not s.IS_PUBLIC_MODE,
+            "telegram_bridge": s.ENABLE_TELEGRAM,
+            "desktop_chrome_bridge": not s.IS_PUBLIC_MODE,
+            "computer_use_bridge": not s.IS_PUBLIC_MODE,
+        },
+        "public_features": {
+            "web_ui": True,
+            "openai_compatible_models": True,
+            "persistent_data_dir": str(s.DATA_DIR),
+        },
+    }
+
+def install_engine(
+    engine: str,
+    confirmation_token: Optional[str] = None,
+    *,
+    state: ModelRuntimeState,
+) -> Dict:
+    return _install_engine(
+        engine,
+        confirmation_token=confirmation_token,
+        base_dir=state.BASE_DIR,
+    )

package/latticeai/services/product_readiness.py

@@ -18,7 +18,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "11.2.0"
+PRODUCT_VERSION_TARGET = "11.4.0"
 
 
 @dataclass(frozen=True)
@@ -44,7 +44,10 @@ PRODUCT_GATES: List[ProductGate] = [
             "frontend/src/features/brain/BrainHome.tsx",
             "frontend/src/App.tsx::brain-mobile-nav",
             "latticeai/setup/auto_setup.py",
-            "latticeai/setup/wizard.py",
+            # v11.3.0: the wizard is a package (paths / detect / plans /
+            # catalog / recommend / install); the recommender is the piece
+            # first-run actually shows.
+            "latticeai/setup/wizard/recommend.py",
         ],
     ),
     ProductGate(
@@ -64,8 +67,11 @@ PRODUCT_GATES: List[ProductGate] = [
             "latticeai/api/chat_intents.py::direct_write_file",
             # v9.9.2 ArtifactWritePipeline: every write path shares the same
             # extract → validate → repair guarantee, proven by the FG harness.
-            "latticeai/core/file_generation.py::sanitize_write_content",
-            "latticeai/core/agent.py::content_sanitize",
+            # v11.3.0: both modules became packages — the write-side door is
+            # its own submodule, and the agent's use of it lives in the
+            # EXECUTE phase.
+            "latticeai/core/file_generation/sanitize.py::sanitize_write_content",
+            "latticeai/core/agent/execution.py::content_sanitize",
             "tests/unit/test_artifact_write_scenarios.py::test_fg06_agent_dispatch_strips_fences_from_write_file_content",
             "tests/unit/test_chat_telegram_decoupling.py::test_chat_file_creation_intent_writes_real_file",
         ],
@@ -110,12 +116,14 @@ PRODUCT_GATES: List[ProductGate] = [
             f"docs/CHANGELOG.md::## [{PRODUCT_VERSION_TARGET}]",
             "FEATURE_STATUS.md",
             f"RELEASE_NOTES_v{PRODUCT_VERSION_TARGET}.md",
-            "latticeai/core/agent.py::SingleAgentRuntime",
+            # v11.3.0: the single-agent loop is a package; the composed
+            # class and its boundary contract live in the runtime half.
+            "latticeai/core/agent/runtime.py::SingleAgentRuntime",
             "lattice_brain/runtime/agent_runtime.py::class AgentRuntime",
             "lattice_brain/runtime/contracts.py::runtime-boundary/v1",
             "lattice_brain/runtime/contracts.py::RuntimeBoundaryProtocol",
             "lattice_brain/runtime/agent_runtime.py::def boundary",
-            "latticeai/core/agent.py::def boundary",
+            "latticeai/core/agent/runtime.py::def boundary",
             "latticeai/services/architecture_readiness.py::lattice-architecture-contract/v1",
             "latticeai/services/tool_dispatch.py::rollback_file",
         ],
@@ -148,7 +156,7 @@ PRODUCT_GATES: List[ProductGate] = [
             "scripts/brain_quality_eval.py",
             "scripts/product_readiness.py",
             "tests/unit/test_product_readiness.py",
-            "tests/visual/v3.spec.js::Brain Chat Home",
+            "tests/visual/v3.surfaces.spec.js::Brain Chat Home",
             ".github/workflows/ci.yml::scripts/product_readiness.py",
             ".github/workflows/release.yml::npm run lint",
         ],

package/latticeai/setup/wizard/__init__.py

@@ -0,0 +1,126 @@
+"""
+Smart Setup Wizard — Environment Scanner, Recommender & Auto-Installer
+Detects hardware, tools, and API keys; returns tailored recommendations;
+streams SSE installation progress.
+
+Formerly the root ``setup.py``; renamed in v4 so it no longer collides with
+the setuptools build entrypoint and actually ships in the wheel
+(``pyproject.toml`` py-modules). Packaging is owned entirely by
+``pyproject.toml`` — there is deliberately no root ``setup.py``.
+
+Split into cohesive submodules in v11.3.0 (no behaviour change): ``paths``
+(PATH repair + binary lookup + the module-level ``COMMON_PATH_DIRS``),
+``detect`` (hardware/OS/tool probes and ``scan_environment``), ``plans``
+(SSE framing + confirmation-token command plans), ``catalog`` (model tables),
+``recommend`` (``get_recommendations``) and ``install`` (verify/repair and the
+SSE ``install_stream``). This module re-exports every name the single file
+exposed, so ``latticeai.setup.wizard.X`` keeps working.
+
+Stubbing note: rebinding one of these names *here* changes only this module's
+name. The submodule that calls it holds its own reference, so a test standing
+in for a helper patches the submodule that uses it.
+"""
+
+from __future__ import annotations
+
+# The single file had no ``__all__``, so its public surface was "every module
+# global" — including the names it imported for its own use. Every re-export
+# below therefore uses the redundant-alias form: it reproduces exactly that
+# surface, and it marks each name as deliberate rather than a leftover import.
+from latticeai.core.quiet import quiet as quiet
+from latticeai.services.process_audit import (
+    CommandConfirmationError as CommandConfirmationError,
+)
+from latticeai.services.process_audit import (
+    append_process_audit_event as append_process_audit_event,
+)
+from latticeai.services.process_audit import command_plan as command_plan
+from latticeai.services.process_audit import (
+    command_plan_for_commands as command_plan_for_commands,
+)
+from latticeai.services.process_audit import (
+    require_command_confirmation as require_command_confirmation,
+)
+from latticeai.services.setup_detection import detect_cuda as detect_cuda
+from latticeai.services.setup_detection import detect_tools as detect_tools
+from latticeai.services.setup_detection import (
+    detect_wsl_from_text as detect_wsl_from_text,
+)
+from latticeai.setup.wizard.catalog import (
+    _BEST_MODEL_TIERS as _BEST_MODEL_TIERS,
+)
+from latticeai.setup.wizard.catalog import (
+    _CROSS_PLATFORM_MODEL_CATALOG as _CROSS_PLATFORM_MODEL_CATALOG,
+)
+from latticeai.setup.wizard.catalog import (
+    _MODEL_CATALOG as _MODEL_CATALOG,
+)
+from latticeai.setup.wizard.catalog import (
+    _VERSIONED_MODEL_PATTERNS as _VERSIONED_MODEL_PATTERNS,
+)
+from latticeai.setup.wizard.catalog import (
+    _best_model_for_engine as _best_model_for_engine,
+)
+from latticeai.setup.wizard.catalog import (
+    _catalog_row_family_version as _catalog_row_family_version,
+)
+from latticeai.setup.wizard.catalog import (
+    _filter_lower_family_versions as _filter_lower_family_versions,
+)
+from latticeai.setup.wizard.catalog import (
+    _version_tuple as _version_tuple,
+)
+from latticeai.setup.wizard.detect import _cmd as _cmd
+from latticeai.setup.wizard.detect import _detect_api_keys as _detect_api_keys
+from latticeai.setup.wizard.detect import _detect_chip as _detect_chip
+from latticeai.setup.wizard.detect import _detect_cpu as _detect_cpu
+from latticeai.setup.wizard.detect import _detect_cuda as _detect_cuda
+from latticeai.setup.wizard.detect import (
+    _detect_disk_free_gb as _detect_disk_free_gb,
+)
+from latticeai.setup.wizard.detect import _detect_gpu as _detect_gpu
+from latticeai.setup.wizard.detect import _detect_mlx as _detect_mlx
+from latticeai.setup.wizard.detect import _detect_ram_gb as _detect_ram_gb
+from latticeai.setup.wizard.detect import _detect_tools as _detect_tools
+from latticeai.setup.wizard.detect import _detect_wsl as _detect_wsl
+from latticeai.setup.wizard.detect import (
+    _parse_windows_video_controllers as _parse_windows_video_controllers,
+)
+from latticeai.setup.wizard.detect import scan_environment as scan_environment
+from latticeai.setup.wizard.install import _brew_install as _brew_install
+from latticeai.setup.wizard.install import _pip_install as _pip_install
+from latticeai.setup.wizard.install import _repair_action as _repair_action
+from latticeai.setup.wizard.install import _verify_action as _verify_action
+from latticeai.setup.wizard.install import _verify_binary as _verify_binary
+from latticeai.setup.wizard.install import _wait_for_binary as _wait_for_binary
+from latticeai.setup.wizard.install import install_stream as install_stream
+from latticeai.setup.wizard.install import open_url as open_url
+from latticeai.setup.wizard.paths import COMMON_PATH_DIRS as COMMON_PATH_DIRS
+from latticeai.setup.wizard.paths import OFFICIAL_DOWNLOADS as OFFICIAL_DOWNLOADS
+from latticeai.setup.wizard.paths import PACKAGE_MODULES as PACKAGE_MODULES
+from latticeai.setup.wizard.paths import (
+    WINDOWS_BINARY_CANDIDATES as WINDOWS_BINARY_CANDIDATES,
+)
+from latticeai.setup.wizard.paths import _component_detail as _component_detail
+from latticeai.setup.wizard.paths import _merge_path_dirs as _merge_path_dirs
+from latticeai.setup.wizard.paths import _module_available as _module_available
+from latticeai.setup.wizard.paths import _package_module as _package_module
+from latticeai.setup.wizard.paths import _persist_extra_path as _persist_extra_path
+from latticeai.setup.wizard.paths import _project_env_file as _project_env_file
+from latticeai.setup.wizard.paths import _update_env_file as _update_env_file
+from latticeai.setup.wizard.paths import _which_any as _which_any
+from latticeai.setup.wizard.paths import _which_detail as _which_detail
+from latticeai.setup.wizard.paths import repair_path_for as repair_path_for
+from latticeai.setup.wizard.plans import _action_command_plan as _action_command_plan
+from latticeai.setup.wizard.plans import _action_commands as _action_commands
+from latticeai.setup.wizard.plans import _attach_action_plan as _attach_action_plan
+from latticeai.setup.wizard.plans import (
+    _hydrate_install_actions as _hydrate_install_actions,
+)
+from latticeai.setup.wizard.plans import _sse as _sse
+from latticeai.setup.wizard.plans import (
+    _verify_action_confirmation as _verify_action_confirmation,
+)
+from latticeai.setup.wizard.recommend import (
+    get_recommendations as get_recommendations,
+)