@maudecode/talaria-web 1.18.0 → 1.19.0

package/sidecar/talaria_sidecar/methods/write_approval.py

@@ -0,0 +1,181 @@
+"""``write_approval.*``: the Agent's staged skill and memory writes (TAL-819).
+
+With ``skills.write_approval`` or ``memory.write_approval`` on, the Agent stages writes under
+``<home>/pending/<kind>/<id>.json`` instead of committing them. These methods list them with
+the diff an approval would apply, and approve or reject them through the Agent's own
+``/skills`` and ``/memory`` review handlers.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import difflib
+import hashlib
+import re
+import tempfile
+import threading
+from pathlib import Path
+
+from ..errors import InvalidParams, RpcError
+from ..home import profile_home_param, scoped_home
+from ..rpc import CallContext
+
+KINDS = ("skills", "memory")
+# The Agent names records ``uuid4().hex[:8]`` and builds their path from the id; anything else could leave the pending dir.
+_ID = re.compile(r"[A-Za-z0-9_-]{1,64}")
+# One review at a time in this process, so two approvals of one record cannot both replay it.
+_LOCK = threading.Lock()
+
+
+def _agent():
+    try:
+        from hermes_cli import write_approval_commands
+        from tools import write_approval
+    except ImportError as exc:
+        raise RpcError("This Hermes Agent cannot review staged writes", condition="write_approval_unavailable") from exc
+    return write_approval, write_approval_commands
+
+
+def _kind(params: dict) -> str:
+    kind = str(params.get("kind") or "")
+    if kind not in KINDS:
+        raise InvalidParams("kind must be skills or memory")
+    return kind
+
+
+def _memory_diff(payload: dict) -> str:
+    """Replay the record on a scratch copy of its file through the Agent's approve path; the diff is what approval commits."""
+    from tools.memory_tool import ENTRY_DELIMITER, apply_memory_pending, load_on_disk_store
+
+    store = load_on_disk_store()
+    target = "user" if payload.get("target") == "user" else "memory"
+    real = store._path_for(target)
+    before = list(store._entries_for(target))
+    with tempfile.TemporaryDirectory(prefix="talaria-pending-") as scratch:
+        copy = Path(scratch) / real.name
+        if real.is_file():
+            copy.write_bytes(real.read_bytes())
+        # The store resolves every read, lock and write through ``self._path_for``.
+        store._path_for = lambda t: Path(scratch) / ("USER.md" if t == "user" else "MEMORY.md")
+        result = apply_memory_pending(payload, store)
+        after = list(store._entries_for(target))
+    if not result.get("success"):
+        raise _Unapprovable(f"(approve would fail: {result.get('error') or 'unknown error'})")
+    lines = lambda entries: ENTRY_DELIMITER.join(entries).splitlines(keepends=True)  # noqa: E731
+    diff = difflib.unified_diff(lines(before), lines(after), fromfile=f"a/{real.name}", tofile=f"b/{real.name}")
+    return "".join(diff) or "(no textual change)"
+
+
+class _Unapprovable(Exception):
+    """A write with no diff the user could review: its message replaces the diff and approval is refused."""
+
+
+def _skill_names(payload: dict) -> list[str]:
+    ops = payload.get("operations") or [] if payload.get("action") == "batch" else [payload]
+    return list(dict.fromkeys(str(op.get("name")) for op in ops if isinstance(op, dict) and op.get("name")))
+
+
+def _item(wa, kind: str, record: dict) -> dict:
+    payload = record.get("payload") if isinstance(record.get("payload"), dict) else {}
+    if kind == "memory":
+        target = "user" if payload.get("target") == "user" else "memory"
+    else:
+        target = ", ".join(_skill_names(payload))
+    diff, approvable = _diff(wa, kind, record)
+    return {
+        "id": str(record.get("id") or ""), "kind": kind, "target": target, "op": str(payload.get("action") or record.get("action") or ""),
+        "summary": str(record.get("summary") or ""), "origin": str(record.get("origin") or "foreground"),
+        "created_at": float(record.get("created_at") or 0), "diff": diff,
+        "approvable": approvable, "revision": _revision(diff) if approvable else "",
+    }
+
+
+def _diff(wa, kind: str, record: dict) -> tuple[str, bool]:
+    """The diff approving ``record`` applies and whether it may be approved; a diff that cannot be built is never approvable."""
+    payload = record.get("payload") if isinstance(record.get("payload"), dict) else {}
+    try:
+        return (_memory_diff(payload) if kind == "memory" else wa.skill_pending_diff(record)), True
+    except _Unapprovable as exc:
+        return str(exc), False
+    except Exception as exc:  # noqa: BLE001 - one unreadable record must not hide the rest
+        return f"(diff unavailable: {exc})", False
+
+
+def _apply_lock(kind: str, record: dict):
+    """Hold the Agent's own per-skill locks across the revision check and the apply (they are re-entrant in this thread, so
+    the Agent's apply takes them again). Memory needs none: the Agent applies a staged remove/patch only to the exact entry
+    it pinned at staging and an add only appends, so a concurrent write can never be dropped by an approval."""
+    if kind != "skills":
+        return contextlib.nullcontext()
+    from tools.skill_manager_tool import _skill_mutation_locks
+
+    return _skill_mutation_locks(_skill_names(record.get("payload") if isinstance(record.get("payload"), dict) else {}))
+
+
+def _revision(diff: str) -> str:
+    """What the reviewer saw: the diff changes whenever the record or the file it applies to does."""
+    return hashlib.sha256(diff.encode("utf-8")).hexdigest()
+
+
+def pending(kind: str) -> dict:
+    try:
+        wa, _ = _agent()
+    except RpcError:
+        return {"supported": False, "enabled": False, "items": []}
+    items = [_item(wa, kind, record) for record in wa.list_pending(kind) if _ID.fullmatch(str(record.get("id") or ""))]
+    return {"supported": True, "enabled": wa.write_approval_enabled(kind), "items": items}
+
+
+def review(kind: str, verb: str, writes: list[dict]) -> dict:
+    """``approve`` or ``reject`` each write through the Agent's handler; a record that is gone afterwards was applied or dropped.
+
+    An approval applies only while the write's diff still has the ``revision`` the reviewer saw; a changed file or record
+    is refused, so nothing lands that the user did not review.
+    """
+    wa, commands = _agent()
+    if not writes or any(not (isinstance(w, dict) and _ID.fullmatch(str(w.get("id") or "")) and isinstance(w.get("revision"), str)) for w in writes):
+        raise InvalidParams("writes must be pending write ids with the revision reviewed")
+    results = []
+    with _LOCK:
+        for write in writes:
+            pending_id = write["id"]
+            record = wa.get_pending(kind, pending_id)
+            if record is None:
+                results.append({"id": pending_id, "done": False, "message": f"No pending {kind} write with id '{pending_id}'."})
+                continue
+            if verb == "reject":
+                message = commands.handle_pending_subcommand(kind, [verb, pending_id]) or ""
+            else:
+                with _apply_lock(kind, record):
+                    diff, approvable = _diff(wa, kind, record)
+                    if not approvable:
+                        results.append({"id": pending_id, "done": False, "message": f"This write cannot be approved: {diff}"})
+                        continue
+                    if _revision(diff) != write["revision"]:
+                        results.append({"id": pending_id, "done": False, "message": "This write's diff changed after you reviewed it. Review the new diff, then approve again."})
+                        continue
+                    store = None
+                    if kind == "memory":
+                        from tools.memory_tool import load_on_disk_store
+
+                        store = load_on_disk_store()
+                    message = commands.handle_pending_subcommand(kind, [verb, pending_id], memory_store=store) or ""
+            results.append({"id": pending_id, "done": wa.get_pending(kind, pending_id) is None, "message": message})
+    return {"results": results}
+
+
+def register(registry) -> None:
+    @registry.method("write_approval.pending")
+    def pending_(ctx: CallContext, params: dict) -> dict:
+        kind = _kind(params)
+        with scoped_home(profile_home_param(params)):
+            return pending(kind)
+
+    for verb in ("approve", "reject"):
+        def handler(ctx: CallContext, params: dict, verb: str = verb) -> dict:
+            kind = _kind(params)
+            writes = list(params.get("writes") or [])
+            with scoped_home(profile_home_param(params)):
+                return review(kind, verb, writes)
+
+        registry.method(f"write_approval.{verb}")(handler)

