ltcai 11.5.0 → 11.5.2

package/latticeai/core/local_embeddings.py

@@ -1,104 +0,0 @@
-"""Local deterministic embeddings for Lattice AI search.
-
-The v3 backend needs a local-first vector signal without introducing a cloud
-runtime requirement. This module provides a small feature-hashing embedder that
-is deterministic, cheap to run, and good enough for indexing/search tests. A
-future runtime can swap the implementation behind the same interface when a
-local model server is available.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import math
-import os
-import re
-import struct
-from dataclasses import dataclass
-from typing import Iterable, List
-
-DEFAULT_EMBEDDING_DIM = int(os.getenv("LATTICEAI_VECTOR_DIM", "384"))
-EMBEDDING_MODEL_ID = f"lattice-local-hash-v1:{DEFAULT_EMBEDDING_DIM}"
-
-
-def embedding_model_id(dim: int) -> str:
-    return f"lattice-local-hash-v1:{int(dim)}"
-
-
-def _tokenize(text: str) -> List[str]:
-    raw = str(text or "").lower()
-    tokens = re.findall(r"[a-z0-9][a-z0-9_.:/+-]{1,}|[가-힣]{2,}", raw)
-    features: List[str] = []
-    for token in tokens:
-        features.append(f"tok:{token}")
-        if len(token) >= 5 and re.search(r"[a-z]", token):
-            for i in range(0, len(token) - 2):
-                features.append(f"tri:{token[i:i+3]}")
-        if re.search(r"[가-힣]", token) and len(token) >= 3:
-            for i in range(0, len(token) - 1):
-                features.append(f"ko:{token[i:i+2]}")
-    return features
-
-
-def _hash_to_index(feature: str, dim: int) -> tuple[int, float]:
-    digest = hashlib.blake2b(feature.encode("utf-8"), digest_size=8).digest()
-    value = int.from_bytes(digest, "big", signed=False)
-    sign = 1.0 if (value & 1) == 0 else -1.0
-    return value % dim, sign
-
-
-@dataclass(frozen=True)
-class LocalEmbeddingModel:
-    """Deterministic feature-hashing embedder.
-
-    The output vectors are L2-normalized, so cosine similarity is just a dot
-    product. No network access, model download, or global mutable state is
-    required.
-    """
-
-    dim: int = DEFAULT_EMBEDDING_DIM
-    model_id: str = EMBEDDING_MODEL_ID
-
-    def __post_init__(self) -> None:
-        if self.model_id == EMBEDDING_MODEL_ID and self.dim != DEFAULT_EMBEDDING_DIM:
-            object.__setattr__(self, "model_id", embedding_model_id(self.dim))
-
-    def embed(self, text: str) -> List[float]:
-        vector = [0.0] * self.dim
-        features = _tokenize(text)
-        if not features:
-            return vector
-        for feature in features:
-            index, sign = _hash_to_index(feature, self.dim)
-            vector[index] += sign
-        norm = math.sqrt(sum(value * value for value in vector))
-        if norm <= 0:
-            return vector
-        return [value / norm for value in vector]
-
-    def similarity(self, left: Iterable[float], right: Iterable[float]) -> float:
-        # strict=True: a dimension mismatch means the two vectors came from
-        # different embedding models. Truncating to the shorter one produces a
-        # plausible-looking similarity that is meaningless — exactly the silent
-        # wrongness this codebase keeps finding. Callers that can hit a model
-        # swap already handle failure and fall back to lexical search.
-        left_v, right_v = list(left), list(right)
-        if len(left_v) != len(right_v):
-            raise ValueError(
-                f"embedding dimension mismatch: {len(left_v)} vs {len(right_v)}; "
-                "the vector index was built with a different model"
-            )
-        return float(sum(a * b for a, b in zip(left_v, right_v, strict=True)))
-
-    def encode(self, vector: Iterable[float]) -> bytes:
-        values = list(vector)
-        return struct.pack(f"<{len(values)}f", *values)
-
-    def decode(self, payload: bytes, dim: int | None = None) -> List[float]:
-        if not payload:
-            return []
-        count = int(dim or self.dim)
-        expected = count * 4
-        if len(payload) != expected:
-            count = len(payload) // 4
-        return list(struct.unpack(f"<{count}f", payload[: count * 4]))

package/latticeai/core/multi_agent.py

@@ -1,11 +0,0 @@
-"""Compatibility shim: physically moved to ``lattice_brain.runtime.multi_agent``.
-
-Aliases itself to the physical module so identity, module-level state, and
-monkeypatching keep working through the old import path.
-"""
-
-import sys
-
-import lattice_brain.runtime.multi_agent as _impl
-
-sys.modules[__name__] = _impl

package/latticeai/core/workflow_engine.py

@@ -1,11 +0,0 @@
-"""Compatibility shim: physically moved to ``lattice_brain.workflow``.
-
-Aliases itself to the physical module so identity, module-level state, and
-monkeypatching keep working through the old import path.
-"""
-
-import sys
-
-import lattice_brain.workflow as _impl
-
-sys.modules[__name__] = _impl

package/latticeai/services/ingestion.py

@@ -1,11 +0,0 @@
-"""Compatibility shim: physically moved to ``lattice_brain.ingestion``.
-
-Aliases itself to the physical module so identity, module-level state, and
-monkeypatching keep working through the old import path.
-"""
-
-import sys
-
-import lattice_brain.ingestion as _impl
-
-sys.modules[__name__] = _impl

package/latticeai/services/kg_portability.py

@@ -1,11 +0,0 @@
-"""Compatibility shim: physically moved to ``lattice_brain.portability``.
-
-Aliases itself to the physical module so identity, module-level state, and
-monkeypatching keep working through the old import path.
-"""
-
-import sys
-
-import lattice_brain.portability as _impl
-
-sys.modules[__name__] = _impl

package/latticeai/services/multimodal_streaming.py

@@ -1,129 +0,0 @@
-"""Multimodal / video streaming contracts behind NetworkBoundaryMode (Phase 3).
-
-Video generation and other multimodal cloud calls share the same boundary dial
-as text: nothing leaves the machine unless mode is CLOUD_ALLOWED *and* the
-hybrid policy has ``allow_multimodal=True``.
-
-This module is intentionally adapter-shaped: concrete providers (Runway, Luma,
-Veo-compatible endpoints, etc.) plug in later without changing the chat path.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, AsyncIterator, Dict, List, Optional, Protocol
-
-from latticeai.core.network_boundary import (
-    NetworkBoundaryMode,
-    normalize_network_mode,
-)
-from latticeai.services.hybrid_context import MinimalContext
-
-
-@dataclass
-class MultimodalTurnResult:
-    user_message: str
-    media_urls: List[str] = field(default_factory=list)
-    media_kind: str = "video"  # video | image | audio
-    answer_text: str = ""
-    sent_node_ids: List[str] = field(default_factory=list)
-    provider: str = ""
-    model: str = ""
-    usage: Dict[str, Any] = field(default_factory=dict)
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "user_message": self.user_message,
-            "media_urls": list(self.media_urls),
-            "media_kind": self.media_kind,
-            "answer_text": self.answer_text,
-            "sent_node_ids": list(self.sent_node_ids),
-            "provider": self.provider,
-            "model": self.model,
-            "usage": dict(self.usage),
-        }
-
-
-class MultimodalAdapter(Protocol):
-    # See CloudLLMAdapter.stream: an async generator is declared with `def`.
-    def stream_media(
-        self,
-        *,
-        prompt: str,
-        context: str,
-        model: Optional[str] = None,
-    ) -> AsyncIterator[Any]:
-        """Yield progress events, then a final event with media_urls.
-
-        Typed as ``Any`` rather than ``Dict[str, Any]`` because adapters are
-        supplied by callers: the bridge validates each event's shape rather
-        than trusting the annotation.
-        """
-        ...
-
-
-class MultimodalStreamingBridge:
-    """Boundary-gated multimodal turn orchestrator."""
-
-    def __init__(self, adapter: Optional[MultimodalAdapter] = None) -> None:
-        self._adapter = adapter
-
-    async def run_turn(
-        self,
-        *,
-        user_message: str,
-        minimal: MinimalContext,
-        mode: NetworkBoundaryMode | str,
-        allow_multimodal: bool,
-        model: Optional[str] = None,
-    ) -> MultimodalTurnResult:
-        mode = normalize_network_mode(mode)
-        if mode != NetworkBoundaryMode.CLOUD_ALLOWED:
-            raise PermissionError(
-                f"multimodal cloud refused under NetworkBoundaryMode={mode.value!r}"
-            )
-        if not allow_multimodal:
-            raise PermissionError(
-                "multimodal cloud is disabled by hybrid policy (allow_multimodal=false)"
-            )
-        if self._adapter is None:
-            return MultimodalTurnResult(
-                user_message=user_message,
-                media_urls=[],
-                answer_text=(
-                    "[multimodal adapter not configured] "
-                    f"Would stream media grounded on {len(minimal.node_ids)} local node(s)."
-                ),
-                sent_node_ids=list(minimal.node_ids),
-                provider="none",
-                model=model or "",
-            )
-
-        urls: List[str] = []
-        notes: List[str] = []
-        async for event in self._adapter.stream_media(
-            prompt=user_message,
-            context=minimal.compact_text,
-            model=model,
-        ):
-            if not isinstance(event, dict):
-                continue
-            if event.get("media_url"):
-                urls.append(str(event["media_url"]))
-            if event.get("text"):
-                notes.append(str(event["text"]))
-        return MultimodalTurnResult(
-            user_message=user_message,
-            media_urls=urls,
-            answer_text="\n".join(notes),
-            sent_node_ids=list(minimal.node_ids),
-            provider=getattr(self._adapter, "provider_name", "multimodal"),
-            model=str(model or getattr(self._adapter, "default_model", "")),
-        )
-
-
-__all__ = [
-    "MultimodalTurnResult",
-    "MultimodalAdapter",
-    "MultimodalStreamingBridge",
-]

