Convert to standard model repository layout

.gitattributes

@@ -1,2 +1,2 @@
-*.tar.gz filter=lfs diff=lfs merge=lfs -text
-leo-ui7m-v0.1.0-private.tar.gz.sha256 filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text

MODEL_REPO_MANIFEST.json

@@ -0,0 +1,50 @@
+{
+  "project": "LEO-UI7M",
+  "status": "STANDARD_MODEL_REPO_LAYOUT_READY",
+  "created_unix": 1780431992,
+  "parameter_count": 7458567,
+  "safetensors_status": "created",
+  "files": [
+    ".gitattributes",
+    "README.md",
+    "config.json",
+    "examples/run_agent.py",
+    "leo_ui7m/__init__.py",
+    "leo_ui7m/__pycache__/__init__.cpython-312.pyc",
+    "leo_ui7m/__pycache__/api.cpython-312.pyc",
+    "leo_ui7m/__pycache__/cli.cpython-312.pyc",
+    "leo_ui7m/__pycache__/schema.cpython-312.pyc",
+    "leo_ui7m/adapters/__init__.py",
+    "leo_ui7m/adapters/__pycache__/__init__.cpython-312.pyc",
+    "leo_ui7m/adapters/__pycache__/playwright_dom.cpython-312.pyc",
+    "leo_ui7m/adapters/__pycache__/real_web_v2.cpython-312.pyc",
+    "leo_ui7m/adapters/playwright_dom.py",
+    "leo_ui7m/adapters/real_web_v2.py",
+    "leo_ui7m/agent/__pycache__/chat_agent_v1.cpython-312.pyc",
+    "leo_ui7m/agent/chat_agent_v1.py",
+    "leo_ui7m/api.py",
+    "leo_ui7m/cli.py",
+    "leo_ui7m/config.json",
+    "leo_ui7m/executors/__init__.py",
+    "leo_ui7m/executors/__pycache__/__init__.cpython-312.pyc",
+    "leo_ui7m/executors/__pycache__/playwright_executor.cpython-312.pyc",
+    "leo_ui7m/executors/playwright_executor.py",
+    "leo_ui7m/outcomes/__pycache__/work_outcome_v1.cpython-312.pyc",
+    "leo_ui7m/outcomes/work_outcome_v1.py",
+    "leo_ui7m/runtime/__init__.py",
+    "leo_ui7m/runtime/__pycache__/__init__.cpython-312.pyc",
+    "leo_ui7m/runtime/__pycache__/model.cpython-312.pyc",
+    "leo_ui7m/runtime/__pycache__/navigation_reranker_v1.cpython-312.pyc",
+    "leo_ui7m/runtime/__pycache__/safe_executor_v2.cpython-312.pyc",
+    "leo_ui7m/runtime/model.py",
+    "leo_ui7m/runtime/navigation_reranker_v1.py",
+    "leo_ui7m/runtime/safe_executor_v2.py",
+    "leo_ui7m/schema.py",
+    "model.safetensors",
+    "pytorch_model.bin",
+    "requirements.txt",
+    "tests/__pycache__/test_private_package_v0_1.cpython-312-pytest-9.0.3.pyc",
+    "tests/test_private_package_v0_1.py"
+  ],
+  "pytorch_model_sha256": "dbbb598fffba5f19558264165c3c3636c76f1a530c12c80c7528d5addd6c870a"
+}

README.md

@@ -13,26 +13,30 @@ license: other
 
 # LEO-UI7M v0.1-private
 
-LEO-UI7M v0.1-private is a private bounded useful browser-agent release.
+Private bounded useful browser-agent release.
 
-Correct parameter count: **7,458,567**.
+Correct parameter count: 7,458,567.
 
-## Artifact
+This repository uses a standard model-repo layout with direct weight files, config, source package, requirements, examples, and tests.
 
-- File: `leo-ui7m-v0.1.0-private.tar.gz`
-- SHA256: `4cb33cb984cbfe273c27e0d7636e7be6d2d478c3bf86fe9a0b6d6ec9408f8648`
-
-## Validated capabilities
+Files:
+- pytorch_model.bin
+- model.safetensors when available
+- config.json
+- leo_ui7m/
+- requirements.txt
+- examples/
+- tests/
 
+Validated capabilities:
 - Wikipedia command to research note
 - Python docs command to structured docs results
 - Hacker News jobs command to job digest
 - Example or IANA command to page explanation
-- Forbidden login/payment/sensitive command to refusal
-
-## Non-claims
+- Refusal for unsafe tasks
 
-- Not a general Fara replacement
-- Not screenshot-based visual computer-use
-- Not arbitrary-web automation
-- Not public-product-ready
+Non-claims:
+- not a general Fara replacement
+- not screenshot-based visual computer-use
+- not arbitrary-web automation
+- not public-product-ready

config.json