package/sidecar/talaria_sidecar/rpc.py

@@ -13,6 +13,9 @@ from __future__ import annotations
 
 import json
 import logging
+import os
+import queue
+import time
 import sys
 import threading
 import traceback
@@ -121,6 +124,9 @@ class RpcServer:
     def request_shutdown(self, exit_code: int = 0) -> None:
         self.exit_code = exit_code
         self._closed.set()
+        with self._active_lock:
+            for ctx in self._active.values():
+                ctx.cancel_event.set()
 
     # ── dispatch ──────────────────────────────────────────────────────────
     def _register(self, request: dict) -> CallContext | None:
@@ -182,12 +188,38 @@ class RpcServer:
 
     def serve_forever(self) -> int:
         """Read requests until stdin closes or shutdown is requested."""
-        while not self._closed.is_set():
+        incoming = queue.Queue(maxsize=1)
+        def read_input():
             try:
-                raw = self._in.readline()
+                try:
+                    fd = self._in.fileno()
+                except (AttributeError, OSError, ValueError):
+                    fd = None
+                if fd is None:
+                    while raw := self._in.readline():
+                        incoming.put(raw)
+                else:
+                    # An unbuffered OS read cannot hold sys.stdin's Python buffer lock at interpreter exit.
+                    pending = []
+                    while chunk := os.read(fd, 65536):
+                        lines = chunk.split(b"\n")
+                        pending.append(lines[0])
+                        for line in lines[1:]:
+                            incoming.put(b"".join(pending))
+                            pending = [line]
+                    if pending:
+                        incoming.put(b"".join(pending))
             except (OSError, ValueError):