package/scripts/measure_brain_home_fill.mjs

@@ -1,141 +0,0 @@
-#!/usr/bin/env node
-/**
- * Measure Brain chat home (screen 04) content fill against the viewport.
- *
- * The layout rebuild requires the empty home's content bottom to reach at
- * least 90% of the 920px capture viewport — not "looks better" prose.
- *
- * Walks the same onboarding path as capture_release_evidence.mjs so #/brain
- * is the empty first-run home against the visual mock server.
- *
- * Exit 0 when bottom/viewport >= --min-ratio (default 0.90), else 1.
- */
-import { chromium } from "playwright";
-import { spawn } from "node:child_process";
-
-const repoRoot = process.cwd();
-const port = Number(process.env.LTCAI_RELEASE_EVIDENCE_PORT || 4937);
-const baseURL = `http://127.0.0.1:${port}`;
-const minRatio = Number(process.env.LTCAI_HOME_FILL_MIN || "0.90");
-
-const server = spawn(process.execPath, ["tests/visual/mock_server.cjs"], {
-  cwd: repoRoot,
-  env: { ...process.env, LTCAI_VISUAL_PORT: String(port) },
-  stdio: ["ignore", "pipe", "pipe"],
-});
-
-async function waitForServer() {
-  const deadline = Date.now() + 15000;
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(`${baseURL}/health`);
-      if (res.ok) return;
-    } catch {
-      /* retry */
-    }
-    await new Promise((r) => setTimeout(r, 150));
-  }
-  throw new Error(`visual server did not start on ${baseURL}`);
-}
-
-async function main() {
-  await waitForServer();
-  const browser = await chromium.launch({ headless: true });
-  const context = await browser.newContext({
-    viewport: { width: 1440, height: 920 },
-  });
-  const page = await context.newPage();
-  page.setDefaultTimeout(15000);
-
-  // Same first-run reset as release capture — without this the product flow
-  // may already be complete and the wake button never appears.
-  await page.addInitScript(() => {
-    localStorage.removeItem("lattice.productFlow.complete");
-    localStorage.removeItem("lattice.productFlow.user");
-    localStorage.setItem("lattice.language", "ko");
-    localStorage.setItem("lattice.mode", "basic");
-  });
-
-  await page.goto(`${baseURL}/app`, { waitUntil: "networkidle" });
-  const korean = page.getByRole("button", { name: "한국어" });
-  if (await korean.count()) {
-    await korean.click();
-  }
-  await page.getByRole("button", { name: "Brain 지금 깨우기" }).click();
-  await page.getByText("이 Brain의 주인을 정합니다.").waitFor();
-  await page.getByPlaceholder(/You|나/).fill("Codex");
-  await page.getByPlaceholder("you@local").fill("codex@local");
-  await page.getByPlaceholder("로컬 Brain 비밀번호").fill("Lattice123");
-  await page.getByRole("button", { name: "내 Brain 시작하기" }).click();
-  await page.getByText("추천대로 시작하세요.").waitFor();
-  await page.getByRole("button", { name: "추천으로 바로 시작" }).click();
-  await page.getByText("모델을 준비하고 시작합니다.").waitFor();
-  await page.getByRole("button", { name: "준비하고 시작하기" }).click();
-  await page.waitForTimeout(180);
-  await page
-    .getByRole("button", { name: /시작|들어가|Brain 열기|Open Brain/i })
-    .first()
-    .click({ timeout: 5000 })
-    .catch(() => {});
-  await page.locator("main[aria-label='Lattice Brain']").waitFor({ timeout: 15000 });
-  await page.waitForTimeout(250);
-
-  const metrics = await page.evaluate(() => {
-    const main = document.querySelector("main[aria-label='Lattice Brain']");
-    const home =
-      document.querySelector(".brain-centered-home") ||
-      document.querySelector(".brain-home-station") ||
-      main;
-    const quiet = document.querySelector(
-      "footer.brain-home-quiet, .brain-home-quiet, .brain-home-shelves",
-    );
-    const composer = document.querySelector(
-      ".brain-composer, [data-testid='brain-composer'], textarea",
-    );
-    const box = (el) => {
-      if (!el) return null;
-      const r = el.getBoundingClientRect();
-      return { top: r.top, bottom: r.bottom, height: r.height, width: r.width };
-    };
-    const candidates = [home, quiet, composer, main].filter(Boolean);
-    let bottom = 0;
-    let top = Infinity;
-    for (const el of candidates) {
-      const r = el.getBoundingClientRect();
-      bottom = Math.max(bottom, r.bottom);
-      top = Math.min(top, r.top);
-    }
-    return {
-      viewport: { width: window.innerWidth, height: window.innerHeight },
-      main: box(main),
-      home: box(home),
-      quiet: box(quiet),
-      composer: box(composer),
-      contentTop: top === Infinity ? 0 : top,
-      contentBottom: bottom,
-    };
-  });
-
-  await browser.close();
-
-  const ratio = metrics.contentBottom / metrics.viewport.height;
-  const pct = (100 * ratio).toFixed(1);
-  console.log(JSON.stringify({ ...metrics, fillRatio: ratio, fillPct: `${pct}%`, minRatio }, null, 2));
-  console.log(
-    `brain home fill: contentBottom=${metrics.contentBottom.toFixed(1)}px / viewport=${metrics.viewport.height}px = ${pct}% (need >= ${(100 * minRatio).toFixed(0)}%)`,
-  );
-
-  if (ratio + 1e-6 < minRatio) {
-    console.error(
-      `brain home fill FAIL: content only reaches ${pct}% of viewport (required ${(100 * minRatio).toFixed(0)}%).`,
-    );
-    process.exit(1);
-  }
-  console.log("brain home fill PASS");
-}
-
-try {
-  await main();
-} finally {
-  server.kill();
-}

package/static/app/assets/arrow-left-DwkSYrjR.js

@@ -1 +0,0 @@
-import{_ as e}from"./utils-V_5-wxr5.js";var t=e(`arrow-left`,[[`path`,{d:`m12 19-7-7 7-7`,key:`1l729n`}],[`path`,{d:`M19 12H5`,key:`x3x0zl`}]]);export{t};

package/static/app/assets/circle-check-CxOVPwYq.js

@@ -1 +0,0 @@
-import{_ as e}from"./utils-V_5-wxr5.js";var t=e(`circle-check`,[[`circle`,{cx:`12`,cy:`12`,r:`10`,key:`1mglay`}],[`path`,{d:`m9 12 2 2 4-4`,key:`dzmm74`}]]);export{t};