@@ -1,13 +1,14 @@
 {
+  "model_type": "leo_ui7m_browser_agent",
   "name": "LEO-UI7M v0.1-private",
-  "version": "0.1.0-private",
   "parameter_count": 7458567,
-  "release_type": "private_useful_browser_agent",
-  "artifact": "leo-ui7m-v0.1.0-private.tar.gz",
-  "sha256": "4cb33cb984cbfe273c27e0d7636e7be6d2d478c3bf86fe9a0b6d6ec9408f8648",
+  "version": "0.1.0-private",
+  "library_name": "other",
+  "weights": "pytorch_model.bin",
+  "safetensors": "model.safetensors",
   "python_package": "leo_ui7m",
-  "cli": "bin/leo-ui7m-chat",
-  "checkpoint": "checkpoints/leo_ui7m_v4_best.pt",
+  "entrypoint": "leo_ui7m.agent.chat_agent_v1:run_chat_message",
+  "scope": "private safe read-only browser agent",
   "not_claimed": [
     "not a general Fara replacement",
     "not screenshot-based visual computer-use",

evidence/leo_ui7m_final_clean_release_v1.json

@@ -1,7 +0,0 @@
-{
-  "project": "LEO-UI7M",
-  "parameter_count": 7458567,
-  "pytest_stdout": ".....                                                                    [100%]\n5 passed in 24.86s\n",
-  "old_name_hits": [],
-  "artifact_sha256": "4cb33cb984cbfe273c27e0d7636e7be6d2d478c3bf86fe9a0b6d6ec9408f8648"
-}

examples/run_agent.py

@@ -0,0 +1,3 @@
+from leo_ui7m.agent.chat_agent_v1 import run_chat_message
+r = run_chat_message('Search Wikipedia for Alan Turing')
+print((r.get('work_outcome') or {}).get('answer', '')[:800])

leo_ui7m/__init__.py

@@ -0,0 +1,6 @@
+"""LEO-UI7M local UI-action inference package."""
+
+__version__ = "0.1.0"
+from .api import UIActionModel, UIAction, UIElement
+
+__all__ = ["UIActionModel", "UIAction", "UIElement"]

leo_ui7m/adapters/playwright_dom.py

@@ -0,0 +1,41 @@
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def extract_ui_elements(page) -> list[dict[str, Any]]:
+    """Extract browser DOM elements into LEO-UI7M UIElement-compatible dicts.
+
+    Supports Playwright sync Page.
+    """
+    return page.evaluate(
+        """() => Array.from(document.querySelectorAll('button,input,select,a,[role="row"],[role="tab"],[role="menuitem"],textarea')).map((el, i) => {
+          const tag = el.tagName.toLowerCase();
+          const typ = (el.getAttribute('type') || '').toLowerCase();
+          let role = el.getAttribute('role') || (
+            tag === 'button' ? 'button' :
+            tag === 'select' ? 'combobox' :
+            tag === 'a' ? 'link' :
+            tag === 'textarea' ? 'textbox' :
+            typ === 'checkbox' ? 'checkbox' :
+            tag === 'input' ? 'textbox' :
+            'button'
+          );
+          const r = el.getBoundingClientRect();
+          const text = (el.innerText || el.value || '').trim();
+          const name = el.getAttribute('aria-label') || el.getAttribute('placeholder') || el.getAttribute('name') || text || el.id || el.dataset.eid || '';
+          return {
+            element_id: el.id || el.dataset.eid || `auto_${i}`,
+            role,
+            text,
+            name,
+            value: el.value || '',
+            enabled: !el.disabled,
+            visible: !!(r.width || r.height),
+            section: el.closest('[data-section]')?.dataset.section || 'main',
+            bbox: [r.x, r.y, r.width, r.height],
+            depth: 1
+          };
+        })"""
+    )

leo_ui7m/adapters/real_web_v2.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+
+EXTRACT_REAL_WEB_ELEMENTS_V2_JS = r"""
+() => {
+  const isVisible = (el) => {
+    const r = el.getBoundingClientRect();
+    const st = window.getComputedStyle(el);
+    return !!(r.width || r.height) && st.visibility !== 'hidden' && st.display !== 'none' && st.opacity !== '0';
+  };
+
+  const cssPath = (el) => {
+    const parts = [];
+    let cur = el;
+    while (cur && cur.nodeType === 1 && cur !== document.body && parts.length < 6) {
+      let part = cur.tagName.toLowerCase();
+      if (cur.id) {
+        part += '#' + CSS.escape(cur.id);
+        parts.unshift(part);
+        break;
+      }
+      const parent = cur.parentElement;
+      if (parent) {
+        const siblings = Array.from(parent.children).filter(x => x.tagName === cur.tagName);
+        if (siblings.length > 1) part += `:nth-of-type(${siblings.indexOf(cur) + 1})`;
+      }
+      parts.unshift(part);
+      cur = parent;
+    }
+    return parts.join(' > ');
+  };
+
+  const inferRole = (el) => {
+    const tag = el.tagName.toLowerCase();
+    const typ = (el.getAttribute('type') || '').toLowerCase();
+    return el.getAttribute('role') || (
+      tag === 'button' ? 'button' :
+      tag === 'select' ? 'combobox' :
+      tag === 'a' ? 'link' :
+      tag === 'textarea' ? 'textbox' :
+      typ === 'checkbox' ? 'checkbox' :
+      tag === 'input' ? (typ === 'submit' || typ === 'button' ? 'button' : 'textbox') :
+      'button'
+    );
+  };
+
+  const nodes = Array.from(document.querySelectorAll(
+    'button,input,select,a,textarea,[role="button"],[role="link"],[role="tab"],[role="menuitem"],[role="combobox"],[contenteditable="true"]'
+  ));
+
+  return nodes.map((el, i) => {
+    if (!el.dataset.leoStableUid) {
+      el.dataset.leoStableUid = `leo_stable_${Date.now()}_${i}_${Math.random().toString(16).slice(2)}`;
+    }
+
+    const role = inferRole(el);
+    const r = el.getBoundingClientRect();
+    const text = (el.innerText || el.value || el.getAttribute('value') || '').trim();
+    const name = (
+      el.getAttribute('aria-label') ||
+      el.getAttribute('placeholder') ||
+      el.getAttribute('name') ||
+      el.getAttribute('title') ||
+      text ||
+      el.id ||
+      el.dataset.leoStableUid ||
+      ''
+    ).trim();
+
+    const stable_uid = el.dataset.leoStableUid;
+    const element_id = el.id || stable_uid;
+
+    const selectors = [];
+    selectors.push(`[data-leo-stable-uid="${stable_uid}"]`);
+    if (el.id) selectors.push(`#${CSS.escape(el.id)}`);
+    if (el.getAttribute('name')) selectors.push(`${el.tagName.toLowerCase()}[name="${CSS.escape(el.getAttribute('name'))}"]`);
+    if (el.getAttribute('aria-label')) selectors.push(`${el.tagName.toLowerCase()}[aria-label="${CSS.escape(el.getAttribute('aria-label'))}"]`);
+    const path = cssPath(el);
+    if (path) selectors.push(path);
+
+    return {
+      element_id,
+      stable_uid,
+      role,
+      text,
+      name,
+      value: el.value || el.getAttribute('value') || '',
+      href: el.href || '',
+      tag: el.tagName.toLowerCase(),
+      type: (el.getAttribute('type') || '').toLowerCase(),
+      enabled: !el.disabled,
+      visible: isVisible(el),
+      section: el.closest('[data-section]')?.dataset.section || 'main',
+      bbox: [r.x, r.y, r.width, r.height],
+      depth: 1,
+      selectors,
+      fingerprint: {
+        role,
+        name,
+        text,
+        tag: el.tagName.toLowerCase(),
+        type: (el.getAttribute('type') || '').toLowerCase(),
+        href: el.href || '',
+        id: el.id || '',
+        stable_uid,
+        css_path: path,
+      }
+    };
+  });
+}
+"""
+
+
+def extract_real_web_elements_v2(page, *, include_hidden: bool = False) -> List[Dict[str, Any]]:
+    elements = page.evaluate(EXTRACT_REAL_WEB_ELEMENTS_V2_JS)
+    if not include_hidden:
+        elements = [e for e in elements if e.get("visible") and e.get("enabled")]
+    return elements
+
+
+def _score_candidate(element: Dict[str, Any], cand: Dict[str, Any]) -> float:
+    fp = element.get("fingerprint") or {}
+    score = 0.0
+
+    if cand.get("role") == element.get("role"):
+        score += 3.0
+    if cand.get("name") and cand.get("name") == element.get("name"):
+        score += 3.0
+    if cand.get("text") and cand.get("text") == element.get("text"):
+        score += 2.0
+    if cand.get("tag") == fp.get("tag"):
+        score += 1.0
+    if cand.get("href") and cand.get("href") == fp.get("href"):
+        score += 2.0
+    if cand.get("element_id") == element.get("element_id"):
+        score += 4.0
+    if cand.get("stable_uid") == element.get("stable_uid"):
+        score += 8.0
+
+    return score
+
+
+def resolve_real_web_locator_v2(page, element: Dict[str, Any]):
+    """Resolve a Playwright locator for a previously extracted element.
+
+    Priority:
+    1. Stable injected data uid.
+    2. Original id/name/aria selectors.
+    3. Best fingerprint match from fresh extraction.
+    """
+    selectors = element.get("selectors") or []
+    for sel in selectors:
+        try:
+            loc = page.locator(sel).first
+            if loc.count() > 0:
+                return loc
+        except Exception:
+            continue
+
+    # Re-extract and find best current fingerprint match.
+    fresh = extract_real_web_elements_v2(page, include_hidden=False)
+    if not fresh:
+        return None
+
+    best = max(fresh, key=lambda c: _score_candidate(element, c))
+    if _score_candidate(element, best) < 4.0:
+        return None
+
+    for sel in best.get("selectors") or []:
+        try:
+            loc = page.locator(sel).first
+            if loc.count() > 0:
+                return loc
+        except Exception:
+            continue
+    return None
+
+
+def real_web_element_safe_text(element: Optional[Dict[str, Any]]) -> str:
+    if not element:
+        return ""
+    fields = [
+        element.get("element_id"),
+        element.get("role"),
+        element.get("name"),
+        element.get("text"),
+        element.get("href"),
+    ]
+    return " ".join(str(x or "") for x in fields).lower()

leo_ui7m/agent/chat_agent_v1.py

@@ -0,0 +1,395 @@
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from playwright.sync_api import sync_playwright, TimeoutError as PlaywrightTimeoutError
+
+from leo_ui7m import UIActionModel
+from leo_ui7m.adapters.real_web_v2 import extract_real_web_elements_v2, resolve_real_web_locator_v2
+from leo_ui7m.runtime.navigation_reranker_v1 import rerank_navigation_action
+from leo_ui7m.runtime.safe_executor_v2 import check_safe_action, find_element, strict_url_success
+from leo_ui7m.outcomes.work_outcome_v1 import build_work_outcome_v1
+
+
+ROOT = Path(__file__).resolve().parents[2]
+RUN_LOG = ROOT / "reports/leo_ui7m_agent_chat_v1_runs.jsonl"
+RUN_LOG.parent.mkdir(parents=True, exist_ok=True)
+
+
+@dataclass
+class RouteResult:
+    ok: bool
+    task: Optional[Dict[str, Any]] = None
+    refusal: Optional[str] = None
+
+
+def _clean_query(q: str) -> str:
+    q = re.sub(r"\s+", " ", q or "").strip()
+    q = q.strip(" .!?\"'")
+    return q
+
+
+def route_message_to_task(message: str) -> RouteResult:
+    """Safe bounded natural-language router.
+
+    This is intentionally not a general web agent router. It only maps messages into
+    accepted safe read-only task families.
+    """
+    raw = message or ""
+    msg = raw.lower().strip()
+
+    forbidden = [
+        "login", "sign in", "password", "checkout", "buy ", "purchase", "payment",
+        "credit card", "bank", "send email", "post ", "comment ", "delete ",
+        "account", "captcha", "upload", "download private", "personal data",
+    ]
+    if any(x in msg for x in forbidden):
+        return RouteResult(False, refusal="Blocked: this private agent only supports safe read-only/no-login/no-payment tasks.")
+
+    # Wikipedia search: "search wikipedia for X", "wikipedia X"
+    m = re.search(r"(?:search\s+)?wikipedia\s+(?:for\s+)?(.+)$", msg)
+    if m:
+        query = _clean_query(m.group(1))
+        if not query:
+            return RouteResult(False, refusal="Missing Wikipedia search query.")
+        return RouteResult(True, {
+            "family": "wikipedia_search",
+            "title": f"Wikipedia search: {query}",
+            "url": "https://www.wikipedia.org/",
+            "goal": f"Search Wikipedia for {query}.",
+            "values": {"searchInput": query},
+            "default_type_text": query,
+            "success_url_contains": ["wikipedia.org/wiki/"],
+            "safe_target_contains": {"type": ["search"], "click": ["search"], "press": ["search"]},
+            "max_steps": 5,
+        })
+
+    # Python docs search: "search python docs for X"
+    m = re.search(r"(?:search\s+)?(?:python\s+docs|python\s+documentation|docs\.python)\s+(?:for\s+)?(.+)$", msg)
+    if m:
+        query = _clean_query(m.group(1))
+        if not query:
+            return RouteResult(False, refusal="Missing Python docs search query.")
+        return RouteResult(True, {
+            "family": "python_docs_search",
+            "title": f"Python docs search: {query}",
+            "url": "https://docs.python.org/3/",
+            "goal": f"Search Python documentation for {query}.",
+            "values": {},
+            "default_type_text": query,
+            "success_url_contains": ["docs.python.org/3/search.html", query.lower().replace(" ", "+").replace("_", "_")],
+            "safe_target_contains": {"type": ["search", "quick search"], "click": ["go", "search"], "press": ["search", "quick search"]},
+            "max_steps": 5,
+        })
+
+    # Hacker News nav.
+    hn_targets = {
+        "new": ("new stories", "https://news.ycombinator.com/", ["news.ycombinator.com/newest"], ["new"]),
+        "newest": ("new stories", "https://news.ycombinator.com/", ["news.ycombinator.com/newest"], ["new"]),
+        "jobs": ("jobs", "https://news.ycombinator.com/", ["news.ycombinator.com/jobs"], ["jobs"]),
+        "ask": ("ask", "https://news.ycombinator.com/", ["news.ycombinator.com/ask"], ["ask"]),
+        "show": ("show", "https://news.ycombinator.com/", ["news.ycombinator.com/show"], ["show"]),
+        "comments": ("comments", "https://news.ycombinator.com/", ["news.ycombinator.com/newcomments"], ["comments"]),
+    }
+    if "hacker news" in msg or "hn " in msg or msg.startswith("hn"):
+        for key, (label, url, success, safe_words) in hn_targets.items():
+            if re.search(rf"\b{re.escape(key)}\b", msg):
+                return RouteResult(True, {
+                    "family": "hn_navigation",
+                    "title": f"Hacker News navigation: {label}",
+                    "url": url,
+                    "goal": f"Open the {label} navigation link.",
+                    "values": {},
+                    "default_type_text": "",
+                    "success_url_contains": success,
+                    "safe_target_contains": {"click": safe_words, "wait": [""]},
+                    "max_steps": 4,
+                })
+
+    # Example.com
+    if "example.com" in msg and ("learn more" in msg or "more information" in msg or "main link" in msg):
+        return RouteResult(True, {
+            "family": "example_learn_more",
+            "title": "Example.com Learn more",
+            "url": "https://example.com/",
+            "goal": "Open the main Learn more link.",
+            "values": {},
+            "default_type_text": "",
+            "success_url_contains": ["iana.org/help/example-domains"],
+            "safe_target_contains": {"click": ["learn more"], "wait": [""]},
+            "max_steps": 4,
+        })
+
+    return RouteResult(False, refusal=(
+        "Unsupported safe task. Try: 'Search Wikipedia for Alan Turing', "
+        "'Search Python docs for asyncio', 'Open Hacker News jobs', or 'Open example.com learn more'."
+    ))
+
+
+def best_value(task: Dict[str, Any], eid: Optional[str]) -> str:
+    if eid and eid in task.get("values", {}):
+        return task["values"][eid]
+    return task.get("default_type_text", "")
+
+
+def apply_action(page, action: Dict[str, Any], elements, task: Dict[str, Any], last_text_target: Optional[str]):
+    act = action.get("action")
+    eid = action.get("target_element_id")
+
+    if act == "done":
+        return {"ok": True, "event": "done", "last_text_target": last_text_target}
+    if act == "wait":
+        page.wait_for_timeout(500)
+        return {"ok": True, "event": "wait", "last_text_target": last_text_target}
+    if act == "press":
+        if not last_text_target:
+            return {"ok": False, "error": "press_without_last_text_target"}
+        e = find_element(elements, last_text_target)
+        loc = resolve_real_web_locator_v2(page, e) if e else None
+        if loc is None:
+            return {"ok": False, "error": "press_target_not_resolved", "target": last_text_target}
+        loc.press("Enter", timeout=4000)
+        try:
+            page.wait_for_load_state("domcontentloaded", timeout=7000)
+        except Exception:
+            pass
+        return {"ok": True, "event": "press_enter", "target": last_text_target, "last_text_target": last_text_target}
+
+    if not eid:
+        return {"ok": False, "error": "missing_target"}
+
+    e = find_element(elements, eid)
+    if not e:
+        return {"ok": False, "error": "target_not_in_snapshot", "target": eid}
+
+    loc = resolve_real_web_locator_v2(page, e)
+    if loc is None or loc.count() < 1:
+        return {"ok": False, "error": "target_not_resolved", "target": eid}
+
+    if act == "type":
+        text = best_value(task, eid)
+        if not text:
+            return {"ok": False, "error": "missing_type_text", "target": eid}
+        loc.fill(text, timeout=4000)
+        return {"ok": True, "event": "type", "target": eid, "text": text, "last_text_target": eid}
+
+    if act == "select":
+        value = best_value(task, eid)
+        if value:
+            loc.select_option(label=value, timeout=4000)
+        return {"ok": True, "event": "select", "target": eid, "value": value, "last_text_target": last_text_target}
+
+    if act == "click":
+        before = page.url
+        loc.click(timeout=6000)
+        try:
+            page.wait_for_load_state("domcontentloaded", timeout=7000)
+        except Exception:
+            pass
+        return {"ok": True, "event": "click", "target": eid, "url_before": before, "url_after": page.url, "last_text_target": last_text_target}
+
+    return {"ok": False, "error": "unsupported_action", "action": act}
+
+
+def search_fallback(page, task: Dict[str, Any]):
+    elems = extract_real_web_elements_v2(page, include_hidden=False)
+    candidates = []
+    for e in elems:
+        txt = " ".join(str(e.get(k) or "") for k in ["element_id", "role", "name", "text"]).lower()
+        if e.get("role") == "textbox" and ("search" in txt or "quick search" in txt or str(e.get("name", "")).lower() == "q"):
+            candidates.append(e)
+    if not candidates:
+        return False, {"event": "fallback_no_search_box"}
+    target = candidates[0]
+    loc = resolve_real_web_locator_v2(page, target)
+    text = best_value(task, target.get("element_id"))
+    if loc is None or not text:
+        return False, {"event": "fallback_missing_locator_or_text"}
+    before = page.url
+    loc.fill(text, timeout=4000)
+    loc.press("Enter", timeout=4000)
+    try:
+        page.wait_for_load_state("domcontentloaded", timeout=7000)
+    except Exception:
+        pass
+    page.wait_for_timeout(900)
+    ok = strict_url_success(page.url, task["success_url_contains"])
+    return ok, {
+        "event": "search_fallback_fill_enter",
+        "target": target.get("element_id"),
+        "text": text,
+        "url_before": before,
+        "url_after": page.url,
+        "success": ok,
+    }
+
+
+def run_chat_message(message: str, *, headed: bool = False) -> Dict[str, Any]:
+    route = route_message_to_task(message)
+    if not route.ok:
+        result = {
+            "ok": False,
+            "accepted": False,
+            "message": message,
+            "refusal": route.refusal,
+            "hard_rules": {
+                "no_login": True,
+                "no_payment": True,
+                "no_sensitive_data": True,
+                "no_training": True,
+                "no_gpu": True,
+            },
+        }
+        return result
+
+    task = route.task
+    model = UIActionModel()
+    trace = []
+    unsafe_attempts = 0
+    executor_errors = 0
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=not headed, slow_mo=500 if headed else 0)
+        page = browser.new_page(viewport={"width": 1200, "height": 820})
+        page.goto(task["url"], wait_until="domcontentloaded", timeout=30000)
+        page.wait_for_timeout(1000)
+
+        history = []
+        completed = set()
+        last_text_target = None
+
+        for step in range(task["max_steps"]):
+            if strict_url_success(page.url, task["success_url_contains"]):
+                trace.append({"step": step, "result": "SUCCESS_BEFORE_ACTION", "url": page.url})
+                break
+
+            elements = extract_real_web_elements_v2(page, include_hidden=False)
+            for e in elements:
+                if e["element_id"] in completed:
+                    e["enabled"] = False
+
+            raw_obj = model.predict_action(task["goal"], elements, history, step)
+            raw = raw_obj.to_dict()
+            raw["raw"] = raw_obj.raw
+
+            rerank = rerank_navigation_action(goal=task["goal"], elements=elements, model_action=raw)
+            action = rerank["action"]
+            safe = check_safe_action(action=action, elements=elements, safe_target_contains=task["safe_target_contains"])
+
+            row = {
+                "step": step,
+                "url_before": page.url,
+                "raw_action": {"action": raw.get("action"), "target": raw.get("target_element_id"), "confidence": raw.get("confidence")},
+                "final_action": {"action": action.get("action"), "target": action.get("target_element_id")},
+                "reranker_changed": bool(rerank.get("changed")),
+                "safe": safe.safe,
+                "safe_reason": safe.reason,
+            }
+
+            if not safe.safe:
+                unsafe_attempts += 1
+                row["blocked"] = True
+                trace.append(row)
+                break
+
+            try:
+                result = apply_action(page, action, elements, task, last_text_target)
+            except PlaywrightTimeoutError as exc:
+                executor_errors += 1
+                result = {"ok": False, "error": "playwright_timeout", "message": str(exc).splitlines()[0]}
+            except Exception as exc:
+                executor_errors += 1
+                result = {"ok": False, "error": type(exc).__name__, "message": str(exc)[:300]}
+
+            row["executor_result"] = result
+            if "last_text_target" in result:
+                last_text_target = result["last_text_target"]
+
+            if result.get("ok") and action.get("target_element_id"):
+                completed.add(action["target_element_id"])
+                history.append({
+                    "action": action["action"],
+                    "target_element_id": action.get("target_element_id"),
+                    "text": best_value(task, action.get("target_element_id")),
+                    "value": best_value(task, action.get("target_element_id")),
+                })
+
+            page.wait_for_timeout(800)
+            row["url_after"] = page.url
+            row["success_after"] = strict_url_success(page.url, task["success_url_contains"])
+            trace.append(row)
+
+            if not result.get("ok"):
+                break
+            if row["success_after"]:
+                break
+
+            if action.get("action") in {"type", "done"} and "search" in task.get("family", ""):
+                ok, fb = search_fallback(page, task)
+                trace.append({"step": step + 0.5, "fallback": fb})
+                if ok:
+                    break
+                if action.get("action") == "done":
+                    break
+
+            if action.get("action") == "done":
+                break
+
+        success = strict_url_success(page.url, task["success_url_contains"])
+        work_outcome = None
+        if success:
+            work_outcome = build_work_outcome_v1(page=page, task=task, message=message, root=ROOT)
+        final = {
+            "ok": True,
+            "accepted": True,
+            "message": message,
+            "task_title": task["title"],
+            "goal": task["goal"],
+            "success": success,
+            "final_url": page.url,
+            "final_title": page.title(),
+            "unsafe_attempts": unsafe_attempts,
+            "executor_errors": executor_errors,
+            "work_outcome": work_outcome,
+            "trace": trace,
+            "runtime_stack": {
+                "checkpoint": "V4",
+                "adapter": "real_web_v2",
+                "safe_executor": "safe_executor_v2",
+                "navigation_reranker": "navigation_reranker_v1_repaired_explicit_target_groups",
+            },
+            "hard_rules": {
+                "no_login": True,
+                "no_payment": True,
+                "no_sensitive_data": True,
+                "no_training": True,
+                "no_gpu": True,
+            },
+        }
+
+        browser.close()
+
+    with RUN_LOG.open("a", encoding="utf-8") as f:
+        f.write(json.dumps({"created_unix": int(time.time()), **final}, ensure_ascii=False) + "\n")
+
+    return final
+
+
+def main():
+    ap = argparse.ArgumentParser(description="LEO-UI7M chat-style private agent interface v1")
+    ap.add_argument("message", nargs="+")
+    ap.add_argument("--headed", action="store_true", help="headed browser; only use on local desktop/XServer")
+    args = ap.parse_args()
+    msg = " ".join(args.message)
+    result = run_chat_message(msg, headed=args.headed)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

leo_ui7m/api.py

@@ -0,0 +1,45 @@
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from .runtime.model import LoadedUIActionPolicy
+from .schema import UIAction, UIElement
+
+
+import os
+DEFAULT_CHECKPOINT = Path(os.environ.get("LEO_UI7M_CHECKPOINT", Path(__file__).resolve().parents[1] / "checkpoints" / "leo_ui7m_v4_best.pt"))
+
+
+class UIActionModel:
+    """LEO-UI7M local inference API."""
+
+    def __init__(self, checkpoint_path: str | Path | None = None, device: str = "cpu") -> None:
+        self.checkpoint_path = Path(checkpoint_path) if checkpoint_path else DEFAULT_CHECKPOINT
+        self.device = device
+        self.policy = LoadedUIActionPolicy(self.checkpoint_path, device=device)
+
+    def predict_action(
+        self,
+        goal: str,
+        elements: list[UIElement | dict[str, Any]],
+        history: list[dict[str, Any]] | None = None,
+        step_index: int = 0,
+    ) -> UIAction:
+        normalized = [
+            e if isinstance(e, dict) else e.__dict__
+            for e in elements
+        ]
+        raw = self.policy.predict_raw(
+            goal=goal,
+            elements=normalized,
+            history=history or [],
+            step_index=step_index,
+        )
+        return UIAction(
+            action=raw["action"],
+            target_element_id=raw.get("target_element_id"),
+            confidence=raw.get("confidence"),
+            raw=raw,
+        )

leo_ui7m/cli.py

@@ -0,0 +1,38 @@
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from leo_ui7m import UIActionModel
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="LEO-UI7M local UI-action prediction CLI")
+    parser.add_argument("--goal", required=True, help="Task goal")
+    parser.add_argument("--elements", required=True, help="Path to JSON file containing a list of UI elements")
+    parser.add_argument("--history", default=None, help="Optional path to JSON file containing action history")
+    parser.add_argument("--checkpoint", default=None, help="Optional checkpoint path")
+    parser.add_argument("--step-index", type=int, default=0)
+    parser.add_argument("--pretty", action="store_true")
+    args = parser.parse_args()
+
+    elements = json.loads(Path(args.elements).read_text(encoding="utf-8"))
+    history = json.loads(Path(args.history).read_text(encoding="utf-8")) if args.history else []
+
+    model = UIActionModel(checkpoint_path=args.checkpoint)
+    action = model.predict_action(
+        goal=args.goal,
+        elements=elements,
+        history=history,
+        step_index=args.step_index,
+    )
+
+    out = action.to_dict()
+    print(json.dumps(out, indent=2 if args.pretty else None, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

leo_ui7m/config.json

@@ -0,0 +1,7 @@
+{
+  "project": "LEO-UI7M",
+  "default_model": "V4",
+  "default_checkpoint": "/root/leo-ui7m/reports/leo_ui7m_action_v4_elem_repair_probe_account_A_output/leo_ui7m_action_v4_elem_repair_probe_best.pt",
+  "public_product_ready": false,
+  "gpu_required": false
+}

leo_ui7m/executors/playwright_executor.py

@@ -0,0 +1,63 @@
+
+from __future__ import annotations
+
+from typing import Any
+
+from leo_ui7m.schema import UIAction
+
+
+class PlaywrightExecutor:
+    """Execute LEO-UI7M UIAction objects on a Playwright sync Page."""
+
+    def __init__(self, page) -> None:
+        self.page = page
+        self.history: list[dict[str, Any]] = []
+        self.completed_ids: set[str] = set()
+
+    def apply(self, action: UIAction, values: dict[str, str] | None = None) -> dict[str, Any]:
+        values = values or {}
+        data = action.to_dict()
+        act = data["action"]
+        eid = data.get("target_element_id")
+
+        if act == "done":
+            event = {"type": "done", "action": "done", "target_element_id": None}
+            self.history.append(event)
+            return {"ok": True, "event": event}
+
+        if act == "wait":
+            self.page.wait_for_timeout(100)
+            event = {"type": "wait", "action": "wait", "target_element_id": None}
+            self.history.append(event)
+            return {"ok": True, "event": event}
+
+        if not eid:
+            return {"ok": False, "error": "missing_target_element_id", "action": data}
+
+        loc = self.page.locator(f"#{eid}")
+        if loc.count() < 1:
+            return {"ok": False, "error": "target_not_found", "target_element_id": eid, "action": data}
+
+        try:
+            if act == "type":
+                text = data.get("text") or values.get(eid, "")
+                loc.fill(text)
+                event = {"type": "type", "action": "type", "target_element_id": eid, "text": text}
+            elif act == "select":
+                value = data.get("value") or values.get(eid, "")
+                loc.select_option(label=value)
+                event = {"type": "select", "action": "select", "target_element_id": eid, "value": value}
+            elif act == "click":
+                if loc.get_attribute("type") == "checkbox":
+                    loc.check()
+                else:
+                    loc.click()
+                event = {"type": "click", "action": "click", "target_element_id": eid}
+            else:
+                return {"ok": False, "error": "unsupported_action", "action": data}
+        except Exception as e:
+            return {"ok": False, "error": type(e).__name__, "message": str(e), "action": data}
+
+        self.completed_ids.add(eid)
+        self.history.append(event)
+        return {"ok": True, "event": event}

leo_ui7m/outcomes/work_outcome_v1.py

@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+import json
+import re
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+def _slug(s: str) -> str:
+    s = (s or "").lower()
+    s = re.sub(r"[^a-z0-9]+", "_", s).strip("_")
+    return s[:80] or "outcome"
+
+
+def _clean(s: str) -> str:
+    return re.sub(r"\s+", " ", (s or "")).strip()
+
+
+def _page_snapshot(page) -> Dict[str, Any]:
+    return page.evaluate("""
+    () => {
+      const clean = s => (s || '').replace(/\\s+/g, ' ').trim();
+      const paragraphs = Array.from(document.querySelectorAll('p'))
+        .map(p => clean(p.innerText))
+        .filter(t => t.length > 40)
+        .slice(0, 20);
+      const links = Array.from(document.querySelectorAll('a'))
+        .map(a => ({
+          text: clean(a.innerText || a.textContent || ''),
+          href: a.href || '',
+          title: clean(a.getAttribute('title') || '')
+        }))
+        .filter(x => x.text.length > 0 && x.href.length > 0)
+        .slice(0, 200);
+      const headings = Array.from(document.querySelectorAll('h1,h2,h3'))
+        .map(h => clean(h.innerText))
+        .filter(Boolean)
+        .slice(0, 20);
+      return {
+        url: location.href,
+        title: document.title || '',
+        h1: clean((document.querySelector('h1') || {}).innerText || ''),
+        headings,
+        paragraphs,
+        links,
+        body_text: clean(document.body ? document.body.innerText : '').slice(0, 8000)
+      };
+    }
+    """)
+
+
+def _dedupe_items(items: List[Dict[str, Any]], limit: int = 10) -> List[Dict[str, Any]]:
+    seen = set()
+    out = []
+    for it in items:
+        key = (it.get("title") or it.get("text") or "", it.get("url") or it.get("href") or "")
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(it)
+        if len(out) >= limit:
+            break
+    return out
+
+
+def _write_artifact(root: Path, slug: str, title: str, content: str) -> str:
+    out_dir = root / "reports" / "outcomes"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    path = out_dir / f"{slug}.md"
+    path.write_text(content, encoding="utf-8")
+    return str(path)
+
+
+def build_work_outcome_v1(*, page, task: Dict[str, Any], message: str, root: Path) -> Dict[str, Any]:
+    """Convert a completed browser task into a useful user-facing outcome.
+
+    This layer intentionally does not train, browse extra pages, log in, or perform risky actions.
+    It only extracts from the page already reached by the safe browser action loop.
+    """
+    snap = _page_snapshot(page)
+    family = task.get("family") or ""
+    title = _clean(task.get("title") or snap.get("title") or message)
+    url = snap.get("url") or ""
+    paragraphs = [_clean(x) for x in snap.get("paragraphs", []) if _clean(x)]
+    links = snap.get("links", [])
+
+    outcome: Dict[str, Any] = {
+        "version": "work_outcome_v1",
+        "created_unix": int(time.time()),
+        "message": message,
+        "task_family": family,
+        "page_title": snap.get("title"),
+        "final_url": url,
+        "useful_output": False,
+        "outcome_type": None,
+        "answer": None,
+        "structured_items": [],
+        "sources": [url] if url else [],
+        "artifact_path": None,
+        "notes": [],
+    }
+
+    if family == "wikipedia_search":
+        answer_parts = paragraphs[:2]
+        answer = "\\n\\n".join(answer_parts)
+        key_facts = []
+        for p in paragraphs[:4]:
+            if len(p) > 80:
+                key_facts.append(p[:280])
+            if len(key_facts) >= 4:
+                break
+
+        outcome.update({
+            "useful_output": bool(answer),
+            "outcome_type": "research_note",
+            "answer": answer,
+            "structured_items": [{"type": "key_fact", "text": x} for x in key_facts],
+        })
+
+        md = "# " + title + "\\n\\n"
+        md += "Source: " + url + "\\n\\n"
+        md += "## Summary\\n\\n" + (answer or "No summary extracted.") + "\\n\\n"
+        if key_facts:
+            md += "## Key facts\\n\\n" + "\\n".join("- " + x for x in key_facts) + "\\n"
+        outcome["artifact_path"] = _write_artifact(root, _slug("wikipedia_" + title), title, md)
+
+    elif family == "python_docs_search":
+        candidates = []
+        for a in links:
+            text = _clean(a.get("text"))
+            href = a.get("href") or ""
+            if not text or len(text) < 2:
+                continue
+            if "docs.python.org/3/" not in href:
+                continue
+            if any(skip in text.lower() for skip in ["previous topic", "next topic", "navigation", "index"]):
+                continue
+            candidates.append({"title": text[:160], "url": href})
+
+        items = _dedupe_items(candidates, limit=8)
+        answer = "Found " + str(len(items)) + " Python documentation result(s)." if items else "No Python documentation result was extracted."
+
+        outcome.update({
+            "useful_output": bool(items),
+            "outcome_type": "docs_search_results",
+            "answer": answer,
+            "structured_items": items,
+        })
+
+        md = "# " + title + "\\n\\n"
+        md += "Source: " + url + "\\n\\n"
+        md += "## Results\\n\\n"
+        md += "\\n".join("- " + it["title"] + " — " + it["url"] for it in items) if items else "No results extracted."
+        md += "\\n"
+        outcome["artifact_path"] = _write_artifact(root, _slug("python_docs_" + title), title, md)
+
+    elif family == "hn_navigation":
+        nav_words = {"new", "past", "comments", "ask", "show", "jobs", "submit", "login", "news", "guidelines", "faq", "lists"}
+        items = []
+        for a in links:
+            text = _clean(a.get("text"))
+            href = a.get("href") or ""
+            low = text.lower()
+            if not text or low in nav_words:
+                continue
+            if low in {"hacker news", "more", "hide", "discuss"}:
+                continue
+            if len(text) < 8:
+                continue
+            if "news.ycombinator.com" not in href and not href.startswith("http"):
+                continue
+            items.append({"title": text[:180], "url": href})
+        # For HN jobs, keep only job-like items; remove nav/domain/date/comment metadata.
+        if "jobs" in family or "jobs" in title.lower() or "jobs" in url.lower():
+            job_words = [
+                "hiring", "engineer", "developer", "designer", "design", "gtm",
+                "sales", "founder", "software", "backend", "frontend", "full-stack",
+                "full stack", "ai", "ml", "data", "platform", "infrastructure",
+                "security", "product", "remote", "onsite", "on-site", "yc"
+            ]
+            bad_exact = {"hacker news", "ycombinator.com/jobs", "news", "jobs", "comments", "ask", "show"}
+            bad_patterns = ["from?site=", "item?id=", "news.ycombinator.com/item", " day ago", " hours ago", " minutes ago"]
+
+            filtered = []
+            for it in items:
+                t = (it.get("title") or "").strip()
+                u = (it.get("url") or "").strip()
+                low = t.lower()
+                ulow = u.lower()
+
+                if not t or low in bad_exact:
+                    continue
+                if any(x in low for x in [" day ago", " hours ago", " minutes ago"]):
+                    continue
+                if any(x in ulow for x in bad_patterns):
+                    continue
+
+                jobish_title = any(w in low for w in job_words)
+                jobish_url = ("ycombinator.com/companies/" in ulow and "/jobs/" in ulow)
+
+                if jobish_title or jobish_url:
+                    filtered.append(it)
+
+            items = filtered
+
+        items = _dedupe_items(items, limit=15)
+
+        # HN jobs can expose useful job text without clean external links.
+        # If link extraction is empty, fall back to visible body lines.
+        if not items:
+            body = snap.get("body_text") or ""
+            raw_lines = []
+            noise_exact = {
+                "hacker news", "new", "past", "comments", "ask", "show", "jobs", "submit",
+                "login", "news", "guidelines", "faq", "lists", "api", "security", "legal",
+                "apply to yc", "contact"
+            }
+            noise_contains = [
+                "applications are open", "y combinator", "hacker news guidelines",
+                "more", "hide", "discuss", "past", "submit", "login"
+            ]
+
+            for line in body.split("\n"):
+                line = _clean(line)
+                if not line:
+                    continue
+                low = line.lower().strip()
+                if low in noise_exact:
+                    continue
+                if any(x in low for x in noise_contains):
+                    continue
+                if len(line) < 28:
+                    continue
+
+                # Prefer lines that look like job/work/company postings.
+                jobish = any(x in low for x in [
+                    "hiring", "engineer", "developer", "remote", "onsite", "founder",
+                    "startup", "full-time", "full time", "software", "ai", "ml",
+                    "data", "backend", "frontend", "infrastructure", "product",
+                    "design", "security", "platform"
+                ])
+                if not jobish and "jobs" in family:
+                    continue
+
+                raw_lines.append(line)
+
+            fallback_items = []
+            for line in raw_lines[:15]:
+                fallback_items.append({
+                    "title": line[:220],
+                    "url": url,
+                    "source": "visible_page_text"
+                })
+            items = _dedupe_items(fallback_items, limit=10)
+
+        answer = "Extracted " + str(len(items)) + " visible Hacker News item(s)." if items else "No Hacker News items extracted."
+
+        outcome.update({
+            "useful_output": bool(items),
+            "outcome_type": "link_digest",
+            "answer": answer,
+            "structured_items": items,
+        })
+
+        md = "# " + title + "\\n\\n"
+        md += "Source: " + url + "\\n\\n"
+        md += "## Items\\n\\n"
+        md += "\\n".join("- " + it["title"] + " — " + it["url"] for it in items) if items else "No items extracted."
+        md += "\\n"
+        outcome["artifact_path"] = _write_artifact(root, _slug("hn_" + title), title, md)
+
+    elif family == "example_learn_more":
+        answer = "\\n\\n".join(paragraphs[:3])
+        if not answer:
+            answer = snap.get("body_text", "")[:700]
+
+        outcome.update({
+            "useful_output": bool(answer),
+            "outcome_type": "page_explanation",
+            "answer": answer,
+            "structured_items": [{"title": _clean(a.get("text")), "url": a.get("href")} for a in links[:5]],
+        })
+
+        md = "# " + title + "\\n\\n"
+        md += "Source: " + url + "\\n\\n"
+        md += "## Explanation\\n\\n" + (answer or "No explanation extracted.") + "\\n"
+        outcome["artifact_path"] = _write_artifact(root, _slug("example_" + title), title, md)
+
+    else:
+        answer = "\\n\\n".join(paragraphs[:2]) or snap.get("body_text", "")[:1000]
+        outcome.update({
+            "useful_output": bool(answer),
+            "outcome_type": "generic_page_summary",
+            "answer": answer,
+            "structured_items": [{"title": _clean(a.get("text")), "url": a.get("href")} for a in links[:10]],
+        })
+        md = "# " + title + "\\n\\nSource: " + url + "\\n\\n" + (answer or "No output extracted.") + "\\n"
+        outcome["artifact_path"] = _write_artifact(root, _slug("generic_" + title), title, md)
+
+    if outcome["useful_output"] and not outcome.get("answer") and not outcome.get("structured_items"):
+        outcome["useful_output"] = False
+        outcome["notes"].append("Marked not useful because answer and structured_items are empty.")
+
+    return outcome

leo_ui7m/runtime/model.py

@@ -0,0 +1,198 @@
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn as nn
+
+
+MAX_CTX = 96
+MAX_ELEMS = 72
+MAX_ETXT = 28
+
+
+def _tok(text: str) -> list[str]:
+    text = (text or "").lower()
+    for c in "\n\t\r.,:;!?()[]{}<>/\\|\"'`~@#$%^&*+=_-":
+        text = text.replace(c, " ")
+    return [x for x in text.split() if x]
+
+
+def _enc(text: str, n: int, vocab: dict[str, int]) -> list[int]:
+    ids = [vocab.get(t, 1) for t in _tok(text)[:n]]
+    return ids + [0] * (n - len(ids))
+
+
+def _state_for(element_id: str, history: list[dict[str, Any]], states: dict[str, int]) -> int:
+    clicked = typed = selected = False
+    for h in history:
+        if h.get("target_element_id") == element_id:
+            clicked = clicked or h.get("action", h.get("type")) == "click"
+            typed = typed or h.get("action", h.get("type")) == "type"
+            selected = selected or h.get("action", h.get("type")) == "select"
+    key = "_".join(
+        name for name, flag in [
+            ("clicked", clicked),
+            ("typed", typed),
+            ("selected", selected),
+        ] if flag
+    ) or "none"
+    return states.get(key, 0)
+
+
+class _TorchPolicy(nn.Module):
+    def __init__(self, vocab_size: int, role_size: int, state_size: int, d: int, layers: int, heads: int, action_size: int) -> None:
+        super().__init__()
+        self.emb = nn.Embedding(vocab_size, d, padding_idx=0)
+        self.role = nn.Embedding(role_size, d)
+        self.state = nn.Embedding(state_size, d)
+        self.eproj = nn.Linear(d * 3, d)
+        layer = nn.TransformerEncoderLayer(d, heads, d * 4, 0.1, batch_first=True, activation="gelu")
+        self.tr = nn.TransformerEncoder(layer, layers)
+        self.action = nn.Linear(d, action_size)
+        self.elem = nn.Linear(d, 1)
+
+    def _mean(self, ids: torch.Tensor) -> torch.Tensor:
+        x = self.emb(ids)
+        m = (ids != 0).float().unsqueeze(-1)
+        return (x * m).sum(1) / m.sum(1).clamp_min(1)
+
+    def forward(self, ctx: torch.Tensor, et: torch.Tensor, er: torch.Tensor, es: torch.Tensor, em: torch.Tensor):
+        b, e, t = et.shape
+        cv = self._mean(ctx)
+        ev = self._mean(et.reshape(b * e, t)).reshape(b, e, -1)
+        ev = self.eproj(torch.cat([ev, self.role(er), self.state(es)], -1))
+        seq = torch.cat([cv[:, None, :], ev], 1)
+        pad = torch.cat([torch.zeros(b, 1, dtype=torch.bool, device=em.device), ~em], 1)
+        z = self.tr(seq, src_key_padding_mask=pad)
+        return self.action(z[:, 0]), self.elem(z[:, 1:]).squeeze(-1).masked_fill(~em, -1e9)
+
+
+class LoadedUIActionPolicy:
+    def __init__(self, checkpoint_path: str | Path, device: str = "cpu") -> None:
+        self.checkpoint_path = Path(checkpoint_path)
+        self.device = torch.device(device)
+        self.ckpt = torch.load(self.checkpoint_path, map_location=self.device, weights_only=False)
+        self.vocab = self.ckpt["vocab"]
+        self.roles = self.ckpt["roles"]
+        self.states = self.ckpt["states"]
+        self.actions = self.ckpt["actions"]
+        cfg = self.ckpt["config"]
+
+        self.model = _TorchPolicy(
+            vocab_size=len(self.vocab),
+            role_size=len(self.roles),
+            state_size=len(self.states),
+            d=cfg["d"],
+            layers=cfg["layers"],
+            heads=cfg["heads"],
+            action_size=len(self.actions),
+        ).to(self.device)
+        self.model.load_state_dict(self.ckpt["state_dict"])
+        self.model.eval()
+
+    def predict_raw(
+        self,
+        goal: str,
+        elements: list[dict[str, Any]],
+        history: list[dict[str, Any]] | None = None,
+        step_index: int = 0,
+    ) -> dict[str, Any]:
+        history = history or []
+        elems = elements[:MAX_ELEMS]
+
+        ctx_text = " ".join(
+            [f"step {step_index}", goal]
+            + [
+                f"{h.get('action', h.get('type', ''))} {h.get('target_element_id', '')} {h.get('text', h.get('value', ''))}"
+                for h in history
+            ]
+        )
+
+        et, er, es, em = [], [], [], []
+        for i in range(MAX_ELEMS):
+            if i < len(elems):
+                e = elems[i]
+                et.append(_enc(" ".join([
+                    str(e.get("role", "")),
+                    str(e.get("name", "")),
+                    str(e.get("text", "")),
+                    str(e.get("value", "")),
+                    str(e.get("section", "")),
+                ]), MAX_ETXT, self.vocab))
+                er.append(self.roles.get(str(e.get("role", "")), 0))
+                es.append(_state_for(str(e.get("element_id", "")), history, self.states))
+                em.append(bool(e.get("visible", True) and e.get("enabled", True)))
+            else:
+                et.append([0] * MAX_ETXT)
+                er.append(0)
+                es.append(0)
+                em.append(False)
+
+        with torch.no_grad():
+            al, el = self.model(
+                torch.tensor([_enc(ctx_text, MAX_CTX, self.vocab)], device=self.device),
+                torch.tensor([et], device=self.device),
+                torch.tensor([er], device=self.device),
+                torch.tensor([es], device=self.device),
+                torch.tensor([em], device=self.device).bool(),
+            )
+            action_probs = torch.softmax(al, dim=-1)[0].detach().cpu()
+            elem_probs = torch.softmax(el, dim=-1)[0][:len(elems)].detach().cpu()
+
+        action_order = [self.actions[i] for i in torch.argsort(action_probs, descending=True).tolist()]
+        elem_order = torch.argsort(elem_probs, descending=True).tolist()
+
+        compatible = {
+            "select": {"combobox"},
+            "type": {"textbox"},
+            "click": {"button", "link", "checkbox", "row", "tab", "menuitem"},
+        }
+
+        selected_action = "done"
+        selected_idx = None
+        for action in action_order:
+            if action in {"done", "wait", "press"}:
+                selected_action = action
+                selected_idx = None
+                break
+            for idx in elem_order:
+                if idx < len(elems):
+                    e = elems[idx]
+                    if (
+                        e.get("visible", True)
+                        and e.get("enabled", True)
+                        and str(e.get("role", "")) in compatible.get(action, set())
+                    ):
+                        selected_action = action
+                        selected_idx = idx
+                        break
+            if selected_idx is not None:
+                break
+
+        target_id = elems[selected_idx]["element_id"] if selected_idx is not None else None
+        confidence = float(action_probs[self.actions.index(selected_action)])
+        if selected_idx is not None:
+            confidence *= float(elem_probs[selected_idx])
+
+        return {
+            "action": selected_action,
+            "target_element_id": target_id,
+            "confidence": confidence,
+            "top_actions": [
+                {"action": self.actions[i], "prob": float(action_probs[i])}
+                for i in torch.argsort(action_probs, descending=True).tolist()[:6]
+            ],
+            "top_elements": [
+                {
+                    "element_id": elems[i]["element_id"],
+                    "role": elems[i].get("role", ""),
+                    "name": elems[i].get("name", ""),
+                    "text": elems[i].get("text", ""),
+                    "prob": float(elem_probs[i]),
+                }
+                for i in elem_order[: min(8, len(elems))]
+            ],
+        }

leo_ui7m/runtime/navigation_reranker_v1.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, Iterable
+
+
+TARGET_ORDER = [
+    ("comments", {"comments", "comment", "newcomments"}),
+    ("jobs", {"jobs", "job"}),
+    ("ask", {"ask"}),
+    ("show", {"show"}),
+    ("new", {"new", "newest", "latest", "recent"}),
+    ("past", {"past"}),
+]
+
+
+def _tokens(s: str) -> set[str]:
+    return set(re.findall(r"[a-z0-9]+", (s or "").lower()))
+
+
+def _label(e: Dict[str, Any]) -> str:
+    return " ".join(str(e.get(k) or "") for k in ["name", "text", "element_id", "href"]).strip().lower()
+
+
+def _text(e: Dict[str, Any]) -> str:
+    return str(e.get("text") or e.get("name") or "").strip().lower()
+
+
+def _is_nav_intent(goal: str) -> bool:
+    g = goal.lower()
+    return any(x in g for x in ["navigation", "nav", "open the", "go to", "stories", "new stories", "latest", "comments", "jobs", "ask", "show"])
+
+
+def infer_target_group(goal: str) -> str | None:
+    g = goal.lower()
+    toks = _tokens(g)
+    for group, words in TARGET_ORDER:
+        if toks & words:
+            return group
+    return None
+
+
+def score_navigation_candidate(goal: str, e: Dict[str, Any]) -> float:
+    if e.get("role") != "link":
+        return -100.0
+
+    target_group = infer_target_group(goal)
+    label = _label(e)
+    label_tokens = _tokens(label)
+    text = _text(e)
+    href = str(e.get("href") or "").lower()
+    word_count = len(_tokens(text))
+
+    score = 0.0
+
+    if target_group:
+        group_words = dict(TARGET_ORDER)[target_group]
+
+        # Strong exact target priority.
+        if text in group_words:
+            score += 50.0
+        if label_tokens & group_words:
+            score += 25.0
+        if any(w in href for w in group_words):
+            score += 20.0
+
+        # Penalize other nav labels when a different target is requested.
+        for other_group, other_words in TARGET_ORDER:
+            if other_group != target_group and (text in other_words or label_tokens & other_words):
+                score -= 25.0
+
+    # Generic concise-nav preference, but not enough to override explicit target.
+    if text in {"new", "newest", "ask", "show", "jobs", "comments", "past"}:
+        score += 8.0
+    if word_count <= 2:
+        score += 5.0
+    elif word_count >= 6:
+        score -= 10.0
+
+    # Penalize story/article-looking links.
+    if word_count >= 5:
+        score -= 12.0
+
+    # Site/nav URL hints.
+    if "news.ycombinator.com" in href:
+        score += 3.0
+
+    return score
+
+
+def rerank_navigation_action(
+    *,
+    goal: str,
+    elements: Iterable[Dict[str, Any]],
+    model_action: Dict[str, Any],
+    min_score: float = 20.0,
+) -> Dict[str, Any]:
+    if not _is_nav_intent(goal):
+        return {"changed": False, "reason": "not_navigation_intent", "action": model_action}
+
+    candidates = []
+    for e in elements:
+        if not e.get("visible", True) or not e.get("enabled", True):
+            continue
+        candidates.append((score_navigation_candidate(goal, e), e))
+
+    candidates.sort(key=lambda x: x[0], reverse=True)
+    best_score, best = candidates[0] if candidates else (-999.0, None)
+
+    if best is not None and best_score >= min_score:
+        new_action = dict(model_action)
+        new_action["action"] = "click"
+        new_action["target_element_id"] = best.get("element_id")
+        new_action["reranked_by"] = "navigation_reranker_v1_repaired"
+        new_action["reranker_score"] = best_score
+        return {
+            "changed": True,
+            "reason": "navigation_candidate_above_threshold",
+            "score": best_score,
+            "target_group": infer_target_group(goal),
+            "selected": {
+                "element_id": best.get("element_id"),
+                "role": best.get("role"),
+                "name": best.get("name"),
+                "text": best.get("text"),
+                "href": best.get("href"),
+            },
+            "top_candidates": [
+                {"score": s, "element_id": e.get("element_id"), "name": e.get("name"), "text": e.get("text"), "href": e.get("href")}
+                for s, e in candidates[:8]
+            ],
+            "action": new_action,
+        }
+
+    return {
+        "changed": False,
+        "reason": "no_navigation_candidate_above_threshold",
+        "score": best_score,
+        "target_group": infer_target_group(goal),
+        "top_candidates": [
+            {"score": s, "element_id": e.get("element_id"), "name": e.get("name"), "text": e.get("text"), "href": e.get("href")}
+            for s, e in candidates[:8]
+        ],
+        "action": model_action,
+    }

leo_ui7m/runtime/safe_executor_v2.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, Optional, Tuple
+
+
+@dataclass
+class SafeActionCheck:
+    safe: bool
+    reason: Any
+
+
+def element_text(element: Optional[Dict[str, Any]]) -> str:
+    if not element:
+        return ""
+    fields = [
+        element.get("element_id"),
+        element.get("stable_uid"),
+        element.get("role"),
+        element.get("name"),
+        element.get("text"),
+        element.get("href"),
+        element.get("tag"),
+        element.get("type"),
+    ]
+    return " ".join(str(x or "") for x in fields).lower()
+
+
+def find_element(elements: Iterable[Dict[str, Any]], element_id: Optional[str]) -> Optional[Dict[str, Any]]:
+    if not element_id:
+        return None
+    for e in elements:
+        if e.get("element_id") == element_id or e.get("stable_uid") == element_id:
+            return e
+    return None
+
+
+def check_safe_action(
+    *,
+    action: Dict[str, Any],
+    elements: Iterable[Dict[str, Any]],
+    safe_target_contains: Dict[str, list[str]],
+    allow_done: bool = True,
+    allow_wait: bool = True,
+) -> SafeActionCheck:
+    act = action.get("action")
+    target = action.get("target_element_id")
+
+    if act == "done":
+        return SafeActionCheck(bool(allow_done), "done_allowed" if allow_done else "done_blocked")
+    if act == "wait":
+        return SafeActionCheck(bool(allow_wait), "wait_allowed" if allow_wait else "wait_blocked")
+
+    rules = safe_target_contains.get(act)
+    if not rules:
+        return SafeActionCheck(False, {"reason": "no_safe_rule_for_action", "action": act})
+
+    e = find_element(elements, target)
+    txt = element_text(e)
+
+    if any(str(rule).lower() in txt for rule in rules):
+        return SafeActionCheck(True, {"reason": "target_matches_safe_rule", "target_text": txt})
+
+    return SafeActionCheck(False, {
+        "reason": "target_mismatch",
+        "action": act,
+        "target": target,
+        "target_text": txt,
+        "required_any": rules,
+    })
+
+
+def strict_url_success(url: str, required_substrings: list[str]) -> bool:
+    u = (url or "").lower()
+    return any(x.lower() in u for x in required_substrings)

leo_ui7m/schema.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+ActionType = Literal["click", "type", "select", "press", "wait", "done"]
+
+
+@dataclass
+class UIElement:
+    element_id: str
+    role: str
+    text: str = ""
+    name: str = ""
+    value: str = ""
+    enabled: bool = True
+    visible: bool = True
+    section: str = "main"
+    bbox: list[float] = field(default_factory=list)
+    depth: int = 1
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "UIElement":
+        return cls(
+            element_id=str(data.get("element_id", data.get("id", ""))),
+            role=str(data.get("role", "")),
+            text=str(data.get("text", "")),
+            name=str(data.get("name", "")),
+            value=str(data.get("value", "")),
+            enabled=bool(data.get("enabled", True)),
+            visible=bool(data.get("visible", True)),
+            section=str(data.get("section", "main")),
+            bbox=list(data.get("bbox", [])),
+            depth=int(data.get("depth", 1)),
+        )
+
+
+@dataclass
+class UIAction:
+    action: ActionType
+    target_element_id: str | None = None
+    text: str | None = None
+    value: str | None = None
+    confidence: float | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "action": self.action,
+            "target_element_id": self.target_element_id,
+            "text": self.text,
+            "value": self.value,
+            "confidence": self.confidence,
+            "raw": self.raw,
+        }

leo-ui7m-v0.1.0-private.tar.gz → model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4cb33cb984cbfe273c27e0d7636e7be6d2d478c3bf86fe9a0b6d6ec9408f8648
-size 27834754
+oid sha256:4d6b6a084ed720266b6c34ecf38dd060efbf7a0681f4284c53394bcd1c8d7968
+size 29840268

leo-ui7m-v0.1.0-private.tar.gz.sha256 → pytorch_model.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d1a8bbfe11c982f9c2135b9dc25b7934e4c7bc56d51310581eb78dab47a1fc5f
-size 97
+oid sha256:dbbb598fffba5f19558264165c3c3636c76f1a530c12c80c7528d5addd6c870a
+size 30166357

requirements.txt

@@ -0,0 +1,3 @@
+torch
+playwright
+safetensors

tests/test_private_package_v0_1.py

@@ -0,0 +1,47 @@
+import json, subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+def run_msg(msg):
+    p = subprocess.run([str(ROOT / 'bin/leo-ui7m-chat'), msg], cwd=str(ROOT), text=True, capture_output=True, timeout=120)
+    assert p.returncode == 0, p.stderr
+    return json.loads(p.stdout)
+
+def assert_useful(r, expected_type):
+    assert r['accepted'] is True
+    assert r['success'] is True
+    assert r['unsafe_attempts'] == 0
+    assert r['executor_errors'] == 0
+    wo = r.get('work_outcome') or {}
+    assert wo.get('useful_output') is True
+    assert wo.get('outcome_type') == expected_type
+    assert wo.get('answer') or wo.get('structured_items')
+    assert wo.get('artifact_path')
+    assert Path(wo.get('artifact_path')).exists()
+
+def test_refusal():
+    r = run_msg('login to my bank')
+    assert r['accepted'] is False
+    assert 'Blocked:' in r['refusal']
+
+def test_wikipedia_outcome():
+    r = run_msg('Search Wikipedia for Alan Turing')
+    assert_useful(r, 'research_note')
+
+def test_python_docs_outcome():
+    r = run_msg('Search Python docs for asyncio')
+    assert_useful(r, 'docs_search_results')
+
+def test_hn_jobs_outcome_quality():
+    r = run_msg('Open Hacker News jobs')
+    assert_useful(r, 'link_digest')
+    items = (r.get('work_outcome') or {}).get('structured_items') or []
+    assert len(items) >= 3
+    top = ' '.join((x.get('title') or '').lower() for x in items[:5])
+    assert ('hiring' in top) or ('engineer' in top) or ('job' in top)
+    assert 'hacker news' not in (items[0].get('title') or '').lower()
+
+def test_example_outcome():
+    r = run_msg('Open example.com learn more')
+    assert_useful(r, 'page_explanation')