-                break
-            if not raw:
+                pass
+            finally:
+                incoming.put(None)
+        threading.Thread(target=read_input, name="rpc-input", daemon=True).start()
+        while not self._closed.is_set():
+            try:
+                raw = incoming.get(timeout=.1)
+            except queue.Empty:
+                continue
+            if raw is None or self._closed.is_set():
                 break
             raw = raw.strip()
             if not raw:
@@ -209,6 +241,15 @@ class RpcServer:
                 continue
             ctx = self._register(request)
             threading.Thread(target=self._dispatch_slot, args=(request, ctx), name=f"rpc-{request.get('method')}", daemon=True).start()
+        if self._closed.is_set():
+            # Let the terminal reply reach stdout before the process returns its final exit code.
+            deadline = time.monotonic() + 5
+            while time.monotonic() < deadline:
+                with self._active_lock:
+                    terminal_reply = any(ctx.method in {"runtime.shutdown", "runtime.handshake"} for ctx in self._active.values())
+                if not terminal_reply:
+                    break
+                threading.Event().wait(.01)
         return self.exit_code
 
     def _dispatch_slot(self, request: dict, ctx: CallContext | None) -> None:

package/sidecar/talaria_sidecar/runtime.py

@@ -10,12 +10,15 @@ from __future__ import annotations
 
 import errno
 import importlib
+import hashlib
 import json
 import math
 import os
+import re
 import stat
 import subprocess
 import sys
+import sysconfig
 import threading
 import time
 from pathlib import Path
@@ -24,11 +27,8 @@ from . import SIDECAR_RPC_VERSION
 from .errors import RpcError
 
 PIN_PATH = Path(__file__).resolve().parent.parent / "agent_dependency.json"
-_RESTART_REQUIRED_MESSAGE = (
-    "Hermes Agent was updated while Talaria Web was running. "
-    "Talaria Web cannot verify that the Agent update completed safely. "
-    "Check the Agent update outcome and environment first. "
-    "Restart Talaria Web manually before retrying this action."
+_RUNTIME_UNAVAILABLE_MESSAGE = (
+    "Agent runtime is unavailable. Check the Agent update outcome before retrying this action."
 )
 _AGENT_UPDATE_MARKER = ".hermes-update-in-progress"
 _AGENT_RECOVERY_MARKERS = (".update-incomplete", ".lazy-refresh-incomplete")
@@ -40,11 +40,16 @@ _MARKER_SAFE_OPEN_AVAILABLE = bool(_O_NOFOLLOW) and bool(_O_NONBLOCK)
 
 
 class AgentRuntimeStale(RpcError):
-    def __init__(self, update_state: str | None):
-        data = {"retryable": True, "restart_scheduled": False}
+    def __init__(self, update_state: str | None, message: str | None = None, *, source_changed: bool = False):
+        data = {"retryable": True, "restart_scheduled": False, "agent_source_changed": source_changed}
         if update_state is not None:
             data["agent_update_state"] = update_state
-        super().__init__(_RESTART_REQUIRED_MESSAGE, condition="agent_runtime_stale", data=data)
+        if message is None:
+            message = {
+                "active": "Agent update is in progress. Wait for it to finish before starting new work.",
+                "incomplete": "Agent update recovery is incomplete. Finish the Agent update before starting new work.",
+            }.get(update_state, _RUNTIME_UNAVAILABLE_MESSAGE)
+        super().__init__(message, condition="agent_runtime_stale", data=data)
 
 
 class AgentIncompatible(RpcError):
@@ -217,6 +222,45 @@ def installed_agent_version() -> str | None:
     return get_version_info().base_version
 
 
+def _python_abi(major: int | str, minor: int | str, free_threaded: bool) -> str:
+    """``3.14`` or ``3.14t``: regular and free-threaded builds of one version load different native extensions."""
+    return f"{major}.{minor}{'t' if free_threaded else ''}"
+
+
+def _site_packages_python(entry: str) -> tuple[str, Path] | None:
+    """The Python ABI a ``sys.path`` site-packages directory was built for, and that venv's interpreter."""
+    path = Path(entry)
+    if path.name != "site-packages" or not path.is_dir():
+        return None
+    match = re.fullmatch(r"python(\d+)\.(\d+)(t?)", path.parent.name)
+    if match and path.parent.parent.name in {"lib", "lib64"}:
+        return _python_abi(match[1], match[2], bool(match[3])), path.parent.parent.parent / "bin" / "python"
+    if path.parent.name.lower() == "lib":
+        venv = path.parent.parent
+        try:
+            config = (venv / "pyvenv.cfg").read_text(encoding="utf-8")
+        except OSError:
+            return None
+        found = re.search(r"^\s*version(?:_info)?\s*=\s*(\d+)\.(\d+)", config, re.MULTILINE)
+        if found:
+            free_threaded = re.search(r"^\s*executable\s*=.*python\d+\.\d+t(?:\.exe)?\s*$", config, re.MULTILINE | re.IGNORECASE)
+            return _python_abi(found[1], found[2], bool(free_threaded)), venv / "Scripts" / "python.exe"
+    return None
+
+
+def _check_site_packages_python() -> None:
+    """Compiled Agent dependencies load lazily on the first chat; fail the handshake when ``sys.path`` holds
+    site-packages built for another Python (a stale ``HERMES_WEBUI_PYTHON`` after a PM environment update)."""
+    running = _python_abi(sys.version_info[0], sys.version_info[1], bool(sysconfig.get_config_var("Py_GIL_DISABLED")))
+    for entry in sys.path:
+        built = _site_packages_python(entry)
+        if built is not None and built[0] != running:
+            raise ImportError(
+                f"interpreter Python {running} cannot load Agent packages built for Python {built[0]} ({entry}); "
+                f"unset HERMES_WEBUI_PYTHON or point it at {built[1]}"
+            )
+
+
 class AgentRuntime:
     """Loads the Agent once and guards against a changed checkout."""
 
@@ -224,6 +268,7 @@ class AgentRuntime:
         self.hermes_home = Path(hermes_home)
         self._stale_lock = threading.Lock()
         self._stale = False
+        self._source_changed = False
         self._stale_stamp: tuple | None = None
         self.agent_dir = Path(agent_dir).resolve() if agent_dir else None
         self.pin = read_pin()
@@ -239,12 +284,18 @@ class AgentRuntime:
             if self.loaded:
                 return
             try:
+                # Direct Agent imports skip CLI startup's PM tool PATH activation.
+                if self.agent_dir is not None and (self.agent_dir / "pm").is_dir():
+                    compose_path = getattr(importlib.import_module("pm"), "store_first_path", None)
+                    if compose_path is not None:
+                        os.environ["PATH"] = compose_path(os.environ.get("PATH", ""))
                 module = importlib.import_module("run_agent")
                 getattr(module, "AIAgent")
                 # Agent 0.21.3 snapshots its auth provider registry, discovered plugins included, when hermes_cli.auth
                 # first imports. Take it here, under the launch profile and before any profile-scoped method runs, so
                 # a named profile's plugin loaded later never enters that process-wide snapshot.
                 importlib.import_module("hermes_cli.auth")
+                _check_site_packages_python()
             except Exception as exc:  # noqa: BLE001 - reported as a handshake condition
                 self.import_error = f"{type(exc).__name__}: {exc}"
                 raise AgentIncompatible(f"Hermes Agent could not be imported: {self.import_error}", import_error=self.import_error)
@@ -276,9 +327,12 @@ class AgentRuntime:
 
     def update_transaction_state(self) -> str:
         live = _read_live_agent_update(self.hermes_home / _AGENT_UPDATE_MARKER)
-        if live == "unknown":
+        if live in {"unknown", "active"}:
+            return live
+        repair = self.web_repair_state()
+        if repair == "unknown":
             return "unknown"
-        recovery = False
+        recovery = repair == "present"
         for root in self._install_roots():
             for name in _AGENT_RECOVERY_MARKERS:
                 presence = _marker_presence(root / name)
@@ -289,6 +343,16 @@ class AgentRuntime:
             return "incomplete"
         return "unverified" if live == "absent" else live
 
+    def web_repair_state(self) -> str:
+        if self.agent_dir is None:
+            return "absent"
+        from .agent_mutation import recovery_receipts
+        try:
+            receipts, _ = recovery_receipts(self)
+            return 'present' if receipts else 'absent'
+        except (OSError, UnicodeError):
+            return 'unknown'
+
     def is_stale(self) -> bool:
         """True when the checkout revision no longer matches the loaded module.
 
@@ -310,14 +374,18 @@ class AgentRuntime:
                     fresh = None
                 if fresh is not None:
                     break
+            self._source_changed = fresh is not None and fresh != self.revision
             self._stale = fresh != self.revision
             self._stale_stamp = stamp if fresh is not None else None
             return self._stale
 
     def ensure_current(self) -> None:
-        """Raise ``agent_runtime_stale`` when the checkout changed since import."""
+        """Refuse Agent work until source drift or a durable Web update obligation is reconciled."""
+        repair = self.web_repair_state()
+        if repair != "absent":
+            raise AgentRuntimeStale("unknown" if repair == "unknown" else self.update_transaction_state())
         if self.is_stale():
-            raise AgentRuntimeStale(self.update_transaction_state())
+            raise AgentRuntimeStale(self.update_transaction_state(), source_changed=self._source_changed)
 
     # ── handshake ─────────────────────────────────────────────────────────
     def describe(self) -> dict:
@@ -335,6 +403,7 @@ class AgentRuntime:
             "pinned_image": self.pin["image"],
             "compatible": self.loaded,
             "stale": self.is_stale(),
+            "agent_source_changed": self._source_changed,
             "update_state": self.update_transaction_state(),
             "import_error": self.import_error,
         }

package/sidecar/talaria_sidecar/speed.py

@@ -0,0 +1,35 @@
+"""One route-aware speed gate for the model catalog and chat request overrides."""
+
+from __future__ import annotations
+
+import inspect
+import re
+from urllib.parse import urlparse
+
+
+def fast_overrides(model: str, provider: str, base_url: str, tier: str) -> dict | None:
+    if tier not in ("priority", "ultrafast"):
+        return None
+    from hermes_cli import models
+
+    resolver = getattr(models, "resolve_fast_mode_overrides", None)
+    if resolver is not None:
+        if "tier" in inspect.signature(resolver).parameters:
+            return resolver(model, provider=provider, base_url=base_url, tier=tier)
+        return resolver(model, provider=provider, base_url=base_url) if tier == "priority" else None
+    # Older Agents have no resolver. Keep the former GPT-5/o-series gate, restricted to first-party routes.
+    hosts = {"openai": "api.openai.com", "openai-api": "api.openai.com", "openai-codex": "chatgpt.com"}
+    model = model.strip().lower().removeprefix("openai/")
+    host = urlparse(base_url).hostname if base_url else None
+    if tier == "priority" and provider in hosts and (not host or host == hosts[provider]) and (model.startswith("gpt-5") or re.match(r"o[0-9]", model)):
+        return {"service_tier": "priority"}
+    return None
+
+
+def supported_speed_tiers(model: str, provider: str, base_url: str) -> list[dict]:
+    tiers = []
+    for tier in ("priority", "ultrafast"):
+        override = fast_overrides(model, provider, base_url, tier)
+        if override:
+            tiers.append({"id": "fast" if override.get("speed") == "fast" else tier, "service_tier": tier})
+    return [{"id": "standard", "service_tier": "default"}, *tiers] if tiers else []